diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java index 701d2332cd4..49019d900dd 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java @@ -178,23 +178,23 @@ public class InjectorForLazyResolveWithJava { this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider(); this.lazyResolveToken = new LazyResolveToken(); this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct(); - this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(); - this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$; + this.descriptorResolver = new DescriptorResolver(); this.annotationResolver = new AnnotationResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.dynamicTypesSettings = new DynamicTypesSettings(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings); + this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$; this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); this.expressionTypingComponents = new ExpressionTypingComponents(); this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); - this.dynamicTypesSettings = new DynamicTypesSettings(); this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); - this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java index 1b9dd5cbf3e..9d9643fb2cd 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java @@ -207,24 +207,24 @@ public class InjectorForReplWithJava { this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct(); this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider(); this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$; - this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(); - this.additionalFileScopeProvider = additionalFileScopeProvider; + this.descriptorResolver = new DescriptorResolver(); this.annotationResolver = new AnnotationResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.lazinessToken = new LazinessToken(); + this.dynamicTypesSettings = new DynamicTypesSettings(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); + this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.additionalFileScopeProvider = additionalFileScopeProvider; this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); this.expressionTypingComponents = new ExpressionTypingComponents(); this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); - this.dynamicTypesSettings = new DynamicTypesSettings(); this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); - this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); - this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java index 5e4f9ce599b..2e60bb78a4b 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java @@ -206,23 +206,23 @@ public class InjectorForTopDownAnalyzerForJvm { this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct(); this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider(); this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$; - this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(); + this.descriptorResolver = new DescriptorResolver(); this.annotationResolver = new AnnotationResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.lazinessToken = new LazinessToken(); + this.dynamicTypesSettings = new DynamicTypesSettings(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); + this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); this.expressionTypingComponents = new ExpressionTypingComponents(); this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); - this.dynamicTypesSettings = new DynamicTypesSettings(); this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); - this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); - this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java index a8f9051970d..6cdf253546f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java @@ -32,7 +32,7 @@ import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer; import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider; import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl; import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver; -import org.jetbrains.kotlin.resolve.BodyResolver; +import org.jetbrains.kotlin.resolve.DescriptorResolver; import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallResolver; import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver; @@ -43,16 +43,16 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils; import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker; import org.jetbrains.kotlin.types.reflect.ReflectionTypes; import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; -import org.jetbrains.kotlin.resolve.DescriptorResolver; -import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver; +import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider; import org.jetbrains.kotlin.resolve.TypeResolver; import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver; import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.kotlin.context.LazinessToken; -import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider; import org.jetbrains.kotlin.resolve.calls.CallCompleter; import org.jetbrains.kotlin.resolve.calls.CandidateResolver; import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer; +import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver; +import org.jetbrains.kotlin.resolve.BodyResolver; import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer; import org.jetbrains.kotlin.resolve.DeclarationsChecker; import org.jetbrains.kotlin.resolve.ModifiersChecker; @@ -87,7 +87,7 @@ public class InjectorForLazyBodyResolve { private final AdditionalFileScopeProvider additionalFileScopeProvider; private final DeclarationScopeProviderImpl declarationScopeProvider; private final LazyDeclarationResolver lazyDeclarationResolver; - private final BodyResolver bodyResolver; + private final DescriptorResolver descriptorResolver; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; @@ -98,16 +98,16 @@ public class InjectorForLazyBodyResolve { private final ForLoopConventionsChecker forLoopConventionsChecker; private final ReflectionTypes reflectionTypes; private final CallExpressionResolver callExpressionResolver; - private final DescriptorResolver descriptorResolver; - private final DelegatedPropertyResolver delegatedPropertyResolver; + private final PartialBodyResolveProvider partialBodyResolveProvider; private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; - private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; private final TaskPrioritizer taskPrioritizer; + private final DelegatedPropertyResolver delegatedPropertyResolver; + private final BodyResolver bodyResolver; private final ControlFlowAnalyzer controlFlowAnalyzer; private final DeclarationsChecker declarationsChecker; private final ModifiersChecker modifiersChecker; @@ -139,13 +139,17 @@ public class InjectorForLazyBodyResolve { this.dynamicTypesSettings = dynamicTypesSettings; this.kotlinBuiltIns = moduleDescriptor.getBuiltIns(); this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); - this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(); + this.descriptorResolver = new DescriptorResolver(); + this.annotationResolver = new AnnotationResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.lazinessToken = new LazinessToken(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); + this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); this.additionalFileScopeProvider = new AdditionalFileScopeProvider(); this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace); this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver); - this.bodyResolver = new BodyResolver(); - this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); this.expressionTypingComponents = new ExpressionTypingComponents(); @@ -155,16 +159,12 @@ public class InjectorForLazyBodyResolve { this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.callExpressionResolver = new CallExpressionResolver(); - this.descriptorResolver = new DescriptorResolver(); - this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); - this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); - this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); this.taskPrioritizer = new TaskPrioritizer(storageManager); + this.delegatedPropertyResolver = new DelegatedPropertyResolver(); + this.bodyResolver = new BodyResolver(); this.controlFlowAnalyzer = new ControlFlowAnalyzer(); this.declarationsChecker = new DeclarationsChecker(); this.modifiersChecker = new ModifiersChecker(bindingTrace, additionalCheckerProvider); @@ -197,15 +197,12 @@ public class InjectorForLazyBodyResolve { lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider); lazyDeclarationResolver.setTopLevelDescriptorProvider(analyzer); - bodyResolver.setAnnotationResolver(annotationResolver); - bodyResolver.setCallResolver(callResolver); - bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer); - bodyResolver.setDeclarationsChecker(declarationsChecker); - bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); - bodyResolver.setExpressionTypingServices(expressionTypingServices); - bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension); - bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver); - bodyResolver.setTrace(bindingTrace); + descriptorResolver.setAnnotationResolver(annotationResolver); + descriptorResolver.setBuiltIns(kotlinBuiltIns); + descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); + descriptorResolver.setExpressionTypingServices(expressionTypingServices); + descriptorResolver.setStorageManager(storageManager); + descriptorResolver.setTypeResolver(typeResolver); annotationResolver.setCallResolver(callResolver); annotationResolver.setStorageManager(storageManager); @@ -251,18 +248,21 @@ public class InjectorForLazyBodyResolve { callExpressionResolver.setExpressionTypingServices(expressionTypingServices); - descriptorResolver.setAnnotationResolver(annotationResolver); - descriptorResolver.setBuiltIns(kotlinBuiltIns); - descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); - descriptorResolver.setExpressionTypingServices(expressionTypingServices); - descriptorResolver.setStorageManager(storageManager); - descriptorResolver.setTypeResolver(typeResolver); + candidateResolver.setArgumentTypeResolver(argumentTypeResolver); delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns); delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); - candidateResolver.setArgumentTypeResolver(argumentTypeResolver); + bodyResolver.setAnnotationResolver(annotationResolver); + bodyResolver.setCallResolver(callResolver); + bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer); + bodyResolver.setDeclarationsChecker(declarationsChecker); + bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); + bodyResolver.setExpressionTypingServices(expressionTypingServices); + bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension); + bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver); + bodyResolver.setTrace(bindingTrace); controlFlowAnalyzer.setTrace(bindingTrace); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java index 9f5546b9831..b28d2878203 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java @@ -25,10 +25,13 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider; import org.jetbrains.kotlin.types.DynamicTypesSettings; +import org.jetbrains.kotlin.resolve.LocalClassDescriptorManager; import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer; import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider; import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider; import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer; +import org.jetbrains.kotlin.resolve.DeclarationScopeProviderForLocalClassifierAnalyzer; +import org.jetbrains.kotlin.resolve.LocalLazyDeclarationResolver; import org.jetbrains.kotlin.resolve.BodyResolver; import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallResolver; @@ -58,8 +61,6 @@ import org.jetbrains.kotlin.resolve.ScriptBodyResolver; import org.jetbrains.kotlin.resolve.DeclarationResolver; import org.jetbrains.kotlin.resolve.ImportsResolver; import org.jetbrains.kotlin.psi.JetImportsFactory; -import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl; -import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver; import org.jetbrains.kotlin.resolve.OverloadResolver; import org.jetbrains.kotlin.resolve.OverrideResolver; import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker; @@ -79,10 +80,13 @@ public class InjectorForLazyLocalClassifierAnalyzer { private final PlatformToKotlinClassMap platformToKotlinClassMap; private final AdditionalCheckerProvider additionalCheckerProvider; private final DynamicTypesSettings dynamicTypesSettings; + private final LocalClassDescriptorManager localClassDescriptorManager; private final LazyTopDownAnalyzer lazyTopDownAnalyzer; private final NoTopLevelDescriptorProvider noTopLevelDescriptorProvider; private final NoFileScopeProvider noFileScopeProvider; private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer; + private final DeclarationScopeProviderForLocalClassifierAnalyzer declarationScopeProviderForLocalClassifierAnalyzer; + private final LocalLazyDeclarationResolver localLazyDeclarationResolver; private final BodyResolver bodyResolver; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; @@ -112,8 +116,6 @@ public class InjectorForLazyLocalClassifierAnalyzer { private final DeclarationResolver declarationResolver; private final ImportsResolver importsResolver; private final JetImportsFactory jetImportsFactory; - private final DeclarationScopeProviderImpl declarationScopeProvider; - private final LazyDeclarationResolver lazyDeclarationResolver; private final OverloadResolver overloadResolver; private final OverrideResolver overrideResolver; private final VarianceChecker varianceChecker; @@ -124,7 +126,8 @@ public class InjectorForLazyLocalClassifierAnalyzer { @NotNull BindingTrace bindingTrace, @NotNull ModuleDescriptor module, @NotNull AdditionalCheckerProvider additionalCheckerProvider, - @NotNull DynamicTypesSettings dynamicTypesSettings + @NotNull DynamicTypesSettings dynamicTypesSettings, + @NotNull LocalClassDescriptorManager localClassDescriptorManager ) { this.project = project; this.globalContext = globalContext; @@ -135,12 +138,20 @@ public class InjectorForLazyLocalClassifierAnalyzer { this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap(); this.additionalCheckerProvider = additionalCheckerProvider; this.dynamicTypesSettings = dynamicTypesSettings; + this.localClassDescriptorManager = localClassDescriptorManager; this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); this.noTopLevelDescriptorProvider = NoTopLevelDescriptorProvider.INSTANCE$; this.noFileScopeProvider = NoFileScopeProvider.INSTANCE$; - this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(); - this.bodyResolver = new BodyResolver(); + this.descriptorResolver = new DescriptorResolver(); this.annotationResolver = new AnnotationResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.lazinessToken = new LazinessToken(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); + this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.localLazyDeclarationResolver = new LocalLazyDeclarationResolver(globalContext, bindingTrace, localClassDescriptorManager); + this.declarationScopeProviderForLocalClassifierAnalyzer = new DeclarationScopeProviderForLocalClassifierAnalyzer(localLazyDeclarationResolver, localClassDescriptorManager); + this.bodyResolver = new BodyResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); this.expressionTypingComponents = new ExpressionTypingComponents(); @@ -150,12 +161,7 @@ public class InjectorForLazyLocalClassifierAnalyzer { this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); - this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); - this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); - this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -168,17 +174,15 @@ public class InjectorForLazyLocalClassifierAnalyzer { this.declarationResolver = new DeclarationResolver(); this.importsResolver = new ImportsResolver(); this.jetImportsFactory = new JetImportsFactory(); - this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace); - this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); this.varianceChecker = new VarianceChecker(bindingTrace); this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver); this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver); - this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider); + this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProviderForLocalClassifierAnalyzer); this.lazyTopDownAnalyzer.setFileScopeProvider(noFileScopeProvider); - this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver); + this.lazyTopDownAnalyzer.setLazyDeclarationResolver(localLazyDeclarationResolver); this.lazyTopDownAnalyzer.setModuleDescriptor(module); this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver); this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver); @@ -186,6 +190,12 @@ public class InjectorForLazyLocalClassifierAnalyzer { this.lazyTopDownAnalyzer.setTrace(bindingTrace); this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker); + declarationScopeProviderForLocalClassifierAnalyzer.setFileScopeProvider(noFileScopeProvider); + + localLazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProviderForLocalClassifierAnalyzer); + localLazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProviderForLocalClassifierAnalyzer); + localLazyDeclarationResolver.setTopLevelDescriptorProvider(noTopLevelDescriptorProvider); + bodyResolver.setAnnotationResolver(annotationResolver); bodyResolver.setCallResolver(callResolver); bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer); @@ -275,11 +285,6 @@ public class InjectorForLazyLocalClassifierAnalyzer { jetImportsFactory.setProject(project); - declarationScopeProvider.setFileScopeProvider(noFileScopeProvider); - - lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider); - lazyDeclarationResolver.setTopLevelDescriptorProvider(noTopLevelDescriptorProvider); - overloadResolver.setTrace(bindingTrace); overrideResolver.setTrace(bindingTrace); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java index fc5376dd2f3..35db10c0db5 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java @@ -122,8 +122,12 @@ public class InjectorForLazyResolve { this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace); this.scopeProvider = new ScopeProvider(getResolveSession()); this.lazyResolveToken = new LazyResolveToken(); - this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(); + this.descriptorResolver = new DescriptorResolver(); this.annotationResolver = new AnnotationResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings); + this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); this.expressionTypingComponents = new ExpressionTypingComponents(); @@ -133,11 +137,7 @@ public class InjectorForLazyResolve { this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.callExpressionResolver = new CallExpressionResolver(); - this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); - this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java index 143e84cdf1f..3cc8d8861b3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java @@ -144,24 +144,24 @@ public class InjectorForLazyTopDownAnalyzerBasic { this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel(); this.defaultProvider = DefaultProvider.INSTANCE$; - this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(); + this.descriptorResolver = new DescriptorResolver(); this.annotationResolver = new AnnotationResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.lazinessToken = new LazinessToken(); + this.dynamicTypesSettings = new DynamicTypesSettings(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); + this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); this.expressionTypingComponents = new ExpressionTypingComponents(); this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); - this.dynamicTypesSettings = new DynamicTypesSettings(); this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); - this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); - this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); - this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyLocalClassifierAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyLocalClassifierAnalyzer.kt index c5991794b3b..2ea91ddfeed 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyLocalClassifierAnalyzer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyLocalClassifierAnalyzer.kt @@ -1,18 +1,18 @@ /* - * Copyright 2010-2015 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ +* Copyright 2010-2015 JetBrains s.r.o. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ package org.jetbrains.kotlin.resolve @@ -25,8 +25,32 @@ import org.jetbrains.kotlin.psi.JetClassOrObject import org.jetbrains.kotlin.types.DynamicTypesSettings import com.google.common.base.Predicates import org.jetbrains.kotlin.di.InjectorForLazyLocalClassifierAnalyzer +import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl +import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.resolve.scopes.JetScope +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyClassContext +import org.jetbrains.kotlin.resolve.lazy.data.JetClassInfoUtil +import org.jetbrains.kotlin.psi.debugText.getDebugText +import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor +import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory +import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo +import org.jetbrains.kotlin.resolve.lazy.declarations.ClassMemberDeclarationProvider +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.resolve.lazy.declarations.PackageMemberDeclarationProvider +import org.jetbrains.kotlin.resolve.lazy.declarations.PsiBasedClassMemberDeclarationProvider +import org.jetbrains.kotlin.storage.StorageManager +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProvider +import org.jetbrains.kotlin.psi.psiUtil.isObjectLiteral +import org.jetbrains.kotlin.name.SpecialNames -public class LazyLocalClassifierAnalyzer : LocalClassifierAnalyzer() { +public class LazyLocalClassifierAnalyzer( + val descriptorResolver: DescriptorResolver, + val typeResolver: TypeResolver, + val annotationResolver: AnnotationResolver +) : LocalClassifierAnalyzer() { override fun processClassOrObject( globalContext: GlobalContext, scope: WritableScope?, @@ -44,13 +68,24 @@ public class LazyLocalClassifierAnalyzer : LocalClassifierAnalyzer() { val c = TopDownAnalysisContext(topDownAnalysisParameters) c.setOuterDataFlowInfo(context.dataFlowInfo) + val moduleDescriptor = DescriptorUtils.getContainingModule(containingDeclaration) val injector = InjectorForLazyLocalClassifierAnalyzer( classOrObject.getProject(), globalContext, context.trace, - DescriptorUtils.getContainingModule(containingDeclaration), + moduleDescriptor, additionalCheckerProvider, - dynamicTypesSettings + dynamicTypesSettings, + LocalClassDescriptorManager( + classOrObject, + containingDeclaration, + globalContext.storageManager, + context, + moduleDescriptor, + descriptorResolver, + typeResolver, + annotationResolver + ) ) injector.getLazyTopDownAnalyzer().analyzeDeclarations( @@ -58,4 +93,85 @@ public class LazyLocalClassifierAnalyzer : LocalClassifierAnalyzer() { listOf(classOrObject) ) } +} + +class LocalClassDescriptorManager( + val myClass: JetClassOrObject, + val containingDeclaration: DeclarationDescriptor, + val storageManager: StorageManager, + val expressionTypingContext: ExpressionTypingContext, + val moduleDescriptor: ModuleDescriptor, + val descriptorResolver: DescriptorResolver, + val typeResolver: TypeResolver, + val annotationResolver: AnnotationResolver +) { + // We do not need to synchronize here, because this code is used strictly from one thread + private var classDescriptor: ClassDescriptor? = null + + fun isMyClass(c: PsiElement): Boolean = c == myClass + + fun createClassDescriptor(classOrObject: JetClassOrObject, declarationScopeProvider: DeclarationScopeProvider): ClassDescriptor { + assert(isMyClass(classOrObject)) {"Called on a wrong class: ${classOrObject.getDebugText()}"} + if (classDescriptor == null) { + classDescriptor = LazyClassDescriptor( + object : LazyClassContext { + override val scopeProvider = declarationScopeProvider + override val storageManager = this@LocalClassDescriptorManager.storageManager + override val trace = expressionTypingContext.trace + override val moduleDescriptor = this@LocalClassDescriptorManager.moduleDescriptor + override val descriptorResolver = this@LocalClassDescriptorManager.descriptorResolver + override val typeResolver = this@LocalClassDescriptorManager.typeResolver + override val declarationProviderFactory = object : DeclarationProviderFactory { + override fun getClassMemberDeclarationProvider(classLikeInfo: JetClassLikeInfo): ClassMemberDeclarationProvider { + return PsiBasedClassMemberDeclarationProvider(storageManager, classLikeInfo) + } + + override fun getPackageMemberDeclarationProvider(packageFqName: FqName): PackageMemberDeclarationProvider? { + throw UnsupportedOperationException("Should not be called for top-level declarations") + } + + } + override val annotationResolver = this@LocalClassDescriptorManager.annotationResolver + } + , + containingDeclaration, + if (classOrObject.isObjectLiteral()) SpecialNames.NO_NAME_PROVIDED else classOrObject.getNameAsName(), + JetClassInfoUtil.createClassLikeInfo(classOrObject) + ) + } + + return classDescriptor!! + } + + fun getResolutionScopeForClass(classOrObject: JetClassOrObject): JetScope { + assert (isMyClass(classOrObject)) {"Called on a wrong class: ${classOrObject.getDebugText()}"} + return expressionTypingContext.scope + } +} + +class LocalLazyDeclarationResolver( + globalContext: GlobalContext, + trace: BindingTrace, + val localClassDescriptorManager: LocalClassDescriptorManager +) : LazyDeclarationResolver(globalContext, trace) { + + override fun getClassDescriptor(classOrObject: JetClassOrObject): ClassDescriptor { + if (localClassDescriptorManager.isMyClass(classOrObject)) { + return localClassDescriptorManager.createClassDescriptor(classOrObject, scopeProvider) + } + return super.getClassDescriptor(classOrObject) + } +} + + +class DeclarationScopeProviderForLocalClassifierAnalyzer( + lazyDeclarationResolver: LazyDeclarationResolver, + val localClassDescriptorManager: LocalClassDescriptorManager +) : DeclarationScopeProviderImpl(lazyDeclarationResolver) { + override fun getResolutionScopeForDeclaration(elementOfDeclaration: PsiElement): JetScope { + if (localClassDescriptorManager.isMyClass(elementOfDeclaration)) { + return localClassDescriptorManager.getResolutionScopeForClass(elementOfDeclaration as JetClassOrObject) + } + return super.getResolutionScopeForDeclaration(elementOfDeclaration) + } } \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java index 4f4961f67ce..c35a346e0cf 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java @@ -39,7 +39,7 @@ public class LazyDeclarationResolver { private final BindingTrace trace; - private DeclarationScopeProvider scopeProvider; + protected DeclarationScopeProvider scopeProvider; private TopLevelDescriptorProvider topLevelDescriptorProvider; @Inject diff --git a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt index 019a8c30bb2..4bed75f8d15 100644 --- a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt @@ -53,6 +53,7 @@ import org.jetbrains.kotlin.types.DynamicTypesAllowed import org.jetbrains.kotlin.types.DynamicTypesSettings import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider +import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl // NOTE: After making changes, you need to re-generate the injectors. // To do that, you can run main in this file. @@ -121,12 +122,15 @@ private fun generatorForLazyLocalClassifierAnalyzer() = parameter(name = "module", useAsContext = true) parameter() parameter() + parameter() publicField() field() field() field() + field() + field() } private fun generatorForLazyBodyResolve() = diff --git a/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java b/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java index 52e6be2884b..03de807c94c 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java @@ -145,8 +145,13 @@ public class InjectorForTopDownAnalyzerForJs { this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel(); this.kotlinJsCheckerProvider = KotlinJsCheckerProvider.INSTANCE$; this.dynamicTypesAllowed = new DynamicTypesAllowed(); - this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(); + this.descriptorResolver = new DescriptorResolver(); this.annotationResolver = new AnnotationResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.lazinessToken = new LazinessToken(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesAllowed); + this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); this.expressionTypingComponents = new ExpressionTypingComponents(); @@ -156,12 +161,7 @@ public class InjectorForTopDownAnalyzerForJs { this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); - this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); - this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); - this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesAllowed); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);