@NotNull propagated to JetVisitor implementations

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.codegen;
 
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.*;
 
 public class CodegenStatementVisitor extends JetVisitor<StackValue, StackValue> {
@@ -26,22 +27,22 @@ public class CodegenStatementVisitor extends JetVisitor<StackValue, StackValue>
     }
 
     @Override
-    public StackValue visitJetElement(JetElement element, StackValue receiver) {
+    public StackValue visitJetElement(@NotNull JetElement element, StackValue receiver) {
         return element.accept(codegen, receiver);
     }
 
     @Override
-    public StackValue visitIfExpression(JetIfExpression expression, StackValue receiver) {
+    public StackValue visitIfExpression(@NotNull JetIfExpression expression, StackValue receiver) {
         return codegen.generateIfExpression(expression, true);
     }
 
     @Override
-    public StackValue visitTryExpression(JetTryExpression expression, StackValue data) {
+    public StackValue visitTryExpression(@NotNull JetTryExpression expression, StackValue data) {
         return codegen.generateTryExpression(expression, true);
     }
 
     @Override
-    public StackValue visitWhenExpression(JetWhenExpression expression, StackValue data) {
+    public StackValue visitWhenExpression(@NotNull JetWhenExpression expression, StackValue data) {
         return codegen.generateWhenExpression(expression, true);
     }
 }

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

@@ -279,7 +279,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitClass(JetClass klass, StackValue data) {
+    public StackValue visitClass(@NotNull JetClass klass, StackValue data) {
         return visitClassOrObject(klass);
     }
 
@@ -297,17 +297,17 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitObjectDeclaration(JetObjectDeclaration declaration, StackValue data) {
+    public StackValue visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, StackValue data) {
         return visitClassOrObject(declaration);
     }
 
     @Override
-    public StackValue visitExpression(JetExpression expression, StackValue receiver) {
+    public StackValue visitExpression(@NotNull JetExpression expression, StackValue receiver) {
         throw new UnsupportedOperationException("Codegen for " + expression + " is not yet implemented");
     }
 
     @Override
-    public StackValue visitSuperExpression(JetSuperExpression expression, StackValue data) {
+    public StackValue visitSuperExpression(@NotNull JetSuperExpression expression, StackValue data) {
         return StackValue.thisOrOuter(this, getSuperCallLabelTarget(expression), true);
     }
 
@@ -339,12 +339,12 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitParenthesizedExpression(JetParenthesizedExpression expression, StackValue receiver) {
+    public StackValue visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression, StackValue receiver) {
         return genQualified(receiver, expression.getExpression());
     }
 
     @Override
-    public StackValue visitAnnotatedExpression(JetAnnotatedExpression expression, StackValue receiver) {
+    public StackValue visitAnnotatedExpression(@NotNull JetAnnotatedExpression expression, StackValue receiver) {
         return genQualified(receiver, expression.getBaseExpression());
     }
 
@@ -363,7 +363,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitIfExpression(JetIfExpression expression, StackValue receiver) {
+    public StackValue visitIfExpression(@NotNull JetIfExpression expression, StackValue receiver) {
         return generateIfExpression(expression, false);
     }
 
@@ -410,7 +410,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitWhileExpression(JetWhileExpression expression, StackValue receiver) {
+    public StackValue visitWhileExpression(@NotNull JetWhileExpression expression, StackValue receiver) {
         Label condition = new Label();
         v.mark(condition);
 
@@ -432,7 +432,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
 
     @Override
-    public StackValue visitDoWhileExpression(JetDoWhileExpression expression, StackValue receiver) {
+    public StackValue visitDoWhileExpression(@NotNull JetDoWhileExpression expression, StackValue receiver) {
         Label continueLabel = new Label();
         v.mark(continueLabel);
 
@@ -468,7 +468,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitForExpression(JetForExpression forExpression, StackValue receiver) {
+    public StackValue visitForExpression(@NotNull JetForExpression forExpression, StackValue receiver) {
         // Is it a "1..2" or so
         RangeCodegenUtil.BinaryCall binaryCall = RangeCodegenUtil.getRangeAsBinaryCall(forExpression);
         if (binaryCall != null) {
@@ -1142,12 +1142,12 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
 
     @Override
-    public StackValue visitBreakExpression(JetBreakExpression expression, StackValue receiver) {
+    public StackValue visitBreakExpression(@NotNull JetBreakExpression expression, StackValue receiver) {
         return visitBreakOrContinueExpression(expression, receiver, true);
     }
 
     @Override
-    public StackValue visitContinueExpression(JetContinueExpression expression, StackValue receiver) {
+    public StackValue visitContinueExpression(@NotNull JetContinueExpression expression, StackValue receiver) {
         return visitBreakOrContinueExpression(expression, receiver, false);
     }
 
@@ -1223,14 +1223,14 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitConstantExpression(JetConstantExpression expression, StackValue receiver) {
+    public StackValue visitConstantExpression(@NotNull JetConstantExpression expression, StackValue receiver) {
         CompileTimeConstant<?> compileTimeValue = bindingContext.get(BindingContext.COMPILE_TIME_VALUE, expression);
         assert compileTimeValue != null;
         return StackValue.constant(compileTimeValue.getValue(), expressionType(expression));
     }
 
     @Override
-    public StackValue visitStringTemplateExpression(JetStringTemplateExpression expression, StackValue receiver) {
+    public StackValue visitStringTemplateExpression(@NotNull JetStringTemplateExpression expression, StackValue receiver) {
         StringBuilder constantValue = new StringBuilder("");
         JetStringTemplateEntry[] entries = expression.getEntries();
 
@@ -1275,7 +1275,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitBlockExpression(JetBlockExpression expression, StackValue receiver) {
+    public StackValue visitBlockExpression(@NotNull JetBlockExpression expression, StackValue receiver) {
         List<JetElement> statements = expression.getStatements();
         JetType unitType = KotlinBuiltIns.getInstance().getUnitType();
         boolean lastStatementIsExpression = !unitType.equals(bindingContext.get(EXPRESSION_TYPE, expression));
@@ -1283,7 +1283,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitNamedFunction(JetNamedFunction function, StackValue data) {
+    public StackValue visitNamedFunction(@NotNull JetNamedFunction function, StackValue data) {
         assert data == StackValue.none();
 
         if (JetPsiUtil.isScriptDeclaration(function)) {
@@ -1299,7 +1299,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitFunctionLiteralExpression(JetFunctionLiteralExpression expression, StackValue receiver) {
+    public StackValue visitFunctionLiteralExpression(@NotNull JetFunctionLiteralExpression expression, StackValue receiver) {
         //noinspection ConstantConditions
         if (bindingContext.get(BindingContext.BLOCK, expression)) {
             //noinspection ConstantConditions
@@ -1325,7 +1325,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitObjectLiteralExpression(JetObjectLiteralExpression expression, StackValue receiver) {
+    public StackValue visitObjectLiteralExpression(@NotNull JetObjectLiteralExpression expression, StackValue receiver) {
         CalculatedClosure closure = this.generateObjectLiteral(state, expression);
 
         ConstructorDescriptor constructorDescriptor = bindingContext.get(BindingContext.CONSTRUCTOR, expression.getObjectDeclaration());
@@ -1568,7 +1568,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitReturnExpression(JetReturnExpression expression, StackValue receiver) {
+    public StackValue visitReturnExpression(@NotNull JetReturnExpression expression, StackValue receiver) {
         JetExpression returnedExpression = expression.getReturnedExpression();
         if (returnedExpression != null) {
             gen(returnedExpression, returnType);
@@ -1604,7 +1604,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitSimpleNameExpression(JetSimpleNameExpression expression, StackValue receiver) {
+    public StackValue visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression, StackValue receiver) {
         ResolvedCall<? extends CallableDescriptor> resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, expression);
 
         DeclarationDescriptor descriptor;
@@ -1877,7 +1877,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitCallExpression(JetCallExpression expression, StackValue receiver) {
+    public StackValue visitCallExpression(@NotNull JetCallExpression expression, StackValue receiver) {
         JetExpression callee = expression.getCalleeExpression();
         assert callee != null;
 
@@ -2424,7 +2424,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitCallableReferenceExpression(JetCallableReferenceExpression expression, StackValue data) {
+    public StackValue visitCallableReferenceExpression(@NotNull JetCallableReferenceExpression expression, StackValue data) {
         // TODO: properties
         final FunctionDescriptor functionDescriptor = bindingContext.get(FUNCTION, expression);
         assert functionDescriptor != null : "Callable reference is not resolved to descriptor: " + expression.getText();
@@ -2585,13 +2585,13 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitDotQualifiedExpression(JetDotQualifiedExpression expression, StackValue receiver) {
+    public StackValue visitDotQualifiedExpression(@NotNull JetDotQualifiedExpression expression, StackValue receiver) {
         StackValue receiverValue = StackValue.none();
         return genQualified(receiverValue, expression.getSelectorExpression());
     }
 
     @Override
-    public StackValue visitSafeQualifiedExpression(JetSafeQualifiedExpression expression, StackValue receiver) {
+    public StackValue visitSafeQualifiedExpression(@NotNull JetSafeQualifiedExpression expression, StackValue receiver) {
         JetExpression expr = expression.getReceiverExpression();
         Type receiverType = expressionType(expr);
         gen(expr, receiverType);
@@ -2624,7 +2624,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitBinaryExpression(JetBinaryExpression expression, StackValue receiver) {
+    public StackValue visitBinaryExpression(@NotNull JetBinaryExpression expression, StackValue receiver) {
         IElementType opToken = expression.getOperationReference().getReferencedNameElementType();
         if (opToken == JetTokens.EQ) {
             return generateAssignmentExpression(expression);
@@ -2979,7 +2979,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitPrefixExpression(JetPrefixExpression expression, StackValue receiver) {
+    public StackValue visitPrefixExpression(@NotNull JetPrefixExpression expression, StackValue receiver) {
         JetSimpleNameExpression operationSign = expression.getOperationReference();
         if (JetTokens.LABELS.contains(operationSign.getReferencedNameElementType())) {
             return genQualified(receiver, expression.getBaseExpression());
@@ -3035,7 +3035,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitPostfixExpression(JetPostfixExpression expression, StackValue receiver) {
+    public StackValue visitPostfixExpression(@NotNull JetPostfixExpression expression, StackValue receiver) {
         if (expression.getOperationReference().getReferencedNameElementType() == JetTokens.EXCLEXCL) {
             StackValue base = genQualified(receiver, expression.getBaseExpression());
             if (isPrimitive(base.type)) {
@@ -3139,7 +3139,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitProperty(JetProperty property, StackValue receiver) {
+    public StackValue visitProperty(@NotNull JetProperty property, StackValue receiver) {
         final JetExpression initializer = property.getInitializer();
         if (initializer == null) {
             return StackValue.none();
@@ -3156,7 +3156,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitMultiDeclaration(JetMultiDeclaration multiDeclaration, StackValue receiver) {
+    public StackValue visitMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration, StackValue receiver) {
         JetExpression initializer = multiDeclaration.getInitializer();
         if (initializer == null) return StackValue.none();
 
@@ -3351,7 +3351,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitArrayAccessExpression(JetArrayAccessExpression expression, StackValue receiver) {
+    public StackValue visitArrayAccessExpression(@NotNull JetArrayAccessExpression expression, StackValue receiver) {
         JetExpression array = expression.getArrayExpression();
         JetType type = bindingContext.get(BindingContext.EXPRESSION_TYPE, array);
         Type arrayType = asmTypeOrVoid(type);
@@ -3407,14 +3407,14 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitThrowExpression(JetThrowExpression expression, StackValue receiver) {
+    public StackValue visitThrowExpression(@NotNull JetThrowExpression expression, StackValue receiver) {
         gen(expression.getThrownExpression(), JAVA_THROWABLE_TYPE);
         v.athrow();
         return StackValue.none();
     }
 
     @Override
-    public StackValue visitThisExpression(JetThisExpression expression, StackValue receiver) {
+    public StackValue visitThisExpression(@NotNull JetThisExpression expression, StackValue receiver) {
         DeclarationDescriptor descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, expression.getInstanceReference());
         if (descriptor instanceof ClassDescriptor) {
             return StackValue.thisOrOuter(this, (ClassDescriptor) descriptor, false);
@@ -3428,7 +3428,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitTryExpression(JetTryExpression expression, StackValue receiver) {
+    public StackValue visitTryExpression(@NotNull JetTryExpression expression, StackValue receiver) {
         return generateTryExpression(expression, false);
     }
 
@@ -3562,7 +3562,7 @@ The "returned" value of try expression with no finally is either the last expres
     }
 
     @Override
-    public StackValue visitBinaryWithTypeRHSExpression(JetBinaryExpressionWithTypeRHS expression, StackValue receiver) {
+    public StackValue visitBinaryWithTypeRHSExpression(@NotNull JetBinaryExpressionWithTypeRHS expression, StackValue receiver) {
         JetSimpleNameExpression operationSign = expression.getOperationReference();
         IElementType opToken = operationSign.getReferencedNameElementType();
         if (opToken == JetTokens.COLON) {
@@ -3612,7 +3612,7 @@ The "returned" value of try expression with no finally is either the last expres
     }
 
     @Override
-    public StackValue visitIsExpression(JetIsExpression expression, StackValue receiver) {
+    public StackValue visitIsExpression(@NotNull JetIsExpression expression, StackValue receiver) {
         StackValue match = StackValue.expression(OBJECT_TYPE, expression.getLeftHandSide(), this);
         return generateIsCheck(match, expression.getTypeRef(), expression.isNegated());
     }
@@ -3676,7 +3676,7 @@ The "returned" value of try expression with no finally is either the last expres
     }
 
     @Override
-    public StackValue visitWhenExpression(JetWhenExpression expression, StackValue receiver) {
+    public StackValue visitWhenExpression(@NotNull JetWhenExpression expression, StackValue receiver) {
         return generateWhenExpression(expression, false);
     }
 

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java

@@ -72,7 +72,7 @@ public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
     }
 
     @Override
-    public JetType visitNullableType(JetNullableType nullableType, Void aVoid) {
+    public JetType visitNullableType(@NotNull JetNullableType nullableType, Void aVoid) {
         if (!originalType.isNullable() && typeUsage != TYPE_ARGUMENT) {
             throw new AlternativeSignatureMismatchException("Auto type '%s' is not-null, while type in alternative signature is nullable: '%s'",
                  DescriptorRenderer.TEXT.renderType(originalType), nullableType.getText());
@@ -81,14 +81,14 @@ public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
     }
 
     @Override
-    public JetType visitFunctionType(JetFunctionType type, Void data) {
+    public JetType visitFunctionType(@NotNull JetFunctionType type, Void data) {
         return visitCommonType(type.getReceiverTypeRef() == null
                 ? KotlinBuiltIns.getInstance().getFunction(type.getParameters().size())
                 : KotlinBuiltIns.getInstance().getExtensionFunction(type.getParameters().size()), type);
     }
 
     @Override
-    public JetType visitUserType(JetUserType type, Void data) {
+    public JetType visitUserType(@NotNull JetUserType type, Void data) {
         JetUserType qualifier = type.getQualifier();
 
         //noinspection ConstantConditions
@@ -221,7 +221,7 @@ public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
     }
 
     @Override
-    public JetType visitSelfType(JetSelfType type, Void data) {
+    public JetType visitSelfType(@NotNull JetSelfType type, Void data) {
         throw new UnsupportedOperationException("Self-types are not supported yet");
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTreeVisitor.java

@@ -16,9 +16,11 @@
 
 package org.jetbrains.jet.lang.psi;
 
+import org.jetbrains.annotations.NotNull;
+
 public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
-    public Void visitJetElement(JetElement element, D data) {
+    public Void visitJetElement(@NotNull JetElement element, D data) {
         element.acceptChildren(this, data);
         return null;
     }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java

@@ -255,7 +255,7 @@ public class AnnotationResolver {
     ) {
         JetVisitor<CompileTimeConstant<?>, Void> visitor = new JetVisitor<CompileTimeConstant<?>, Void>() {
             @Override
-            public CompileTimeConstant<?> visitConstantExpression(JetConstantExpression expression, Void nothing) {
+            public CompileTimeConstant<?> visitConstantExpression(@NotNull JetConstantExpression expression, Void nothing) {
                 JetType type = expressionTypingServices.getType(JetScope.EMPTY, expression, expectedType, DataFlowInfo.EMPTY, trace);
                 if (type == null) {
                     // TODO:
@@ -276,20 +276,21 @@ public class AnnotationResolver {
 //            }
 
             @Override
-            public CompileTimeConstant<?> visitParenthesizedExpression(JetParenthesizedExpression expression, Void nothing) {
+            public CompileTimeConstant<?> visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression, Void nothing) {
                 JetExpression innerExpression = expression.getExpression();
                 if (innerExpression == null) return null;
                 return innerExpression.accept(this, null);
             }
 
             @Override
-            public CompileTimeConstant<?> visitStringTemplateExpression(JetStringTemplateExpression expression,
+            public CompileTimeConstant<?> visitStringTemplateExpression(
+                    @NotNull JetStringTemplateExpression expression,
                                                                         Void nothing) {
                 return trace.get(BindingContext.COMPILE_TIME_VALUE, expression);
             }
 
             @Override
-            public CompileTimeConstant<?> visitSimpleNameExpression(JetSimpleNameExpression expression, Void data) {
+            public CompileTimeConstant<?> visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression, Void data) {
                 ResolvedCall<? extends CallableDescriptor> resolvedCall =
                         trace.getBindingContext().get(BindingContext.RESOLVED_CALL, expression);
                 if (resolvedCall != null) {
@@ -308,7 +309,7 @@ public class AnnotationResolver {
             }
 
             @Override
-            public CompileTimeConstant<?> visitQualifiedExpression(JetQualifiedExpression expression, Void data) {
+            public CompileTimeConstant<?> visitQualifiedExpression(@NotNull JetQualifiedExpression expression, Void data) {
                 JetExpression selectorExpression = expression.getSelectorExpression();
                 if (selectorExpression != null) {
                     return selectorExpression.accept(this, null);
@@ -317,7 +318,7 @@ public class AnnotationResolver {
             }
 
             @Override
-            public CompileTimeConstant<?> visitCallExpression(JetCallExpression expression, Void data) {
+            public CompileTimeConstant<?> visitCallExpression(@NotNull JetCallExpression expression, Void data) {
                 ResolvedCall<? extends CallableDescriptor> call =
                         trace.getBindingContext().get(BindingContext.RESOLVED_CALL, (expression).getCalleeExpression());
                 if (call != null) {
@@ -350,7 +351,7 @@ public class AnnotationResolver {
             }
 
             @Override
-            public CompileTimeConstant<?> visitJetElement(JetElement element, Void nothing) {
+            public CompileTimeConstant<?> visitJetElement(@NotNull JetElement element, Void nothing) {
                 // TODO:
                 //trace.report(ANNOTATION_PARAMETER_SHOULD_BE_CONSTANT.on(element));
                 return null;

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java

@@ -414,27 +414,27 @@ public class CandidateResolver {
             }
 
             @Override
-            public JetExpression visitQualifiedExpression(JetQualifiedExpression expression, Void data) {
+            public JetExpression visitQualifiedExpression(@NotNull JetQualifiedExpression expression, Void data) {
                 return visitInnerExpression(expression.getSelectorExpression());
             }
 
             @Override
-            public JetExpression visitExpression(JetExpression expression, Void data) {
+            public JetExpression visitExpression(@NotNull JetExpression expression, Void data) {
                 return expression;
             }
 
             @Override
-            public JetExpression visitParenthesizedExpression(JetParenthesizedExpression expression, Void data) {
+            public JetExpression visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression, Void data) {
                 return visitInnerExpression(expression.getExpression());
             }
 
             @Override
-            public JetExpression visitPrefixExpression(JetPrefixExpression expression, Void data) {
+            public JetExpression visitPrefixExpression(@NotNull JetPrefixExpression expression, Void data) {
                 return visitInnerExpression(JetPsiUtil.getBaseExpressionIfLabeledExpression(expression));
             }
 
             @Override
-            public JetExpression visitBlockExpression(JetBlockExpression expression, Void data) {
+            public JetExpression visitBlockExpression(@NotNull JetBlockExpression expression, Void data) {
                 JetElement lastStatement = JetPsiUtil.getLastStatementInABlock(expression);
                 if (lastStatement != null) {
                     return visitInnerExpression(lastStatement);
@@ -443,7 +443,7 @@ public class CandidateResolver {
             }
 
             @Override
-            public JetExpression visitBinaryExpression(JetBinaryExpression expression, Void data) {
+            public JetExpression visitBinaryExpression(@NotNull JetBinaryExpression expression, Void data) {
                 return ExpressionTypingUtils.isBinaryExpressionDependentOnExpectedType(expression) ? expression : null;
             }
         }, null);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java

@@ -250,12 +250,12 @@ public class ResolveSession implements KotlinCodeAnalyzer {
     public DeclarationDescriptor resolveToDescriptor(JetDeclaration declaration) {
         DeclarationDescriptor result = declaration.accept(new JetVisitor<DeclarationDescriptor, Void>() {
             @Override
-            public DeclarationDescriptor visitClass(JetClass klass, Void data) {
+            public DeclarationDescriptor visitClass(@NotNull JetClass klass, Void data) {
                 return getClassDescriptor(klass);
             }
 
             @Override
-            public DeclarationDescriptor visitObjectDeclaration(JetObjectDeclaration declaration, Void data) {
+            public DeclarationDescriptor visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, Void data) {
                 PsiElement parent = declaration.getParent();
                 if (parent instanceof JetClassObject) {
                     JetClassObject jetClassObject = (JetClassObject) parent;
@@ -265,12 +265,12 @@ public class ResolveSession implements KotlinCodeAnalyzer {
             }
 
             @Override
-            public DeclarationDescriptor visitClassObject(JetClassObject classObject, Void data) {
+            public DeclarationDescriptor visitClassObject(@NotNull JetClassObject classObject, Void data) {
                 return getClassObjectDescriptor(classObject);
             }
 
             @Override
-            public DeclarationDescriptor visitTypeParameter(JetTypeParameter parameter, Void data) {
+            public DeclarationDescriptor visitTypeParameter(@NotNull JetTypeParameter parameter, Void data) {
                 JetTypeParameterListOwner ownerElement = PsiTreeUtil.getParentOfType(parameter, JetTypeParameterListOwner.class);
                 DeclarationDescriptor ownerDescriptor = resolveToDescriptor(ownerElement);
 
@@ -298,14 +298,14 @@ public class ResolveSession implements KotlinCodeAnalyzer {
             }
 
             @Override
-            public DeclarationDescriptor visitNamedFunction(JetNamedFunction function, Void data) {
+            public DeclarationDescriptor visitNamedFunction(@NotNull JetNamedFunction function, Void data) {
                 JetScope scopeForDeclaration = getInjector().getScopeProvider().getResolutionScopeForDeclaration(function);
                 scopeForDeclaration.getFunctions(safeNameForLazyResolve(function));
                 return getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, function);
             }
 
             @Override
-            public DeclarationDescriptor visitParameter(JetParameter parameter, Void data) {
+            public DeclarationDescriptor visitParameter(@NotNull JetParameter parameter, Void data) {
                 PsiElement grandFather = parameter.getParent().getParent();
                 if (grandFather instanceof JetClass) {
                     JetClass jetClass = (JetClass) grandFather;
@@ -326,21 +326,21 @@ public class ResolveSession implements KotlinCodeAnalyzer {
             }
 
             @Override
-            public DeclarationDescriptor visitProperty(JetProperty property, Void data) {
+            public DeclarationDescriptor visitProperty(@NotNull JetProperty property, Void data) {
                 JetScope scopeForDeclaration = getInjector().getScopeProvider().getResolutionScopeForDeclaration(property);
                 scopeForDeclaration.getProperties(safeNameForLazyResolve(property));
                 return getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, property);
             }
 
             @Override
-            public DeclarationDescriptor visitObjectDeclarationName(JetObjectDeclarationName declarationName, Void data) {
+            public DeclarationDescriptor visitObjectDeclarationName(@NotNull JetObjectDeclarationName declarationName, Void data) {
                 JetScope scopeForDeclaration = getInjector().getScopeProvider().getResolutionScopeForDeclaration(declarationName.getParent());
                 scopeForDeclaration.getProperties(safeNameForLazyResolve(declarationName));
                 return getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, declarationName);
             }
 
             @Override
-            public DeclarationDescriptor visitJetElement(JetElement element, Void data) {
+            public DeclarationDescriptor visitJetElement(@NotNull JetElement element, Void data) {
                 throw new IllegalArgumentException("Unsupported declaration type: " + element + " " +
                                                    JetPsiUtil.getElementTextWithContext(element));
             }

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java

@@ -94,7 +94,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitSimpleNameExpression(JetSimpleNameExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression, ExpressionTypingContext context) {
         // TODO : other members
         // TODO : type substitutions???
         CallExpressionResolver callExpressionResolver = context.expressionTypingServices.getCallExpressionResolver();
@@ -105,7 +105,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitParenthesizedExpression(JetParenthesizedExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression, ExpressionTypingContext context) {
         return visitParenthesizedExpression(expression, context, false);
     }
 
@@ -130,7 +130,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitConstantExpression(JetConstantExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitConstantExpression(@NotNull JetConstantExpression expression, ExpressionTypingContext context) {
         IElementType elementType = expression.getNode().getElementType();
         String text = expression.getNode().getText();
         KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance();
@@ -163,7 +163,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitBinaryWithTypeRHSExpression(JetBinaryExpressionWithTypeRHS expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitBinaryWithTypeRHSExpression(@NotNull JetBinaryExpressionWithTypeRHS expression, ExpressionTypingContext context) {
         ExpressionTypingContext contextWithNoExpectedType =
                 context.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT);
         JetExpression left = expression.getLeft();
@@ -259,7 +259,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitThisExpression(JetThisExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitThisExpression(@NotNull JetThisExpression expression, ExpressionTypingContext context) {
         JetType result = null;
         LabelResolver.LabeledReceiverResolutionResult resolutionResult = resolveToReceiver(expression, context, false);
 
@@ -279,7 +279,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitSuperExpression(JetSuperExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitSuperExpression(@NotNull JetSuperExpression expression, ExpressionTypingContext context) {
         LabelResolver.LabeledReceiverResolutionResult resolutionResult = resolveToReceiver(expression, context, true);
 
         if (context.expressionPosition == ExpressionPosition.FREE) {
@@ -438,7 +438,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitBlockExpression(JetBlockExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitBlockExpression(@NotNull JetBlockExpression expression, ExpressionTypingContext context) {
         return visitBlockExpression(expression, context, false);
     }
 
@@ -448,7 +448,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitCallableReferenceExpression(JetCallableReferenceExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitCallableReferenceExpression(@NotNull JetCallableReferenceExpression expression, ExpressionTypingContext context) {
         JetTypeReference typeReference = expression.getTypeReference();
 
         JetType receiverType =
@@ -589,19 +589,19 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitQualifiedExpression(JetQualifiedExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitQualifiedExpression(@NotNull JetQualifiedExpression expression, ExpressionTypingContext context) {
         CallExpressionResolver callExpressionResolver = context.expressionTypingServices.getCallExpressionResolver();
         return callExpressionResolver.getQualifiedExpressionTypeInfo(expression, context);
     }
 
     @Override
-    public JetTypeInfo visitCallExpression(JetCallExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitCallExpression(@NotNull JetCallExpression expression, ExpressionTypingContext context) {
         CallExpressionResolver callExpressionResolver = context.expressionTypingServices.getCallExpressionResolver();
         return callExpressionResolver.getCallExpressionTypeInfo(expression, NO_RECEIVER, null, context);
     }
 
     @Override
-    public JetTypeInfo visitUnaryExpression(JetUnaryExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitUnaryExpression(@NotNull JetUnaryExpression expression, ExpressionTypingContext context) {
         return visitUnaryExpression(expression, context, false);
     }
 
@@ -762,7 +762,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitBinaryExpression(JetBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
+    public JetTypeInfo visitBinaryExpression(@NotNull JetBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
         ExpressionTypingContext context = isBinaryExpressionDependentOnExpectedType(expression)
                 ? contextWithExpectedType
                 : contextWithExpectedType.replaceContextDependency(INDEPENDENT).replaceExpectedType(NO_EXPECTED_TYPE);
@@ -1051,7 +1051,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitArrayAccessExpression(JetArrayAccessExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitArrayAccessExpression(@NotNull JetArrayAccessExpression expression, ExpressionTypingContext context) {
         JetTypeInfo typeInfo = resolveArrayAccessGetMethod(expression, context);
         return DataFlowUtils.checkType(typeInfo, expression, context);
     }
@@ -1106,13 +1106,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitDeclaration(JetDeclaration dcl, ExpressionTypingContext context) {
+    public JetTypeInfo visitDeclaration(@NotNull JetDeclaration dcl, ExpressionTypingContext context) {
         context.trace.report(DECLARATION_IN_ILLEGAL_CONTEXT.on(dcl));
         return JetTypeInfo.create(null, context.dataFlowInfo);
     }
 
     @Override
-    public JetTypeInfo visitRootNamespaceExpression(JetRootNamespaceExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitRootNamespaceExpression(@NotNull JetRootNamespaceExpression expression, ExpressionTypingContext context) {
         if (context.expressionPosition == ExpressionPosition.LHS_OF_DOT) {
             return DataFlowUtils.checkType(JetModuleUtil.getRootNamespaceType(expression), expression, context, context.dataFlowInfo);
         }
@@ -1122,7 +1122,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
 
     @Override
-    public JetTypeInfo visitStringTemplateExpression(JetStringTemplateExpression expression, ExpressionTypingContext contextWithExpectedType) {
+    public JetTypeInfo visitStringTemplateExpression(@NotNull JetStringTemplateExpression expression, ExpressionTypingContext contextWithExpectedType) {
         final ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT);
         final StringBuilder builder = new StringBuilder();
         final boolean[] isCompileTimeValue = new boolean[] { true };
@@ -1168,7 +1168,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitAnnotatedExpression(JetAnnotatedExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitAnnotatedExpression(@NotNull JetAnnotatedExpression expression, ExpressionTypingContext context) {
         return visitAnnotatedExpression(expression, context, false);
     }
 
@@ -1184,7 +1184,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitJetElement(JetElement element, ExpressionTypingContext context) {
+    public JetTypeInfo visitJetElement(@NotNull JetElement element, ExpressionTypingContext context) {
         context.trace.report(UNSUPPORTED.on(element, getClass().getCanonicalName()));
         return JetTypeInfo.create(null, context.dataFlowInfo);
     }

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java

@@ -52,7 +52,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitObjectLiteralExpression(final JetObjectLiteralExpression expression, final ExpressionTypingContext context) {
+    public JetTypeInfo visitObjectLiteralExpression(@NotNull final JetObjectLiteralExpression expression, final ExpressionTypingContext context) {
         DelegatingBindingTrace delegatingBindingTrace = context.trace.get(TRACE_DELTAS_CACHE, expression.getObjectDeclaration());
         if (delegatingBindingTrace != null) {
             delegatingBindingTrace.addAllMyDataTo(context.trace);
@@ -95,7 +95,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitFunctionLiteralExpression(JetFunctionLiteralExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitFunctionLiteralExpression(@NotNull JetFunctionLiteralExpression expression, ExpressionTypingContext context) {
         JetBlockExpression bodyExpression = expression.getFunctionLiteral().getBodyExpression();
         if (bodyExpression == null) return null;
 
@@ -381,7 +381,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
                 new JetTreeVisitor<Collection<JetReturnExpression>>() {
                     @Override
                     public Void visitReturnExpression(
-                            JetReturnExpression expression, Collection<JetReturnExpression> data
+                            @NotNull JetReturnExpression expression, Collection<JetReturnExpression> data
                     ) {
                         data.add(expression);
                         return null;

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingUtils.java

@@ -268,14 +268,14 @@ public class ControlStructureTypingUtils {
             }
 
             @Override
-            public Void visitIfExpression(JetIfExpression ifExpression, CheckTypeContext c) {
+            public Void visitIfExpression(@NotNull JetIfExpression ifExpression, CheckTypeContext c) {
                 checkExpressionType(ifExpression.getThen(), c);
                 checkExpressionType(ifExpression.getElse(), c);
                 return null;
             }
 
             @Override
-            public Void visitBlockExpression(JetBlockExpression expression, CheckTypeContext c) {
+            public Void visitBlockExpression(@NotNull JetBlockExpression expression, CheckTypeContext c) {
                 if (expression.getStatements().isEmpty()) {
                     visitExpression(expression, c);
                     return null;
@@ -288,7 +288,7 @@ public class ControlStructureTypingUtils {
             }
 
             @Override
-            public Void visitPostfixExpression(JetPostfixExpression expression, CheckTypeContext c) {
+            public Void visitPostfixExpression(@NotNull JetPostfixExpression expression, CheckTypeContext c) {
                 if (expression.getOperationReference().getReferencedNameElementType() == JetTokens.EXCLEXCL) {
                     checkExpressionType(expression.getBaseExpression(), c.makeTypeNullable());
                     return null;
@@ -297,7 +297,7 @@ public class ControlStructureTypingUtils {
             }
 
             @Override
-            public Void visitBinaryExpression(JetBinaryExpression expression, CheckTypeContext c) {
+            public Void visitBinaryExpression(@NotNull JetBinaryExpression expression, CheckTypeContext c) {
                 if (expression.getOperationReference().getReferencedNameElementType() == JetTokens.ELVIS) {
                     checkExpressionType(expression.getLeft(), c.makeTypeNullable());
                     checkExpressionType(expression.getRight(), c);
@@ -307,7 +307,7 @@ public class ControlStructureTypingUtils {
             }
 
             @Override
-            public Void visitExpression(JetExpression expression, CheckTypeContext c) {
+            public Void visitExpression(@NotNull JetExpression expression, CheckTypeContext c) {
                 JetTypeInfo typeInfo = BindingContextUtils.getRecordedTypeInfo(expression, c.trace.getBindingContext());
                 if (typeInfo != null) {
                     DataFlowUtils.checkType(typeInfo.getType(), expression, c.expectedType, typeInfo.getDataFlowInfo(), c.trace);

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java

@@ -86,7 +86,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
 
 
     @Override
-    public JetTypeInfo visitIfExpression(JetIfExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitIfExpression(@NotNull JetIfExpression expression, ExpressionTypingContext context) {
         return visitIfExpression(expression, context, false);
     }
 
@@ -180,7 +180,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitWhileExpression(JetWhileExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitWhileExpression(@NotNull JetWhileExpression expression, ExpressionTypingContext context) {
         return visitWhileExpression(expression, context, false);
     }
 
@@ -213,7 +213,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
         //todo breaks in inline function literals
         loopExpression.accept(new JetTreeVisitor<List<JetLoopExpression>>() {
             @Override
-            public Void visitBreakExpression(JetBreakExpression breakExpression, List<JetLoopExpression> outerLoops) {
+            public Void visitBreakExpression(@NotNull JetBreakExpression breakExpression, List<JetLoopExpression> outerLoops) {
                 JetSimpleNameExpression targetLabel = breakExpression.getTargetLabel();
                 PsiElement element = targetLabel != null ? context.trace.get(LABEL_TARGET, targetLabel) : null;
                 if (element == loopExpression || (targetLabel == null && outerLoops.get(outerLoops.size() - 1) == loopExpression)) {
@@ -223,7 +223,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
             }
 
             @Override
-            public Void visitContinueExpression(JetContinueExpression expression, List<JetLoopExpression> outerLoops) {
+            public Void visitContinueExpression(@NotNull JetContinueExpression expression, List<JetLoopExpression> outerLoops) {
                 // continue@someOuterLoop is also considered as break
                 JetSimpleNameExpression targetLabel = expression.getTargetLabel();
                 if (targetLabel != null) {
@@ -236,7 +236,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
             }
 
             @Override
-            public Void visitLoopExpression(JetLoopExpression loopExpression, List<JetLoopExpression> outerLoops) {
+            public Void visitLoopExpression(@NotNull JetLoopExpression loopExpression, List<JetLoopExpression> outerLoops) {
                 List<JetLoopExpression> newOuterLoops = Lists.newArrayList(outerLoops);
                 newOuterLoops.add(loopExpression);
                 return super.visitLoopExpression(loopExpression, newOuterLoops);
@@ -247,7 +247,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitDoWhileExpression(JetDoWhileExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitDoWhileExpression(@NotNull JetDoWhileExpression expression, ExpressionTypingContext context) {
         return visitDoWhileExpression(expression, context, false);
     }
     public JetTypeInfo visitDoWhileExpression(JetDoWhileExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) {
@@ -296,7 +296,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitForExpression(JetForExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitForExpression(@NotNull JetForExpression expression, ExpressionTypingContext context) {
         return visitForExpression(expression, context, false);
     }
 
@@ -453,7 +453,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitTryExpression(JetTryExpression expression, ExpressionTypingContext typingContext) {
+    public JetTypeInfo visitTryExpression(@NotNull JetTryExpression expression, ExpressionTypingContext typingContext) {
         ExpressionTypingContext context = typingContext.replaceContextDependency(INDEPENDENT);
         JetExpression tryBlock = expression.getTryBlock();
         List<JetCatchClause> catchClauses = expression.getCatchClauses();
@@ -500,7 +500,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitThrowExpression(JetThrowExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitThrowExpression(@NotNull JetThrowExpression expression, ExpressionTypingContext context) {
         JetExpression thrownExpression = expression.getThrownExpression();
         if (thrownExpression != null) {
             JetType throwableType = KotlinBuiltIns.getInstance().getThrowable().getDefaultType();
@@ -511,7 +511,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitReturnExpression(JetReturnExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitReturnExpression(@NotNull JetReturnExpression expression, ExpressionTypingContext context) {
         JetElement labelTargetElement = context.labelResolver.resolveLabel(expression, context);
 
         JetExpression returnedExpression = expression.getReturnedExpression();
@@ -583,13 +583,13 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitBreakExpression(JetBreakExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitBreakExpression(@NotNull JetBreakExpression expression, ExpressionTypingContext context) {
         context.labelResolver.resolveLabel(expression, context);
         return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getNothingType(), expression, context, context.dataFlowInfo);
     }
 
     @Override
-    public JetTypeInfo visitContinueExpression(JetContinueExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitContinueExpression(@NotNull JetContinueExpression expression, ExpressionTypingContext context) {
         context.labelResolver.resolveLabel(expression, context);
         return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getNothingType(), expression, context, context.dataFlowInfo);
     }

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java

@@ -144,78 +144,78 @@ public class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTypeInfo, E
     //////////////////////////////////////////////////////////////////////////////////////////////
 
     @Override
-    public JetTypeInfo visitFunctionLiteralExpression(JetFunctionLiteralExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitFunctionLiteralExpression(@NotNull JetFunctionLiteralExpression expression, ExpressionTypingContext data) {
         return expression.accept(closures, data);
     }
 
     @Override
-    public JetTypeInfo visitObjectLiteralExpression(JetObjectLiteralExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitObjectLiteralExpression(@NotNull JetObjectLiteralExpression expression, ExpressionTypingContext data) {
         return expression.accept(closures, data);
     }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
 
     @Override
-    public JetTypeInfo visitThrowExpression(JetThrowExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitThrowExpression(@NotNull JetThrowExpression expression, ExpressionTypingContext data) {
         return expression.accept(controlStructures, data);
     }
 
     @Override
-    public JetTypeInfo visitReturnExpression(JetReturnExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitReturnExpression(@NotNull JetReturnExpression expression, ExpressionTypingContext data) {
         return expression.accept(controlStructures, data);
     }
 
     @Override
-    public JetTypeInfo visitContinueExpression(JetContinueExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitContinueExpression(@NotNull JetContinueExpression expression, ExpressionTypingContext data) {
         return expression.accept(controlStructures, data);
     }
 
     @Override
-    public JetTypeInfo visitIfExpression(JetIfExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitIfExpression(@NotNull JetIfExpression expression, ExpressionTypingContext data) {
         return expression.accept(controlStructures, data);
     }
 
     @Override
-    public JetTypeInfo visitTryExpression(JetTryExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitTryExpression(@NotNull JetTryExpression expression, ExpressionTypingContext data) {
         return expression.accept(controlStructures, data);
     }
 
     @Override
-    public JetTypeInfo visitForExpression(JetForExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitForExpression(@NotNull JetForExpression expression, ExpressionTypingContext data) {
         return expression.accept(controlStructures, data);
     }
 
     @Override
-    public JetTypeInfo visitWhileExpression(JetWhileExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitWhileExpression(@NotNull JetWhileExpression expression, ExpressionTypingContext data) {
         return expression.accept(controlStructures, data);
     }
 
     @Override
-    public JetTypeInfo visitDoWhileExpression(JetDoWhileExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitDoWhileExpression(@NotNull JetDoWhileExpression expression, ExpressionTypingContext data) {
         return expression.accept(controlStructures, data);
     }
 
     @Override
-    public JetTypeInfo visitBreakExpression(JetBreakExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitBreakExpression(@NotNull JetBreakExpression expression, ExpressionTypingContext data) {
         return expression.accept(controlStructures, data);
     }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
 
     @Override
-    public JetTypeInfo visitIsExpression(JetIsExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitIsExpression(@NotNull JetIsExpression expression, ExpressionTypingContext data) {
         return expression.accept(patterns, data);
     }
 
     @Override
-    public JetTypeInfo visitWhenExpression(JetWhenExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitWhenExpression(@NotNull JetWhenExpression expression, ExpressionTypingContext data) {
         return expression.accept(patterns, data);
     }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
 
     @Override
-    public JetTypeInfo visitJetElement(JetElement element, ExpressionTypingContext data) {
+    public JetTypeInfo visitJetElement(@NotNull JetElement element, ExpressionTypingContext data) {
         return element.accept(basic, data);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java

@@ -83,7 +83,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @Override
-    public JetTypeInfo visitObjectDeclaration(JetObjectDeclaration declaration, ExpressionTypingContext context) {
+    public JetTypeInfo visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, ExpressionTypingContext context) {
         TopDownAnalyzer.processClassOrObject(
                 context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), declaration);
         ClassDescriptor classDescriptor = context.trace.getBindingContext().get(BindingContext.CLASS, declaration);
@@ -96,7 +96,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @Override
-    public JetTypeInfo visitProperty(JetProperty property, ExpressionTypingContext typingContext) {
+    public JetTypeInfo visitProperty(@NotNull JetProperty property, ExpressionTypingContext typingContext) {
         ExpressionTypingContext context = typingContext.replaceContextDependency(INDEPENDENT).replaceScope(scope);
         JetTypeReference receiverTypeRef = property.getReceiverTypeRef();
         if (receiverTypeRef != null) {
@@ -144,7 +144,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @Override
-    public JetTypeInfo visitMultiDeclaration(JetMultiDeclaration multiDeclaration, ExpressionTypingContext context) {
+    public JetTypeInfo visitMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration, ExpressionTypingContext context) {
         context.expressionTypingServices.getAnnotationResolver().resolveAnnotationsWithArguments(
                 scope, multiDeclaration.getModifierList(), context.trace);
 
@@ -164,7 +164,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @Override
-    public JetTypeInfo visitNamedFunction(JetNamedFunction function, ExpressionTypingContext context) {
+    public JetTypeInfo visitNamedFunction(@NotNull JetNamedFunction function, ExpressionTypingContext context) {
         SimpleFunctionDescriptor functionDescriptor = context.expressionTypingServices.getDescriptorResolver().
                 resolveFunctionDescriptorWithAnnotationArguments(
                         scope.getContainingDeclaration(), scope, function, context.trace, context.dataFlowInfo);
@@ -181,7 +181,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @Override
-    public JetTypeInfo visitClass(JetClass klass, ExpressionTypingContext context) {
+    public JetTypeInfo visitClass(@NotNull JetClass klass, ExpressionTypingContext context) {
         TopDownAnalyzer.processClassOrObject(
                 context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), klass);
         ClassDescriptor classDescriptor = context.trace.getBindingContext().get(BindingContext.CLASS, klass);
@@ -192,17 +192,17 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @Override
-    public JetTypeInfo visitTypedef(JetTypedef typedef, ExpressionTypingContext context) {
+    public JetTypeInfo visitTypedef(@NotNull JetTypedef typedef, ExpressionTypingContext context) {
         return super.visitTypedef(typedef, context); // TODO
     }
 
     @Override
-    public JetTypeInfo visitDeclaration(JetDeclaration dcl, ExpressionTypingContext context) {
+    public JetTypeInfo visitDeclaration(@NotNull JetDeclaration dcl, ExpressionTypingContext context) {
         return DataFlowUtils.checkStatementType(dcl, context, context.dataFlowInfo);
     }
 
     @Override
-    public JetTypeInfo visitBinaryExpression(JetBinaryExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitBinaryExpression(@NotNull JetBinaryExpression expression, ExpressionTypingContext context) {
         JetSimpleNameExpression operationSign = expression.getOperationReference();
         IElementType operationType = operationSign.getReferencedNameElementType();
         JetTypeInfo result;
@@ -331,28 +331,28 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
 
 
     @Override
-    public JetTypeInfo visitExpression(JetExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitExpression(@NotNull JetExpression expression, ExpressionTypingContext context) {
         return facade.getTypeInfo(expression, context);
     }
 
     @Override
-    public JetTypeInfo visitJetElement(JetElement element, ExpressionTypingContext context) {
+    public JetTypeInfo visitJetElement(@NotNull JetElement element, ExpressionTypingContext context) {
         context.trace.report(UNSUPPORTED.on(element, "in a block"));
         return JetTypeInfo.create(null, context.dataFlowInfo);
     }
 
     @Override
-    public JetTypeInfo visitWhileExpression(JetWhileExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitWhileExpression(@NotNull JetWhileExpression expression, ExpressionTypingContext context) {
         return controlStructures.visitWhileExpression(expression, context, true);
     }
 
     @Override
-    public JetTypeInfo visitDoWhileExpression(JetDoWhileExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitDoWhileExpression(@NotNull JetDoWhileExpression expression, ExpressionTypingContext context) {
         return controlStructures.visitDoWhileExpression(expression, context, true);
     }
 
     @Override
-    public JetTypeInfo visitForExpression(JetForExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitForExpression(@NotNull JetForExpression expression, ExpressionTypingContext context) {
         return controlStructures.visitForExpression(expression, context, true);
     }
 
@@ -364,27 +364,27 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @Override
-    public JetTypeInfo visitIfExpression(JetIfExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitIfExpression(@NotNull JetIfExpression expression, ExpressionTypingContext context) {
         return controlStructures.visitIfExpression(expression, context, true);
     }
 
     @Override
-    public JetTypeInfo visitWhenExpression(JetWhenExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitWhenExpression(@NotNull JetWhenExpression expression, ExpressionTypingContext context) {
         return patterns.visitWhenExpression(expression, context, true);
     }
 
     @Override
-    public JetTypeInfo visitBlockExpression(JetBlockExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitBlockExpression(@NotNull JetBlockExpression expression, ExpressionTypingContext context) {
         return BasicExpressionTypingVisitor.visitBlockExpression(expression, context, true);
     }
 
     @Override
-    public JetTypeInfo visitParenthesizedExpression(JetParenthesizedExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression, ExpressionTypingContext context) {
         return basic.visitParenthesizedExpression(expression, context, true);
     }
 
     @Override
-    public JetTypeInfo visitUnaryExpression(JetUnaryExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitUnaryExpression(@NotNull JetUnaryExpression expression, ExpressionTypingContext context) {
         return basic.visitUnaryExpression(expression, context, true);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java

@@ -48,7 +48,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitIsExpression(JetIsExpression expression, ExpressionTypingContext contextWithExpectedType) {
+    public JetTypeInfo visitIsExpression(@NotNull JetIsExpression expression, ExpressionTypingContext contextWithExpectedType) {
         ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT);
         JetExpression leftHandSide = expression.getLeftHandSide();
         JetTypeInfo typeInfo = facade.safeGetTypeInfo(leftHandSide, context.replaceScope(context.scope));
@@ -65,7 +65,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitWhenExpression(JetWhenExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitWhenExpression(@NotNull JetWhenExpression expression, ExpressionTypingContext context) {
         return visitWhenExpression(expression, context, false);
     }
 

idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java

@@ -429,22 +429,22 @@ public class JetSourceNavigationHelper {
 
     private static class SourceForDecompiledExtractingVisitor extends JetVisitor<JetDeclaration, Void> {
         @Override
-        public JetDeclaration visitNamedFunction(JetNamedFunction function, Void data) {
+        public JetDeclaration visitNamedFunction(@NotNull JetNamedFunction function, Void data) {
             return getSourceFunction(function);
         }
 
         @Override
-        public JetDeclaration visitProperty(JetProperty property, Void data) {
+        public JetDeclaration visitProperty(@NotNull JetProperty property, Void data) {
             return getSourceProperty(property);
         }
 
         @Override
-        public JetDeclaration visitObjectDeclaration(JetObjectDeclaration declaration, Void data) {
+        public JetDeclaration visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, Void data) {
             return getSourceClassOrObject(declaration);
         }
 
         @Override
-        public JetDeclaration visitClass(JetClass klass, Void data) {
+        public JetDeclaration visitClass(@NotNull JetClass klass, Void data) {
             return getSourceClassOrObject(klass);
         }
     }

idea/src/org/jetbrains/jet/plugin/libraries/MemberMatching.java

@@ -70,19 +70,19 @@ public class MemberMatching {
         assert typeElement != null;
         return typeElement.accept(new JetVisitor<String, Void>() {
             @Override
-            public String visitDeclaration(JetDeclaration declaration, Void data) {
+            public String visitDeclaration(@NotNull JetDeclaration declaration, Void data) {
                 throw new IllegalStateException("This visitor shouldn't be invoked for " + declaration.getClass());
             }
 
             @Override
-            public String visitUserType(JetUserType type, Void data) {
+            public String visitUserType(@NotNull JetUserType type, Void data) {
                 JetSimpleNameExpression referenceExpression = type.getReferenceExpression();
                 assert referenceExpression != null;
                 return referenceExpression.getReferencedName();
             }
 
             @Override
-            public String visitFunctionType(JetFunctionType type, Void data) {
+            public String visitFunctionType(@NotNull JetFunctionType type, Void data) {
                 KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance();
                 int parameterCount = type.getParameters().size();
 
@@ -95,7 +95,7 @@ public class MemberMatching {
             }
 
             @Override
-            public String visitNullableType(JetNullableType nullableType, Void data) {
+            public String visitNullableType(@NotNull JetNullableType nullableType, Void data) {
                 return nullableType.getInnerType().accept(this, null);
             }
         }, null);

idea/src/org/jetbrains/jet/plugin/util/JetPsiMatcher.java

@@ -86,12 +86,12 @@ public class JetPsiMatcher {
 
     private static final JetVisitor<Boolean, JetElement> VISITOR = new JetVisitor<Boolean, JetElement>() {
         @Override
-        public Boolean visitJetElement(JetElement element, JetElement data) {
+        public Boolean visitJetElement(@NotNull JetElement element, JetElement data) {
             return false;
         }
 
         @Override
-        public Boolean visitArrayAccessExpression(JetArrayAccessExpression aae1, JetElement data) {
+        public Boolean visitArrayAccessExpression(@NotNull JetArrayAccessExpression aae1, JetElement data) {
             JetArrayAccessExpression aae2 = (JetArrayAccessExpression) data;
 
             return checkElementMatch(aae1.getArrayExpression(), aae2.getArrayExpression()) &&
@@ -99,7 +99,7 @@ public class JetPsiMatcher {
         }
 
         @Override
-        public Boolean visitBinaryExpression(JetBinaryExpression be1, JetElement data) {
+        public Boolean visitBinaryExpression(@NotNull JetBinaryExpression be1, JetElement data) {
             JetBinaryExpression be2 = (JetBinaryExpression) data;
 
             return be1.getOperationToken() == be2.getOperationToken() &&
@@ -108,7 +108,7 @@ public class JetPsiMatcher {
         }
 
         @Override
-        public Boolean visitBinaryWithTypeRHSExpression(JetBinaryExpressionWithTypeRHS bet1, JetElement data) {
+        public Boolean visitBinaryWithTypeRHSExpression(@NotNull JetBinaryExpressionWithTypeRHS bet1, JetElement data) {
             JetBinaryExpressionWithTypeRHS bet2 = (JetBinaryExpressionWithTypeRHS) data;
 
             return checkElementMatch(bet1.getLeft(), bet2.getLeft()) &&
@@ -116,7 +116,7 @@ public class JetPsiMatcher {
         }
 
         @Override
-        public Boolean visitCallExpression(JetCallExpression call1, JetElement data) {
+        public Boolean visitCallExpression(@NotNull JetCallExpression call1, JetElement data) {
             JetCallExpression call2 = (JetCallExpression) data;
 
             if (!checkElementMatch(call1.getCalleeExpression(), call2.getCalleeExpression())) return false;
@@ -126,17 +126,17 @@ public class JetPsiMatcher {
         }
 
         @Override
-        public Boolean visitSimpleNameExpression(JetSimpleNameExpression expression, JetElement data) {
+        public Boolean visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression, JetElement data) {
             return checkIdentifierMatch(expression.getText(), data.getText());
         }
 
         @Override
-        public Boolean visitConstantExpression(JetConstantExpression expression, JetElement data) {
+        public Boolean visitConstantExpression(@NotNull JetConstantExpression expression, JetElement data) {
             return expression.getText().equals(data.getText());
         }
 
         @Override
-        public Boolean visitIsExpression(JetIsExpression is1, JetElement data) {
+        public Boolean visitIsExpression(@NotNull JetIsExpression is1, JetElement data) {
             JetIsExpression is2 = (JetIsExpression) data;
 
             return checkElementMatch(is1.getLeftHandSide(), is2.getLeftHandSide()) &&
@@ -145,7 +145,7 @@ public class JetPsiMatcher {
         }
 
         @Override
-        public Boolean visitQualifiedExpression(JetQualifiedExpression qe1, JetElement data) {
+        public Boolean visitQualifiedExpression(@NotNull JetQualifiedExpression qe1, JetElement data) {
             JetQualifiedExpression qe2 = (JetQualifiedExpression) data;
 
             return qe1.getOperationSign() == qe2.getOperationSign() &&
@@ -154,7 +154,7 @@ public class JetPsiMatcher {
         }
 
         @Override
-        public Boolean visitStringTemplateExpression(JetStringTemplateExpression expression, JetElement data) {
+        public Boolean visitStringTemplateExpression(@NotNull JetStringTemplateExpression expression, JetElement data) {
             return checkListMatch(
                     Arrays.asList(expression.getEntries()),
                     Arrays.asList(((JetStringTemplateExpression) data).getEntries())
@@ -162,22 +162,22 @@ public class JetPsiMatcher {
         }
 
         @Override
-        public Boolean visitStringTemplateEntryWithExpression(JetStringTemplateEntryWithExpression entry, JetElement data) {
+        public Boolean visitStringTemplateEntryWithExpression(@NotNull JetStringTemplateEntryWithExpression entry, JetElement data) {
             return checkElementMatch(entry.getExpression(), ((JetStringTemplateEntryWithExpression) data).getExpression());
         }
 
         @Override
-        public Boolean visitLiteralStringTemplateEntry(JetLiteralStringTemplateEntry entry, JetElement data) {
+        public Boolean visitLiteralStringTemplateEntry(@NotNull JetLiteralStringTemplateEntry entry, JetElement data) {
             return entry.getText().equals(data.getText());
         }
 
         @Override
-        public Boolean visitEscapeStringTemplateEntry(JetEscapeStringTemplateEntry entry, JetElement data) {
+        public Boolean visitEscapeStringTemplateEntry(@NotNull JetEscapeStringTemplateEntry entry, JetElement data) {
             return entry.getText().equals(data.getText());
         }
 
         @Override
-        public Boolean visitSuperExpression(JetSuperExpression super1, JetElement data) {
+        public Boolean visitSuperExpression(@NotNull JetSuperExpression super1, JetElement data) {
             JetSuperExpression super2 = (JetSuperExpression) data;
 
             return checkTypeReferenceMatch(super1.getSuperTypeQualifier(), super2.getSuperTypeQualifier()) &&
@@ -186,17 +186,17 @@ public class JetPsiMatcher {
         }
 
         @Override
-        public Boolean visitThrowExpression(JetThrowExpression expression, JetElement data) {
+        public Boolean visitThrowExpression(@NotNull JetThrowExpression expression, JetElement data) {
             return checkElementMatch(expression.getThrownExpression(), ((JetThrowExpression) data).getThrownExpression());
         }
 
         @Override
-        public Boolean visitThisExpression(JetThisExpression this1, JetElement data) {
+        public Boolean visitThisExpression(@NotNull JetThisExpression this1, JetElement data) {
             return checkElementMatch(this1.getTargetLabel(), ((JetThisExpression) data).getTargetLabel());
         }
 
         @Override
-        public Boolean visitUnaryExpression(JetUnaryExpression ue1, JetElement data) {
+        public Boolean visitUnaryExpression(@NotNull JetUnaryExpression ue1, JetElement data) {
             JetUnaryExpression ue2 = (JetUnaryExpression) data;
 
             return checkElementMatch(ue1.getBaseExpression(), ue2.getBaseExpression()) &&
@@ -204,12 +204,12 @@ public class JetPsiMatcher {
         }
 
         @Override
-        public Boolean visitTypeReference(JetTypeReference typeReference, JetElement data) {
+        public Boolean visitTypeReference(@NotNull JetTypeReference typeReference, JetElement data) {
             return checkElementMatch(typeReference.getTypeElement(), ((JetTypeReference) data).getTypeElement());
         }
 
         @Override
-        public Boolean visitFunctionType(JetFunctionType type1, JetElement data) {
+        public Boolean visitFunctionType(@NotNull JetFunctionType type1, JetElement data) {
             JetFunctionType type2 = (JetFunctionType) data;
 
             return checkElementMatch(type1.getReceiverTypeRef(), type2.getReceiverTypeRef()) &&
@@ -218,7 +218,7 @@ public class JetPsiMatcher {
         }
 
         @Override
-        public Boolean visitUserType(JetUserType type1, JetElement data) {
+        public Boolean visitUserType(@NotNull JetUserType type1, JetElement data) {
             JetUserType type2 = (JetUserType) data;
 
             return checkElementMatch(type1.getReferenceExpression(), type2.getReferenceExpression()) &&
@@ -227,12 +227,12 @@ public class JetPsiMatcher {
         }
 
         @Override
-        public Boolean visitSelfType(JetSelfType type, JetElement data) {
+        public Boolean visitSelfType(@NotNull JetSelfType type, JetElement data) {
             return true;
         }
 
         @Override
-        public Boolean visitNullableType(JetNullableType nullableType, JetElement data) {
+        public Boolean visitNullableType(@NotNull JetNullableType nullableType, JetElement data) {
             return checkElementMatch(nullableType.getInnerType(), ((JetNullableType) data).getInnerType());
         }
     };

js/js.translator/src/org/jetbrains/k2js/translate/declaration/DeclarationBodyVisitor.java

@@ -70,7 +70,7 @@ public class DeclarationBodyVisitor extends TranslatorVisitor<Void> {
 
     @Override
     public Void visitEnumEntry(
-            final JetEnumEntry enumEntry, TranslationContext data
+            @NotNull final JetEnumEntry enumEntry, TranslationContext data
     ) {
         JsExpression jsEnumEntryCreation;
         ClassDescriptor descriptor = getClassDescriptor(data.bindingContext(), enumEntry);
@@ -96,7 +96,7 @@ public class DeclarationBodyVisitor extends TranslatorVisitor<Void> {
 
     @Override
     public Void visitClassObject(
-            JetClassObject classObject, TranslationContext context
+            @NotNull JetClassObject classObject, TranslationContext context
     ) {
         JetObjectDeclaration declaration = classObject.getObjectDeclaration();
         assert declaration != null : "Declaration for class object must be not null";

js/js.translator/src/org/jetbrains/k2js/translate/general/TranslatorVisitor.java

@@ -27,7 +27,7 @@ public class TranslatorVisitor<T> extends JetVisitor<T, TranslationContext> {
 
     @Override
     @NotNull
-    public T visitJetElement(JetElement expression, TranslationContext context) {
+    public T visitJetElement(@NotNull JetElement expression, TranslationContext context) {
         throw new UnsupportedOperationException("Unsupported expression encountered:" + expression.toString());
     }
 

js/js.translator/src/org/jetbrains/k2js/translate/utils/dangerous/FindDangerousVisitor.java

@@ -33,12 +33,12 @@ public final class FindDangerousVisitor extends JetTreeVisitor<DangerousData> {
     }
 
     @Override
-    public Void visitDeclaration(JetDeclaration dcl, DangerousData data) {
+    public Void visitDeclaration(@NotNull JetDeclaration dcl, DangerousData data) {
         return null;
     }
 
     @Override
-    public Void visitJetElement(JetElement element, DangerousData data) {
+    public Void visitJetElement(@NotNull JetElement element, DangerousData data) {
         if (data.exists()) {
             return null;
         }
@@ -46,7 +46,7 @@ public final class FindDangerousVisitor extends JetTreeVisitor<DangerousData> {
     }
 
     @Override
-    public Void visitWhenExpression(JetWhenExpression expression, DangerousData data) {
+    public Void visitWhenExpression(@NotNull JetWhenExpression expression, DangerousData data) {
         if (expressionFound(expression, data)) {
             return null;
         }
@@ -54,7 +54,7 @@ public final class FindDangerousVisitor extends JetTreeVisitor<DangerousData> {
     }
 
     @Override
-    public Void visitIfExpression(JetIfExpression expression, DangerousData data) {
+    public Void visitIfExpression(@NotNull JetIfExpression expression, DangerousData data) {
         if (expressionFound(expression, data)) {
             return null;
         }
@@ -62,7 +62,7 @@ public final class FindDangerousVisitor extends JetTreeVisitor<DangerousData> {
     }
 
     @Override
-    public Void visitBlockExpression(JetBlockExpression expression, DangerousData data) {
+    public Void visitBlockExpression(@NotNull JetBlockExpression expression, DangerousData data) {
         if (isStatement(context.bindingContext(), expression)) {
             return null;
         }
@@ -72,7 +72,7 @@ public final class FindDangerousVisitor extends JetTreeVisitor<DangerousData> {
     }
 
     @Override
-    public Void visitCallExpression(JetCallExpression expression, DangerousData data) {
+    public Void visitCallExpression(@NotNull JetCallExpression expression, DangerousData data) {
         if (InlinedCallExpressionTranslator.shouldBeInlined(expression, context)) {
             if (expressionFound(expression, data)) {
                 return null;

js/js.translator/src/org/jetbrains/k2js/translate/utils/dangerous/FindPreviousVisitor.java

@@ -43,7 +43,7 @@ public final class FindPreviousVisitor extends JetTreeVisitor<DangerousData> {
     }
 
     @Override
-    public Void visitJetElement(JetElement element, DangerousData data) {
+    public Void visitJetElement(@NotNull JetElement element, DangerousData data) {
         if (data.getDangerousNode() == element) {
             return null;
         }