From b40fe9d5bab0db8ca1ade525aaabc6c94d189f78 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Tue, 21 Apr 2015 18:26:26 +0300 Subject: [PATCH] Refactoring: TypeInfoFactory.createTypeInfo() without type -> noTypeInfo(), getNotNullType -> getTypeNotNull, nullability refined, style fixes --- .../kotlin/resolve/BindingContextUtils.java | 4 +-- .../kotlin/resolve/BindingContextUtils.kt | 5 +-- .../resolve/calls/ArgumentTypeResolver.java | 2 +- .../resolve/calls/CallExpressionResolver.java | 10 +++--- .../kotlin/resolve/calls/util/callUtil.kt | 4 +-- .../BasicExpressionTypingVisitor.java | 35 ++++++++++--------- .../ControlStructureTypingVisitor.java | 15 ++++---- .../types/expressions/DataFlowUtils.java | 2 +- .../expressions/ExpressionTypingServices.java | 4 +-- .../expressions/ExpressionTypingUtils.java | 2 +- .../ExpressionTypingVisitorDispatcher.java | 12 ++++--- .../ExpressionTypingVisitorForStatements.java | 24 ++++++------- .../expressions/FunctionsTypingVisitor.kt | 1 + .../PatternMatchingTypingVisitor.java | 5 +-- .../types/expressions/TypeInfoFactory.kt | 18 +++++----- .../expression/ExpressionVisitor.java | 2 +- .../operation/UnaryOperationTranslator.java | 2 +- .../js/translate/utils/BindingUtils.java | 2 +- 18 files changed, 78 insertions(+), 71 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java index d59d0f1dd28..3b4850f6bb9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java @@ -82,7 +82,7 @@ public class BindingContextUtils { } @NotNull - public static JetType getNotNullType( + public static JetType getTypeNotNull( @NotNull BindingContext bindingContext, @NotNull JetExpression expression ) { @@ -160,7 +160,7 @@ public class BindingContextUtils { // NB: should never return null if expression is already processed if (!Boolean.TRUE.equals(context.get(BindingContext.PROCESSED, expression))) return null; JetTypeInfo result = context.get(BindingContext.EXPRESSION_TYPE_INFO, expression); - return result != null ? result : TypeInfoFactoryPackage.createTypeInfo(DataFlowInfo.EMPTY); + return result != null ? result : TypeInfoFactoryPackage.noTypeInfo(DataFlowInfo.EMPTY); } public static boolean isExpressionWithValidReference( diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.kt index 73727214c73..3accfe40761 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.kt @@ -31,7 +31,7 @@ import org.jetbrains.kotlin.psi.JetExpression import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext -import org.jetbrains.kotlin.types.expressions.typeInfoFactory.createTypeInfo +import org.jetbrains.kotlin.types.expressions.typeInfoFactory.noTypeInfo public fun JetReturnExpression.getTargetFunctionDescriptor(context: BindingContext): FunctionDescriptor? { val targetLabel = getTargetLabel() @@ -63,7 +63,8 @@ public fun > ResolutionContext.recordScopeAndDataFlo trace.record(BindingContext.EXPRESSION_TYPE_INFO, expression, typeInfo.replaceDataFlowInfo(dataFlowInfo)) } else if (dataFlowInfo != DataFlowInfo.EMPTY) { - trace.record(BindingContext.EXPRESSION_TYPE_INFO, expression, createTypeInfo(dataFlowInfo)) + // Don't store anything in BindingTrace if it's simply an empty DataFlowInfo + trace.record(BindingContext.EXPRESSION_TYPE_INFO, expression, noTypeInfo(dataFlowInfo)) } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java index 1d846ff5b0f..972f399856a 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java @@ -192,7 +192,7 @@ public class ArgumentTypeResolver { @NotNull ResolveArgumentsMode resolveArgumentsMode ) { if (expression == null) { - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } if (isFunctionLiteralArgument(expression, context)) { return getFunctionLiteralTypeInfo(expression, getFunctionLiteralArgument(expression, context), context, resolveArgumentsMode); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java index 90bfb663562..1fc5ed8b9b2 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java @@ -158,7 +158,7 @@ public class CallExpressionResolver { } temporaryForVariable.commit(); - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } @NotNull @@ -201,7 +201,7 @@ public class CallExpressionResolver { context.trace.report(FUNCTION_CALL_EXPECTED.on(callExpression, callExpression, hasValueParameters)); } if (functionDescriptor == null) { - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } if (functionDescriptor instanceof ConstructorDescriptor && DescriptorUtils.isAnnotationClass(functionDescriptor.getContainingDeclaration())) { @@ -226,11 +226,11 @@ public class CallExpressionResolver { temporaryForVariable.commit(); context.trace.report(FUNCTION_EXPECTED.on(calleeExpression, calleeExpression, type != null ? type : ErrorUtils.createErrorType(""))); - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } } temporaryForFunction.commit(); - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } private static boolean canInstantiateAnnotationClass(@NotNull JetCallExpression expression) { @@ -265,7 +265,7 @@ public class CallExpressionResolver { else if (selectorExpression != null) { context.trace.report(ILLEGAL_SELECTOR.on(selectorExpression, selectorExpression.getText())); } - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } /** diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt index 9dbc99d7d60..b3bc155dcc4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt @@ -66,7 +66,7 @@ public fun ResolvedCall.getParameterForArgument(valu // call public fun > Call.hasUnresolvedArguments(context: ResolutionContext): Boolean { - val arguments = getValueArguments().map { it?.getArgumentExpression() } + val arguments = getValueArguments().map { it.getArgumentExpression() } return arguments.any { argument -> val expressionType = argument?.let { context.trace.getBindingContext().getType(it) } @@ -135,7 +135,7 @@ public fun JetElement.getCall(context: BindingContext): Call? { } public fun JetElement.getParentCall(context: BindingContext, strict: Boolean = true): Call? { - val callExpressionTypes = array?>( + val callExpressionTypes = arrayOf?>( javaClass(), javaClass(), javaClass(), javaClass(), javaClass()) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java index 0c0742291c0..ccbf06ea810 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java @@ -111,7 +111,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { public JetTypeInfo visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression, ExpressionTypingContext context) { JetExpression innerExpression = expression.getExpression(); if (innerExpression == null) { - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } return facade.getTypeInfo(innerExpression, context.replaceScope(context.scope)); } @@ -287,7 +287,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (superTypeQualifier != null) { components.expressionTypingServices.getTypeResolver().resolveType(context.scope, superTypeQualifier, context.trace, true); } - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } private JetType checkPossiblyQualifiedSuper( @@ -812,7 +812,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { : contextWithExpectedType.replaceContextDependency(INDEPENDENT).replaceExpectedType(NO_EXPECTED_TYPE); JetExpression baseExpression = expression.getBaseExpression(); - if (baseExpression == null) return TypeInfoFactoryPackage.createTypeInfo(context); + if (baseExpression == null) return TypeInfoFactoryPackage.noTypeInfo(context); JetSimpleNameExpression operationSign = expression.getOperationReference(); @@ -953,7 +953,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { boolean isStatement ) { JetExpression baseExpression = expression.getBaseExpression(); - if (baseExpression == null) return TypeInfoFactoryPackage.createTypeInfo(context); + if (baseExpression == null) return TypeInfoFactoryPackage.noTypeInfo(context); return facade.getTypeInfo(baseExpression, context, isStatement); } @@ -1079,7 +1079,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } else { context.trace.report(UNSUPPORTED.on(operationSign, "Unknown operation")); - result = TypeInfoFactoryPackage.createTypeInfo(context); + result = TypeInfoFactoryPackage.noTypeInfo(context); } CompileTimeConstant value = ConstantExpressionEvaluator.evaluate( expression, contextWithExpectedType.trace, contextWithExpectedType.expectedType @@ -1222,7 +1222,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (left == null || right == null) { getTypeInfoOrNullType(left, context, facade); - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } Call call = createCallForSpecialConstruction(expression, expression.getOperationReference(), Lists.newArrayList(left, right)); @@ -1245,7 +1245,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { dataFlowInfo = dataFlowInfo.disequate(value, DataFlowValue.NULL); } JetType type = resolvedCall.getResultingDescriptor().getReturnType(); - if (type == null || rightType == null) return TypeInfoFactoryPackage.createTypeInfo(dataFlowInfo); + if (type == null || rightType == null) return TypeInfoFactoryPackage.noTypeInfo(dataFlowInfo); // Sometimes return type for special call for elvis operator might be nullable, // but result is not nullable if the right type is not nullable @@ -1255,6 +1255,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (context.contextDependency == DEPENDENT) { return TypeInfoFactoryPackage.createTypeInfo(type, dataFlowInfo); } + + // If break or continue was possible, take condition check info as the jump info return TypeInfoFactoryPackage.createTypeInfo(DataFlowUtils.checkType(type, expression, context), dataFlowInfo, loopBreakContinuePossible, @@ -1273,7 +1275,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { ExpressionTypingContext contextWithNoExpectedType = context.replaceExpectedType(NO_EXPECTED_TYPE); if (right == null) { if (left != null) facade.getTypeInfo(left, contextWithNoExpectedType); - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } JetTypeInfo rightTypeInfo = facade.getTypeInfo(right, contextWithNoExpectedType); @@ -1350,7 +1352,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { private JetTypeInfo assignmentIsNotAnExpressionError(JetBinaryExpression expression, ExpressionTypingContext context) { facade.checkStatementType(expression, context); context.trace.report(ASSIGNMENT_IN_EXPRESSION_CONTEXT.on(expression)); - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } @Override @@ -1370,7 +1372,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { //left here is a receiver, so it doesn't depend on expected type typeInfo = facade.getTypeInfo(left, context.replaceContextDependency(INDEPENDENT).replaceExpectedType(NO_EXPECTED_TYPE)); } else { - typeInfo = TypeInfoFactoryPackage.createTypeInfo(context); + typeInfo = TypeInfoFactoryPackage.noTypeInfo(context); } ExpressionTypingContext contextWithDataFlow = context.replaceDataFlowInfo(typeInfo.getDataFlowInfo()); @@ -1396,7 +1398,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { @Override public JetTypeInfo visitDeclaration(@NotNull JetDeclaration dcl, ExpressionTypingContext context) { context.trace.report(DECLARATION_IN_ILLEGAL_CONTEXT.on(dcl)); - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } @Override @@ -1404,10 +1406,9 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (!JetPsiUtil.isLHSOfDot(expression)) { context.trace.report(PACKAGE_IS_NOT_AN_EXPRESSION.on(expression)); } - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } - private class StringTemplateVisitor extends JetVisitorVoid { final ExpressionTypingContext context; @@ -1416,7 +1417,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { StringTemplateVisitor(ExpressionTypingContext context) { this.context = context; - this.typeInfo = TypeInfoFactoryPackage.createTypeInfo(context); + this.typeInfo = TypeInfoFactoryPackage.noTypeInfo(context); } @Override @@ -1460,7 +1461,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { JetExpression baseExpression = expression.getBaseExpression(); if (baseExpression == null) { - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } return facade.getTypeInfo(baseExpression, context, isStatement); } @@ -1468,7 +1469,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { @Override public JetTypeInfo visitJetElement(@NotNull JetElement element, ExpressionTypingContext context) { context.trace.report(UNSUPPORTED.on(element, getClass().getCanonicalName())); - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } @NotNull @@ -1488,7 +1489,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { @NotNull BindingTrace traceForResolveResult, boolean isGet) { JetExpression arrayExpression = arrayAccessExpression.getArrayExpression(); - if (arrayExpression == null) return TypeInfoFactoryPackage.createTypeInfo(oldContext); + if (arrayExpression == null) return TypeInfoFactoryPackage.noTypeInfo(oldContext); JetTypeInfo arrayTypeInfo = facade.safeGetTypeInfo(arrayExpression, oldContext.replaceExpectedType(NO_EXPECTED_TYPE) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java index 4aaf6e79165..ce05ec4c672 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java @@ -111,8 +111,8 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { : result; } return TypeInfoFactoryPackage.createTypeInfo(DataFlowUtils.checkImplicitCast( - components.builtIns.getUnitType(), ifExpression, - contextWithExpectedType, isStatement + components.builtIns.getUnitType(), ifExpression, + contextWithExpectedType, isStatement ), thenInfo.or(elseInfo) ); @@ -221,8 +221,9 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { bodyTypeInfo = components.expressionTypingServices.getBlockReturnedTypeWithWritableScope( scopeToExtend, Collections.singletonList(body), CoercionStrategy.NO_COERCION, context.replaceDataFlowInfo(conditionInfo)); - } else { - bodyTypeInfo = TypeInfoFactoryPackage.createTypeInfo(conditionInfo); + } + else { + bodyTypeInfo = TypeInfoFactoryPackage.noTypeInfo(conditionInfo); } // Condition is false at this point only if there is no jumps outside @@ -331,7 +332,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { writableScope, block, CoercionStrategy.NO_COERCION, context); } else { - bodyTypeInfo = TypeInfoFactoryPackage.createTypeInfo(context); + bodyTypeInfo = TypeInfoFactoryPackage.noTypeInfo(context); } JetExpression condition = expression.getCondition(); DataFlowInfo conditionDataFlowInfo = checkCondition(conditionScope, condition, context); @@ -380,7 +381,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { } } else { - loopRangeInfo = TypeInfoFactoryPackage.createTypeInfo(context); + loopRangeInfo = TypeInfoFactoryPackage.noTypeInfo(context); } WritableScope loopScope = newWritableScopeImpl(context, "Scope with for-loop index"); @@ -480,7 +481,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { } } - JetTypeInfo result = TypeInfoFactoryPackage.createTypeInfo(context); + JetTypeInfo result = TypeInfoFactoryPackage.noTypeInfo(context); if (finallyBlock != null) { result = facade.getTypeInfo(finallyBlock.getFinalExpression(), context.replaceExpectedType(NO_EXPECTED_TYPE)); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowUtils.java index 951b2517797..1fdb4673068 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowUtils.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowUtils.java @@ -225,7 +225,7 @@ public class DataFlowUtils { facade.checkStatementType( expression, context.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT)); context.trace.report(EXPRESSION_EXPECTED.on(expression, expression)); - return TypeInfoFactoryPackage.createTypeInfo(context); + return TypeInfoFactoryPackage.noTypeInfo(context); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java index 581d1a6d7de..94460733925 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java @@ -315,13 +315,13 @@ public class ExpressionTypingServices { @NotNull ExpressionTypingContext context ) { if (block.isEmpty()) { - return new JetTypeInfo(builtIns.getUnitType(), context.dataFlowInfo, false, context.dataFlowInfo); + return TypeInfoFactoryPackage.createTypeInfo(builtIns.getUnitType(), context); } ExpressionTypingInternals blockLevelVisitor = ExpressionTypingVisitorDispatcher.createForBlock(expressionTypingComponents, scope); ExpressionTypingContext newContext = context.replaceScope(scope).replaceExpectedType(NO_EXPECTED_TYPE); - JetTypeInfo result = TypeInfoFactoryPackage.createTypeInfo(context); + JetTypeInfo result = TypeInfoFactoryPackage.noTypeInfo(context); // Jump point data flow info DataFlowInfo beforeJumpInfo = newContext.dataFlowInfo; boolean jumpOutPossible = false; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java index 07e2ccaf671..0abb2bfbe09 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java @@ -336,7 +336,7 @@ public class ExpressionTypingUtils { ) { return expression != null ? facade.getTypeInfo(expression, context) - : TypeInfoFactoryPackage.createTypeInfo(context); + : TypeInfoFactoryPackage.noTypeInfo(context); } @SuppressWarnings("SuspiciousMethodCalls") diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java index 19ea2c2a5d1..49a13e3a785 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java @@ -99,8 +99,9 @@ public class ExpressionTypingVisitorDispatcher extends JetVisitor visitor) { + private static JetTypeInfo getTypeInfo(@NotNull JetExpression expression, ExpressionTypingContext context, JetVisitor visitor) { try { JetTypeInfo recordedTypeInfo = BindingContextUtils.getRecordedTypeInfo(expression, context.trace.getBindingContext()); if (recordedTypeInfo != null) { @@ -141,7 +142,8 @@ public class ExpressionTypingVisitorDispatcher extends JetVisitor): JetTypeInfo = createTypeInfo(context.dataFlowInfo) - public fun createTypeInfo(type: JetType?, dataFlowInfo: DataFlowInfo): JetTypeInfo = JetTypeInfo(type, dataFlowInfo) -public fun createTypeInfo(type: JetType?, context: ResolutionContext<*>): JetTypeInfo = createTypeInfo(type, context.dataFlowInfo) - public fun createTypeInfo(type: JetType?, dataFlowInfo: DataFlowInfo, jumpPossible: Boolean, jumpFlowInfo: DataFlowInfo): JetTypeInfo = JetTypeInfo(type, dataFlowInfo, jumpPossible, jumpFlowInfo) +public fun createTypeInfo(type: JetType?): JetTypeInfo = createTypeInfo(type, DataFlowInfo.EMPTY) + +public fun createTypeInfo(type: JetType?, context: ResolutionContext<*>): JetTypeInfo = createTypeInfo(type, context.dataFlowInfo) + +public fun noTypeInfo(dataFlowInfo: DataFlowInfo): JetTypeInfo = createTypeInfo(null, dataFlowInfo) + +public fun noTypeInfo(context: ResolutionContext<*>): JetTypeInfo = noTypeInfo(context.dataFlowInfo) + public fun createCheckedTypeInfo(type: JetType?, context: ResolutionContext<*>, expression: JetExpression): JetTypeInfo = createTypeInfo(type, context).checkType(expression, context) diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java index 16b24f8f32e..8ab76ed82fe 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java @@ -356,7 +356,7 @@ public final class ExpressionVisitor extends TranslatorVisitor { assert right != null; JetType rightType = BindingContextUtils.getNotNull(context.bindingContext(), BindingContext.TYPE, right); - JetType leftType = BindingContextUtils.getNotNullType(context.bindingContext(), expression.getLeft()); + JetType leftType = BindingContextUtils.getTypeNotNull(context.bindingContext(), expression.getLeft()); if (TypeUtils.isNullableType(rightType) || !TypeUtils.isNullableType(leftType)) { return jsExpression.source(expression); } diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/UnaryOperationTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/UnaryOperationTranslator.java index 84df664fe62..bc4fb748931 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/UnaryOperationTranslator.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/UnaryOperationTranslator.java @@ -55,7 +55,7 @@ public final class UnaryOperationTranslator { IElementType operationToken = expression.getOperationReference().getReferencedNameElementType(); if (operationToken == JetTokens.EXCLEXCL) { JetExpression baseExpression = getBaseExpression(expression); - JetType type = BindingContextUtils.getNotNullType(context.bindingContext(), baseExpression); + JetType type = BindingContextUtils.getTypeNotNull(context.bindingContext(), baseExpression); JsExpression translatedExpression = translateAsExpression(baseExpression, context); return type.isMarkedNullable() ? sure(translatedExpression, context) : translatedExpression; } diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/BindingUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/BindingUtils.java index 79fac375103..09b5b127e81 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/BindingUtils.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/BindingUtils.java @@ -210,7 +210,7 @@ public final class BindingUtils { @NotNull public static JetType getTypeForExpression(@NotNull BindingContext context, @NotNull JetExpression expression) { - return BindingContextUtils.getNotNullType(context, expression); + return BindingContextUtils.getTypeNotNull(context, expression); } @NotNull