From b81d8eb484849f754a7595b2a6f48545913c8fa0 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Fri, 19 Jun 2015 15:56:51 +0300 Subject: [PATCH] Refactoring: Don't depend on whole context if only DataFlowInfo is needed --- .../kotlin/resolve/BodiesResolveContext.java | 2 + .../kotlin/resolve/BodyResolver.java | 64 ++++++++++--------- .../kotlin/resolve/lazy/ElementResolver.kt | 31 ++++----- 3 files changed, 49 insertions(+), 48 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java index 8af57873a30..b3670ef13d4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java @@ -47,6 +47,8 @@ public interface BodiesResolveContext { Map getFunctions(); Function getDeclaringScopes(); + + @NotNull DataFlowInfo getOuterDataFlowInfo(); @NotNull diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java index 36ad7f00221..5d7267295cf 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java @@ -66,6 +66,7 @@ public class BodyResolver { private AdditionalCheckerProvider additionalCheckerProvider; private ValueParameterResolver valueParameterResolver; + // @Inject public void setScriptBodyResolverResolver(@NotNull ScriptBodyResolver scriptBodyResolverResolver) { this.scriptBodyResolverResolver = scriptBodyResolverResolver; @@ -120,6 +121,7 @@ public class BodyResolver { public void setValueParameterResolver(ValueParameterResolver valueParameterResolver) { this.valueParameterResolver = valueParameterResolver; } + // private void resolveBehaviorDeclarationBodies(@NotNull BodiesResolveContext c) { resolveDelegationSpecifierLists(c); @@ -144,7 +146,7 @@ public class BodyResolver { for (Map.Entry entry : c.getSecondaryConstructors().entrySet()) { JetScope declaringScope = c.getDeclaringScopes().apply(entry.getKey()); assert declaringScope != null : "Declaring scope should be registered before body resolve"; - resolveSecondaryConstructorBody(c, trace, entry.getKey(), entry.getValue(), declaringScope); + resolveSecondaryConstructorBody(c.getOuterDataFlowInfo(), trace, entry.getKey(), entry.getValue(), declaringScope); } if (c.getSecondaryConstructors().isEmpty()) return; Set visitedConstructors = Sets.newHashSet(); @@ -154,7 +156,7 @@ public class BodyResolver { } public void resolveSecondaryConstructorBody( - @NotNull final BodiesResolveContext c, + @NotNull final DataFlowInfo outerDataFlowInfo, @NotNull final BindingTrace trace, @NotNull final JetSecondaryConstructor constructor, @NotNull final ConstructorDescriptor descriptor, @@ -163,11 +165,11 @@ public class BodyResolver { ForceResolveUtil.forceResolveAllContents(descriptor.getAnnotations()); final CallChecker callChecker = new ConstructorHeaderCallChecker(descriptor, additionalCheckerProvider.getCallChecker()); - resolveFunctionBody(c, trace, constructor, descriptor, declaringScope, + resolveFunctionBody(outerDataFlowInfo, trace, constructor, descriptor, declaringScope, new Function1() { @Override public DataFlowInfo invoke(@NotNull JetScope headerInnerScope) { - return resolveSecondaryConstructorDelegationCall(c, trace, headerInnerScope, constructor, descriptor, + return resolveSecondaryConstructorDelegationCall(outerDataFlowInfo, trace, headerInnerScope, constructor, descriptor, callChecker); } }, @@ -176,7 +178,7 @@ public class BodyResolver { @Nullable private DataFlowInfo resolveSecondaryConstructorDelegationCall( - @NotNull BodiesResolveContext c, + @NotNull DataFlowInfo outerDataFlowInfo, @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull JetSecondaryConstructor constructor, @@ -184,7 +186,7 @@ public class BodyResolver { @NotNull CallChecker callChecker ) { OverloadResolutionResults results = callResolver.resolveConstructorDelegationCall( - trace, scope, c.getOuterDataFlowInfo(), + trace, scope, outerDataFlowInfo, descriptor, constructor.getDelegationCall(), callChecker); @@ -262,7 +264,7 @@ public class BodyResolver { JetClassOrObject classOrObject = entry.getKey(); ClassDescriptorWithResolutionScopes descriptor = entry.getValue(); - resolveDelegationSpecifierList(c, classOrObject, descriptor, + resolveDelegationSpecifierList(c.getOuterDataFlowInfo(), classOrObject, descriptor, descriptor.getUnsubstitutedPrimaryConstructor(), descriptor.getScopeForClassHeaderResolution(), descriptor.getScopeForMemberDeclarationResolution()); @@ -270,12 +272,13 @@ public class BodyResolver { } public void resolveDelegationSpecifierList( - @NotNull final BodiesResolveContext c, + @NotNull final DataFlowInfo outerDataFlowInfo, @NotNull JetClassOrObject jetClass, @NotNull final ClassDescriptor descriptor, @Nullable final ConstructorDescriptor primaryConstructor, @NotNull JetScope scopeForSupertypeResolution, - @NotNull final JetScope scopeForMemberResolution) { + @NotNull final JetScope scopeForMemberResolution + ) { final JetScope scopeForConstructor = primaryConstructor == null ? null : FunctionDescriptorUtil.getFunctionInnerScope(scopeForSupertypeResolution, primaryConstructor, trace); @@ -309,7 +312,7 @@ public class BodyResolver { if (delegateExpression != null) { JetScope scope = scopeForConstructor == null ? scopeForMemberResolution : scopeForConstructor; JetType expectedType = supertype != null ? supertype : NO_EXPECTED_TYPE; - typeInferrer.getType(scope, delegateExpression, expectedType, c.getOuterDataFlowInfo(), trace); + typeInferrer.getType(scope, delegateExpression, expectedType, outerDataFlowInfo, trace); } if (primaryConstructor == null) { trace.report(UNSUPPORTED.on(specifier, "Delegation without primary constructor is not supported")); @@ -334,7 +337,7 @@ public class BodyResolver { } OverloadResolutionResults results = callResolver.resolveFunctionCall( trace, scopeForConstructor, - CallMaker.makeCall(ReceiverValue.NO_RECEIVER, null, call), NO_EXPECTED_TYPE, c.getOuterDataFlowInfo(), false); + CallMaker.makeCall(ReceiverValue.NO_RECEIVER, null, call), NO_EXPECTED_TYPE, outerDataFlowInfo, false); if (results.isSuccess()) { JetType supertype = results.getResultingDescriptor().getReturnType(); recordSupertype(typeReference, supertype); @@ -509,12 +512,12 @@ public class BodyResolver { for (Map.Entry entry : c.getAnonymousInitializers().entrySet()) { JetClassInitializer initializer = entry.getKey(); ClassDescriptorWithResolutionScopes descriptor = entry.getValue(); - resolveAnonymousInitializer(c, initializer, descriptor); + resolveAnonymousInitializer(c.getOuterDataFlowInfo(), initializer, descriptor); } } public void resolveAnonymousInitializer( - @NotNull BodiesResolveContext c, + @NotNull DataFlowInfo outerDataFlowInfo, @NotNull JetClassInitializer anonymousInitializer, @NotNull ClassDescriptorWithResolutionScopes classDescriptor ) { @@ -522,7 +525,7 @@ public class BodyResolver { if (!classDescriptor.getConstructors().isEmpty()) { JetExpression body = anonymousInitializer.getBody(); if (body != null) { - expressionTypingServices.getType(scopeForInitializers, body, NO_EXPECTED_TYPE, c.getOuterDataFlowInfo(), trace); + expressionTypingServices.getType(scopeForInitializers, body, NO_EXPECTED_TYPE, outerDataFlowInfo, trace); } processModifiersOnInitializer(anonymousInitializer, scopeForInitializers); } @@ -588,13 +591,13 @@ public class BodyResolver { parentScope = propertyScope; } if (initializer != null) { - resolvePropertyInitializer(c, property, propertyDescriptor, initializer, propertyScope); + resolvePropertyInitializer(c.getOuterDataFlowInfo(), property, propertyDescriptor, initializer, propertyScope); } JetExpression delegateExpression = property.getDelegateExpression(); if (delegateExpression != null) { assert initializer == null : "Initializer should be null for delegated property : " + property.getText(); - resolvePropertyDelegate(c, property, propertyDescriptor, delegateExpression, parentScope, propertyScope); + resolvePropertyDelegate(c.getOuterDataFlowInfo(), property, propertyDescriptor, delegateExpression, parentScope, propertyScope); } resolvePropertyAccessors(c, property, propertyDescriptor); @@ -647,7 +650,7 @@ public class BodyResolver { if (getter != null && getterDescriptor != null) { JetScope accessorScope = makeScopeForPropertyAccessor(c, getter, propertyDescriptor); ForceResolveUtil.forceResolveAllContents(getterDescriptor.getAnnotations()); - resolveFunctionBody(c, fieldAccessTrackingTrace, getter, getterDescriptor, accessorScope); + resolveFunctionBody(c.getOuterDataFlowInfo(), fieldAccessTrackingTrace, getter, getterDescriptor, accessorScope); } JetPropertyAccessor setter = property.getSetter(); @@ -655,7 +658,7 @@ public class BodyResolver { if (setter != null && setterDescriptor != null) { JetScope accessorScope = makeScopeForPropertyAccessor(c, setter, propertyDescriptor); ForceResolveUtil.forceResolveAllContents(setterDescriptor.getAnnotations()); - resolveFunctionBody(c, fieldAccessTrackingTrace, setter, setterDescriptor, accessorScope); + resolveFunctionBody(c.getOuterDataFlowInfo(), fieldAccessTrackingTrace, setter, setterDescriptor, accessorScope); } } @@ -677,7 +680,7 @@ public class BodyResolver { } public void resolvePropertyDelegate( - @NotNull BodiesResolveContext c, + @NotNull DataFlowInfo outerDataFlowInfo, @NotNull JetProperty jetProperty, @NotNull PropertyDescriptor propertyDescriptor, @NotNull JetExpression delegateExpression, @@ -701,7 +704,7 @@ public class BodyResolver { JetType delegateType = delegatedPropertyResolver.resolveDelegateExpression( delegateExpression, jetProperty, propertyDescriptor, propertyDeclarationInnerScope, accessorScope, trace, - c.getOuterDataFlowInfo()); + outerDataFlowInfo); delegatedPropertyResolver.resolveDelegatedPropertyGetMethod(propertyDescriptor, delegateExpression, delegateType, trace, accessorScope); @@ -716,7 +719,7 @@ public class BodyResolver { } public void resolvePropertyInitializer( - @NotNull BodiesResolveContext c, + @NotNull DataFlowInfo outerDataFlowInfo, @NotNull JetProperty property, @NotNull PropertyDescriptor propertyDescriptor, @NotNull JetExpression initializer, @@ -728,7 +731,7 @@ public class BodyResolver { CompileTimeConstant compileTimeInitializer = propertyDescriptor.getCompileTimeInitializer(); if (compileTimeInitializer == null) { expressionTypingServices.getType(propertyDeclarationInnerScope, initializer, expectedTypeForInitializer, - c.getOuterDataFlowInfo(), trace); + outerDataFlowInfo, trace); } } @@ -749,24 +752,24 @@ public class BodyResolver { JetScope declaringScope = c.getDeclaringScopes().apply(declaration); assert declaringScope != null; - resolveFunctionBody(c, trace, declaration, descriptor, declaringScope); + resolveFunctionBody(c.getOuterDataFlowInfo(), trace, declaration, descriptor, declaringScope); assert descriptor.getReturnType() != null; } } public void resolveFunctionBody( - @NotNull BodiesResolveContext c, + @NotNull DataFlowInfo outerDataFlowInfo, @NotNull BindingTrace trace, @NotNull JetDeclarationWithBody function, @NotNull FunctionDescriptor functionDescriptor, @NotNull JetScope declaringScope ) { - resolveFunctionBody(c, trace, function, functionDescriptor, declaringScope, null, null); + resolveFunctionBody(outerDataFlowInfo, trace, function, functionDescriptor, declaringScope, null, null); } public void resolveFunctionBody( - @NotNull BodiesResolveContext c, + @NotNull DataFlowInfo outerDataFlowInfo, @NotNull BindingTrace trace, @NotNull JetDeclarationWithBody function, @NotNull FunctionDescriptor functionDescriptor, @@ -781,7 +784,7 @@ public class BodyResolver { valueParameterResolver.resolveValueParameters( valueParameters, valueParameterDescriptors, ExpressionTypingContext.newContext( - additionalCheckerProvider, trace, innerScope, c.getOuterDataFlowInfo(), NO_EXPECTED_TYPE, callChecker) + additionalCheckerProvider, trace, innerScope, outerDataFlowInfo, NO_EXPECTED_TYPE, callChecker) ); DataFlowInfo dataFlowInfo = null; @@ -792,14 +795,14 @@ public class BodyResolver { if (function.hasBody()) { expressionTypingServices.checkFunctionReturnType( - innerScope, function, functionDescriptor, dataFlowInfo != null ? dataFlowInfo : c.getOuterDataFlowInfo(), null, trace); + innerScope, function, functionDescriptor, dataFlowInfo != null ? dataFlowInfo : outerDataFlowInfo, null, trace); } assert functionDescriptor.getReturnType() != null; } public void resolveConstructorParameterDefaultValuesAndAnnotations( - @NotNull BodiesResolveContext c, + @NotNull DataFlowInfo outerDataFlowInfo, @NotNull BindingTrace trace, @NotNull JetClass klass, @NotNull ConstructorDescriptor constructorDescriptor, @@ -810,8 +813,7 @@ public class BodyResolver { JetScope scope = getPrimaryConstructorParametersScope(declaringScope, constructorDescriptor); - valueParameterResolver.resolveValueParameters(valueParameters, valueParameterDescriptors, scope, - c.getOuterDataFlowInfo(), trace); + valueParameterResolver.resolveValueParameters(valueParameters, valueParameterDescriptors, scope, outerDataFlowInfo, trace); } private static void computeDeferredType(JetType type) { diff --git a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt index d975a6a454c..8e354abdbee 100644 --- a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt +++ b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt @@ -294,7 +294,7 @@ public abstract class ElementResolver protected constructor( ForceResolveUtil.forceResolveAllContents(descriptor.getTypeConstructor().getSupertypes()) val bodyResolver = createBodyResolver(resolveSession, trace, file, StatementFilter.NONE) - bodyResolver.resolveDelegationSpecifierList(createEmptyContext(), + bodyResolver.resolveDelegationSpecifierList(DataFlowInfo.EMPTY, classOrObject, descriptor, descriptor.getUnsubstitutedPrimaryConstructor(), @@ -305,26 +305,27 @@ public abstract class ElementResolver protected constructor( private fun propertyAdditionalResolve(resolveSession: ResolveSession, jetProperty: JetProperty, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter) { val propertyResolutionScope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(jetProperty) - val bodyResolveContext = BodyResolveContextForLazy(TopDownAnalysisMode.LocalDeclarations, object : Function { - override fun apply(declaration: JetDeclaration?): JetScope? { - assert(declaration!!.getParent() == jetProperty) { "Must be called only for property accessors, but called for " + declaration } - return resolveSession.getScopeProvider().getResolutionScopeForDeclaration(declaration) - } - }) val bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter) val descriptor = resolveSession.resolveToDescriptor(jetProperty) as PropertyDescriptor ForceResolveUtil.forceResolveAllContents(descriptor) val propertyInitializer = jetProperty.getInitializer() if (propertyInitializer != null) { - bodyResolver.resolvePropertyInitializer(bodyResolveContext, jetProperty, descriptor, propertyInitializer, propertyResolutionScope) + bodyResolver.resolvePropertyInitializer(DataFlowInfo.EMPTY, jetProperty, descriptor, propertyInitializer, propertyResolutionScope) } val propertyDelegate = jetProperty.getDelegateExpression() if (propertyDelegate != null) { - bodyResolver.resolvePropertyDelegate(bodyResolveContext, jetProperty, descriptor, propertyDelegate, propertyResolutionScope, propertyResolutionScope) + bodyResolver.resolvePropertyDelegate(DataFlowInfo.EMPTY, jetProperty, descriptor, propertyDelegate, propertyResolutionScope, propertyResolutionScope) } + val bodyResolveContext = BodyResolveContextForLazy(TopDownAnalysisMode.LocalDeclarations, object : Function { + override fun apply(declaration: JetDeclaration?): JetScope? { + assert(declaration!!.getParent() == jetProperty) { "Must be called only for property accessors, but called for " + declaration } + return resolveSession.getScopeProvider().getResolutionScopeForDeclaration(declaration) + } + }) + bodyResolver.resolvePropertyAccessors(bodyResolveContext, jetProperty, descriptor) for (accessor in jetProperty.getAccessors()) { @@ -338,7 +339,7 @@ public abstract class ElementResolver protected constructor( ForceResolveUtil.forceResolveAllContents(functionDescriptor) val bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter) - bodyResolver.resolveFunctionBody(createEmptyContext(), trace, namedFunction, functionDescriptor, scope) + bodyResolver.resolveFunctionBody(DataFlowInfo.EMPTY, trace, namedFunction, functionDescriptor, scope) } private fun secondaryConstructorAdditionalResolve(resolveSession: ResolveSession, constructor: JetSecondaryConstructor, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter) { @@ -347,7 +348,7 @@ public abstract class ElementResolver protected constructor( ForceResolveUtil.forceResolveAllContents(constructorDescriptor) val bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter) - bodyResolver.resolveSecondaryConstructorBody(createEmptyContext(), trace, constructor, constructorDescriptor, scope) + bodyResolver.resolveSecondaryConstructorBody(DataFlowInfo.EMPTY, trace, constructor, constructorDescriptor, scope) } private fun constructorAdditionalResolve(resolveSession: ResolveSession, klass: JetClass, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter) { @@ -358,7 +359,7 @@ public abstract class ElementResolver protected constructor( ?: error("Can't get primary constructor for descriptor '$classDescriptor' in from class '${klass.getElementTextWithContext()}'") val bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter) - bodyResolver.resolveConstructorParameterDefaultValuesAndAnnotations(createEmptyContext(), trace, klass, constructorDescriptor, scope) + bodyResolver.resolveConstructorParameterDefaultValuesAndAnnotations(DataFlowInfo.EMPTY, trace, klass, constructorDescriptor, scope) } private fun initializerAdditionalResolve(resolveSession: ResolveSession, classInitializer: JetClassInitializer, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter) { @@ -366,7 +367,7 @@ public abstract class ElementResolver protected constructor( val classOrObjectDescriptor = resolveSession.resolveToDescriptor(classOrObject) as LazyClassDescriptor val bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter) - bodyResolver.resolveAnonymousInitializer(createEmptyContext(), classInitializer, classOrObjectDescriptor) + bodyResolver.resolveAnonymousInitializer(DataFlowInfo.EMPTY, classInitializer, classOrObjectDescriptor) } private fun createBodyResolver(resolveSession: ResolveSession, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter): BodyResolver { @@ -377,10 +378,6 @@ public abstract class ElementResolver protected constructor( ).get() } - private fun createEmptyContext(): BodyResolveContextForLazy { - return BodyResolveContextForLazy(TopDownAnalysisMode.LocalDeclarations, Functions.constant(null)) - } - private fun getExpressionResolutionScope(resolveSession: ResolveSession, expression: JetExpression): JetScope { val provider = resolveSession.getScopeProvider() val parentDeclaration = expression.getParentOfType(true)