diff --git a/annotations/com/intellij/codeInspection/annotations.xml b/annotations/com/intellij/codeInspection/annotations.xml
new file mode 100644
index 00000000000..88e163e023b
--- /dev/null
+++ b/annotations/com/intellij/codeInspection/annotations.xml
@@ -0,0 +1,10 @@
+<root>
+  <item name='com.intellij.codeInspection.InspectionToolProvider java.lang.Class[] getInspectionClasses()'>
+    <annotation name='jet.runtime.typeinfo.KotlinSignature'>
+      <val name="value" val="&quot;fun getInspectionClasses(): Array&lt;Class&lt;out Any?&gt;&gt;&quot;"/>
+    </annotation>
+  </item>
+  <item name='com.intellij.codeInspection.SuppressIntentionAction EMPTY_ARRAY'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+</root>
\ No newline at end of file
diff --git a/annotations/com/intellij/lang/annotations.xml b/annotations/com/intellij/lang/annotations.xml
new file mode 100644
index 00000000000..f603cab30a6
--- /dev/null
+++ b/annotations/com/intellij/lang/annotations.xml
@@ -0,0 +1,5 @@
+<root>
+  <item name='com.intellij.lang.ASTNode java.lang.String getText()'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+</root>
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java
index f4bf83011f0..a05442b676e 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java
@@ -55,6 +55,7 @@ public class JetPsiFactory {
         return property.getInitializer();
     }
 
+    @NotNull
     public static JetValueArgumentList createCallArguments(Project project, String text) {
         JetProperty property = createProperty(project, "val x = foo" + text);
         JetExpression initializer = property.getInitializer();
@@ -121,6 +122,7 @@ public class JetPsiFactory {
         return Pair.create(functionType.findElementAt(2), functionType.findElementAt(3));
     }
 
+    @NotNull
     public static PsiElement createWhiteSpace(Project project) {
         return createWhiteSpace(project, " ");
     }
@@ -130,6 +132,7 @@ public class JetPsiFactory {
         return property.findElementAt(3);
     }
 
+    @NotNull
     public static PsiElement createNewLine(Project project) {
         return createWhiteSpace(project, "\n");
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetValueArgumentList.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetValueArgumentList.java
index 800fb4fe878..41b46fc5043 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetValueArgumentList.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetValueArgumentList.java
@@ -40,6 +40,7 @@ public class JetValueArgumentList extends JetElementImpl {
         return visitor.visitValueArgumentList(this, data);
     }
 
+    @NotNull
     public List<JetValueArgument> getArguments() {
         return findChildrenByType(JetNodeTypes.VALUE_ARGUMENT);
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java
index 1fdfdaee25c..0ff97c83382 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java
@@ -17,391 +17,392 @@
 package org.jetbrains.jet.lang.psi;
 
 import com.intellij.psi.PsiElementVisitor;
+import org.jetbrains.annotations.NotNull;
 
 public class JetVisitor<R, D> extends PsiElementVisitor {
-    public R visitJetElement(JetElement element, D data) {
+    public R visitJetElement(@NotNull JetElement element, D data) {
         visitElement(element);
         return null;
     }
 
-    public R visitDeclaration(JetDeclaration dcl, D data) {
+    public R visitDeclaration(@NotNull JetDeclaration dcl, D data) {
         return visitExpression(dcl, data);
     }
 
-    public R visitClass(JetClass klass, D data) {
+    public R visitClass(@NotNull JetClass klass, D data) {
         return visitNamedDeclaration(klass, data);
     }
 
-    public R visitClassObject(JetClassObject classObject, D data) {
+    public R visitClassObject(@NotNull JetClassObject classObject, D data) {
         return visitDeclaration(classObject, data);
     }
 
-    public R visitNamedFunction(JetNamedFunction function, D data) {
+    public R visitNamedFunction(@NotNull JetNamedFunction function, D data) {
         return visitNamedDeclaration(function, data);
     }
 
-    public R visitProperty(JetProperty property, D data) {
+    public R visitProperty(@NotNull JetProperty property, D data) {
         return visitNamedDeclaration(property, data);
     }
 
-    public R visitMultiDeclaration(JetMultiDeclaration multiDeclaration, D data) {
+    public R visitMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration, D data) {
         return visitDeclaration(multiDeclaration, data);
     }
 
-    public R visitMultiDeclarationEntry(JetMultiDeclarationEntry multiDeclarationEntry, D data) {
+    public R visitMultiDeclarationEntry(@NotNull JetMultiDeclarationEntry multiDeclarationEntry, D data) {
         return visitNamedDeclaration(multiDeclarationEntry, data);
     }
 
-    public R visitTypedef(JetTypedef typedef, D data) {
+    public R visitTypedef(@NotNull JetTypedef typedef, D data) {
         return visitNamedDeclaration(typedef, data);
     }
 
-    public R visitJetFile(JetFile file, D data) {
+    public R visitJetFile(@NotNull JetFile file, D data) {
         visitFile(file);
         return null;
     }
 
-    public R visitScript(JetScript script, D data) {
+    public R visitScript(@NotNull JetScript script, D data) {
         return visitDeclaration(script, data);
     }
 
-    public R visitImportDirective(JetImportDirective importDirective, D data) {
+    public R visitImportDirective(@NotNull JetImportDirective importDirective, D data) {
         return visitJetElement(importDirective, data);
     }
 
-    public R visitClassBody(JetClassBody classBody, D data) {
+    public R visitClassBody(@NotNull JetClassBody classBody, D data) {
         return visitJetElement(classBody, data);
     }
 
-    public R visitModifierList(JetModifierList list, D data) {
+    public R visitModifierList(@NotNull JetModifierList list, D data) {
         return visitJetElement(list, data);
     }
 
-    public R visitAnnotation(JetAnnotation annotation, D data) {
+    public R visitAnnotation(@NotNull JetAnnotation annotation, D data) {
         return visitJetElement(annotation, data);
     }
 
-    public R visitAnnotationEntry(JetAnnotationEntry annotationEntry, D data) {
+    public R visitAnnotationEntry(@NotNull JetAnnotationEntry annotationEntry, D data) {
         return visitJetElement(annotationEntry, data);
     }
 
-    public R visitTypeParameterList(JetTypeParameterList list, D data) {
+    public R visitTypeParameterList(@NotNull JetTypeParameterList list, D data) {
         return visitJetElement(list, data);
     }
 
-    public R visitTypeParameter(JetTypeParameter parameter, D data) {
+    public R visitTypeParameter(@NotNull JetTypeParameter parameter, D data) {
         return visitNamedDeclaration(parameter, data);
     }
 
-    public R visitEnumEntry(JetEnumEntry enumEntry, D data) {
+    public R visitEnumEntry(@NotNull JetEnumEntry enumEntry, D data) {
         return visitClass(enumEntry, data);
     }
 
-    public R visitParameterList(JetParameterList list, D data) {
+    public R visitParameterList(@NotNull JetParameterList list, D data) {
         return visitJetElement(list, data);
     }
 
-    public R visitParameter(JetParameter parameter, D data) {
+    public R visitParameter(@NotNull JetParameter parameter, D data) {
         return visitNamedDeclaration(parameter, data);
     }
 
-    public R visitDelegationSpecifierList(JetDelegationSpecifierList list, D data) {
+    public R visitDelegationSpecifierList(@NotNull JetDelegationSpecifierList list, D data) {
         return visitJetElement(list, data);
     }
 
-    public R visitDelegationSpecifier(JetDelegationSpecifier specifier, D data) {
+    public R visitDelegationSpecifier(@NotNull JetDelegationSpecifier specifier, D data) {
         return visitJetElement(specifier, data);
     }
 
-    public R visitDelegationByExpressionSpecifier(JetDelegatorByExpressionSpecifier specifier, D data) {
+    public R visitDelegationByExpressionSpecifier(@NotNull JetDelegatorByExpressionSpecifier specifier, D data) {
         return visitDelegationSpecifier(specifier, data);
     }
 
-    public R visitDelegationToSuperCallSpecifier(JetDelegatorToSuperCall call, D data) {
+    public R visitDelegationToSuperCallSpecifier(@NotNull JetDelegatorToSuperCall call, D data) {
         return visitDelegationSpecifier(call, data);
     }
 
-    public R visitDelegationToSuperClassSpecifier(JetDelegatorToSuperClass specifier, D data) {
+    public R visitDelegationToSuperClassSpecifier(@NotNull JetDelegatorToSuperClass specifier, D data) {
         return visitDelegationSpecifier(specifier, data);
     }
 
-    public R visitDelegationToThisCall(JetDelegatorToThisCall thisCall, D data) {
+    public R visitDelegationToThisCall(@NotNull JetDelegatorToThisCall thisCall, D data) {
         return visitDelegationSpecifier(thisCall, data);
     }
 
-    public R visitPropertyDelegate(JetPropertyDelegate delegate, D data) {
+    public R visitPropertyDelegate(@NotNull JetPropertyDelegate delegate, D data) {
         return visitJetElement(delegate, data);
     }
 
-    public R visitTypeReference(JetTypeReference typeReference, D data) {
+    public R visitTypeReference(@NotNull JetTypeReference typeReference, D data) {
         return visitJetElement(typeReference, data);
     }
 
-    public R visitValueArgumentList(JetValueArgumentList list, D data) {
+    public R visitValueArgumentList(@NotNull JetValueArgumentList list, D data) {
         return visitJetElement(list, data);
     }
 
-    public R visitArgument(JetValueArgument argument, D data) {
+    public R visitArgument(@NotNull JetValueArgument argument, D data) {
         return visitJetElement(argument, data);
     }
 
-    public R visitExpression(JetExpression expression, D data) {
+    public R visitExpression(@NotNull JetExpression expression, D data) {
         return visitJetElement(expression, data);
     }
 
-    public R visitLoopExpression(JetLoopExpression loopExpression, D data) {
+    public R visitLoopExpression(@NotNull JetLoopExpression loopExpression, D data) {
         return visitExpression(loopExpression, data);
     }
 
-    public R visitConstantExpression(JetConstantExpression expression, D data) {
+    public R visitConstantExpression(@NotNull JetConstantExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitSimpleNameExpression(JetSimpleNameExpression expression, D data) {
+    public R visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression, D data) {
         return visitReferenceExpression(expression, data);
     }
 
-    public R visitReferenceExpression(JetReferenceExpression expression, D data) {
+    public R visitReferenceExpression(@NotNull JetReferenceExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitPrefixExpression(JetPrefixExpression expression, D data) {
+    public R visitPrefixExpression(@NotNull JetPrefixExpression expression, D data) {
         return visitUnaryExpression(expression, data);
     }
 
-    public R visitPostfixExpression(JetPostfixExpression expression, D data) {
+    public R visitPostfixExpression(@NotNull JetPostfixExpression expression, D data) {
         return visitUnaryExpression(expression, data);
     }
 
-    public R visitUnaryExpression(JetUnaryExpression expression, D data) {
+    public R visitUnaryExpression(@NotNull JetUnaryExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitBinaryExpression(JetBinaryExpression expression, D data) {
+    public R visitBinaryExpression(@NotNull JetBinaryExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-//    public R visitNewExpression(JetNewExpression expression, D data) {
+//    public R visitNewExpression(@NotNull JetNewExpression expression, D data) {
 //        return visitExpression(expression, data);
 //    }
 //
-    public R visitReturnExpression(JetReturnExpression expression, D data) {
+    public R visitReturnExpression(@NotNull JetReturnExpression expression, D data) {
         return visitLabelQualifiedExpression(expression, data);
     }
 
-    public R visitLabelQualifiedExpression(JetLabelQualifiedExpression expression, D data) {
+    public R visitLabelQualifiedExpression(@NotNull JetLabelQualifiedExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitThrowExpression(JetThrowExpression expression, D data) {
+    public R visitThrowExpression(@NotNull JetThrowExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitBreakExpression(JetBreakExpression expression, D data) {
+    public R visitBreakExpression(@NotNull JetBreakExpression expression, D data) {
         return visitLabelQualifiedExpression(expression, data);
     }
 
-    public R visitContinueExpression(JetContinueExpression expression, D data) {
+    public R visitContinueExpression(@NotNull JetContinueExpression expression, D data) {
         return visitLabelQualifiedExpression(expression, data);
     }
 
-    public R visitIfExpression(JetIfExpression expression, D data) {
+    public R visitIfExpression(@NotNull JetIfExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitWhenExpression(JetWhenExpression expression, D data) {
+    public R visitWhenExpression(@NotNull JetWhenExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitTryExpression(JetTryExpression expression, D data) {
+    public R visitTryExpression(@NotNull JetTryExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitForExpression(JetForExpression expression, D data) {
+    public R visitForExpression(@NotNull JetForExpression expression, D data) {
         return visitLoopExpression(expression, data);
     }
 
-    public R visitWhileExpression(JetWhileExpression expression, D data) {
+    public R visitWhileExpression(@NotNull JetWhileExpression expression, D data) {
         return visitLoopExpression(expression, data);
     }
 
-    public R visitDoWhileExpression(JetDoWhileExpression expression, D data) {
+    public R visitDoWhileExpression(@NotNull JetDoWhileExpression expression, D data) {
         return visitLoopExpression(expression, data);
     }
 
-    public R visitFunctionLiteralExpression(JetFunctionLiteralExpression expression, D data) {
+    public R visitFunctionLiteralExpression(@NotNull JetFunctionLiteralExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitAnnotatedExpression(JetAnnotatedExpression expression, D data) {
+    public R visitAnnotatedExpression(@NotNull JetAnnotatedExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitCallExpression(JetCallExpression expression, D data) {
+    public R visitCallExpression(@NotNull JetCallExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitArrayAccessExpression(JetArrayAccessExpression expression, D data) {
+    public R visitArrayAccessExpression(@NotNull JetArrayAccessExpression expression, D data) {
         return visitReferenceExpression(expression, data);
     }
 
-    public R visitQualifiedExpression(JetQualifiedExpression expression, D data) {
+    public R visitQualifiedExpression(@NotNull JetQualifiedExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitCallableReferenceExpression(JetCallableReferenceExpression expression, D data) {
+    public R visitCallableReferenceExpression(@NotNull JetCallableReferenceExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitDotQualifiedExpression(JetDotQualifiedExpression expression, D data) {
+    public R visitDotQualifiedExpression(@NotNull JetDotQualifiedExpression expression, D data) {
         return visitQualifiedExpression(expression, data);
     }
 
-    public R visitSafeQualifiedExpression(JetSafeQualifiedExpression expression, D data) {
+    public R visitSafeQualifiedExpression(@NotNull JetSafeQualifiedExpression expression, D data) {
         return visitQualifiedExpression(expression, data);
     }
 
-    public R visitObjectLiteralExpression(JetObjectLiteralExpression expression, D data) {
+    public R visitObjectLiteralExpression(@NotNull JetObjectLiteralExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitRootNamespaceExpression(JetRootNamespaceExpression expression, D data) {
+    public R visitRootNamespaceExpression(@NotNull JetRootNamespaceExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitBlockExpression(JetBlockExpression expression, D data) {
+    public R visitBlockExpression(@NotNull JetBlockExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitCatchSection(JetCatchClause catchClause, D data) {
+    public R visitCatchSection(@NotNull JetCatchClause catchClause, D data) {
         return visitJetElement(catchClause, data);
     }
 
-    public R visitFinallySection(JetFinallySection finallySection, D data) {
+    public R visitFinallySection(@NotNull JetFinallySection finallySection, D data) {
         return visitJetElement(finallySection, data);
     }
 
-    public R visitTypeArgumentList(JetTypeArgumentList typeArgumentList, D data) {
+    public R visitTypeArgumentList(@NotNull JetTypeArgumentList typeArgumentList, D data) {
         return visitJetElement(typeArgumentList, data);
     }
 
-    public R visitThisExpression(JetThisExpression expression, D data) {
+    public R visitThisExpression(@NotNull JetThisExpression expression, D data) {
         return visitLabelQualifiedExpression(expression, data);
     }
 
-    public R visitSuperExpression(JetSuperExpression expression, D data) {
+    public R visitSuperExpression(@NotNull JetSuperExpression expression, D data) {
         return visitLabelQualifiedExpression(expression, data);
     }
 
-    public R visitParenthesizedExpression(JetParenthesizedExpression expression, D data) {
+    public R visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitInitializerList(JetInitializerList list, D data) {
+    public R visitInitializerList(@NotNull JetInitializerList list, D data) {
         return visitJetElement(list, data);
     }
 
-    public R visitAnonymousInitializer(JetClassInitializer initializer, D data) {
+    public R visitAnonymousInitializer(@NotNull JetClassInitializer initializer, D data) {
         return visitDeclaration(initializer, data);
     }
 
-    public R visitPropertyAccessor(JetPropertyAccessor accessor, D data) {
+    public R visitPropertyAccessor(@NotNull JetPropertyAccessor accessor, D data) {
         return visitDeclaration(accessor, data);
     }
 
-    public R visitTypeConstraintList(JetTypeConstraintList list, D data) {
+    public R visitTypeConstraintList(@NotNull JetTypeConstraintList list, D data) {
         return visitJetElement(list, data);
     }
 
-    public R visitTypeConstraint(JetTypeConstraint constraint, D data) {
+    public R visitTypeConstraint(@NotNull JetTypeConstraint constraint, D data) {
         return visitJetElement(constraint, data);
     }
 
-    private R visitTypeElement(JetTypeElement type, D data) {
+    private R visitTypeElement(@NotNull JetTypeElement type, D data) {
         return visitJetElement(type, data);
     }
 
-    public R visitUserType(JetUserType type, D data) {
+    public R visitUserType(@NotNull JetUserType type, D data) {
         return visitTypeElement(type, data);
     }
 
-    public R visitFunctionType(JetFunctionType type, D data) {
+    public R visitFunctionType(@NotNull JetFunctionType type, D data) {
         return visitTypeElement(type, data);
     }
 
-    public R visitSelfType(JetSelfType type, D data) {
+    public R visitSelfType(@NotNull JetSelfType type, D data) {
         return visitTypeElement(type, data);
     }
 
-    public R visitBinaryWithTypeRHSExpression(JetBinaryExpressionWithTypeRHS expression, D data) {
+    public R visitBinaryWithTypeRHSExpression(@NotNull JetBinaryExpressionWithTypeRHS expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitStringTemplateExpression(JetStringTemplateExpression expression, D data) {
+    public R visitStringTemplateExpression(@NotNull JetStringTemplateExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitNamedDeclaration(JetNamedDeclaration declaration, D data) {
+    public R visitNamedDeclaration(@NotNull JetNamedDeclaration declaration, D data) {
         return visitDeclaration(declaration, data);
     }
 
-    public R visitNullableType(JetNullableType nullableType, D data) {
+    public R visitNullableType(@NotNull JetNullableType nullableType, D data) {
         return visitTypeElement(nullableType, data);
     }
 
-    public R visitTypeProjection(JetTypeProjection typeProjection, D data) {
+    public R visitTypeProjection(@NotNull JetTypeProjection typeProjection, D data) {
         return visitJetElement(typeProjection, data);
     }
 
-    public R visitWhenEntry(JetWhenEntry jetWhenEntry, D data) {
+    public R visitWhenEntry(@NotNull JetWhenEntry jetWhenEntry, D data) {
         return visitJetElement(jetWhenEntry, data);
     }
 
-    public R visitIsExpression(JetIsExpression expression, D data) {
+    public R visitIsExpression(@NotNull JetIsExpression expression, D data) {
         return visitExpression(expression, data);
     }
 
-    public R visitWhenConditionIsPattern(JetWhenConditionIsPattern condition, D data) {
+    public R visitWhenConditionIsPattern(@NotNull JetWhenConditionIsPattern condition, D data) {
         return visitJetElement(condition, data);
     }
 
-    public R visitWhenConditionInRange(JetWhenConditionInRange condition, D data) {
+    public R visitWhenConditionInRange(@NotNull JetWhenConditionInRange condition, D data) {
         return visitJetElement(condition, data);
     }
     
-    public R visitWhenConditionExpression(JetWhenConditionWithExpression condition, D data) {
+    public R visitWhenConditionExpression(@NotNull JetWhenConditionWithExpression condition, D data) {
         return visitJetElement(condition, data);
     }
 
-    public R visitObjectDeclaration(JetObjectDeclaration declaration, D data) {
+    public R visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, D data) {
         return visitNamedDeclaration(declaration, data);
     }
     
-    public R visitObjectDeclarationName(JetObjectDeclarationName declarationName, D data) {
+    public R visitObjectDeclarationName(@NotNull JetObjectDeclarationName declarationName, D data) {
         return visitNamedDeclaration(declarationName, data);
     }
 
-    public R visitStringTemplateEntry(JetStringTemplateEntry entry, D data) {
+    public R visitStringTemplateEntry(@NotNull JetStringTemplateEntry entry, D data) {
         return visitJetElement(entry, data);
     }
 
-    public R visitStringTemplateEntryWithExpression(JetStringTemplateEntryWithExpression entry, D data) {
+    public R visitStringTemplateEntryWithExpression(@NotNull JetStringTemplateEntryWithExpression entry, D data) {
         return visitStringTemplateEntry(entry, data);
     }
 
-    public R visitBlockStringTemplateEntry(JetBlockStringTemplateEntry entry, D data) {
+    public R visitBlockStringTemplateEntry(@NotNull JetBlockStringTemplateEntry entry, D data) {
         return visitStringTemplateEntryWithExpression(entry, data);
     }
 
-    public R visitSimpleNameStringTemplateEntry(JetSimpleNameStringTemplateEntry entry, D data) {
+    public R visitSimpleNameStringTemplateEntry(@NotNull JetSimpleNameStringTemplateEntry entry, D data) {
         return visitStringTemplateEntryWithExpression(entry, data);
     }
 
-    public R visitLiteralStringTemplateEntry(JetLiteralStringTemplateEntry entry, D data) {
+    public R visitLiteralStringTemplateEntry(@NotNull JetLiteralStringTemplateEntry entry, D data) {
         return visitStringTemplateEntry(entry, data);
     }
 
-    public R visitEscapeStringTemplateEntry(JetEscapeStringTemplateEntry entry, D data) {
+    public R visitEscapeStringTemplateEntry(@NotNull JetEscapeStringTemplateEntry entry, D data) {
         return visitStringTemplateEntry(entry, data);
     }
 }
diff --git a/idea/src/org/jetbrains/jet/plugin/JetBundle.java b/idea/src/org/jetbrains/jet/plugin/JetBundle.java
index 80ebe6c13ed..03f19a89c40 100644
--- a/idea/src/org/jetbrains/jet/plugin/JetBundle.java
+++ b/idea/src/org/jetbrains/jet/plugin/JetBundle.java
@@ -18,6 +18,7 @@ package org.jetbrains.jet.plugin;
 
 import com.intellij.CommonBundle;
 import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.PropertyKey;
 
 import java.lang.ref.Reference;
@@ -33,6 +34,7 @@ public class JetBundle {
     private JetBundle() {
     }
 
+    @NotNull
     public static String message(@NonNls @PropertyKey(resourceBundle = BUNDLE)String key, Object... params) {
       return CommonBundle.message(getBundle(), key, params);
     }
diff --git a/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java b/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java
index b7e363cc62c..26fd05c926d 100644
--- a/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java
+++ b/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java
@@ -80,6 +80,7 @@ public final class AnalyzerFacadeWithCache {
         }
     }
 
+    @NotNull
     public static BindingContext getContextForElement(@NotNull JetElement jetElement) {
         CancelableResolveSession cancelableResolveSession = getLazyResolveSessionForFile((JetFile) jetElement.getContainingFile());
         return cancelableResolveSession.resolveToElement(jetElement);
diff --git a/idea/src/org/jetbrains/jet/plugin/project/CancelableResolveSession.java b/idea/src/org/jetbrains/jet/plugin/project/CancelableResolveSession.java
index 1f60db7837b..e752b807f32 100644
--- a/idea/src/org/jetbrains/jet/plugin/project/CancelableResolveSession.java
+++ b/idea/src/org/jetbrains/jet/plugin/project/CancelableResolveSession.java
@@ -58,6 +58,7 @@ public class CancelableResolveSession implements KotlinCodeAnalyzer, Modificatio
         this.resolveElementCache = new ResolveElementCache(resolveSession, project);
     }
 
+    @NotNull
     public BindingContext resolveToElement(final JetElement element) {
         return computableWithProcessingCancel(new Computable<BindingContext>() {
             @Override