From 1948fb4c3653ecec63dc4c0325240abf214b475c Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Fri, 20 Sep 2013 15:43:25 +0400 Subject: [PATCH] @Nullable/@NotNull added to various classes --- .../intellij/codeInspection/annotations.xml | 10 + annotations/com/intellij/lang/annotations.xml | 5 + .../jetbrains/jet/lang/psi/JetPsiFactory.java | 3 + .../jet/lang/psi/JetValueArgumentList.java | 1 + .../jetbrains/jet/lang/psi/JetVisitor.java | 193 +++++++++--------- .../org/jetbrains/jet/plugin/JetBundle.java | 2 + .../project/AnalyzerFacadeWithCache.java | 1 + .../project/CancelableResolveSession.java | 1 + 8 files changed, 120 insertions(+), 96 deletions(-) create mode 100644 annotations/com/intellij/codeInspection/annotations.xml create mode 100644 annotations/com/intellij/lang/annotations.xml 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 @@ + + + + + + + + + + \ 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 @@ + + + + + \ 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 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 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() { @Override