From 4644858b11084e56ef1fcb56eb1bc79a6806cfa6 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Mon, 23 Sep 2013 15:54:31 +0400 Subject: [PATCH] @NotNull propagated to JetVisitor implementations --- .../jet/codegen/CodegenStatementVisitor.java | 9 +-- .../jet/codegen/ExpressionCodegen.java | 72 +++++++++---------- .../TypeTransformingVisitor.java | 8 +-- .../jet/lang/psi/JetTreeVisitor.java | 4 +- .../jet/lang/resolve/AnnotationResolver.java | 15 ++-- .../lang/resolve/calls/CandidateResolver.java | 12 ++-- .../jet/lang/resolve/lazy/ResolveSession.java | 18 ++--- .../BasicExpressionTypingVisitor.java | 36 +++++----- .../ClosureExpressionsTypingVisitor.java | 6 +- .../ControlStructureTypingUtils.java | 10 +-- .../ControlStructureTypingVisitor.java | 24 +++---- .../ExpressionTypingVisitorDispatcher.java | 28 ++++---- .../ExpressionTypingVisitorForStatements.java | 36 +++++----- .../PatternMatchingTypingVisitor.java | 4 +- .../libraries/JetSourceNavigationHelper.java | 8 +-- .../jet/plugin/libraries/MemberMatching.java | 8 +-- .../jet/plugin/util/JetPsiMatcher.java | 44 ++++++------ .../declaration/DeclarationBodyVisitor.java | 4 +- .../translate/general/TranslatorVisitor.java | 2 +- .../utils/dangerous/FindDangerousVisitor.java | 12 ++-- .../utils/dangerous/FindPreviousVisitor.java | 2 +- 21 files changed, 183 insertions(+), 179 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenStatementVisitor.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenStatementVisitor.java index 512674aa5ac..e559f87fb04 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenStatementVisitor.java +++ b/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 { @@ -26,22 +27,22 @@ public class CodegenStatementVisitor extends JetVisitor } @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); } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 0daeccde04d..92dd75e06a8 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -279,7 +279,7 @@ public class ExpressionCodegen extends JetVisitor 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 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 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 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 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 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 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 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 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 implem } @Override - public StackValue visitBlockExpression(JetBlockExpression expression, StackValue receiver) { + public StackValue visitBlockExpression(@NotNull JetBlockExpression expression, StackValue receiver) { List 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 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 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 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 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 implem } @Override - public StackValue visitSimpleNameExpression(JetSimpleNameExpression expression, StackValue receiver) { + public StackValue visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression, StackValue receiver) { ResolvedCall resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, expression); DeclarationDescriptor descriptor; @@ -1877,7 +1877,7 @@ public class ExpressionCodegen extends JetVisitor 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 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 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 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 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 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 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 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 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 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 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); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java index 9b37cf8865d..53db74e9e42 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java @@ -72,7 +72,7 @@ public class TypeTransformingVisitor extends JetVisitor { } @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 { } @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 { } @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"); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTreeVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTreeVisitor.java index a20c313cd6a..0b61c5b65a4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTreeVisitor.java +++ b/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 extends JetVisitor { @Override - public Void visitJetElement(JetElement element, D data) { + public Void visitJetElement(@NotNull JetElement element, D data) { element.acceptChildren(this, data); return null; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java index dad93e92178..9559a636b97 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java @@ -255,7 +255,7 @@ public class AnnotationResolver { ) { JetVisitor, Void> visitor = new JetVisitor, 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 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 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; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java index c1021b179b2..1dd3020ab3c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java +++ b/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); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java index 9ac7bdd145f..f8758c78175 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java +++ b/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() { @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)); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java index 02241b6b24b..282f338f6fc 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java +++ b/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); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java index 21d91d38c35..fbad40619d3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java +++ b/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>() { @Override public Void visitReturnExpression( - JetReturnExpression expression, Collection data + @NotNull JetReturnExpression expression, Collection data ) { data.add(expression); return null; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingUtils.java index 780617b78af..a2f7488699f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingUtils.java +++ b/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); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java index b6624d54df7..a9a1aaccbc2 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java +++ b/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>() { @Override - public Void visitBreakExpression(JetBreakExpression breakExpression, List outerLoops) { + public Void visitBreakExpression(@NotNull JetBreakExpression breakExpression, List 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 outerLoops) { + public Void visitContinueExpression(@NotNull JetContinueExpression expression, List 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 outerLoops) { + public Void visitLoopExpression(@NotNull JetLoopExpression loopExpression, List outerLoops) { List 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 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); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java index 43ae649fb79..0dff98efcf2 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java @@ -144,78 +144,78 @@ public class ExpressionTypingVisitorDispatcher extends JetVisitor { @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); } } diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/MemberMatching.java b/idea/src/org/jetbrains/jet/plugin/libraries/MemberMatching.java index 22b92fa7b66..bfd8d63c98a 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/MemberMatching.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/MemberMatching.java @@ -70,19 +70,19 @@ public class MemberMatching { assert typeElement != null; return typeElement.accept(new JetVisitor() { @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); diff --git a/idea/src/org/jetbrains/jet/plugin/util/JetPsiMatcher.java b/idea/src/org/jetbrains/jet/plugin/util/JetPsiMatcher.java index e23bfcb1d25..41e7d80ac98 100644 --- a/idea/src/org/jetbrains/jet/plugin/util/JetPsiMatcher.java +++ b/idea/src/org/jetbrains/jet/plugin/util/JetPsiMatcher.java @@ -86,12 +86,12 @@ public class JetPsiMatcher { private static final JetVisitor VISITOR = new JetVisitor() { @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()); } }; diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/declaration/DeclarationBodyVisitor.java b/js/js.translator/src/org/jetbrains/k2js/translate/declaration/DeclarationBodyVisitor.java index 51de8164615..28703d43ff8 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/declaration/DeclarationBodyVisitor.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/declaration/DeclarationBodyVisitor.java @@ -70,7 +70,7 @@ public class DeclarationBodyVisitor extends TranslatorVisitor { @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 { @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"; diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/general/TranslatorVisitor.java b/js/js.translator/src/org/jetbrains/k2js/translate/general/TranslatorVisitor.java index 646280873e8..04a0e34b87c 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/general/TranslatorVisitor.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/general/TranslatorVisitor.java @@ -27,7 +27,7 @@ public class TranslatorVisitor extends JetVisitor { @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()); } diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/utils/dangerous/FindDangerousVisitor.java b/js/js.translator/src/org/jetbrains/k2js/translate/utils/dangerous/FindDangerousVisitor.java index 4359c0f1a43..7d44c81f674 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/utils/dangerous/FindDangerousVisitor.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/utils/dangerous/FindDangerousVisitor.java @@ -33,12 +33,12 @@ public final class FindDangerousVisitor extends JetTreeVisitor { } @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 { } @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 { } @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 { } @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 { } @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; diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/utils/dangerous/FindPreviousVisitor.java b/js/js.translator/src/org/jetbrains/k2js/translate/utils/dangerous/FindPreviousVisitor.java index 43b2afa02a7..58fb1fa3aae 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/utils/dangerous/FindPreviousVisitor.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/utils/dangerous/FindPreviousVisitor.java @@ -43,7 +43,7 @@ public final class FindPreviousVisitor extends JetTreeVisitor { } @Override - public Void visitJetElement(JetElement element, DangerousData data) { + public Void visitJetElement(@NotNull JetElement element, DangerousData data) { if (data.getDangerousNode() == element) { return null; }