some documentation of jvm backend

compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java

@@ -204,7 +204,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
         }
     }
 
-    private Type asmType(JetType type) {
+    @NotNull
+    private Type asmType(@NotNull JetType type) {
         return typeMapper.mapType(type, MapTypeMode.VALUE);
     }
 
@@ -1460,7 +1461,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
         receiver.put(receiver.type, v);
     }
 
-    public void generateFromResolvedCall(ReceiverDescriptor descriptor, Type type) {
+    public void generateFromResolvedCall(@NotNull ReceiverDescriptor descriptor, @NotNull Type type) {
         if(descriptor instanceof ClassReceiver) {
             Type exprType = asmType(descriptor.getType());
             ClassReceiver classReceiver = (ClassReceiver) descriptor;
@@ -1473,8 +1474,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
             else {
                 generateThisOrOuter(classReceiverDeclarationDescriptor).put(exprType, v);
             }
-            if(type != null)
-                StackValue.onStack(exprType).put(type, v);
+            StackValue.onStack(exprType).put(type, v);
         }
         else if (descriptor instanceof ScriptReceiver) {
             generateScript((ScriptReceiver) descriptor);
@@ -1483,16 +1483,14 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
             Type exprType = asmType(descriptor.getType());
             ExtensionReceiver extensionReceiver = (ExtensionReceiver) descriptor;
             generateReceiver(extensionReceiver.getDeclarationDescriptor()).put(exprType, v);
-            if(type != null)
-                StackValue.onStack(exprType).put(type, v);
+            StackValue.onStack(exprType).put(type, v);
         }
         else if(descriptor instanceof ExpressionReceiver) {
             ExpressionReceiver expressionReceiver = (ExpressionReceiver) descriptor;
             JetExpression expr = expressionReceiver.getExpression();
             Type exprType = asmType(expressionReceiver.getType());
             gen(expr, exprType);
-            if(type != null)
-                StackValue.onStack(exprType).put(type, v);
+            StackValue.onStack(exprType).put(type, v);
         }
         else if(descriptor instanceof AutoCastReceiver) {
             AutoCastReceiver autoCastReceiver = (AutoCastReceiver) descriptor;
@@ -1563,7 +1561,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
 
         throw new UnsupportedOperationException();    }
 
-    public StackValue generateThisOrOuter(ClassDescriptor calleeContainingClass) {
+    public StackValue generateThisOrOuter(@NotNull ClassDescriptor calleeContainingClass) {
         CodegenContext cur = context;
 
         PsiElement psiElement = BindingContextUtils.classDescriptorToDeclaration(bindingContext, calleeContainingClass);

compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java

@@ -40,9 +40,10 @@ import java.util.List;
  * @author alex.tkachman
  */
 public abstract class StackValue {
+    @NotNull
     public final Type type;
 
-    public StackValue(Type type) {
+    public StackValue(@NotNull Type type) {
         this.type = type;
     }
 
@@ -59,6 +60,9 @@ public abstract class StackValue {
         }
     }
 
+    /**
+     * Put this value to the top of the stack.
+     */
     public abstract void put(Type type, InstructionAdapter v);
 
     /**
@@ -73,6 +77,9 @@ public abstract class StackValue {
         put(type, v);
     }
 
+    /**
+     * Set this value from the top of the stack.
+     */
     public void store(Type topOfStackType, InstructionAdapter v) {
         throw new UnsupportedOperationException("cannot store to value " + this);
     }
@@ -107,7 +114,7 @@ public abstract class StackValue {
         return type == Type.VOID_TYPE ? none() : new OnStack(type);
     }
 
-    public static StackValue constant(Object value, Type type) {
+    public static StackValue constant(@Nullable Object value, Type type) {
         return new Constant(value, type);
     }
 
@@ -323,6 +330,10 @@ public abstract class StackValue {
         public Local(int index, Type type) {
             super(type);
             this.index = index;
+
+            if (index < 0) {
+                throw new IllegalStateException("local variable index must be non-negative");
+            }
         }
 
         @Override
@@ -377,9 +388,10 @@ public abstract class StackValue {
     }
 
     public static class Constant extends StackValue {
+        @Nullable
         private final Object value;
 
-        public Constant(Object value, Type type) {
+        public Constant(@Nullable Object value, Type type) {
             super(type);
             this.value = value;
         }
@@ -594,7 +606,7 @@ public abstract class StackValue {
             if(getter instanceof CallableMethod)
                 ((CallableMethod)getter).invoke(v);
             else
-                ((IntrinsicMethod)getter).generate(codegen, v, null, null, null, null, state);
+                ((IntrinsicMethod)getter).generate(codegen, v, type, null, null, null, state);
             coerce(type, v);
         }
 

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayGet.java

@@ -33,7 +33,7 @@ import java.util.List;
  */
 public class ArrayGet implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         receiver.put(JetTypeMapper.TYPE_OBJECT, v);
         Type type = JetTypeMapper.correctElementType(receiver.type);
 

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIndices.java

@@ -30,7 +30,7 @@ import java.util.List;
 
 public class ArrayIndices implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         receiver.put(JetTypeMapper.TYPE_OBJECT, v);
         v.arraylength();
         v.invokestatic("jet/IntRange", "count", "(I)Ljet/IntRange;");

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIterator.java

@@ -41,7 +41,7 @@ import java.util.List;
  */
 public class ArrayIterator implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         receiver.put(JetTypeMapper.TYPE_OBJECT, v);
         JetCallExpression call = (JetCallExpression) element;
         FunctionDescriptor funDescriptor = (FunctionDescriptor) codegen.getBindingContext().get(BindingContext.REFERENCE_TARGET, (JetSimpleNameExpression) call.getCalleeExpression());

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArraySet.java

@@ -33,7 +33,7 @@ import java.util.List;
  */
 public class ArraySet implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         receiver.put(JetTypeMapper.TYPE_OBJECT, v);
         Type type = JetTypeMapper.correctElementType(receiver.type);
 

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArraySize.java

@@ -33,7 +33,7 @@ import java.util.List;
  */
 public class ArraySize implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         receiver.put(JetTypeMapper.TYPE_OBJECT, v);
         v.arraylength();
 

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/BinaryOp.java

@@ -40,7 +40,7 @@ public class BinaryOp implements IntrinsicMethod {
     }
 
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         boolean nullable = expectedType.getSort() == Type.OBJECT;
         if(nullable) {
             expectedType = JetTypeMapper.unboxType(expectedType);

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/CompareTo.java

@@ -33,7 +33,7 @@ import java.util.List;
  */
 public class CompareTo implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, @Nullable PsiElement element, @Nullable List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, @Nullable PsiElement element, @Nullable List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         assert arguments != null;
         receiver.put(receiver.type, v);
         codegen.gen(arguments.get(0), receiver.type);

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Concat.java

@@ -33,7 +33,7 @@ import java.util.List;
  */
 public class Concat implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         if (receiver == null || receiver == StackValue.none()) {                                                     // LHS + RHS
             codegen.generateStringBuilderConstructor();
             codegen.invokeAppend(arguments.get(0));                                // StringBuilder(LHS)

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Equals.java

@@ -37,7 +37,7 @@ import java.util.List;
  */
 public class Equals implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
 
         boolean leftNullable = true;
         JetExpression rightExpr;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IdentityEquals.java

@@ -38,7 +38,7 @@ import java.util.List;
  */
 public class IdentityEquals implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         if(element instanceof JetCallExpression) {
             receiver.put(JetTypeMapper.TYPE_OBJECT, v);
             codegen.gen(arguments.get(0)).put(JetTypeMapper.TYPE_OBJECT, v);

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Increment.java

@@ -41,7 +41,7 @@ public class Increment implements IntrinsicMethod {
     }
 
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         boolean nullable = expectedType.getSort() == Type.OBJECT;
         if(nullable) {
             expectedType = JetTypeMapper.unboxType(expectedType);

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethod.java

@@ -33,6 +33,6 @@ import java.util.List;
  * @author yole
  */
 public interface IntrinsicMethod extends Callable {
-    StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, @Nullable PsiElement element,
+    StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, @Nullable PsiElement element,
             @Nullable List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state);
 }

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Inv.java

@@ -34,7 +34,7 @@ import java.util.List;
  */
 public class Inv implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         boolean nullable = expectedType.getSort() == Type.OBJECT;
         if(nullable) {
             expectedType = JetTypeMapper.unboxType(expectedType);

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IteratorIterator.java

@@ -33,7 +33,7 @@ import java.util.List;
  */
 public class IteratorIterator implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, @Nullable PsiElement element, @Nullable List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, @Nullable PsiElement element, @Nullable List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         return receiver;
     }
 }

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IteratorNext.java

@@ -33,7 +33,7 @@ import java.util.List;
  */
 public class IteratorNext implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         String name;
         if(expectedType == Type.CHAR_TYPE)
             name = "Char";

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassArray.java

@@ -43,7 +43,7 @@ public class JavaClassArray implements IntrinsicMethod {
     @Override
     public StackValue generate(ExpressionCodegen codegen,
                                InstructionAdapter v,
-                               Type expectedType,
+                               @NotNull Type expectedType,
                                @Nullable PsiElement element,
                                @Nullable List<JetExpression> arguments,
                                StackValue receiver,

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassFunction.java

@@ -35,7 +35,7 @@ import java.util.List;
  */
 public class JavaClassFunction implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, @Nullable PsiElement element,
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, @Nullable PsiElement element,
             @Nullable List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         JetCallExpression call = (JetCallExpression) element;
         ResolvedCall<? extends CallableDescriptor> resolvedCall = codegen.getBindingContext().get(BindingContext.RESOLVED_CALL, call.getCalleeExpression());

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassProperty.java

@@ -34,7 +34,7 @@ import java.util.List;
  */
 public class JavaClassProperty implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, @Nullable PsiElement element, @Nullable List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, @Nullable PsiElement element, @Nullable List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         receiver.put(receiver.type, v);
         switch (receiver.type.getSort()) {
             case Type.BOOLEAN:

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/NewArray.java

@@ -34,7 +34,7 @@ import java.util.List;
  */
 public class NewArray implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         codegen.generateNewArray((JetCallExpression) element, codegen.getBindingContext().get(BindingContext.EXPRESSION_TYPE, (JetExpression) element));
         return StackValue.onStack(expectedType);
     }

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Not.java

@@ -32,7 +32,7 @@ import java.util.List;
  */
 public class Not implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         final StackValue stackValue;
         if (arguments.size() == 1) {
             stackValue = codegen.gen(arguments.get(0));

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/NumberCast.java

@@ -32,7 +32,7 @@ import java.util.List;
  */
 public class NumberCast implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         receiver.put(expectedType, v);
         return StackValue.onStack(expectedType);
     }

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/PsiMethodCall.java

@@ -39,7 +39,7 @@ public class PsiMethodCall implements IntrinsicMethod {
     }
 
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element,
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element,
             List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         final CallableMethod callableMethod = state.getInjector().getJetTypeMapper().mapToCallableMethod(myMethod, false, OwnerKind.IMPLEMENTATION);
         codegen.invokeMethodWithArguments(callableMethod, (JetCallExpression) element, receiver);

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StringGetChar.java

@@ -33,7 +33,7 @@ import java.util.List;
  */
 public class StringGetChar implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         if(receiver != null)
             receiver.put(JetTypeMapper.TYPE_OBJECT, v);
         if(arguments != null)

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StringLength.java

@@ -33,7 +33,7 @@ import java.util.List;
  */
 public class StringLength implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         receiver.put(JetTypeMapper.TYPE_OBJECT, v);
         v.invokeinterface("java/lang/CharSequence", "length", "()I");
         return StackValue.onStack(Type.INT_TYPE);

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StringPlus.java

@@ -33,7 +33,7 @@ import java.util.List;
  */
 public class StringPlus implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         if(receiver == null || receiver == StackValue.none()) {
             codegen.gen(arguments.get(0)).put(JetTypeMapper.JL_STRING_TYPE, v);
             codegen.gen(arguments.get(1)).put(JetTypeMapper.TYPE_OBJECT, v);

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StupidSync.java

@@ -33,7 +33,7 @@ import java.util.List;
 
 public class StupidSync implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, @Nullable PsiElement element, @Nullable List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, @Nullable PsiElement element, @Nullable List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         codegen.pushMethodArguments((JetCallExpression)element, Arrays.asList(JetTypeMapper.TYPE_OBJECT, JetTypeMapper.TYPE_FUNCTION0));
         v.invokestatic("jet/runtime/Intrinsics", "stupidSync", "(Ljava/lang/Object;Ljet/Function0;)Ljava/lang/Object;");
         StackValue.onStack(JetTypeMapper.TYPE_OBJECT).put(expectedType, v);

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Sure.java

@@ -37,7 +37,7 @@ import java.util.List;
  */
 public class Sure implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         JetCallExpression call = (JetCallExpression) element;
         ResolvedCall<? extends CallableDescriptor> resolvedCall = codegen.getBindingContext().get(BindingContext.RESOLVED_CALL, call.getCalleeExpression());
         assert resolvedCall != null;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ToString.java

@@ -33,7 +33,7 @@ import java.util.List;
  */
 public class ToString implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         receiver.put(JetTypeMapper.TYPE_OBJECT, v);
         v.invokestatic("java/lang/String", "valueOf", "(Ljava/lang/Object;)Ljava/lang/String;");
         return StackValue.onStack(JetTypeMapper.JL_STRING_TYPE);

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/UnaryMinus.java

@@ -33,7 +33,7 @@ import java.util.List;
  */
 public class UnaryMinus implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         boolean nullable = expectedType.getSort() == Type.OBJECT;
         if(nullable) {
             expectedType = JetTypeMapper.unboxType(expectedType);

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/UnaryPlus.java

@@ -34,7 +34,7 @@ import java.util.List;
  */
 public class UnaryPlus implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, @Nullable PsiElement element, @Nullable List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, @Nullable PsiElement element, @Nullable List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         boolean nullable = expectedType.getSort() == Type.OBJECT;
         if(nullable) {
             expectedType = JetTypeMapper.unboxType(expectedType);

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/UpTo.java

@@ -40,7 +40,7 @@ public class UpTo implements IntrinsicMethod {
     }
 
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
         if(arguments.size()==1) {
             final Type leftType = receiver.type;
             final Type rightType = codegen.expressionType(arguments.get(0));