From 6e3eef2d6f3ff7de0e5d1dbf5358f50ccceb91a4 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Wed, 28 Oct 2015 16:07:23 +0300 Subject: [PATCH] JetTypeInfo renamed to KotlinTypeInfo --- .../kotlin/resolve/BindingContext.java | 4 +- .../kotlin/resolve/BindingContextUtils.java | 6 +- .../kotlin/resolve/BindingTraceContext.java | 6 +- .../resolve/DelegatingBindingTrace.java | 6 +- .../resolve/calls/ArgumentTypeResolver.java | 12 +- .../resolve/calls/CallExpressionResolver.java | 23 ++-- .../BasicExpressionTypingVisitor.java | 116 +++++++++--------- .../ControlStructureTypingUtils.java | 2 +- .../ControlStructureTypingVisitor.java | 48 ++++---- .../types/expressions/DataFlowAnalyzer.java | 10 +- .../expressions/ExpressionTypingFacade.java | 6 +- .../ExpressionTypingInternals.java | 2 +- .../expressions/ExpressionTypingServices.java | 20 +-- .../expressions/ExpressionTypingUtils.java | 6 +- .../expressions/ExpressionTypingVisitor.java | 2 +- .../ExpressionTypingVisitorDispatcher.java | 92 +++++++------- .../ExpressionTypingVisitorForStatements.java | 58 ++++----- .../expressions/FunctionsTypingVisitor.kt | 6 +- .../{JetTypeInfo.kt => KotlinTypeInfo.kt} | 12 +- .../PatternMatchingTypingVisitor.java | 18 +-- .../types/expressions/TypeInfoFactory.kt | 16 +-- .../jetbrains/kotlin/test/JetTestUtils.java | 4 +- .../kotlin/idea/analysis/AnalyzerUtil.kt | 4 +- 23 files changed, 240 insertions(+), 239 deletions(-) rename compiler/frontend/src/org/jetbrains/kotlin/types/expressions/{JetTypeInfo.kt => KotlinTypeInfo.kt} (80%) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java index ac39aaee6b7..e9339e21ad3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java @@ -38,7 +38,7 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.Qualifier; import org.jetbrains.kotlin.types.DeferredType; import org.jetbrains.kotlin.types.KotlinType; import org.jetbrains.kotlin.types.expressions.CaptureKind; -import org.jetbrains.kotlin.types.expressions.JetTypeInfo; +import org.jetbrains.kotlin.types.expressions.KotlinTypeInfo; import org.jetbrains.kotlin.types.expressions.PreliminaryDeclarationVisitor; import org.jetbrains.kotlin.util.Box; import org.jetbrains.kotlin.util.slicedMap.*; @@ -91,7 +91,7 @@ public interface BindingContext { WritableSlice> COMPILE_TIME_VALUE = Slices.createSimpleSlice(); WritableSlice TYPE = Slices.createSimpleSlice(); - WritableSlice EXPRESSION_TYPE_INFO = new BasicWritableSlice(DO_NOTHING); + WritableSlice EXPRESSION_TYPE_INFO = new BasicWritableSlice(DO_NOTHING); WritableSlice EXPECTED_EXPRESSION_TYPE = new BasicWritableSlice(DO_NOTHING); WritableSlice EXPECTED_RETURN_TYPE = new BasicWritableSlice(DO_NOTHING); WritableSlice DATAFLOW_INFO_AFTER_CONDITION = Slices.createSimpleSlice(); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java index 25fc676ac6f..bf68cb9414b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java @@ -33,7 +33,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; import org.jetbrains.kotlin.resolve.diagnostics.MutableDiagnosticsWithSuppression; import org.jetbrains.kotlin.types.KotlinType; import org.jetbrains.kotlin.types.TypeUtils; -import org.jetbrains.kotlin.types.expressions.JetTypeInfo; +import org.jetbrains.kotlin.types.expressions.KotlinTypeInfo; import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt; import org.jetbrains.kotlin.util.slicedMap.MutableSlicedMap; import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice; @@ -155,11 +155,11 @@ public class BindingContextUtils { } @Nullable - public static JetTypeInfo getRecordedTypeInfo(@NotNull KtExpression expression, @NotNull BindingContext context) { + public static KotlinTypeInfo getRecordedTypeInfo(@NotNull KtExpression expression, @NotNull BindingContext context) { // noinspection ConstantConditions if (!context.get(BindingContext.PROCESSED, expression)) return null; // NB: should never return null if expression is already processed - JetTypeInfo result = context.get(BindingContext.EXPRESSION_TYPE_INFO, expression); + KotlinTypeInfo result = context.get(BindingContext.EXPRESSION_TYPE_INFO, expression); return result != null ? result : TypeInfoFactoryKt.noTypeInfo(DataFlowInfo.EMPTY); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingTraceContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingTraceContext.java index f8edef58ff6..ddb3c3dc1aa 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingTraceContext.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingTraceContext.java @@ -25,7 +25,7 @@ import org.jetbrains.kotlin.psi.KtExpression; import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics; import org.jetbrains.kotlin.resolve.diagnostics.MutableDiagnosticsWithSuppression; import org.jetbrains.kotlin.types.KotlinType; -import org.jetbrains.kotlin.types.expressions.JetTypeInfo; +import org.jetbrains.kotlin.types.expressions.KotlinTypeInfo; import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt; import org.jetbrains.kotlin.util.slicedMap.*; @@ -132,13 +132,13 @@ public class BindingTraceContext implements BindingTrace { @Nullable @Override public KotlinType getType(@NotNull KtExpression expression) { - JetTypeInfo typeInfo = get(BindingContext.EXPRESSION_TYPE_INFO, expression); + KotlinTypeInfo typeInfo = get(BindingContext.EXPRESSION_TYPE_INFO, expression); return typeInfo != null ? typeInfo.getType() : null; } @Override public void recordType(@NotNull KtExpression expression, @Nullable KotlinType type) { - JetTypeInfo typeInfo = get(BindingContext.EXPRESSION_TYPE_INFO, expression); + KotlinTypeInfo typeInfo = get(BindingContext.EXPRESSION_TYPE_INFO, expression); typeInfo = typeInfo != null ? typeInfo.replaceType(type) : TypeInfoFactoryKt.createTypeInfo(type); record(BindingContext.EXPRESSION_TYPE_INFO, expression, typeInfo); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatingBindingTrace.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatingBindingTrace.java index 7861467d5dc..2287dccae27 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatingBindingTrace.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatingBindingTrace.java @@ -27,7 +27,7 @@ import org.jetbrains.kotlin.psi.KtExpression; import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics; import org.jetbrains.kotlin.resolve.diagnostics.MutableDiagnosticsWithSuppression; import org.jetbrains.kotlin.types.KotlinType; -import org.jetbrains.kotlin.types.expressions.JetTypeInfo; +import org.jetbrains.kotlin.types.expressions.KotlinTypeInfo; import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt; import org.jetbrains.kotlin.util.slicedMap.*; @@ -140,13 +140,13 @@ public class DelegatingBindingTrace implements BindingTrace { @Nullable @Override public KotlinType getType(@NotNull KtExpression expression) { - JetTypeInfo typeInfo = get(BindingContext.EXPRESSION_TYPE_INFO, expression); + KotlinTypeInfo typeInfo = get(BindingContext.EXPRESSION_TYPE_INFO, expression); return typeInfo != null ? typeInfo.getType() : null; } @Override public void recordType(@NotNull KtExpression expression, @Nullable KotlinType type) { - JetTypeInfo typeInfo = get(BindingContext.EXPRESSION_TYPE_INFO, expression); + KotlinTypeInfo typeInfo = get(BindingContext.EXPRESSION_TYPE_INFO, expression); if (typeInfo == null) { typeInfo = TypeInfoFactoryKt.createTypeInfo(type); } 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 9f4ce5210ae..67e908238f4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java @@ -51,7 +51,7 @@ import org.jetbrains.kotlin.types.KotlinType; import org.jetbrains.kotlin.types.TypeUtils; import org.jetbrains.kotlin.types.checker.KotlinTypeChecker; import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices; -import org.jetbrains.kotlin.types.expressions.JetTypeInfo; +import org.jetbrains.kotlin.types.expressions.KotlinTypeInfo; import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt; import java.util.Collections; @@ -194,7 +194,7 @@ public class ArgumentTypeResolver { } @NotNull - public JetTypeInfo getArgumentTypeInfo( + public KotlinTypeInfo getArgumentTypeInfo( @Nullable KtExpression expression, @NotNull CallResolutionContext context, @NotNull ResolveArgumentsMode resolveArgumentsMode @@ -213,7 +213,7 @@ public class ArgumentTypeResolver { return getCallableReferenceTypeInfo(expression, callableReferenceExpression, context, resolveArgumentsMode); } - JetTypeInfo recordedTypeInfo = getRecordedTypeInfo(expression, context.trace.getBindingContext()); + KotlinTypeInfo recordedTypeInfo = getRecordedTypeInfo(expression, context.trace.getBindingContext()); if (recordedTypeInfo != null) { return recordedTypeInfo; } @@ -224,7 +224,7 @@ public class ArgumentTypeResolver { } @NotNull - public JetTypeInfo getCallableReferenceTypeInfo( + public KotlinTypeInfo getCallableReferenceTypeInfo( @NotNull KtExpression expression, @NotNull KtCallableReferenceExpression callableReferenceExpression, @NotNull CallResolutionContext context, @@ -255,7 +255,7 @@ public class ArgumentTypeResolver { } @NotNull - public JetTypeInfo getFunctionLiteralTypeInfo( + public KotlinTypeInfo getFunctionLiteralTypeInfo( @NotNull KtExpression expression, @NotNull KtFunction functionLiteral, @NotNull CallResolutionContext context, @@ -341,7 +341,7 @@ public class ArgumentTypeResolver { CallResolutionContext newContext = context.replaceDataFlowInfo(infoForArguments.getInfo(argument)); // Here we go inside arguments and determine additional data flow information for them - JetTypeInfo typeInfoForCall = getArgumentTypeInfo(expression, newContext, SHAPE_FUNCTION_ARGUMENTS); + KotlinTypeInfo typeInfoForCall = getArgumentTypeInfo(expression, newContext, SHAPE_FUNCTION_ARGUMENTS); infoForArguments.updateInfo(argument, typeInfoForCall.getDataFlowInfo()); } } 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 c1f7bb423ca..2204efa7a57 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java @@ -48,7 +48,7 @@ import org.jetbrains.kotlin.types.TypeUtils; import org.jetbrains.kotlin.types.expressions.DataFlowAnalyzer; import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext; import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices; -import org.jetbrains.kotlin.types.expressions.JetTypeInfo; +import org.jetbrains.kotlin.types.expressions.KotlinTypeInfo; import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt; import javax.inject.Inject; @@ -142,7 +142,7 @@ public class CallExpressionResolver { } @NotNull - public JetTypeInfo getSimpleNameExpressionTypeInfo( + public KotlinTypeInfo getSimpleNameExpressionTypeInfo( @NotNull KtSimpleNameExpression nameExpression, @NotNull ReceiverValue receiver, @Nullable ASTNode callOperationNode, @NotNull ExpressionTypingContext context ) { @@ -181,11 +181,11 @@ public class CallExpressionResolver { } @NotNull - public JetTypeInfo getCallExpressionTypeInfo( + public KotlinTypeInfo getCallExpressionTypeInfo( @NotNull KtCallExpression callExpression, @NotNull ReceiverValue receiver, @Nullable ASTNode callOperationNode, @NotNull ExpressionTypingContext context ) { - JetTypeInfo typeInfo = getCallExpressionTypeInfoWithoutFinalTypeCheck(callExpression, receiver, callOperationNode, context); + KotlinTypeInfo typeInfo = getCallExpressionTypeInfoWithoutFinalTypeCheck(callExpression, receiver, callOperationNode, context); if (context.contextDependency == INDEPENDENT) { dataFlowAnalyzer.checkType(typeInfo.getType(), callExpression, context); } @@ -197,7 +197,7 @@ public class CallExpressionResolver { * Determines the result type and data flow information after the call. */ @NotNull - public JetTypeInfo getCallExpressionTypeInfoWithoutFinalTypeCheck( + public KotlinTypeInfo getCallExpressionTypeInfoWithoutFinalTypeCheck( @NotNull KtCallExpression callExpression, @NotNull ReceiverValue receiver, @Nullable ASTNode callOperationNode, @NotNull ExpressionTypingContext context ) { @@ -244,7 +244,7 @@ public class CallExpressionResolver { DataFlowInfo jumpFlowInfo = resultFlowInfo; boolean jumpOutPossible = false; for (ValueArgument argument: arguments) { - JetTypeInfo argTypeInfo = context.trace.get(BindingContext.EXPRESSION_TYPE_INFO, argument.getArgumentExpression()); + KotlinTypeInfo argTypeInfo = context.trace.get(BindingContext.EXPRESSION_TYPE_INFO, argument.getArgumentExpression()); if (argTypeInfo != null && argTypeInfo.getJumpOutPossible()) { jumpOutPossible = true; jumpFlowInfo = argTypeInfo.getJumpFlowInfo(); @@ -289,7 +289,7 @@ public class CallExpressionResolver { } @NotNull - private JetTypeInfo getSelectorReturnTypeInfo( + private KotlinTypeInfo getSelectorReturnTypeInfo( @NotNull ReceiverValue receiver, @Nullable ASTNode callOperationNode, @Nullable KtExpression selectorExpression, @@ -314,16 +314,16 @@ public class CallExpressionResolver { * @return qualified expression type together with data flow information */ @NotNull - public JetTypeInfo getQualifiedExpressionTypeInfo( + public KotlinTypeInfo getQualifiedExpressionTypeInfo( @NotNull KtQualifiedExpression expression, @NotNull ExpressionTypingContext context ) { ExpressionTypingContext currentContext = context.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT); Deque elementChain = CallExpressionUnrollerKt.unroll(expression); - JetTypeInfo receiverTypeInfo = expressionTypingServices.getTypeInfo(elementChain.getFirst().getReceiver(), currentContext); + KotlinTypeInfo receiverTypeInfo = expressionTypingServices.getTypeInfo(elementChain.getFirst().getReceiver(), currentContext); KotlinType receiverType = receiverTypeInfo.getType(); DataFlowInfo receiverDataFlowInfo = receiverTypeInfo.getDataFlowInfo(); - JetTypeInfo resultTypeInfo = receiverTypeInfo; + KotlinTypeInfo resultTypeInfo = receiverTypeInfo; boolean unconditional = true; DataFlowInfo unconditionalDataFlowInfo = receiverDataFlowInfo; @@ -344,7 +344,8 @@ public class CallExpressionResolver { currentContext = baseContext.replaceDataFlowInfo(receiverDataFlowInfo); KtExpression selectorExpression = element.getSelector(); - JetTypeInfo selectorReturnTypeInfo = getSelectorReturnTypeInfo(receiver, element.getNode(), selectorExpression, currentContext); + KotlinTypeInfo selectorReturnTypeInfo = + getSelectorReturnTypeInfo(receiver, element.getNode(), selectorExpression, currentContext); KotlinType selectorReturnType = selectorReturnTypeInfo.getType(); resolveDeferredReceiverInQualifiedExpression(qualifierReceiver, element.getQualified(), currentContext); 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 0b4a3fa59b0..4ba6b0d954f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java @@ -98,16 +98,16 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression, ExpressionTypingContext context) { // TODO : other members // TODO : type substitutions??? CallExpressionResolver callExpressionResolver = components.callExpressionResolver; - JetTypeInfo typeInfo = callExpressionResolver.getSimpleNameExpressionTypeInfo(expression, NO_RECEIVER, null, context); + KotlinTypeInfo typeInfo = callExpressionResolver.getSimpleNameExpressionTypeInfo(expression, NO_RECEIVER, null, context); return components.dataFlowAnalyzer.checkType(typeInfo, expression, context); // TODO : Extensions to this } @Override - public JetTypeInfo visitParenthesizedExpression(@NotNull KtParenthesizedExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitParenthesizedExpression(@NotNull KtParenthesizedExpression expression, ExpressionTypingContext context) { KtExpression innerExpression = expression.getExpression(); if (innerExpression == null) { return TypeInfoFactoryKt.noTypeInfo(context); @@ -116,7 +116,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitConstantExpression(@NotNull KtConstantExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitConstantExpression(@NotNull KtConstantExpression expression, ExpressionTypingContext context) { if (expression.getNode().getElementType() == KtNodeTypes.CHARACTER_CONSTANT) { checkStringPrefixAndSuffix(expression, context); } @@ -163,7 +163,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitBinaryWithTypeRHSExpression(@NotNull KtBinaryExpressionWithTypeRHS expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitBinaryWithTypeRHSExpression(@NotNull KtBinaryExpressionWithTypeRHS expression, ExpressionTypingContext context) { ExpressionTypingContext contextWithNoExpectedType = context.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT); KtExpression left = expression.getLeft(); @@ -178,7 +178,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { TypeResolutionContext typeResolutionContext = new TypeResolutionContext(context.scope, context.trace, true, allowBareTypes); PossiblyBareType possiblyBareTarget = components.typeResolver.resolvePossiblyBareType(typeResolutionContext, right); - JetTypeInfo typeInfo = facade.getTypeInfo(left, contextWithNoExpectedType); + KotlinTypeInfo typeInfo = facade.getTypeInfo(left, contextWithNoExpectedType); KotlinType subjectType = typeInfo.getType(); KotlinType targetType = reconstructBareType(right, possiblyBareTarget, subjectType, context.trace, components.builtIns); @@ -275,7 +275,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitThisExpression(@NotNull KtThisExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitThisExpression(@NotNull KtThisExpression expression, ExpressionTypingContext context) { KotlinType result = null; LabelResolver.LabeledReceiverResolutionResult resolutionResult = resolveToReceiver(expression, context, false); @@ -295,7 +295,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitSuperExpression(@NotNull KtSuperExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitSuperExpression(@NotNull KtSuperExpression expression, ExpressionTypingContext context) { LabelResolver.LabeledReceiverResolutionResult resolutionResult = resolveToReceiver(expression, context, true); if (!KtPsiUtil.isLHSOfDot(expression)) { @@ -320,7 +320,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { throw new IllegalStateException("Unknown code: " + resolutionResult.getCode()); } - private JetTypeInfo errorInSuper(KtSuperExpression expression, ExpressionTypingContext context) { + private KotlinTypeInfo errorInSuper(KtSuperExpression expression, ExpressionTypingContext context) { KtTypeReference superTypeQualifier = expression.getSuperTypeQualifier(); if (superTypeQualifier != null) { components.typeResolver.resolveType(context.scope, superTypeQualifier, context.trace, true); @@ -501,12 +501,12 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitBlockExpression(@NotNull KtBlockExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitBlockExpression(@NotNull KtBlockExpression expression, ExpressionTypingContext context) { return components.expressionTypingServices.getBlockReturnedType(expression, context, false); } @Override - public JetTypeInfo visitClassLiteralExpression(@NotNull KtClassLiteralExpression expression, ExpressionTypingContext c) { + public KotlinTypeInfo visitClassLiteralExpression(@NotNull KtClassLiteralExpression expression, ExpressionTypingContext c) { KotlinType type = resolveClassLiteral(expression, c); if (type != null && !type.isError()) { return components.dataFlowAnalyzer.createCheckedTypeInfo( @@ -612,7 +612,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitCallableReferenceExpression(@NotNull KtCallableReferenceExpression expression, ExpressionTypingContext c) { + public KotlinTypeInfo visitCallableReferenceExpression(@NotNull KtCallableReferenceExpression expression, ExpressionTypingContext c) { KtTypeReference typeReference = expression.getTypeReference(); KotlinType receiverType = @@ -632,7 +632,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitObjectLiteralExpression(@NotNull final KtObjectLiteralExpression expression, final ExpressionTypingContext context) { + public KotlinTypeInfo visitObjectLiteralExpression(@NotNull final KtObjectLiteralExpression expression, final ExpressionTypingContext context) { final KotlinType[] result = new KotlinType[1]; TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace, "trace to resolve object literal expression", expression); @@ -664,16 +664,16 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { for (KtDelegationSpecifier specifier: expression.getObjectDeclaration().getDelegationSpecifiers()) { if (specifier instanceof KtDelegatorToSuperCall) { KtDelegatorToSuperCall delegator = (KtDelegatorToSuperCall)specifier; - JetTypeInfo delegatorTypeInfo = context.trace.get(EXPRESSION_TYPE_INFO, delegator.getCalleeExpression()); + KotlinTypeInfo delegatorTypeInfo = context.trace.get(EXPRESSION_TYPE_INFO, delegator.getCalleeExpression()); if (delegatorTypeInfo != null) { resultFlowInfo = resultFlowInfo.and(delegatorTypeInfo.getDataFlowInfo()); } } } // Breaks are not possible inside constructor arguments, so jumpPossible or jumpFlowInfo are not necessary here - JetTypeInfo resultTypeInfo = components.dataFlowAnalyzer.checkType(TypeInfoFactoryKt.createTypeInfo(result[0], resultFlowInfo), - expression, - context); + KotlinTypeInfo resultTypeInfo = components.dataFlowAnalyzer.checkType(TypeInfoFactoryKt.createTypeInfo(result[0], resultFlowInfo), + expression, + context); // We have to record it here, // otherwise ExpressionTypingVisitorDispatcher records wrong information context.trace.record(EXPRESSION_TYPE_INFO, expression, resultTypeInfo); @@ -712,19 +712,19 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitQualifiedExpression(@NotNull KtQualifiedExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitQualifiedExpression(@NotNull KtQualifiedExpression expression, ExpressionTypingContext context) { CallExpressionResolver callExpressionResolver = components.callExpressionResolver; return callExpressionResolver.getQualifiedExpressionTypeInfo(expression, context); } @Override - public JetTypeInfo visitCallExpression(@NotNull KtCallExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitCallExpression(@NotNull KtCallExpression expression, ExpressionTypingContext context) { CallExpressionResolver callExpressionResolver = components.callExpressionResolver; return callExpressionResolver.getCallExpressionTypeInfo(expression, NO_RECEIVER, null, context); } @Override - public JetTypeInfo visitUnaryExpression(@NotNull KtUnaryExpression expression, ExpressionTypingContext contextWithExpectedType) { + public KotlinTypeInfo visitUnaryExpression(@NotNull KtUnaryExpression expression, ExpressionTypingContext contextWithExpectedType) { ExpressionTypingContext context = isUnaryExpressionDependentOnExpectedType(expression) ? contextWithExpectedType : contextWithExpectedType.replaceContextDependency(INDEPENDENT).replaceExpectedType(NO_EXPECTED_TYPE); @@ -742,7 +742,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } // Type check the base expression - JetTypeInfo typeInfo = facade.safeGetTypeInfo(baseExpression, context); + KotlinTypeInfo typeInfo = facade.safeGetTypeInfo(baseExpression, context); KotlinType type = ExpressionTypingUtils.safeGetType(typeInfo); ExpressionReceiver receiver = new ExpressionReceiver(baseExpression, type); @@ -821,7 +821,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { contextWithExpectedType.replaceDataFlowInfo(typeInfo.getDataFlowInfo())); } - private JetTypeInfo visitExclExclExpression(@NotNull KtUnaryExpression expression, @NotNull ExpressionTypingContext context) { + private KotlinTypeInfo visitExclExclExpression(@NotNull KtUnaryExpression expression, @NotNull ExpressionTypingContext context) { KtExpression baseExpression = expression.getBaseExpression(); assert baseExpression != null; KtSimpleNameExpression operationSign = expression.getOperationReference(); @@ -832,7 +832,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { Call call = createCallForSpecialConstruction(expression, expression.getOperationReference(), Collections.singletonList(baseExpression)); components.controlStructureTypingUtils.resolveSpecialConstructionAsCall( call, ResolveConstruct.EXCL_EXCL, Collections.singletonList("baseExpr"), Collections.singletonList(true), context, null); - JetTypeInfo baseTypeInfo = BindingContextUtils.getRecordedTypeInfo(baseExpression, context.trace.getBindingContext()); + KotlinTypeInfo baseTypeInfo = BindingContextUtils.getRecordedTypeInfo(baseExpression, context.trace.getBindingContext()); if (ArgumentTypeResolver.isFunctionLiteralArgument(baseExpression, context)) { context.trace.report(NOT_NULL_ASSERTION_ON_FUNCTION_LITERAL.on(operationSign)); @@ -861,14 +861,14 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitLabeledExpression( + public KotlinTypeInfo visitLabeledExpression( @NotNull KtLabeledExpression expression, ExpressionTypingContext context ) { return visitLabeledExpression(expression, context, false); } @NotNull - public JetTypeInfo visitLabeledExpression( + public KotlinTypeInfo visitLabeledExpression( @NotNull KtLabeledExpression expression, @NotNull ExpressionTypingContext context, boolean isStatement @@ -922,7 +922,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { TemporaryBindingTrace ignoreReportsTrace = TemporaryBindingTrace.create(trace, "Trace for checking set function"); ExpressionTypingContext findSetterContext = context.replaceBindingTrace(ignoreReportsTrace); - JetTypeInfo info = resolveArrayAccessSetMethod(arrayAccessExpression, rightHandSide, findSetterContext, ignoreReportsTrace); + KotlinTypeInfo info = resolveArrayAccessSetMethod(arrayAccessExpression, rightHandSide, findSetterContext, ignoreReportsTrace); return info.getType() != null; } @@ -962,7 +962,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitBinaryExpression(@NotNull KtBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) { + public KotlinTypeInfo visitBinaryExpression(@NotNull KtBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) { ExpressionTypingContext context = isBinaryExpressionDependentOnExpectedType(expression) ? contextWithExpectedType : contextWithExpectedType.replaceContextDependency(INDEPENDENT).replaceExpectedType(NO_EXPECTED_TYPE); @@ -972,7 +972,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { KtExpression right = expression.getRight(); IElementType operationType = operationSign.getReferencedNameElementType(); - JetTypeInfo result; + KotlinTypeInfo result; //Expressions that can depend on expected type if (operationType == KtTokens.IDENTIFIER) { @@ -1027,7 +1027,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { return components.dataFlowAnalyzer.checkType(result, expression, contextWithExpectedType); } - private JetTypeInfo visitEquality( + private KotlinTypeInfo visitEquality( KtBinaryExpression expression, ExpressionTypingContext context, KtSimpleNameExpression operationSign, @@ -1040,12 +1040,12 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { return TypeInfoFactoryKt.createTypeInfo(components.builtIns.getBooleanType(), context); } - JetTypeInfo leftTypeInfo = getTypeInfoOrNullType(left, context, facade); + KotlinTypeInfo leftTypeInfo = getTypeInfoOrNullType(left, context, facade); DataFlowInfo dataFlowInfo = leftTypeInfo.getDataFlowInfo(); ExpressionTypingContext contextWithDataFlow = context.replaceDataFlowInfo(dataFlowInfo); - JetTypeInfo rightTypeInfo = facade.getTypeInfo(right, contextWithDataFlow); + KotlinTypeInfo rightTypeInfo = facade.getTypeInfo(right, contextWithDataFlow); TemporaryBindingTrace traceInterpretingRightAsNullableAny = TemporaryBindingTrace.create( context.trace, "trace to resolve 'equals(Any?)' interpreting as of type Any? an expression:", right); @@ -1104,12 +1104,12 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @NotNull - private JetTypeInfo visitComparison( + private KotlinTypeInfo visitComparison( @NotNull KtBinaryExpression expression, @NotNull ExpressionTypingContext context, @NotNull KtSimpleNameExpression operationSign ) { - JetTypeInfo typeInfo = getTypeInfoForBinaryCall(OperatorNameConventions.COMPARE_TO, context, expression); + KotlinTypeInfo typeInfo = getTypeInfoForBinaryCall(OperatorNameConventions.COMPARE_TO, context, expression); KotlinType compareToReturnType = typeInfo.getType(); KotlinType type = null; if (compareToReturnType != null && !compareToReturnType.isError()) { @@ -1124,14 +1124,14 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @NotNull - private JetTypeInfo visitBooleanOperationExpression( + private KotlinTypeInfo visitBooleanOperationExpression( @Nullable IElementType operationType, @Nullable KtExpression left, @Nullable KtExpression right, @NotNull ExpressionTypingContext context ) { KotlinType booleanType = components.builtIns.getBooleanType(); - JetTypeInfo leftTypeInfo = getTypeInfoOrNullType(left, context.replaceExpectedType(booleanType), facade); + KotlinTypeInfo leftTypeInfo = getTypeInfoOrNullType(left, context.replaceExpectedType(booleanType), facade); DataFlowInfo dataFlowInfo = leftTypeInfo.getDataFlowInfo(); LexicalWritableScope leftScope = newWritableScopeImpl(context, "Left scope of && or ||"); @@ -1149,7 +1149,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @NotNull - private JetTypeInfo visitElvisExpression( + private KotlinTypeInfo visitElvisExpression( @NotNull KtBinaryExpression expression, @NotNull ExpressionTypingContext contextWithExpectedType ) { @@ -1165,7 +1165,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { Call call = createCallForSpecialConstruction(expression, expression.getOperationReference(), Lists.newArrayList(left, right)); ResolvedCall resolvedCall = components.controlStructureTypingUtils.resolveSpecialConstructionAsCall( call, ResolveConstruct.ELVIS, Lists.newArrayList("left", "right"), Lists.newArrayList(true, false), contextWithExpectedType, null); - JetTypeInfo leftTypeInfo = BindingContextUtils.getRecordedTypeInfo(left, context.trace.getBindingContext()); + KotlinTypeInfo leftTypeInfo = BindingContextUtils.getRecordedTypeInfo(left, context.trace.getBindingContext()); if (ArgumentTypeResolver.isFunctionLiteralArgument(left, context)) { context.trace.report(USELESS_ELVIS_ON_FUNCTION_LITERAL.on(expression.getOperationReference())); if (leftTypeInfo == null) return TypeInfoFactoryKt.noTypeInfo(context); @@ -1175,7 +1175,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (leftType != null && isKnownToBeNotNull(left, leftType, context)) { context.trace.report(USELESS_ELVIS.on(expression, leftType)); } - JetTypeInfo rightTypeInfo = BindingContextUtils.getRecordedTypeInfo(right, context.trace.getBindingContext()); + KotlinTypeInfo rightTypeInfo = BindingContextUtils.getRecordedTypeInfo(right, context.trace.getBindingContext()); if (rightTypeInfo == null && ArgumentTypeResolver.isFunctionLiteralArgument(right, context)) { // the type is computed later in call completer according to the '?:' semantics as a function return TypeInfoFactoryKt.noTypeInfo(context); @@ -1215,7 +1215,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @NotNull - public JetTypeInfo checkInExpression( + public KotlinTypeInfo checkInExpression( @NotNull KtElement callElement, @NotNull KtSimpleNameExpression operationSign, @NotNull ValueArgument leftArgument, @@ -1229,7 +1229,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { return TypeInfoFactoryKt.noTypeInfo(context); } - JetTypeInfo rightTypeInfo = facade.getTypeInfo(right, contextWithNoExpectedType); + KotlinTypeInfo rightTypeInfo = facade.getTypeInfo(right, contextWithNoExpectedType); DataFlowInfo dataFlowInfo = rightTypeInfo.getDataFlowInfo(); ExpressionReceiver receiver = safeGetExpressionReceiver(facade, right, contextWithNoExpectedType); @@ -1306,35 +1306,35 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @NotNull - private JetTypeInfo visitAssignmentOperation(KtBinaryExpression expression, ExpressionTypingContext context) { + private KotlinTypeInfo visitAssignmentOperation(KtBinaryExpression expression, ExpressionTypingContext context) { return assignmentIsNotAnExpressionError(expression, context); } @NotNull - private JetTypeInfo visitAssignment(KtBinaryExpression expression, ExpressionTypingContext context) { + private KotlinTypeInfo visitAssignment(KtBinaryExpression expression, ExpressionTypingContext context) { return assignmentIsNotAnExpressionError(expression, context); } @NotNull - private JetTypeInfo assignmentIsNotAnExpressionError(KtBinaryExpression expression, ExpressionTypingContext context) { + private KotlinTypeInfo assignmentIsNotAnExpressionError(KtBinaryExpression expression, ExpressionTypingContext context) { facade.checkStatementType(expression, context); context.trace.report(ASSIGNMENT_IN_EXPRESSION_CONTEXT.on(expression)); return TypeInfoFactoryKt.noTypeInfo(context); } @Override - public JetTypeInfo visitArrayAccessExpression(@NotNull KtArrayAccessExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitArrayAccessExpression(@NotNull KtArrayAccessExpression expression, ExpressionTypingContext context) { return components.dataFlowAnalyzer.checkType(resolveArrayAccessGetMethod(expression, context), expression, context); } @NotNull - public JetTypeInfo getTypeInfoForBinaryCall( + public KotlinTypeInfo getTypeInfoForBinaryCall( @NotNull Name name, @NotNull ExpressionTypingContext context, @NotNull KtBinaryExpression binaryExpression ) { KtExpression left = binaryExpression.getLeft(); - JetTypeInfo typeInfo; + KotlinTypeInfo typeInfo; if (left != null) { //left here is a receiver, so it doesn't depend on expected type typeInfo = facade.getTypeInfo(left, context.replaceContextDependency(INDEPENDENT).replaceExpectedType(NO_EXPECTED_TYPE)); @@ -1363,13 +1363,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitDeclaration(@NotNull KtDeclaration dcl, ExpressionTypingContext context) { + public KotlinTypeInfo visitDeclaration(@NotNull KtDeclaration dcl, ExpressionTypingContext context) { context.trace.report(DECLARATION_IN_ILLEGAL_CONTEXT.on(dcl)); return TypeInfoFactoryKt.noTypeInfo(context); } @Override - public JetTypeInfo visitRootPackageExpression(@NotNull KtRootPackageExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitRootPackageExpression(@NotNull KtRootPackageExpression expression, ExpressionTypingContext context) { if (!KtPsiUtil.isLHSOfDot(expression)) { context.trace.report(PACKAGE_IS_NOT_AN_EXPRESSION.on(expression)); } @@ -1377,13 +1377,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitStringTemplateExpression(@NotNull KtStringTemplateExpression expression, ExpressionTypingContext contextWithExpectedType) { + public KotlinTypeInfo visitStringTemplateExpression(@NotNull KtStringTemplateExpression expression, ExpressionTypingContext contextWithExpectedType) { final ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT); checkStringPrefixAndSuffix(expression, context); class StringTemplateVisitor extends KtVisitorVoid { - private JetTypeInfo typeInfo = TypeInfoFactoryKt.noTypeInfo(context); + private KotlinTypeInfo typeInfo = TypeInfoFactoryKt.noTypeInfo(context); @Override public void visitStringTemplateEntryWithExpression(@NotNull KtStringTemplateEntryWithExpression entry) { @@ -1434,11 +1434,11 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitAnnotatedExpression(@NotNull KtAnnotatedExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitAnnotatedExpression(@NotNull KtAnnotatedExpression expression, ExpressionTypingContext context) { return visitAnnotatedExpression(expression, context, false); } - public JetTypeInfo visitAnnotatedExpression(KtAnnotatedExpression expression, ExpressionTypingContext context, boolean isStatement) { + public KotlinTypeInfo visitAnnotatedExpression(KtAnnotatedExpression expression, ExpressionTypingContext context, boolean isStatement) { components.annotationResolver.resolveAnnotationsWithArguments(context.scope, expression.getAnnotationEntries(), context.trace); KtExpression baseExpression = expression.getBaseExpression(); @@ -1449,23 +1449,23 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitJetElement(@NotNull KtElement element, ExpressionTypingContext context) { + public KotlinTypeInfo visitJetElement(@NotNull KtElement element, ExpressionTypingContext context) { context.trace.report(UNSUPPORTED.on(element, getClass().getCanonicalName())); return TypeInfoFactoryKt.noTypeInfo(context); } @NotNull - /*package*/ JetTypeInfo resolveArrayAccessSetMethod(@NotNull KtArrayAccessExpression arrayAccessExpression, @NotNull KtExpression rightHandSide, @NotNull ExpressionTypingContext context, @NotNull BindingTrace traceForResolveResult) { + /*package*/ KotlinTypeInfo resolveArrayAccessSetMethod(@NotNull KtArrayAccessExpression arrayAccessExpression, @NotNull KtExpression rightHandSide, @NotNull ExpressionTypingContext context, @NotNull BindingTrace traceForResolveResult) { return resolveArrayAccessSpecialMethod(arrayAccessExpression, rightHandSide, context, traceForResolveResult, false); } @NotNull - /*package*/ JetTypeInfo resolveArrayAccessGetMethod(@NotNull KtArrayAccessExpression arrayAccessExpression, @NotNull ExpressionTypingContext context) { + /*package*/ KotlinTypeInfo resolveArrayAccessGetMethod(@NotNull KtArrayAccessExpression arrayAccessExpression, @NotNull ExpressionTypingContext context) { return resolveArrayAccessSpecialMethod(arrayAccessExpression, null, context, context.trace, true); } @NotNull - private JetTypeInfo resolveArrayAccessSpecialMethod(@NotNull KtArrayAccessExpression arrayAccessExpression, + private KotlinTypeInfo resolveArrayAccessSpecialMethod(@NotNull KtArrayAccessExpression arrayAccessExpression, @Nullable KtExpression rightHandSide, //only for 'set' method @NotNull ExpressionTypingContext oldContext, @NotNull BindingTrace traceForResolveResult, @@ -1474,7 +1474,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (arrayExpression == null) return TypeInfoFactoryKt.noTypeInfo(oldContext); - JetTypeInfo arrayTypeInfo = facade.safeGetTypeInfo(arrayExpression, oldContext.replaceExpectedType(NO_EXPECTED_TYPE) + KotlinTypeInfo arrayTypeInfo = facade.safeGetTypeInfo(arrayExpression, oldContext.replaceExpectedType(NO_EXPECTED_TYPE) .replaceContextDependency(INDEPENDENT)); KotlinType arrayType = ExpressionTypingUtils.safeGetType(arrayTypeInfo); @@ -1490,7 +1490,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { List indices = arrayAccessExpression.getIndexExpressions(); // The accumulated data flow info of all index expressions is saved on the last index - JetTypeInfo resultTypeInfo = arrayTypeInfo; + KotlinTypeInfo resultTypeInfo = arrayTypeInfo; if (!indices.isEmpty()) { resultTypeInfo = facade.getTypeInfo(indices.get(indices.size() - 1), context); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java index 465a11cbb4b..01f666f9c8f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java @@ -300,7 +300,7 @@ public class ControlStructureTypingUtils { final KtVisitor checkTypeVisitor = new KtVisitor() { private boolean checkExpressionType(@NotNull KtExpression expression, CheckTypeContext c) { - JetTypeInfo typeInfo = BindingContextUtils.getRecordedTypeInfo(expression, c.trace.getBindingContext()); + KotlinTypeInfo typeInfo = BindingContextUtils.getRecordedTypeInfo(expression, c.trace.getBindingContext()); if (typeInfo == null) return false; Ref hasError = Ref.create(); 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 812aa79db46..5258e900e1f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java @@ -68,7 +68,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { @NotNull private DataFlowInfo checkCondition(@NotNull LexicalScope scope, @Nullable KtExpression condition, ExpressionTypingContext context) { if (condition != null) { - JetTypeInfo typeInfo = facade.getTypeInfo(condition, context.replaceScope(scope) + KotlinTypeInfo typeInfo = facade.getTypeInfo(condition, context.replaceScope(scope) .replaceExpectedType(components.builtIns.getBooleanType()).replaceContextDependency(INDEPENDENT)); KotlinType conditionType = typeInfo.getType(); @@ -85,11 +85,11 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { @Override - public JetTypeInfo visitIfExpression(@NotNull KtIfExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitIfExpression(@NotNull KtIfExpression expression, ExpressionTypingContext context) { return visitIfExpression(expression, context, false); } - public JetTypeInfo visitIfExpression(KtIfExpression ifExpression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) { + public KotlinTypeInfo visitIfExpression(KtIfExpression ifExpression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) { ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE); KtExpression condition = ifExpression.getCondition(); DataFlowInfo conditionDataFlowInfo = checkCondition(context.scope, condition, context); @@ -104,7 +104,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { if (elseBranch == null) { if (thenBranch != null) { - JetTypeInfo result = getTypeInfoWhenOnlyOneBranchIsPresent( + KotlinTypeInfo result = getTypeInfoWhenOnlyOneBranchIsPresent( thenBranch, thenScope, thenInfo, elseInfo, contextWithExpectedType, ifExpression, isStatement); // If jump was possible, take condition check info as the jump info return result.getJumpOutPossible() @@ -134,8 +134,8 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { contextWithExpectedType, dataFlowInfoForArguments); BindingContext bindingContext = context.trace.getBindingContext(); - JetTypeInfo thenTypeInfo = BindingContextUtils.getRecordedTypeInfo(thenBranch, bindingContext); - JetTypeInfo elseTypeInfo = BindingContextUtils.getRecordedTypeInfo(elseBranch, bindingContext); + KotlinTypeInfo thenTypeInfo = BindingContextUtils.getRecordedTypeInfo(thenBranch, bindingContext); + KotlinTypeInfo elseTypeInfo = BindingContextUtils.getRecordedTypeInfo(elseBranch, bindingContext); assert thenTypeInfo != null : "'Then' branch of if expression was not processed: " + ifExpression; assert elseTypeInfo != null : "'Else' branch of if expression was not processed: " + ifExpression; boolean loopBreakContinuePossible = thenTypeInfo.getJumpOutPossible() || elseTypeInfo.getJumpOutPossible(); @@ -170,7 +170,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { } @NotNull - private JetTypeInfo getTypeInfoWhenOnlyOneBranchIsPresent( + private KotlinTypeInfo getTypeInfoWhenOnlyOneBranchIsPresent( @NotNull KtExpression presentBranch, @NotNull LexicalWritableScope presentScope, @NotNull DataFlowInfo presentInfo, @@ -181,7 +181,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { ) { ExpressionTypingContext newContext = context.replaceDataFlowInfo(presentInfo).replaceExpectedType(NO_EXPECTED_TYPE) .replaceContextDependency(INDEPENDENT); - JetTypeInfo typeInfo = components.expressionTypingServices.getBlockReturnedTypeWithWritableScope( + KotlinTypeInfo typeInfo = components.expressionTypingServices.getBlockReturnedTypeWithWritableScope( presentScope, Collections.singletonList(presentBranch), CoercionStrategy.NO_COERCION, newContext); KotlinType type = typeInfo.getType(); DataFlowInfo dataFlowInfo; @@ -203,11 +203,11 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitWhileExpression(@NotNull KtWhileExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitWhileExpression(@NotNull KtWhileExpression expression, ExpressionTypingContext context) { return visitWhileExpression(expression, context, false); } - public JetTypeInfo visitWhileExpression(KtWhileExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) { + public KotlinTypeInfo visitWhileExpression(KtWhileExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) { if (!isStatement) return components.dataFlowAnalyzer.illegalStatementType(expression, contextWithExpectedType, facade); ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency( @@ -223,7 +223,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { DataFlowInfo dataFlowInfo = checkCondition(context.scope, condition, context); KtExpression body = expression.getBody(); - JetTypeInfo bodyTypeInfo; + KotlinTypeInfo bodyTypeInfo; DataFlowInfo conditionInfo = components.dataFlowAnalyzer.extractDataFlowInfoFromCondition(condition, true, context).and(dataFlowInfo); if (body != null) { LexicalWritableScope scopeToExtend = newWritableScopeImpl(context, "Scope extended in while's condition"); @@ -294,11 +294,11 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitDoWhileExpression(@NotNull KtDoWhileExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitDoWhileExpression(@NotNull KtDoWhileExpression expression, ExpressionTypingContext context) { return visitDoWhileExpression(expression, context, false); } - public JetTypeInfo visitDoWhileExpression(KtDoWhileExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) { + public KotlinTypeInfo visitDoWhileExpression(KtDoWhileExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) { if (!isStatement) return components.dataFlowAnalyzer.illegalStatementType(expression, contextWithExpectedType, facade); ExpressionTypingContext context = @@ -313,7 +313,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { // Here we must record data flow information at the end of the body (or at the first jump, to be precise) and // .and it with entrance data flow information, because do-while body is executed at least once // See KT-6283 - JetTypeInfo bodyTypeInfo; + KotlinTypeInfo bodyTypeInfo; if (body instanceof KtFunctionLiteralExpression) { // As a matter of fact, function literal is always unused at this point bodyTypeInfo = facade.getTypeInfo(body, context.replaceScope(context.scope)); @@ -360,11 +360,11 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitForExpression(@NotNull KtForExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitForExpression(@NotNull KtForExpression expression, ExpressionTypingContext context) { return visitForExpression(expression, context, false); } - public JetTypeInfo visitForExpression(KtForExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) { + public KotlinTypeInfo visitForExpression(KtForExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) { if (!isStatement) return components.dataFlowAnalyzer.illegalStatementType(expression, contextWithExpectedType, facade); ExpressionTypingContext context = @@ -375,7 +375,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { KtExpression loopRange = expression.getLoopRange(); KotlinType expectedParameterType = null; - JetTypeInfo loopRangeInfo; + KotlinTypeInfo loopRangeInfo; if (loopRange != null) { ExpressionReceiver loopRangeReceiver = getExpressionReceiver(facade, loopRange, context.replaceScope(context.scope)); loopRangeInfo = facade.getTypeInfo(loopRange, context); @@ -412,7 +412,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { } KtExpression body = expression.getBody(); - JetTypeInfo bodyTypeInfo; + KotlinTypeInfo bodyTypeInfo; if (body != null) { bodyTypeInfo = components.expressionTypingServices.getBlockReturnedTypeWithWritableScope(loopScope, Collections.singletonList(body), CoercionStrategy.NO_COERCION, context.replaceDataFlowInfo(loopRangeInfo.getDataFlowInfo())); @@ -465,7 +465,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitTryExpression(@NotNull KtTryExpression expression, ExpressionTypingContext typingContext) { + public KotlinTypeInfo visitTryExpression(@NotNull KtTryExpression expression, ExpressionTypingContext typingContext) { ExpressionTypingContext context = typingContext.replaceContextDependency(INDEPENDENT); KtExpression tryBlock = expression.getTryBlock(); List catchClauses = expression.getCatchClauses(); @@ -495,7 +495,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { } } - JetTypeInfo result = TypeInfoFactoryKt.noTypeInfo(context); + KotlinTypeInfo result = TypeInfoFactoryKt.noTypeInfo(context); if (finallyBlock != null) { result = facade.getTypeInfo(finallyBlock.getFinalExpression(), context.replaceExpectedType(NO_EXPECTED_TYPE)); @@ -514,7 +514,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitThrowExpression(@NotNull KtThrowExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitThrowExpression(@NotNull KtThrowExpression expression, ExpressionTypingContext context) { KtExpression thrownExpression = expression.getThrownExpression(); if (thrownExpression != null) { KotlinType throwableType = components.builtIns.getThrowable().getDefaultType(); @@ -525,7 +525,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitReturnExpression(@NotNull KtReturnExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitReturnExpression(@NotNull KtReturnExpression expression, ExpressionTypingContext context) { KtElement labelTargetElement = LabelResolver.INSTANCE.resolveControlLabel(expression, context); KtExpression returnedExpression = expression.getReturnedExpression(); @@ -603,14 +603,14 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitBreakExpression(@NotNull KtBreakExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitBreakExpression(@NotNull KtBreakExpression expression, ExpressionTypingContext context) { LabelResolver.INSTANCE.resolveControlLabel(expression, context); return components.dataFlowAnalyzer.createCheckedTypeInfo(components.builtIns.getNothingType(), context, expression). replaceJumpOutPossible(true); } @Override - public JetTypeInfo visitContinueExpression(@NotNull KtContinueExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitContinueExpression(@NotNull KtContinueExpression expression, ExpressionTypingContext context) { LabelResolver.INSTANCE.resolveControlLabel(expression, context); return components.dataFlowAnalyzer.createCheckedTypeInfo(components.builtIns.getNothingType(), context, expression). replaceJumpOutPossible(true); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java index 8596e125d42..80d6adf55d4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java @@ -160,7 +160,7 @@ public class DataFlowAnalyzer { } @NotNull - public JetTypeInfo checkType(@NotNull JetTypeInfo typeInfo, @NotNull KtExpression expression, @NotNull ResolutionContext context) { + public KotlinTypeInfo checkType(@NotNull KotlinTypeInfo typeInfo, @NotNull KtExpression expression, @NotNull ResolutionContext context) { return typeInfo.replaceType(checkType(typeInfo.getType(), expression, context)); } @@ -276,12 +276,12 @@ public class DataFlowAnalyzer { } @NotNull - public JetTypeInfo checkImplicitCast(@NotNull JetTypeInfo typeInfo, @NotNull KtExpression expression, @NotNull ResolutionContext context, boolean isStatement) { + public KotlinTypeInfo checkImplicitCast(@NotNull KotlinTypeInfo typeInfo, @NotNull KtExpression expression, @NotNull ResolutionContext context, boolean isStatement) { return typeInfo.replaceType(checkImplicitCast(typeInfo.getType(), expression, context, isStatement)); } @NotNull - public JetTypeInfo illegalStatementType(@NotNull KtExpression expression, @NotNull ExpressionTypingContext context, @NotNull ExpressionTypingInternals facade) { + public KotlinTypeInfo illegalStatementType(@NotNull KtExpression expression, @NotNull ExpressionTypingContext context, @NotNull ExpressionTypingInternals facade) { facade.checkStatementType( expression, context.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT)); context.trace.report(EXPRESSION_EXPECTED.on(expression, expression)); @@ -304,7 +304,7 @@ public class DataFlowAnalyzer { } @NotNull - public JetTypeInfo createCheckedTypeInfo( + public KotlinTypeInfo createCheckedTypeInfo( @Nullable KotlinType type, @NotNull ResolutionContext context, @NotNull KtExpression expression @@ -313,7 +313,7 @@ public class DataFlowAnalyzer { } @NotNull - public JetTypeInfo createCompileTimeConstantTypeInfo( + public KotlinTypeInfo createCompileTimeConstantTypeInfo( @NotNull CompileTimeConstant value, @NotNull KtExpression expression, @NotNull ExpressionTypingContext context diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingFacade.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingFacade.java index f96d54c7b51..31df5278731 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingFacade.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingFacade.java @@ -21,11 +21,11 @@ import org.jetbrains.kotlin.psi.KtExpression; public interface ExpressionTypingFacade { @NotNull - JetTypeInfo safeGetTypeInfo(@NotNull KtExpression expression, ExpressionTypingContext context); + KotlinTypeInfo safeGetTypeInfo(@NotNull KtExpression expression, ExpressionTypingContext context); @NotNull - JetTypeInfo getTypeInfo(@NotNull KtExpression expression, ExpressionTypingContext context); + KotlinTypeInfo getTypeInfo(@NotNull KtExpression expression, ExpressionTypingContext context); @NotNull - JetTypeInfo getTypeInfo(@NotNull KtExpression expression, ExpressionTypingContext context, boolean isStatement); + KotlinTypeInfo getTypeInfo(@NotNull KtExpression expression, ExpressionTypingContext context, boolean isStatement); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingInternals.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingInternals.java index 51a404df100..aaa757cc368 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingInternals.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingInternals.java @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.psi.*; /*package*/ interface ExpressionTypingInternals extends ExpressionTypingFacade { @NotNull - JetTypeInfo checkInExpression( + KotlinTypeInfo checkInExpression( @NotNull KtElement callElement, @NotNull KtSimpleNameExpression operationSign, @NotNull ValueArgument leftArgument, 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 4e8b21103ce..49d6e11f31b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java @@ -81,7 +81,7 @@ public class ExpressionTypingServices { } @NotNull - public JetTypeInfo getTypeInfo( + public KotlinTypeInfo getTypeInfo( @NotNull LexicalScope scope, @NotNull KtExpression expression, @NotNull KotlinType expectedType, @@ -96,7 +96,7 @@ public class ExpressionTypingServices { } @NotNull - public JetTypeInfo getTypeInfo(@NotNull KtExpression expression, @NotNull ResolutionContext resolutionContext) { + public KotlinTypeInfo getTypeInfo(@NotNull KtExpression expression, @NotNull ResolutionContext resolutionContext) { return expressionTypingFacade.getTypeInfo(expression, ExpressionTypingContext.newContext(resolutionContext)); } @@ -147,12 +147,12 @@ public class ExpressionTypingServices { } @NotNull - public JetTypeInfo getBlockReturnedType(KtBlockExpression expression, ExpressionTypingContext context, boolean isStatement) { + public KotlinTypeInfo getBlockReturnedType(KtBlockExpression expression, ExpressionTypingContext context, boolean isStatement) { return getBlockReturnedType(expression, isStatement ? CoercionStrategy.COERCION_TO_UNIT : CoercionStrategy.NO_COERCION, context); } @NotNull - public JetTypeInfo getBlockReturnedType( + public KotlinTypeInfo getBlockReturnedType( @NotNull KtBlockExpression expression, @NotNull CoercionStrategy coercionStrategyForLastExpression, @NotNull ExpressionTypingContext context @@ -172,7 +172,7 @@ public class ExpressionTypingServices { new TraceBasedRedeclarationHandler(context.trace), "getBlockReturnedType"); scope.changeLockLevel(WritableScope.LockLevel.BOTH); - JetTypeInfo r; + KotlinTypeInfo r; if (block.isEmpty()) { r = expressionTypingComponents.dataFlowAnalyzer .createCheckedTypeInfo(expressionTypingComponents.builtIns.getUnitType(), context, expression); @@ -205,7 +205,7 @@ public class ExpressionTypingServices { ExpressionTypingContext context = ExpressionTypingContext.newContext( trace, functionInnerScope, dataFlowInfo, NO_EXPECTED_TYPE ); - JetTypeInfo typeInfo = expressionTypingFacade.getTypeInfo(bodyExpression, context, function.hasBlockBody()); + KotlinTypeInfo typeInfo = expressionTypingFacade.getTypeInfo(bodyExpression, context, function.hasBlockBody()); KotlinType type = typeInfo.getType(); if (type != null) { @@ -221,7 +221,7 @@ public class ExpressionTypingServices { * Determines block returned type and data flow information at the end of the block AND * at the nearest jump point from the block beginning. */ - /*package*/ JetTypeInfo getBlockReturnedTypeWithWritableScope( + /*package*/ KotlinTypeInfo getBlockReturnedTypeWithWritableScope( @NotNull LexicalWritableScope scope, @NotNull List block, @NotNull CoercionStrategy coercionStrategyForLastExpression, @@ -235,7 +235,7 @@ public class ExpressionTypingServices { expressionTypingComponents, annotationChecker, scope); ExpressionTypingContext newContext = context.replaceScope(scope).replaceExpectedType(NO_EXPECTED_TYPE); - JetTypeInfo result = TypeInfoFactoryKt.noTypeInfo(context); + KotlinTypeInfo result = TypeInfoFactoryKt.noTypeInfo(context); // Jump point data flow info DataFlowInfo beforeJumpInfo = newContext.dataFlowInfo; boolean jumpOutPossible = false; @@ -270,7 +270,7 @@ public class ExpressionTypingServices { return result.replaceJumpOutPossible(jumpOutPossible).replaceJumpFlowInfo(beforeJumpInfo); } - private JetTypeInfo getTypeOfLastExpressionInBlock( + private KotlinTypeInfo getTypeOfLastExpressionInBlock( @NotNull KtExpression statementExpression, @NotNull ExpressionTypingContext context, @NotNull CoercionStrategy coercionStrategyForLastExpression, @@ -288,7 +288,7 @@ public class ExpressionTypingServices { return blockLevelVisitor.getTypeInfo(statementExpression, context.replaceExpectedType(expectedType), true); } - JetTypeInfo result = blockLevelVisitor.getTypeInfo(statementExpression, context, true); + KotlinTypeInfo result = blockLevelVisitor.getTypeInfo(statementExpression, context, true); if (coercionStrategyForLastExpression == COERCION_TO_UNIT) { boolean mightBeUnit = false; if (statementExpression instanceof KtDeclaration) { 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 93409a34ef4..5f8fcf9de79 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java @@ -93,9 +93,9 @@ public class ExpressionTypingUtils { } @NotNull - public static KotlinType safeGetType(@NotNull JetTypeInfo typeInfo) { + public static KotlinType safeGetType(@NotNull KotlinTypeInfo typeInfo) { KotlinType type = typeInfo.getType(); - assert type != null : "safeGetType should be invoked on safe JetTypeInfo; safeGetTypeInfo should return @NotNull type"; + assert type != null : "safeGetType should be invoked on safe KotlinTypeInfo; safeGetTypeInfo should return @NotNull type"; return type; } @@ -156,7 +156,7 @@ public class ExpressionTypingUtils { } @NotNull - public static JetTypeInfo getTypeInfoOrNullType( + public static KotlinTypeInfo getTypeInfoOrNullType( @Nullable KtExpression expression, @NotNull ExpressionTypingContext context, @NotNull ExpressionTypingInternals facade diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitor.java index 28eb1d0e279..0db03a32b1d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitor.java @@ -19,7 +19,7 @@ package org.jetbrains.kotlin.types.expressions; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.psi.KtVisitor; -public abstract class ExpressionTypingVisitor extends KtVisitor { +public abstract class ExpressionTypingVisitor extends KtVisitor { protected final ExpressionTypingInternals facade; protected final ExpressionTypingComponents components; 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 0ab892ef3b5..790ffb77722 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java @@ -39,7 +39,7 @@ import org.jetbrains.kotlin.utils.KotlinFrontEndException; import static org.jetbrains.kotlin.diagnostics.Errors.TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM; -public abstract class ExpressionTypingVisitorDispatcher extends KtVisitor +public abstract class ExpressionTypingVisitorDispatcher extends KtVisitor implements ExpressionTypingInternals { public static final PerformanceCounter typeInfoPerfCounter = PerformanceCounter.Companion.create("Type info", true); @@ -107,7 +107,7 @@ public abstract class ExpressionTypingVisitorDispatcher extends KtVisitor visitor) { - return typeInfoPerfCounter.time(new Function0() { + private static KotlinTypeInfo getTypeInfo(@NotNull final KtExpression expression, final ExpressionTypingContext context, final KtVisitor visitor) { + return typeInfoPerfCounter.time(new Function0() { @Override - public JetTypeInfo invoke() { + public KotlinTypeInfo invoke() { try { - JetTypeInfo recordedTypeInfo = BindingContextUtils.getRecordedTypeInfo(expression, context.trace.getBindingContext()); + KotlinTypeInfo recordedTypeInfo = BindingContextUtils.getRecordedTypeInfo(expression, context.trace.getBindingContext()); if (recordedTypeInfo != null) { return recordedTypeInfo; } - JetTypeInfo result; + KotlinTypeInfo result; try { result = expression.accept(visitor, context); // Some recursive definitions (object expressions) must put their types in the cache manually: @@ -228,178 +228,178 @@ public abstract class ExpressionTypingVisitorDispatcher extends KtVisitor ambiguity OverloadResolutionResults ambiguityResolutionResults = OverloadResolutionResultsUtil.ambiguity(assignmentOperationDescriptors, binaryOperationDescriptors); @@ -327,7 +327,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito } @NotNull - protected JetTypeInfo visitAssignment(KtBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) { + protected KotlinTypeInfo visitAssignment(KtBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) { final ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceScope(scope).replaceContextDependency(INDEPENDENT); KtExpression leftOperand = expression.getLeft(); @@ -342,14 +342,14 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito if (left instanceof KtArrayAccessExpression) { KtArrayAccessExpression arrayAccessExpression = (KtArrayAccessExpression) left; if (right == null) return TypeInfoFactoryKt.noTypeInfo(context); - JetTypeInfo typeInfo = basic.resolveArrayAccessSetMethod(arrayAccessExpression, right, context, context.trace); + KotlinTypeInfo typeInfo = basic.resolveArrayAccessSetMethod(arrayAccessExpression, right, context, context.trace); basic.checkLValue(context.trace, context, arrayAccessExpression, right); return typeInfo.replaceType(checkAssignmentType(typeInfo.getType(), expression, contextWithExpectedType)); } - JetTypeInfo leftInfo = ExpressionTypingUtils.getTypeInfoOrNullType(left, context, facade); + KotlinTypeInfo leftInfo = ExpressionTypingUtils.getTypeInfoOrNullType(left, context, facade); KotlinType leftType = leftInfo.getType(); DataFlowInfo dataFlowInfo = leftInfo.getDataFlowInfo(); - JetTypeInfo resultInfo; + KotlinTypeInfo resultInfo; if (right != null) { resultInfo = facade.getTypeInfo(right, context.replaceDataFlowInfo(dataFlowInfo).replaceExpectedType(leftType)); dataFlowInfo = resultInfo.getDataFlowInfo(); @@ -372,55 +372,55 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito @Override - public JetTypeInfo visitExpression(@NotNull KtExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitExpression(@NotNull KtExpression expression, ExpressionTypingContext context) { return facade.getTypeInfo(expression, context); } @Override - public JetTypeInfo visitJetElement(@NotNull KtElement element, ExpressionTypingContext context) { + public KotlinTypeInfo visitJetElement(@NotNull KtElement element, ExpressionTypingContext context) { context.trace.report(UNSUPPORTED.on(element, "in a block")); return TypeInfoFactoryKt.noTypeInfo(context); } @Override - public JetTypeInfo visitWhileExpression(@NotNull KtWhileExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitWhileExpression(@NotNull KtWhileExpression expression, ExpressionTypingContext context) { return controlStructures.visitWhileExpression(expression, context, true); } @Override - public JetTypeInfo visitDoWhileExpression(@NotNull KtDoWhileExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitDoWhileExpression(@NotNull KtDoWhileExpression expression, ExpressionTypingContext context) { return controlStructures.visitDoWhileExpression(expression, context, true); } @Override - public JetTypeInfo visitForExpression(@NotNull KtForExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitForExpression(@NotNull KtForExpression expression, ExpressionTypingContext context) { return controlStructures.visitForExpression(expression, context, true); } @Override - public JetTypeInfo visitAnnotatedExpression( + public KotlinTypeInfo visitAnnotatedExpression( @NotNull KtAnnotatedExpression expression, ExpressionTypingContext data ) { return basic.visitAnnotatedExpression(expression, data, true); } @Override - public JetTypeInfo visitIfExpression(@NotNull KtIfExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitIfExpression(@NotNull KtIfExpression expression, ExpressionTypingContext context) { return controlStructures.visitIfExpression(expression, context, true); } @Override - public JetTypeInfo visitWhenExpression(@NotNull KtWhenExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitWhenExpression(@NotNull KtWhenExpression expression, ExpressionTypingContext context) { return patterns.visitWhenExpression(expression, context, true); } @Override - public JetTypeInfo visitBlockExpression(@NotNull KtBlockExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitBlockExpression(@NotNull KtBlockExpression expression, ExpressionTypingContext context) { return components.expressionTypingServices.getBlockReturnedType(expression, context, true); } @Override - public JetTypeInfo visitLabeledExpression(@NotNull KtLabeledExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitLabeledExpression(@NotNull KtLabeledExpression expression, ExpressionTypingContext context) { return basic.visitLabeledExpression(expression, context, true); } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt index d9d471e1c41..6569584d7ad 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt @@ -43,7 +43,7 @@ import org.jetbrains.kotlin.utils.addIfNotNull public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : ExpressionTypingVisitor(facade) { - override fun visitNamedFunction(function: KtNamedFunction, data: ExpressionTypingContext): JetTypeInfo { + override fun visitNamedFunction(function: KtNamedFunction, data: ExpressionTypingContext): KotlinTypeInfo { return visitNamedFunction(function, data, false, null) } @@ -52,7 +52,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express context: ExpressionTypingContext, isStatement: Boolean, statementScope: LexicalWritableScope? // must be not null if isStatement - ): JetTypeInfo { + ): KotlinTypeInfo { if (!isStatement) { // function expression if (!function.getTypeParameters().isEmpty()) { @@ -129,7 +129,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express return components.builtIns.getFunctionType(Annotations.EMPTY, receiverType, parameters, returnType) } - override fun visitFunctionLiteralExpression(expression: KtFunctionLiteralExpression, context: ExpressionTypingContext): JetTypeInfo? { + override fun visitFunctionLiteralExpression(expression: KtFunctionLiteralExpression, context: ExpressionTypingContext): KotlinTypeInfo? { if (!expression.getFunctionLiteral().hasBody()) return null val expectedType = context.expectedType diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/JetTypeInfo.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/KotlinTypeInfo.kt similarity index 80% rename from compiler/frontend/src/org/jetbrains/kotlin/types/expressions/JetTypeInfo.kt rename to compiler/frontend/src/org/jetbrains/kotlin/types/expressions/KotlinTypeInfo.kt index 59a05debc7f..b0a47d0931e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/JetTypeInfo.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/KotlinTypeInfo.kt @@ -30,7 +30,7 @@ import org.jetbrains.kotlin.types.KotlinType * At the end current data flow info is x != null && y != null, but jump data flow info is x != null only. * Both break and continue are counted as possible jump outside of a loop, but return is not. */ -class JetTypeInfo( +class KotlinTypeInfo( val type: KotlinType?, val dataFlowInfo: DataFlowInfo, val jumpOutPossible: Boolean = false, @@ -40,20 +40,20 @@ class JetTypeInfo( fun clearType() = replaceType(null) // NB: do not compare type with this.type because this comparison is complex and unstable - fun replaceType(type: KotlinType?) = JetTypeInfo(type, dataFlowInfo, jumpOutPossible, jumpFlowInfo) + fun replaceType(type: KotlinType?) = KotlinTypeInfo(type, dataFlowInfo, jumpOutPossible, jumpFlowInfo) fun replaceJumpOutPossible(jumpOutPossible: Boolean) = - if (jumpOutPossible == this.jumpOutPossible) this else JetTypeInfo(type, dataFlowInfo, jumpOutPossible, jumpFlowInfo) + if (jumpOutPossible == this.jumpOutPossible) this else KotlinTypeInfo(type, dataFlowInfo, jumpOutPossible, jumpFlowInfo) fun replaceJumpFlowInfo(jumpFlowInfo: DataFlowInfo) = - if (jumpFlowInfo == this.jumpFlowInfo) this else JetTypeInfo(type, dataFlowInfo, jumpOutPossible, jumpFlowInfo) + if (jumpFlowInfo == this.jumpFlowInfo) this else KotlinTypeInfo(type, dataFlowInfo, jumpOutPossible, jumpFlowInfo) fun replaceDataFlowInfo(dataFlowInfo: DataFlowInfo) = when (this.dataFlowInfo) { // Nothing changed dataFlowInfo -> this // Jump info is the same as data flow info: change both - jumpFlowInfo -> JetTypeInfo(type, dataFlowInfo, jumpOutPossible, dataFlowInfo) + jumpFlowInfo -> KotlinTypeInfo(type, dataFlowInfo, jumpOutPossible, dataFlowInfo) // Jump info is not the same: change data flow info only - else -> JetTypeInfo(type, dataFlowInfo, jumpOutPossible, jumpFlowInfo) + else -> KotlinTypeInfo(type, dataFlowInfo, jumpOutPossible, jumpFlowInfo) } } \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.java index 55c5d8e2e15..134c5557f34 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.java @@ -53,12 +53,12 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitIsExpression(@NotNull KtIsExpression expression, ExpressionTypingContext contextWithExpectedType) { + public KotlinTypeInfo visitIsExpression(@NotNull KtIsExpression expression, ExpressionTypingContext contextWithExpectedType) { ExpressionTypingContext context = contextWithExpectedType .replaceExpectedType(NO_EXPECTED_TYPE) .replaceContextDependency(INDEPENDENT); KtExpression leftHandSide = expression.getLeftHandSide(); - JetTypeInfo typeInfo = facade.safeGetTypeInfo(leftHandSide, context.replaceScope(context.scope)); + KotlinTypeInfo typeInfo = facade.safeGetTypeInfo(leftHandSide, context.replaceScope(context.scope)); KotlinType knownType = typeInfo.getType(); if (expression.getTypeReference() != null) { DataFlowValue dataFlowValue = DataFlowValueFactory.createDataFlowValue(leftHandSide, knownType, context); @@ -70,11 +70,11 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { } @Override - public JetTypeInfo visitWhenExpression(@NotNull KtWhenExpression expression, ExpressionTypingContext context) { + public KotlinTypeInfo visitWhenExpression(@NotNull KtWhenExpression expression, ExpressionTypingContext context) { return visitWhenExpression(expression, context, false); } - public JetTypeInfo visitWhenExpression(KtWhenExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) { + public KotlinTypeInfo visitWhenExpression(KtWhenExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) { components.dataFlowAnalyzer.recordExpectedType(contextWithExpectedType.trace, expression, contextWithExpectedType.expectedType); ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT); @@ -87,7 +87,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { subjectType = ErrorUtils.createErrorType("Unknown type"); } else { - JetTypeInfo typeInfo = facade.safeGetTypeInfo(subjectExpression, context); + KotlinTypeInfo typeInfo = facade.safeGetTypeInfo(subjectExpression, context); loopBreakContinuePossible = typeInfo.getJumpOutPossible(); subjectType = typeInfo.getType(); assert subjectType != null; @@ -117,7 +117,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { ExpressionTypingContext newContext = contextWithExpectedType .replaceScope(scopeToExtend).replaceDataFlowInfo(infosForCondition.thenInfo).replaceContextDependency(INDEPENDENT); CoercionStrategy coercionStrategy = isStatement ? CoercionStrategy.COERCION_TO_UNIT : CoercionStrategy.NO_COERCION; - JetTypeInfo typeInfo = components.expressionTypingServices.getBlockReturnedTypeWithWritableScope( + KotlinTypeInfo typeInfo = components.expressionTypingServices.getBlockReturnedTypeWithWritableScope( scopeToExtend, Collections.singletonList(bodyExpression), coercionStrategy, newContext); loopBreakContinuePossible |= typeInfo.getJumpOutPossible(); KotlinType type = typeInfo.getType(); @@ -200,8 +200,8 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { return; } ValueArgument argumentForSubject = CallMaker.makeExternalValueArgument(subjectExpression); - JetTypeInfo typeInfo = facade.checkInExpression(condition, condition.getOperationReference(), - argumentForSubject, rangeExpression, context); + KotlinTypeInfo typeInfo = facade.checkInExpression(condition, condition.getOperationReference(), + argumentForSubject, rangeExpression, context); DataFlowInfo dataFlowInfo = typeInfo.getDataFlowInfo(); newDataFlowInfo.set(new DataFlowInfos(dataFlowInfo, dataFlowInfo)); KotlinType type = typeInfo.getType(); @@ -267,7 +267,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { if (expression == null) { return noChange(context); } - JetTypeInfo typeInfo = facade.getTypeInfo(expression, context); + KotlinTypeInfo typeInfo = facade.getTypeInfo(expression, context); KotlinType type = typeInfo.getType(); if (type == null) { return noChange(context); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/TypeInfoFactory.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/TypeInfoFactory.kt index e8db85a54ed..18ec3c372b8 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/TypeInfoFactory.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/TypeInfoFactory.kt @@ -21,21 +21,21 @@ import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.expressions.DataFlowAnalyzer -import org.jetbrains.kotlin.types.expressions.JetTypeInfo +import org.jetbrains.kotlin.types.expressions.KotlinTypeInfo /* * Functions in this file are intended to create type info instances in different circumstances */ -public fun createTypeInfo(type: KotlinType?, dataFlowInfo: DataFlowInfo): JetTypeInfo = JetTypeInfo(type, dataFlowInfo) +public fun createTypeInfo(type: KotlinType?, dataFlowInfo: DataFlowInfo): KotlinTypeInfo = KotlinTypeInfo(type, dataFlowInfo) -public fun createTypeInfo(type: KotlinType?, dataFlowInfo: DataFlowInfo, jumpPossible: Boolean, jumpFlowInfo: DataFlowInfo): JetTypeInfo = - JetTypeInfo(type, dataFlowInfo, jumpPossible, jumpFlowInfo) +public fun createTypeInfo(type: KotlinType?, dataFlowInfo: DataFlowInfo, jumpPossible: Boolean, jumpFlowInfo: DataFlowInfo): KotlinTypeInfo = + KotlinTypeInfo(type, dataFlowInfo, jumpPossible, jumpFlowInfo) -public fun createTypeInfo(type: KotlinType?): JetTypeInfo = createTypeInfo(type, DataFlowInfo.EMPTY) +public fun createTypeInfo(type: KotlinType?): KotlinTypeInfo = createTypeInfo(type, DataFlowInfo.EMPTY) -public fun createTypeInfo(type: KotlinType?, context: ResolutionContext<*>): JetTypeInfo = createTypeInfo(type, context.dataFlowInfo) +public fun createTypeInfo(type: KotlinType?, context: ResolutionContext<*>): KotlinTypeInfo = createTypeInfo(type, context.dataFlowInfo) -public fun noTypeInfo(dataFlowInfo: DataFlowInfo): JetTypeInfo = createTypeInfo(null, dataFlowInfo) +public fun noTypeInfo(dataFlowInfo: DataFlowInfo): KotlinTypeInfo = createTypeInfo(null, dataFlowInfo) -public fun noTypeInfo(context: ResolutionContext<*>): JetTypeInfo = noTypeInfo(context.dataFlowInfo) +public fun noTypeInfo(context: ResolutionContext<*>): KotlinTypeInfo = noTypeInfo(context.dataFlowInfo) diff --git a/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java b/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java index c08ba7d0c51..fe360ad62ac 100644 --- a/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java @@ -76,7 +76,7 @@ import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil; import org.jetbrains.kotlin.storage.LockBasedStorageManager; import org.jetbrains.kotlin.test.util.JetTestUtilsKt; import org.jetbrains.kotlin.types.KotlinType; -import org.jetbrains.kotlin.types.expressions.JetTypeInfo; +import org.jetbrains.kotlin.types.expressions.KotlinTypeInfo; import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice; import org.jetbrains.kotlin.util.slicedMap.SlicedMap; import org.jetbrains.kotlin.util.slicedMap.WritableSlice; @@ -185,7 +185,7 @@ public class JetTestUtils { @Nullable @Override public KotlinType getType(@NotNull KtExpression expression) { - JetTypeInfo typeInfo = get(BindingContext.EXPRESSION_TYPE_INFO, expression); + KotlinTypeInfo typeInfo = get(BindingContext.EXPRESSION_TYPE_INFO, expression); return typeInfo != null ? typeInfo.getType() : null; } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/analysis/AnalyzerUtil.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/analysis/AnalyzerUtil.kt index 8ab1c70097a..74fc36af0e2 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/analysis/AnalyzerUtil.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/analysis/AnalyzerUtil.kt @@ -27,7 +27,7 @@ import org.jetbrains.kotlin.resolve.scopes.LexicalScope import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeUtils import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices -import org.jetbrains.kotlin.types.expressions.JetTypeInfo +import org.jetbrains.kotlin.types.expressions.KotlinTypeInfo import org.jetbrains.kotlin.types.expressions.PreliminaryDeclarationVisitor @JvmOverloads @@ -38,7 +38,7 @@ public fun KtExpression.computeTypeInfoInContext( dataFlowInfo: DataFlowInfo = DataFlowInfo.EMPTY, expectedType: KotlinType = TypeUtils.NO_EXPECTED_TYPE, isStatement: Boolean = false -): JetTypeInfo { +): KotlinTypeInfo { PreliminaryDeclarationVisitor.createForExpression(this, trace) return contextExpression.getResolutionFacade().frontendService() .getTypeInfo(scope, this, expectedType, dataFlowInfo, trace, isStatement)