From f32d8b1d0638b5db3a8dee8f5bcb669db3feb631 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Sat, 22 Feb 2014 18:35:53 +0400 Subject: [PATCH] Do not inject BodiesResolveContext into BodyResolver --- .../di/InjectorForTopDownAnalyzerForJvm.java | 1 - .../analyzer/AnalyzerFacadeForEverything.java | 4 +- .../src/org/jetbrains/jet/context/context.kt | 11 +- .../jet/di/InjectorForBodyResolve.java | 13 +- .../di/InjectorForTopDownAnalyzerBasic.java | 1 - .../jet/lang/resolve/BodyResolver.java | 150 +++++++++--------- .../jet/lang/resolve/TopDownAnalyzer.java | 2 +- .../generators/injectors/GenerateInjectors.kt | 3 +- .../plugin/project/ResolveElementCache.java | 42 +++-- .../di/InjectorForTopDownAnalyzerForJs.java | 1 - 10 files changed, 123 insertions(+), 105 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 862b54a7587..2dfaa9324c7 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -202,7 +202,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly bodyResolver.setAnnotationResolver(annotationResolver); bodyResolver.setCallResolver(callResolver); - bodyResolver.setContext(topDownAnalysisContext); bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer); bodyResolver.setDeclarationsChecker(declarationsChecker); bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java index be00b709797..d14fe2dc213 100644 --- a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java +++ b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java @@ -51,10 +51,10 @@ public class AnalyzerFacadeForEverything { InjectorForBodyResolve injector = new InjectorForBodyResolve( project, topDownAnalysisParameters, new ObservableBindingTrace(traceContext), - bodiesResolveContext, module); + module); try { - injector.getBodyResolver().resolveBodies(); + injector.getBodyResolver().resolveBodies(bodiesResolveContext); return AnalyzeExhaust.success(traceContext.getBindingContext(), module); } finally { injector.destroy(); diff --git a/compiler/frontend/src/org/jetbrains/jet/context/context.kt b/compiler/frontend/src/org/jetbrains/jet/context/context.kt index df48ed61b73..311f21e6f4e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/context/context.kt +++ b/compiler/frontend/src/org/jetbrains/jet/context/context.kt @@ -25,11 +25,18 @@ trait GlobalContext { val exceptionTracker: ExceptionTracker } -open class GlobalContextImpl( - override val storageManager: LockBasedStorageManager, +open class SimpleGlobalContext( + override val storageManager: StorageManager, override val exceptionTracker: ExceptionTracker ) : GlobalContext +open class GlobalContextImpl( + storageManager: LockBasedStorageManager, + exceptionTracker: ExceptionTracker +) : SimpleGlobalContext(storageManager, exceptionTracker) { + override val storageManager: LockBasedStorageManager = super.storageManager as LockBasedStorageManager +} + fun GlobalContext(): GlobalContextImpl { val tracker = ExceptionTracker() return GlobalContextImpl(LockBasedStorageManager.createWithExceptionHandling(tracker), tracker) diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java index 7c53afe7fa6..a9858e4ea1f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java @@ -18,12 +18,13 @@ package org.jetbrains.jet.di; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; +import org.jetbrains.jet.storage.ExceptionTracker; import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.resolve.BodiesResolveContext; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.resolve.BodyResolver; +import org.jetbrains.jet.context.SimpleGlobalContext; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; @@ -53,12 +54,13 @@ public class InjectorForBodyResolve { private final Project project; private final TopDownAnalysisParameters topDownAnalysisParameters; + private final ExceptionTracker exceptionTracker; private final StorageManager storageManager; private final BindingTrace bindingTrace; - private final BodiesResolveContext bodiesResolveContext; private final ModuleDescriptor moduleDescriptor; private final PlatformToKotlinClassMap platformToKotlinClassMap; private final BodyResolver bodyResolver; + private final SimpleGlobalContext simpleGlobalContext; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; @@ -84,17 +86,17 @@ public class InjectorForBodyResolve { @NotNull Project project, @NotNull TopDownAnalysisParameters topDownAnalysisParameters, @NotNull BindingTrace bindingTrace, - @NotNull BodiesResolveContext bodiesResolveContext, @NotNull ModuleDescriptor moduleDescriptor ) { this.project = project; this.topDownAnalysisParameters = topDownAnalysisParameters; + this.exceptionTracker = topDownAnalysisParameters.getExceptionTracker(); this.storageManager = topDownAnalysisParameters.getStorageManager(); this.bindingTrace = bindingTrace; - this.bodiesResolveContext = bodiesResolveContext; this.moduleDescriptor = moduleDescriptor; this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); this.bodyResolver = new BodyResolver(); + this.simpleGlobalContext = new SimpleGlobalContext(storageManager, exceptionTracker); this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); @@ -118,7 +120,6 @@ public class InjectorForBodyResolve { this.bodyResolver.setAnnotationResolver(annotationResolver); this.bodyResolver.setCallResolver(callResolver); - this.bodyResolver.setContext(bodiesResolveContext); this.bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer); this.bodyResolver.setDeclarationsChecker(declarationsChecker); this.bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); @@ -152,7 +153,7 @@ public class InjectorForBodyResolve { expressionTypingComponents.setExpressionTypingServices(expressionTypingServices); expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils); expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker); - expressionTypingComponents.setGlobalContext(bodiesResolveContext); + expressionTypingComponents.setGlobalContext(simpleGlobalContext); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index fd4bda20c12..6a9177a8063 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -157,7 +157,6 @@ public class InjectorForTopDownAnalyzerBasic { bodyResolver.setAnnotationResolver(annotationResolver); bodyResolver.setCallResolver(callResolver); - bodyResolver.setContext(topDownAnalysisContext); bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer); bodyResolver.setDeclarationsChecker(declarationsChecker); bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java index 0e142fb2307..b34027fff91 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java @@ -53,8 +53,6 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.DEFERRED_TYPE; import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; public class BodyResolver { - @NotNull - private BodiesResolveContext context; @NotNull private TopDownAnalysisParameters topDownAnalysisParameters; @NotNull @@ -111,11 +109,6 @@ public class BodyResolver { this.declarationsChecker = declarationsChecker; } - @Inject - public void setContext(@NotNull BodiesResolveContext context) { - this.context = context; - } - @Inject public void setAnnotationResolver(@NotNull AnnotationResolver annotationResolver) { this.annotationResolver = annotationResolver; @@ -131,18 +124,15 @@ public class BodyResolver { this.functionAnalyzerExtension = functionAnalyzerExtension; } - private void resolveBehaviorDeclarationBodies(@NotNull BodiesResolveContext bodiesResolveContext) { - // Initialize context - context = bodiesResolveContext; + private void resolveBehaviorDeclarationBodies(@NotNull BodiesResolveContext c) { + resolveDelegationSpecifierLists(c); - resolveDelegationSpecifierLists(); + resolvePropertyDeclarationBodies(c); + resolveClassAnnotations(c); + resolveAnonymousInitializers(c); + resolvePrimaryConstructorParameters(c); - resolvePropertyDeclarationBodies(); - resolveClassAnnotations(); - resolveAnonymousInitializers(); - resolvePrimaryConstructorParameters(); - - resolveFunctionBodies(); + resolveFunctionBodies(c); scriptBodyResolverResolver.resolveScriptBodies(); @@ -151,30 +141,34 @@ public class BodyResolver { } } - public void resolveBodies() { - resolveBehaviorDeclarationBodies(context); - controlFlowAnalyzer.process(context); - declarationsChecker.process(context); - functionAnalyzerExtension.process(context); + public void resolveBodies(@NotNull BodiesResolveContext c) { + resolveBehaviorDeclarationBodies(c); + controlFlowAnalyzer.process(c); + declarationsChecker.process(c); + functionAnalyzerExtension.process(c); } - private void resolveDelegationSpecifierLists() { + private void resolveDelegationSpecifierLists(@NotNull BodiesResolveContext c) { // TODO : Make sure the same thing is not initialized twice - for (Map.Entry entry : context.getClasses().entrySet()) { + for (Map.Entry entry : c.getClasses().entrySet()) { JetClassOrObject classOrObject = entry.getKey(); ClassDescriptorWithResolutionScopes descriptor = entry.getValue(); - resolveDelegationSpecifierList(classOrObject, descriptor, + + resolveDelegationSpecifierList(c, classOrObject, descriptor, descriptor.getUnsubstitutedPrimaryConstructor(), descriptor.getScopeForClassHeaderResolution(), descriptor.getScopeForMemberDeclarationResolution()); } } - public void resolveDelegationSpecifierList(@NotNull JetClassOrObject jetClass, @NotNull final ClassDescriptor descriptor, + public void resolveDelegationSpecifierList( + @NotNull final BodiesResolveContext c, + @NotNull JetClassOrObject jetClass, + @NotNull final ClassDescriptor descriptor, @Nullable final ConstructorDescriptor primaryConstructor, @NotNull JetScope scopeForSupertypeResolution, @NotNull final JetScope scopeForMemberResolution) { - if (!context.completeAnalysisNeeded(jetClass)) return; + if (!c.completeAnalysisNeeded(jetClass)) return; final JetScope scopeForConstructor = primaryConstructor == null ? null : FunctionDescriptorUtil.getFunctionInnerScope(scopeForSupertypeResolution, primaryConstructor, trace); @@ -208,10 +202,10 @@ public class BodyResolver { JetScope scope = scopeForConstructor == null ? scopeForMemberResolution : scopeForConstructor; - JetType type = typeInferrer.getType(scope, delegateExpression, NO_EXPECTED_TYPE, context.getOuterDataFlowInfo(), trace); + JetType type = typeInferrer.getType(scope, delegateExpression, NO_EXPECTED_TYPE, c.getOuterDataFlowInfo(), trace); if (type != null && supertype != null) { SimpleResolutionContext simpleResolutionContext = new SimpleResolutionContext( - trace, scope, supertype, context.getOuterDataFlowInfo(), ContextDependency.INDEPENDENT, + trace, scope, supertype, c.getOuterDataFlowInfo(), ContextDependency.INDEPENDENT, ResolutionResultsCacheImpl.create(), LabelResolver.create(), expressionTypingServices.createExtension(scope, false), false); DataFlowUtils.checkType(type, delegateExpression, simpleResolutionContext); @@ -235,7 +229,7 @@ public class BodyResolver { } OverloadResolutionResults results = callResolver.resolveFunctionCall( trace, scopeForConstructor, - CallMaker.makeCall(ReceiverValue.NO_RECEIVER, null, call), NO_EXPECTED_TYPE, context.getOuterDataFlowInfo(), false); + CallMaker.makeCall(ReceiverValue.NO_RECEIVER, null, call), NO_EXPECTED_TYPE, c.getOuterDataFlowInfo(), false); if (results.isSuccess()) { JetType supertype = results.getResultingDescriptor().getReturnType(); recordSupertype(typeReference, supertype); @@ -339,31 +333,33 @@ public class BodyResolver { } } - private void resolveClassAnnotations() { - for (Map.Entry entry : context.getClasses().entrySet()) { + private void resolveClassAnnotations(@NotNull BodiesResolveContext c) { + for (Map.Entry entry : c.getClasses().entrySet()) { resolveAnnotationArguments(entry.getValue().getScopeForClassHeaderResolution(), entry.getKey()); } } - private void resolveAnonymousInitializers() { - for (Map.Entry entry : context.getClasses().entrySet()) { + private void resolveAnonymousInitializers(@NotNull BodiesResolveContext c) { + for (Map.Entry entry : c.getClasses().entrySet()) { JetClassOrObject classOrObject = entry.getKey(); ClassDescriptorWithResolutionScopes descriptor = entry.getValue(); - resolveAnonymousInitializers(classOrObject, descriptor.getUnsubstitutedPrimaryConstructor(), + resolveAnonymousInitializers(c, classOrObject, descriptor.getUnsubstitutedPrimaryConstructor(), descriptor.getScopeForInitializerResolution()); } } - public void resolveAnonymousInitializers(JetClassOrObject jetClassOrObject, + public void resolveAnonymousInitializers( + @NotNull BodiesResolveContext c, + @NotNull JetClassOrObject jetClassOrObject, @Nullable ConstructorDescriptor primaryConstructor, @NotNull JetScope scopeForInitializers) { - if (!context.completeAnalysisNeeded(jetClassOrObject)) { + if (!c.completeAnalysisNeeded(jetClassOrObject)) { return; } List anonymousInitializers = jetClassOrObject.getAnonymousInitializers(); if (primaryConstructor != null) { for (JetClassInitializer anonymousInitializer : anonymousInitializers) { - expressionTypingServices.getType(scopeForInitializers, anonymousInitializer.getBody(), NO_EXPECTED_TYPE, context.getOuterDataFlowInfo(), trace); + expressionTypingServices.getType(scopeForInitializers, anonymousInitializer.getBody(), NO_EXPECTED_TYPE, c.getOuterDataFlowInfo(), trace); processModifiersOnInitializer(anonymousInitializer, scopeForInitializers); } } @@ -386,8 +382,8 @@ public class BodyResolver { } } - private void resolvePrimaryConstructorParameters() { - for (Map.Entry entry : context.getClasses().entrySet()) { + private void resolvePrimaryConstructorParameters(@NotNull BodiesResolveContext c) { + for (Map.Entry entry : c.getClasses().entrySet()) { if (!(entry.getKey() instanceof JetClass)) continue; JetClass klass = (JetClass) entry.getKey(); ClassDescriptorWithResolutionScopes classDescriptor = entry.getValue(); @@ -398,7 +394,7 @@ public class BodyResolver { if (unsubstitutedPrimaryConstructor != null) { WritableScope parameterScope = getPrimaryConstructorParametersScope(classDescriptor.getScopeForClassHeaderResolution(), unsubstitutedPrimaryConstructor); expressionTypingServices.resolveValueParameters(klass.getPrimaryConstructorParameters(), unsubstitutedPrimaryConstructor.getValueParameters(), - parameterScope, context.getOuterDataFlowInfo(), trace, context.completeAnalysisNeeded(klass)); + parameterScope, c.getOuterDataFlowInfo(), trace, c.completeAnalysisNeeded(klass)); } } } @@ -419,45 +415,45 @@ public class BodyResolver { return parameterScope; } - private void resolvePropertyDeclarationBodies() { + private void resolvePropertyDeclarationBodies(@NotNull BodiesResolveContext c) { // Member properties Set processed = Sets.newHashSet(); - for (Map.Entry entry : context.getClasses().entrySet()) { + for (Map.Entry entry : c.getClasses().entrySet()) { if (!(entry.getKey() instanceof JetClass)) continue; JetClass jetClass = (JetClass) entry.getKey(); ClassDescriptorWithResolutionScopes classDescriptor = entry.getValue(); for (JetProperty property : jetClass.getProperties()) { - PropertyDescriptor propertyDescriptor = this.context.getProperties().get(property); + PropertyDescriptor propertyDescriptor = c.getProperties().get(property); assert propertyDescriptor != null; computeDeferredType(propertyDescriptor.getReturnType()); JetExpression initializer = property.getInitializer(); - JetScope propertyScope = getScopeForProperty(property); + JetScope propertyScope = getScopeForProperty(c, property); if (initializer != null) { ConstructorDescriptor primaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor(); if (primaryConstructor != null) { - resolvePropertyInitializer(property, propertyDescriptor, initializer, propertyScope); + resolvePropertyInitializer(c, property, propertyDescriptor, initializer, propertyScope); } } JetExpression delegateExpression = property.getDelegateExpression(); if (delegateExpression != null) { assert initializer == null : "Initializer should be null for delegated property : " + property.getText(); - resolvePropertyDelegate(property, propertyDescriptor, delegateExpression, classDescriptor.getScopeForMemberDeclarationResolution(), propertyScope); + resolvePropertyDelegate(c, property, propertyDescriptor, delegateExpression, classDescriptor.getScopeForMemberDeclarationResolution(), propertyScope); } resolveAnnotationArguments(propertyScope, property); - resolvePropertyAccessors(property, propertyDescriptor); + resolvePropertyAccessors(c, property, propertyDescriptor); processed.add(property); } } // Top-level properties & properties of objects - for (Map.Entry entry : this.context.getProperties().entrySet()) { + for (Map.Entry entry : c.getProperties().entrySet()) { JetProperty property = entry.getKey(); if (processed.contains(property)) continue; @@ -466,46 +462,50 @@ public class BodyResolver { computeDeferredType(propertyDescriptor.getReturnType()); JetExpression initializer = property.getInitializer(); - JetScope propertyScope = getScopeForProperty(property); + JetScope propertyScope = getScopeForProperty(c, property); if (initializer != null) { - resolvePropertyInitializer(property, propertyDescriptor, initializer, propertyScope); + resolvePropertyInitializer(c, property, propertyDescriptor, initializer, propertyScope); } JetExpression delegateExpression = property.getDelegateExpression(); if (delegateExpression != null) { assert initializer == null : "Initializer should be null for delegated property : " + property.getText(); - resolvePropertyDelegate(property, propertyDescriptor, delegateExpression, propertyScope, propertyScope); + resolvePropertyDelegate(c, property, propertyDescriptor, delegateExpression, propertyScope, propertyScope); } resolveAnnotationArguments(propertyScope, property); - resolvePropertyAccessors(property, propertyDescriptor); + resolvePropertyAccessors(c, property, propertyDescriptor); } } - private JetScope makeScopeForPropertyAccessor(@NotNull JetPropertyAccessor accessor, @NotNull PropertyDescriptor descriptor) { - JetScope accessorDeclaringScope = context.getDeclaringScopes().apply(accessor); + private JetScope makeScopeForPropertyAccessor(@NotNull BodiesResolveContext c, @NotNull JetPropertyAccessor accessor, @NotNull PropertyDescriptor descriptor) { + JetScope accessorDeclaringScope = c.getDeclaringScopes().apply(accessor); assert accessorDeclaringScope != null : "Scope for accessor " + accessor.getText() + " should exists"; return JetScopeUtils.makeScopeForPropertyAccessor(descriptor, accessorDeclaringScope, trace); } - public void resolvePropertyAccessors(JetProperty property, PropertyDescriptor propertyDescriptor) { + public void resolvePropertyAccessors( + @NotNull BodiesResolveContext c, + @NotNull JetProperty property, + @NotNull PropertyDescriptor propertyDescriptor + ) { ObservableBindingTrace fieldAccessTrackingTrace = createFieldTrackingTrace(propertyDescriptor); JetPropertyAccessor getter = property.getGetter(); PropertyGetterDescriptor getterDescriptor = propertyDescriptor.getGetter(); if (getter != null && getterDescriptor != null) { - JetScope accessorScope = makeScopeForPropertyAccessor(getter, propertyDescriptor); + JetScope accessorScope = makeScopeForPropertyAccessor(c, getter, propertyDescriptor); resolveAnnotationArguments(accessorScope, getter); - resolveFunctionBody(fieldAccessTrackingTrace, getter, getterDescriptor, accessorScope); + resolveFunctionBody(c, fieldAccessTrackingTrace, getter, getterDescriptor, accessorScope); } JetPropertyAccessor setter = property.getSetter(); PropertySetterDescriptor setterDescriptor = propertyDescriptor.getSetter(); if (setter != null && setterDescriptor != null) { - JetScope accessorScope = makeScopeForPropertyAccessor(setter, propertyDescriptor); + JetScope accessorScope = makeScopeForPropertyAccessor(c, setter, propertyDescriptor); resolveAnnotationArguments(accessorScope, setter); - resolveFunctionBody(fieldAccessTrackingTrace, setter, setterDescriptor, accessorScope); + resolveFunctionBody(c, fieldAccessTrackingTrace, setter, setterDescriptor, accessorScope); } } @@ -527,6 +527,7 @@ public class BodyResolver { } public void resolvePropertyDelegate( + @NotNull BodiesResolveContext c, @NotNull JetProperty jetProperty, @NotNull PropertyDescriptor propertyDescriptor, @NotNull JetExpression delegateExpression, @@ -550,7 +551,7 @@ public class BodyResolver { JetType delegateType = delegatedPropertyResolver.resolveDelegateExpression( delegateExpression, jetProperty, propertyDescriptor, propertyDeclarationInnerScope, accessorScope, trace, - context.getOuterDataFlowInfo()); + c.getOuterDataFlowInfo()); delegatedPropertyResolver.resolveDelegatedPropertyGetMethod(propertyDescriptor, delegateExpression, delegateType, trace, accessorScope); @@ -562,6 +563,7 @@ public class BodyResolver { } public void resolvePropertyInitializer( + @NotNull BodiesResolveContext c, @NotNull JetProperty property, @NotNull PropertyDescriptor propertyDescriptor, @NotNull JetExpression initializer, @@ -570,36 +572,37 @@ public class BodyResolver { JetScope propertyDeclarationInnerScope = JetScopeUtils.getPropertyDeclarationInnerScopeForInitializer( scope, propertyDescriptor.getTypeParameters(), NO_RECEIVER_PARAMETER, trace); JetType expectedTypeForInitializer = property.getTypeRef() != null ? propertyDescriptor.getType() : NO_EXPECTED_TYPE; - expressionTypingServices.getType(propertyDeclarationInnerScope, initializer, expectedTypeForInitializer, context.getOuterDataFlowInfo(), trace); + expressionTypingServices.getType(propertyDeclarationInnerScope, initializer, expectedTypeForInitializer, c.getOuterDataFlowInfo(), trace); EvaluatePackage.recordCompileTimeValueForInitializerIfNeeded(propertyDescriptor, initializer, expectedTypeForInitializer, trace); } @NotNull - private JetScope getScopeForProperty(@NotNull JetProperty property) { - JetScope scope = this.context.getDeclaringScopes().apply(property); + private JetScope getScopeForProperty(@NotNull BodiesResolveContext c, @NotNull JetProperty property) { + JetScope scope = c.getDeclaringScopes().apply(property); assert scope != null : "Scope for property " + property.getText() + " should exists"; return scope; } - private void resolveFunctionBodies() { - for (Map.Entry entry : this.context.getFunctions().entrySet()) { + private void resolveFunctionBodies(@NotNull BodiesResolveContext c) { + for (Map.Entry entry : c.getFunctions().entrySet()) { JetNamedFunction declaration = entry.getKey(); SimpleFunctionDescriptor descriptor = entry.getValue(); computeDeferredType(descriptor.getReturnType()); - JetScope declaringScope = this.context.getDeclaringScopes().apply(declaration); + JetScope declaringScope = c.getDeclaringScopes().apply(declaration); assert declaringScope != null; resolveAnnotationArguments(declaringScope, declaration); - resolveFunctionBody(trace, declaration, descriptor, declaringScope); + resolveFunctionBody(c, trace, declaration, descriptor, declaringScope); assert descriptor.getReturnType() != null; } } public void resolveFunctionBody( + @NotNull BodiesResolveContext c, @NotNull BindingTrace trace, @NotNull JetDeclarationWithBody function, @NotNull FunctionDescriptor functionDescriptor, @@ -610,28 +613,29 @@ public class BodyResolver { List valueParameters = function.getValueParameters(); List valueParameterDescriptors = functionDescriptor.getValueParameters(); - boolean needCompleteAnalysis = context.completeAnalysisNeeded(function); + boolean needCompleteAnalysis = c.completeAnalysisNeeded(function); expressionTypingServices.resolveValueParameters(valueParameters, valueParameterDescriptors, functionInnerScope, - context.getOuterDataFlowInfo(), trace, needCompleteAnalysis); + c.getOuterDataFlowInfo(), trace, needCompleteAnalysis); if (!needCompleteAnalysis) return; JetExpression bodyExpression = function.getBodyExpression(); if (bodyExpression != null) { - expressionTypingServices.checkFunctionReturnType(functionInnerScope, function, functionDescriptor, context.getOuterDataFlowInfo(), null, trace); + expressionTypingServices.checkFunctionReturnType(functionInnerScope, function, functionDescriptor, c.getOuterDataFlowInfo(), null, trace); } assert functionDescriptor.getReturnType() != null; } public void resolveConstructorParameterDefaultValuesAndAnnotations( + @NotNull BodiesResolveContext c, @NotNull BindingTrace trace, @NotNull JetClass klass, @NotNull ConstructorDescriptor constructorDescriptor, @NotNull JetScope declaringScope ) { - if (!context.completeAnalysisNeeded(klass)) return; + if (!c.completeAnalysisNeeded(klass)) return; List valueParameters = klass.getPrimaryConstructorParameters(); List valueParameterDescriptors = constructorDescriptor.getValueParameters(); @@ -639,7 +643,7 @@ public class BodyResolver { JetScope scope = getPrimaryConstructorParametersScope(declaringScope, constructorDescriptor); expressionTypingServices.resolveValueParameters(valueParameters, valueParameterDescriptors, scope, - context.getOuterDataFlowInfo(), trace, /* needCompleteAnalysis = */ true); + c.getOuterDataFlowInfo(), trace, /* needCompleteAnalysis = */ true); } private void resolveAnnotationArguments(@NotNull JetScope scope, @NotNull JetModifierListOwner owner) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index 7a903c6b7f9..ead064b3196 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -133,7 +133,7 @@ public class TopDownAnalyzer { overloadResolver.process(); if (!topDownAnalysisParameters.isAnalyzingBootstrapLibrary()) { - bodyResolver.resolveBodies(); + bodyResolver.resolveBodies(context); } context.debug("Exit"); diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt index 154f37e76bf..6281f3a344d 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt @@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices import org.jetbrains.jet.di.* import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils +import org.jetbrains.jet.context.SimpleGlobalContext // NOTE: After making changes, you need to re-generate the injectors. // To do that, you can run main in this file. @@ -194,10 +195,10 @@ private fun generatorForBodyResolve() = parameter(javaClass()) parameter(javaClass(), useAsContext = true) parameter(javaClass()) - parameter(javaClass()) parameter(javaClass(), useAsContext = true) publicField(javaClass()) + field(javaClass()) } private fun generatorForLazyResolve() = diff --git a/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java b/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java index 6400de3cb57..ec0c587f22d 100644 --- a/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java +++ b/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java @@ -229,7 +229,6 @@ public class ResolveElementCache { private static void delegationSpecifierAdditionalResolve( ResolveSession resolveSession, JetDelegationSpecifierList specifier, BindingTrace trace, JetFile file) { - BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file); JetClassOrObject classOrObject = (JetClassOrObject) specifier.getParent(); LazyClassDescriptor descriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor(classOrObject); @@ -237,7 +236,8 @@ public class ResolveElementCache { // Activate resolving of supertypes descriptor.getTypeConstructor().getSupertypes(); - bodyResolver.resolveDelegationSpecifierList(classOrObject, descriptor, + BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file); + bodyResolver.resolveDelegationSpecifierList(createEmptyContext(resolveSession), classOrObject, descriptor, descriptor.getUnsubstitutedPrimaryConstructor(), descriptor.getScopeForClassHeaderResolution(), descriptor.getScopeForMemberDeclarationResolution()); @@ -262,15 +262,15 @@ public class ResolveElementCache { JetExpression propertyInitializer = jetProperty.getInitializer(); if (propertyInitializer != null) { - bodyResolver.resolvePropertyInitializer(jetProperty, descriptor, propertyInitializer, propertyResolutionScope); + bodyResolver.resolvePropertyInitializer(bodyResolveContext, jetProperty, descriptor, propertyInitializer, propertyResolutionScope); } JetExpression propertyDelegate = jetProperty.getDelegateExpression(); if (propertyDelegate != null) { - bodyResolver.resolvePropertyDelegate(jetProperty, descriptor, propertyDelegate, propertyResolutionScope, propertyResolutionScope); + bodyResolver.resolvePropertyDelegate(bodyResolveContext, jetProperty, descriptor, propertyDelegate, propertyResolutionScope, propertyResolutionScope); } - bodyResolver.resolvePropertyAccessors(jetProperty, descriptor); + bodyResolver.resolvePropertyAccessors(bodyResolveContext, jetProperty, descriptor); } private static void functionAdditionalResolve( @@ -279,10 +279,11 @@ public class ResolveElementCache { BindingTrace trace, JetFile file ) { - BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file); JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(namedFunction); FunctionDescriptor functionDescriptor = (FunctionDescriptor) resolveSession.resolveToDescriptor(namedFunction); - bodyResolver.resolveFunctionBody(trace, namedFunction, functionDescriptor, scope); + + BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file); + bodyResolver.resolveFunctionBody(createEmptyContext(resolveSession), trace, namedFunction, functionDescriptor, scope); } private static void constructorAdditionalResolve( @@ -291,14 +292,14 @@ public class ResolveElementCache { BindingTrace trace, JetFile file ) { - BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file); JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(klass); ClassDescriptor classDescriptor = (ClassDescriptor) resolveSession.resolveToDescriptor(klass); ConstructorDescriptor constructorDescriptor = classDescriptor.getUnsubstitutedPrimaryConstructor(); assert constructorDescriptor != null; - bodyResolver.resolveConstructorParameterDefaultValuesAndAnnotations(trace, klass, constructorDescriptor, scope); + BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file); + bodyResolver.resolveConstructorParameterDefaultValuesAndAnnotations(createEmptyContext(resolveSession), trace, klass, constructorDescriptor, scope); } private static boolean initializerAdditionalResolve( @@ -307,11 +308,13 @@ public class ResolveElementCache { BindingTrace trace, JetFile file ) { - BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file); JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(classInitializer, JetClassOrObject.class); LazyClassDescriptor classOrObjectDescriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor(classOrObject); - bodyResolver.resolveAnonymousInitializers(classOrObject, classOrObjectDescriptor.getUnsubstitutedPrimaryConstructor(), - classOrObjectDescriptor.getScopeForInitializerResolution()); + + BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file); + bodyResolver.resolveAnonymousInitializers(createEmptyContext(resolveSession), classOrObject, + classOrObjectDescriptor.getUnsubstitutedPrimaryConstructor(), + classOrObjectDescriptor.getScopeForInitializerResolution()); return true; } @@ -322,7 +325,7 @@ public class ResolveElementCache { bodyResolveContext.getStorageManager(), bodyResolveContext.getExceptionTracker(), Predicates.alwaysTrue(), false, true, Collections.emptyList()); - InjectorForBodyResolve bodyResolve = new InjectorForBodyResolve(file.getProject(), parameters, trace, bodyResolveContext, module); + InjectorForBodyResolve bodyResolve = new InjectorForBodyResolve(file.getProject(), parameters, trace, module); return bodyResolve.getBodyResolver(); } @@ -332,13 +335,18 @@ public class ResolveElementCache { JetFile file ) { return createBodyResolver(trace, file, - new BodyResolveContextForLazy( - resolveSession.getStorageManager(), - resolveSession.getExceptionTracker(), - Functions.constant(null)), + createEmptyContext(resolveSession), resolveSession.getModuleDescriptor()); } + @NotNull + private static BodyResolveContextForLazy createEmptyContext(@NotNull ResolveSession resolveSession) { + return new BodyResolveContextForLazy( + resolveSession.getStorageManager(), + resolveSession.getExceptionTracker(), + Functions.constant(null)); + } + private static JetScope getExpressionResolutionScope(@NotNull ResolveSession resolveSession, @NotNull JetExpression expression) { ScopeProvider provider = resolveSession.getScopeProvider(); JetDeclaration parentDeclaration = PsiTreeUtil.getParentOfType(expression, JetDeclaration.class); diff --git a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index 1d98bd7bd2e..bad7a1cc2f4 100644 --- a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -157,7 +157,6 @@ public class InjectorForTopDownAnalyzerForJs { bodyResolver.setAnnotationResolver(annotationResolver); bodyResolver.setCallResolver(callResolver); - bodyResolver.setContext(topDownAnalysisContext); bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer); bodyResolver.setDeclarationsChecker(declarationsChecker); bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);