From 6395fd819f669e2aec10abb3062b95b6fe59b772 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Fri, 23 Jan 2015 19:02:34 +0300 Subject: [PATCH] Got rid of non-lazy local classifier analyzer --- .../di/InjectorForLazyResolveWithJava.java | 32 +++--- .../kotlin/di/InjectorForReplWithJava.java | 34 +++--- .../di/InjectorForTopDownAnalyzerForJvm.java | 32 +++--- .../kotlin/di/InjectorForBodyResolve.java | 20 ++-- .../kotlin/di/InjectorForLazyBodyResolve.java | 84 +++++++------- ...njectorForLazyLocalClassifierAnalyzer.java | 41 ++++--- .../kotlin/di/InjectorForLazyResolve.java | 30 ++--- .../InjectorForLazyTopDownAnalyzerBasic.java | 34 +++--- .../kotlin/di/InjectorForMacros.java | 2 +- .../di/InjectorForTopDownAnalyzerBasic.java | 20 ++-- .../expressions/LocalClassifierAnalyzer.java | 104 ------------------ .../expressions/LocalClassifierAnalyzer.kt} | 63 ++++++----- .../jetbrains/kotlin/di/InjectorForTests.java | 2 +- .../generators/injectors/GenerateInjectors.kt | 13 +-- .../di/InjectorForTopDownAnalyzerForJs.java | 32 +++--- 15 files changed, 219 insertions(+), 324 deletions(-) delete mode 100644 compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.java rename compiler/frontend/src/org/jetbrains/kotlin/{resolve/LazyLocalClassifierAnalyzer.kt => types/expressions/LocalClassifierAnalyzer.kt} (88%) 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 49019d900dd..e92d400f878 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java @@ -42,7 +42,6 @@ import org.jetbrains.kotlin.load.java.components.JavaSourceElementFactoryImpl; import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider; import org.jetbrains.kotlin.context.LazyResolveToken; import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct; -import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer; import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider; import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallResolver; @@ -53,12 +52,13 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils; import org.jetbrains.kotlin.types.DynamicTypesSettings; 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.types.expressions.LocalClassifierAnalyzer; import org.jetbrains.kotlin.resolve.DescriptorResolver; import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver; import org.jetbrains.kotlin.resolve.TypeResolver; import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver; +import org.jetbrains.kotlin.types.reflect.ReflectionTypes; +import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider; import org.jetbrains.kotlin.resolve.calls.CallCompleter; import org.jetbrains.kotlin.resolve.calls.CandidateResolver; @@ -107,7 +107,6 @@ public class InjectorForLazyResolveWithJava { private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider; private final LazyResolveToken lazyResolveToken; private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct; - private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer; private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; @@ -118,12 +117,13 @@ public class InjectorForLazyResolveWithJava { private final DynamicTypesSettings dynamicTypesSettings; private final ExpressionTypingUtils expressionTypingUtils; private final ForLoopConventionsChecker forLoopConventionsChecker; - private final ReflectionTypes reflectionTypes; - private final CallExpressionResolver callExpressionResolver; + private final LocalClassifierAnalyzer localClassifierAnalyzer; private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; + private final ReflectionTypes reflectionTypes; + private final CallExpressionResolver callExpressionResolver; private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; @@ -178,23 +178,23 @@ public class InjectorForLazyResolveWithJava { this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider(); this.lazyResolveToken = new LazyResolveToken(); this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct(); - 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.annotationResolver = new 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.descriptorResolver = new DescriptorResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); - this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -272,7 +272,7 @@ public class InjectorForLazyResolveWithJava { expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils); expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker); expressionTypingComponents.setGlobalContext(globalContext); - expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer); + expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); @@ -281,8 +281,6 @@ public class InjectorForLazyResolveWithJava { forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils); forLoopConventionsChecker.setProject(project); - callExpressionResolver.setExpressionTypingServices(expressionTypingServices); - descriptorResolver.setAnnotationResolver(annotationResolver); descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); @@ -294,6 +292,8 @@ public class InjectorForLazyResolveWithJava { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); + candidateResolver.setArgumentTypeResolver(argumentTypeResolver); jetImportsFactory.setProject(project); 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 9d9643fb2cd..2e4bc3a9809 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java @@ -45,7 +45,6 @@ import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver; import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct; import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider; import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider; -import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer; import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider; import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallResolver; @@ -56,13 +55,14 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils; import org.jetbrains.kotlin.types.DynamicTypesSettings; 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.types.expressions.LocalClassifierAnalyzer; import org.jetbrains.kotlin.resolve.DescriptorResolver; import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver; import org.jetbrains.kotlin.resolve.TypeResolver; import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver; import org.jetbrains.kotlin.context.LazinessToken; +import org.jetbrains.kotlin.types.reflect.ReflectionTypes; +import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider; import org.jetbrains.kotlin.resolve.calls.CallCompleter; import org.jetbrains.kotlin.resolve.calls.CandidateResolver; @@ -122,7 +122,6 @@ public class InjectorForReplWithJava { private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct; private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider; private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider; - private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer; private final AdditionalFileScopeProvider additionalFileScopeProvider; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; @@ -133,13 +132,14 @@ public class InjectorForReplWithJava { private final DynamicTypesSettings dynamicTypesSettings; private final ExpressionTypingUtils expressionTypingUtils; private final ForLoopConventionsChecker forLoopConventionsChecker; - private final ReflectionTypes reflectionTypes; - private final CallExpressionResolver callExpressionResolver; + private final LocalClassifierAnalyzer localClassifierAnalyzer; private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final LazinessToken lazinessToken; + private final ReflectionTypes reflectionTypes; + private final CallExpressionResolver callExpressionResolver; private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; @@ -207,24 +207,24 @@ public class InjectorForReplWithJava { this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct(); this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider(); this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$; - 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.annotationResolver = new 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.descriptorResolver = new DescriptorResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.lazinessToken = new LazinessToken(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); - this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -325,7 +325,7 @@ public class InjectorForReplWithJava { expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils); expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker); expressionTypingComponents.setGlobalContext(globalContext); - expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer); + expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); @@ -334,8 +334,6 @@ public class InjectorForReplWithJava { forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils); forLoopConventionsChecker.setProject(project); - callExpressionResolver.setExpressionTypingServices(expressionTypingServices); - descriptorResolver.setAnnotationResolver(annotationResolver); descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); @@ -347,6 +345,8 @@ public class InjectorForReplWithJava { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); + candidateResolver.setArgumentTypeResolver(argumentTypeResolver); jetImportsFactory.setProject(project); 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 2e60bb78a4b..102b95799f9 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java @@ -45,7 +45,6 @@ import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver; import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct; import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider; import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider; -import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer; import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallResolver; import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver; @@ -55,13 +54,14 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils; import org.jetbrains.kotlin.types.DynamicTypesSettings; 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.types.expressions.LocalClassifierAnalyzer; import org.jetbrains.kotlin.resolve.DescriptorResolver; import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver; import org.jetbrains.kotlin.resolve.TypeResolver; import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver; import org.jetbrains.kotlin.context.LazinessToken; +import org.jetbrains.kotlin.types.reflect.ReflectionTypes; +import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider; import org.jetbrains.kotlin.resolve.calls.CallCompleter; import org.jetbrains.kotlin.resolve.calls.CandidateResolver; @@ -122,7 +122,6 @@ public class InjectorForTopDownAnalyzerForJvm { private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct; private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider; private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider; - private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; @@ -132,13 +131,14 @@ public class InjectorForTopDownAnalyzerForJvm { private final DynamicTypesSettings dynamicTypesSettings; private final ExpressionTypingUtils expressionTypingUtils; private final ForLoopConventionsChecker forLoopConventionsChecker; - private final ReflectionTypes reflectionTypes; - private final CallExpressionResolver callExpressionResolver; + private final LocalClassifierAnalyzer localClassifierAnalyzer; private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final LazinessToken lazinessToken; + private final ReflectionTypes reflectionTypes; + private final CallExpressionResolver callExpressionResolver; private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; @@ -206,23 +206,23 @@ public class InjectorForTopDownAnalyzerForJvm { this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct(); this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider(); this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$; - 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.descriptorResolver = new DescriptorResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.lazinessToken = new LazinessToken(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); - this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -324,7 +324,7 @@ public class InjectorForTopDownAnalyzerForJvm { expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils); expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker); expressionTypingComponents.setGlobalContext(globalContext); - expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer); + expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); @@ -333,8 +333,6 @@ public class InjectorForTopDownAnalyzerForJvm { forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils); forLoopConventionsChecker.setProject(project); - callExpressionResolver.setExpressionTypingServices(expressionTypingServices); - descriptorResolver.setAnnotationResolver(annotationResolver); descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); @@ -346,6 +344,8 @@ public class InjectorForTopDownAnalyzerForJvm { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); + candidateResolver.setArgumentTypeResolver(argumentTypeResolver); jetImportsFactory.setProject(project); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java index c8e4132a0de..aa9b0c583a2 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java @@ -36,14 +36,14 @@ import org.jetbrains.kotlin.types.DynamicTypesSettings; import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils; import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker; import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer; -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.TypeResolver; import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver; import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.kotlin.context.LazinessToken; +import org.jetbrains.kotlin.types.reflect.ReflectionTypes; +import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.calls.CallCompleter; import org.jetbrains.kotlin.resolve.calls.CandidateResolver; import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer; @@ -79,14 +79,14 @@ public class InjectorForBodyResolve { private final ExpressionTypingUtils expressionTypingUtils; private final ForLoopConventionsChecker forLoopConventionsChecker; private final LocalClassifierAnalyzer localClassifierAnalyzer; - private final ReflectionTypes reflectionTypes; - private final CallExpressionResolver callExpressionResolver; private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; + private final ReflectionTypes reflectionTypes; + private final CallExpressionResolver callExpressionResolver; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; private final TaskPrioritizer taskPrioritizer; @@ -123,15 +123,15 @@ public class InjectorForBodyResolve { this.dynamicTypesSettings = new DynamicTypesSettings(); this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); - this.localClassifierAnalyzer = new LocalClassifierAnalyzer(); - 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.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.delegatedPropertyResolver = new DelegatedPropertyResolver(); + this.reflectionTypes = new ReflectionTypes(moduleDescriptor); + this.callExpressionResolver = new CallExpressionResolver(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); this.taskPrioritizer = new TaskPrioritizer(storageManager); @@ -193,8 +193,6 @@ public class InjectorForBodyResolve { forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils); forLoopConventionsChecker.setProject(project); - callExpressionResolver.setExpressionTypingServices(expressionTypingServices); - descriptorResolver.setAnnotationResolver(annotationResolver); descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); @@ -206,6 +204,8 @@ public class InjectorForBodyResolve { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); + candidateResolver.setArgumentTypeResolver(argumentTypeResolver); controlFlowAnalyzer.setTrace(bindingTrace); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java index 6cdf253546f..8f343f4b4e4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java @@ -27,12 +27,11 @@ import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider; import org.jetbrains.kotlin.types.DynamicTypesSettings; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; -import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer; 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.DescriptorResolver; +import org.jetbrains.kotlin.resolve.BodyResolver; import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallResolver; import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver; @@ -41,18 +40,19 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents; import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils; 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.PartialBodyResolveProvider; +import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer; +import org.jetbrains.kotlin.resolve.DescriptorResolver; +import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver; 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.types.reflect.ReflectionTypes; +import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; +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; @@ -82,12 +82,11 @@ public class InjectorForLazyBodyResolve { private final DynamicTypesSettings dynamicTypesSettings; private final KotlinBuiltIns kotlinBuiltIns; private final PlatformToKotlinClassMap platformToKotlinClassMap; - private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer; private final LazyTopDownAnalyzer lazyTopDownAnalyzer; private final AdditionalFileScopeProvider additionalFileScopeProvider; private final DeclarationScopeProviderImpl declarationScopeProvider; private final LazyDeclarationResolver lazyDeclarationResolver; - private final DescriptorResolver descriptorResolver; + private final BodyResolver bodyResolver; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; @@ -96,18 +95,19 @@ public class InjectorForLazyBodyResolve { private final ControlStructureTypingUtils controlStructureTypingUtils; private final ExpressionTypingUtils expressionTypingUtils; private final ForLoopConventionsChecker forLoopConventionsChecker; - private final ReflectionTypes reflectionTypes; - private final CallExpressionResolver callExpressionResolver; - private final PartialBodyResolveProvider partialBodyResolveProvider; + private final LocalClassifierAnalyzer localClassifierAnalyzer; + private final DescriptorResolver descriptorResolver; + private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; + private final ReflectionTypes reflectionTypes; + private final CallExpressionResolver callExpressionResolver; + 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,17 +139,12 @@ public class InjectorForLazyBodyResolve { this.dynamicTypesSettings = dynamicTypesSettings; this.kotlinBuiltIns = moduleDescriptor.getBuiltIns(); this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); - 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(); @@ -157,14 +152,19 @@ public class InjectorForLazyBodyResolve { this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); + this.descriptorResolver = new DescriptorResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.lazinessToken = new LazinessToken(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.callExpressionResolver = new CallExpressionResolver(); 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,12 +197,15 @@ public class InjectorForLazyBodyResolve { lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider); lazyDeclarationResolver.setTopLevelDescriptorProvider(analyzer); - descriptorResolver.setAnnotationResolver(annotationResolver); - descriptorResolver.setBuiltIns(kotlinBuiltIns); - descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); - descriptorResolver.setExpressionTypingServices(expressionTypingServices); - descriptorResolver.setStorageManager(storageManager); - descriptorResolver.setTypeResolver(typeResolver); + 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); annotationResolver.setCallResolver(callResolver); annotationResolver.setStorageManager(storageManager); @@ -237,7 +240,7 @@ public class InjectorForLazyBodyResolve { expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils); expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker); expressionTypingComponents.setGlobalContext(globalContext); - expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer); + expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); @@ -246,23 +249,20 @@ public class InjectorForLazyBodyResolve { forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils); forLoopConventionsChecker.setProject(project); - callExpressionResolver.setExpressionTypingServices(expressionTypingServices); - - candidateResolver.setArgumentTypeResolver(argumentTypeResolver); + descriptorResolver.setAnnotationResolver(annotationResolver); + descriptorResolver.setBuiltIns(kotlinBuiltIns); + descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); + descriptorResolver.setExpressionTypingServices(expressionTypingServices); + descriptorResolver.setStorageManager(storageManager); + descriptorResolver.setTypeResolver(typeResolver); delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns); delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); - 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); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); + + candidateResolver.setArgumentTypeResolver(argumentTypeResolver); 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 b28d2878203..b34215d9ec4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java @@ -25,13 +25,12 @@ 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.types.expressions.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.types.expressions.DeclarationScopeProviderForLocalClassifierAnalyzer; +import org.jetbrains.kotlin.types.expressions.LocalLazyDeclarationResolver; import org.jetbrains.kotlin.resolve.BodyResolver; import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallResolver; @@ -41,14 +40,15 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents; import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils; 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.types.expressions.LocalClassifierAnalyzer; import org.jetbrains.kotlin.resolve.DescriptorResolver; import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver; 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.types.reflect.ReflectionTypes; +import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider; import org.jetbrains.kotlin.resolve.calls.CallCompleter; import org.jetbrains.kotlin.resolve.calls.CandidateResolver; @@ -84,7 +84,6 @@ public class InjectorForLazyLocalClassifierAnalyzer { 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; @@ -96,14 +95,15 @@ public class InjectorForLazyLocalClassifierAnalyzer { private final ControlStructureTypingUtils controlStructureTypingUtils; private final ExpressionTypingUtils expressionTypingUtils; private final ForLoopConventionsChecker forLoopConventionsChecker; - private final ReflectionTypes reflectionTypes; - private final CallExpressionResolver callExpressionResolver; + private final LocalClassifierAnalyzer localClassifierAnalyzer; private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; + private final ReflectionTypes reflectionTypes; + private final CallExpressionResolver callExpressionResolver; private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; @@ -142,16 +142,10 @@ public class InjectorForLazyLocalClassifierAnalyzer { this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); this.noTopLevelDescriptorProvider = NoTopLevelDescriptorProvider.INSTANCE$; this.noFileScopeProvider = NoFileScopeProvider.INSTANCE$; - 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.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); this.expressionTypingComponents = new ExpressionTypingComponents(); @@ -159,9 +153,15 @@ public class InjectorForLazyLocalClassifierAnalyzer { this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); + this.descriptorResolver = new DescriptorResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.lazinessToken = new LazinessToken(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); - this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -192,7 +192,6 @@ public class InjectorForLazyLocalClassifierAnalyzer { declarationScopeProviderForLocalClassifierAnalyzer.setFileScopeProvider(noFileScopeProvider); - localLazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProviderForLocalClassifierAnalyzer); localLazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProviderForLocalClassifierAnalyzer); localLazyDeclarationResolver.setTopLevelDescriptorProvider(noTopLevelDescriptorProvider); @@ -239,7 +238,7 @@ public class InjectorForLazyLocalClassifierAnalyzer { expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils); expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker); expressionTypingComponents.setGlobalContext(globalContext); - expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer); + expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); @@ -248,8 +247,6 @@ public class InjectorForLazyLocalClassifierAnalyzer { forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils); forLoopConventionsChecker.setProject(project); - callExpressionResolver.setExpressionTypingServices(expressionTypingServices); - descriptorResolver.setAnnotationResolver(annotationResolver); descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); @@ -261,6 +258,8 @@ public class InjectorForLazyLocalClassifierAnalyzer { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); + candidateResolver.setArgumentTypeResolver(argumentTypeResolver); controlFlowAnalyzer.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 35db10c0db5..7815f578591 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java @@ -29,7 +29,6 @@ import org.jetbrains.kotlin.types.DynamicTypesSettings; import org.jetbrains.kotlin.resolve.lazy.ResolveSession; import org.jetbrains.kotlin.resolve.lazy.ScopeProvider; import org.jetbrains.kotlin.context.LazyResolveToken; -import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer; import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallResolver; import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver; @@ -38,13 +37,14 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents; import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils; 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.types.expressions.LocalClassifierAnalyzer; import org.jetbrains.kotlin.resolve.DescriptorResolver; import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver; import org.jetbrains.kotlin.resolve.TypeResolver; import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver; import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; +import org.jetbrains.kotlin.types.reflect.ReflectionTypes; +import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider; import org.jetbrains.kotlin.resolve.calls.CallCompleter; import org.jetbrains.kotlin.resolve.calls.CandidateResolver; @@ -74,7 +74,6 @@ public class InjectorForLazyResolve { private final ResolveSession resolveSession; private final ScopeProvider scopeProvider; private final LazyResolveToken lazyResolveToken; - private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; @@ -83,13 +82,14 @@ public class InjectorForLazyResolve { private final ControlStructureTypingUtils controlStructureTypingUtils; private final ExpressionTypingUtils expressionTypingUtils; private final ForLoopConventionsChecker forLoopConventionsChecker; - private final ReflectionTypes reflectionTypes; - private final CallExpressionResolver callExpressionResolver; + private final LocalClassifierAnalyzer localClassifierAnalyzer; private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; + private final ReflectionTypes reflectionTypes; + private final CallExpressionResolver callExpressionResolver; private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; @@ -122,12 +122,7 @@ public class InjectorForLazyResolve { this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace); this.scopeProvider = new ScopeProvider(getResolveSession()); this.lazyResolveToken = new LazyResolveToken(); - 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(); @@ -135,9 +130,14 @@ public class InjectorForLazyResolve { this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); + this.descriptorResolver = new DescriptorResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.callExpressionResolver = new CallExpressionResolver(); - this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -193,7 +193,7 @@ public class InjectorForLazyResolve { expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils); expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker); expressionTypingComponents.setGlobalContext(globalContext); - expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer); + expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); @@ -202,8 +202,6 @@ public class InjectorForLazyResolve { forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils); forLoopConventionsChecker.setProject(project); - callExpressionResolver.setExpressionTypingServices(expressionTypingServices); - descriptorResolver.setAnnotationResolver(annotationResolver); descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); @@ -215,6 +213,8 @@ public class InjectorForLazyResolve { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); + candidateResolver.setArgumentTypeResolver(argumentTypeResolver); jetImportsFactory.setProject(project); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java index 3cc8d8861b3..452c4016f98 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java @@ -29,7 +29,6 @@ import org.jetbrains.kotlin.resolve.lazy.ScopeProvider; import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer; import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel; import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider.DefaultProvider; -import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer; import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallResolver; import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver; @@ -39,14 +38,15 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils; import org.jetbrains.kotlin.types.DynamicTypesSettings; 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.types.expressions.LocalClassifierAnalyzer; import org.jetbrains.kotlin.resolve.DescriptorResolver; import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver; 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.types.reflect.ReflectionTypes; +import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider; import org.jetbrains.kotlin.resolve.calls.CallCompleter; import org.jetbrains.kotlin.resolve.calls.CandidateResolver; @@ -86,7 +86,6 @@ public class InjectorForLazyTopDownAnalyzerBasic { private final LazyTopDownAnalyzer lazyTopDownAnalyzer; private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel; private final DefaultProvider defaultProvider; - private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; @@ -96,14 +95,15 @@ public class InjectorForLazyTopDownAnalyzerBasic { private final DynamicTypesSettings dynamicTypesSettings; private final ExpressionTypingUtils expressionTypingUtils; private final ForLoopConventionsChecker forLoopConventionsChecker; - private final ReflectionTypes reflectionTypes; - private final CallExpressionResolver callExpressionResolver; + private final LocalClassifierAnalyzer localClassifierAnalyzer; private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; + private final ReflectionTypes reflectionTypes; + private final CallExpressionResolver callExpressionResolver; private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; @@ -144,24 +144,24 @@ public class InjectorForLazyTopDownAnalyzerBasic { this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel(); this.defaultProvider = DefaultProvider.INSTANCE$; - 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.descriptorResolver = new DescriptorResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.lazinessToken = new LazinessToken(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); - this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -242,7 +242,7 @@ public class InjectorForLazyTopDownAnalyzerBasic { expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils); expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker); expressionTypingComponents.setGlobalContext(globalContext); - expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer); + expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); @@ -251,8 +251,6 @@ public class InjectorForLazyTopDownAnalyzerBasic { forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils); forLoopConventionsChecker.setProject(project); - callExpressionResolver.setExpressionTypingServices(expressionTypingServices); - descriptorResolver.setAnnotationResolver(annotationResolver); descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); @@ -264,6 +262,8 @@ public class InjectorForLazyTopDownAnalyzerBasic { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); + candidateResolver.setArgumentTypeResolver(argumentTypeResolver); jetImportsFactory.setProject(project); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java index 5e95e911237..aa1b0352970 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java @@ -109,7 +109,7 @@ public class InjectorForMacros { this.controlStructureTypingUtils = new ControlStructureTypingUtils(getExpressionTypingServices()); this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), getCallResolver(), kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); - this.localClassifierAnalyzer = new LocalClassifierAnalyzer(); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.argumentTypeResolver = new ArgumentTypeResolver(); this.candidateResolver = new CandidateResolver(); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerBasic.java index 3f8d9d5c4aa..f04e5723546 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerBasic.java @@ -37,14 +37,14 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils; import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils; import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker; import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer; -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.TypeResolver; import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver; import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.kotlin.context.LazinessToken; +import org.jetbrains.kotlin.types.reflect.ReflectionTypes; +import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider; import org.jetbrains.kotlin.resolve.calls.CallCompleter; import org.jetbrains.kotlin.resolve.calls.CandidateResolver; @@ -90,14 +90,14 @@ public class InjectorForTopDownAnalyzerBasic { private final ExpressionTypingUtils expressionTypingUtils; private final ForLoopConventionsChecker forLoopConventionsChecker; private final LocalClassifierAnalyzer localClassifierAnalyzer; - private final ReflectionTypes reflectionTypes; - private final CallExpressionResolver callExpressionResolver; private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; + private final ReflectionTypes reflectionTypes; + private final CallExpressionResolver callExpressionResolver; private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; @@ -144,15 +144,15 @@ public class InjectorForTopDownAnalyzerBasic { this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); - this.localClassifierAnalyzer = new LocalClassifierAnalyzer(); - this.reflectionTypes = new ReflectionTypes(getModuleDescriptor()); - 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, getModuleDescriptor(), flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.delegatedPropertyResolver = new DelegatedPropertyResolver(); + this.reflectionTypes = new ReflectionTypes(getModuleDescriptor()); + this.callExpressionResolver = new CallExpressionResolver(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -232,8 +232,6 @@ public class InjectorForTopDownAnalyzerBasic { forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils); forLoopConventionsChecker.setProject(project); - callExpressionResolver.setExpressionTypingServices(expressionTypingServices); - descriptorResolver.setAnnotationResolver(annotationResolver); descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); @@ -245,6 +243,8 @@ public class InjectorForTopDownAnalyzerBasic { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); + candidateResolver.setArgumentTypeResolver(argumentTypeResolver); controlFlowAnalyzer.setTrace(bindingTrace); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.java deleted file mode 100644 index 01ca142fbc3..00000000000 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.java +++ /dev/null @@ -1,104 +0,0 @@ -/* - * 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.types.expressions; - -import com.google.common.base.Predicates; -import com.intellij.psi.PsiElement; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.context.GlobalContext; -import org.jetbrains.kotlin.descriptors.DeclarationDescriptor; -import org.jetbrains.kotlin.descriptors.PropertyDescriptor; -import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor; -import org.jetbrains.kotlin.descriptors.impl.MutableClassDescriptor; -import org.jetbrains.kotlin.descriptors.impl.PackageLikeBuilder; -import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerBasic; -import org.jetbrains.kotlin.psi.JetClassOrObject; -import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider; -import org.jetbrains.kotlin.resolve.DescriptorUtils; -import org.jetbrains.kotlin.resolve.TopDownAnalysisContext; -import org.jetbrains.kotlin.resolve.TopDownAnalysisParameters; -import org.jetbrains.kotlin.resolve.scopes.WritableScope; -import org.jetbrains.kotlin.types.DynamicTypesSettings; - -import java.util.Collections; - -public class LocalClassifierAnalyzer { - public void processClassOrObject( - @NotNull GlobalContext globalContext, - @Nullable final WritableScope scope, - @NotNull ExpressionTypingContext context, - @NotNull final DeclarationDescriptor containingDeclaration, - @NotNull JetClassOrObject object, - @NotNull AdditionalCheckerProvider additionalCheckerProvider, - @NotNull DynamicTypesSettings dynamicTypesSettings - ) { - TopDownAnalysisParameters topDownAnalysisParameters = - TopDownAnalysisParameters.createForLocalDeclarations( - globalContext.getStorageManager(), - globalContext.getExceptionTracker(), - Predicates.equalTo(object.getContainingFile()) - ); - - InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic( - object.getProject(), - topDownAnalysisParameters, - context.trace, - DescriptorUtils.getContainingModule(containingDeclaration), - additionalCheckerProvider, - dynamicTypesSettings - ); - - TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters, context.dataFlowInfo); - - injector.getTopDownAnalyzer().doProcess( - c, - context.scope, - new PackageLikeBuilder() { - - @NotNull - @Override - public DeclarationDescriptor getOwnerForChildren() { - return containingDeclaration; - } - - @Override - public void addClassifierDescriptor(@NotNull MutableClassDescriptor classDescriptor) { - if (scope != null) { - scope.addClassifierDescriptor(classDescriptor); - } - } - - @Override - public void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor) { - throw new UnsupportedOperationException(); - } - - @Override - public void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor) { - - } - - @Override - public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptor classObjectDescriptor) { - return null; - } - }, - Collections.singletonList(object) - ); - } -} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyLocalClassifierAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt similarity index 88% rename from compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyLocalClassifierAnalyzer.kt rename to compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt index 8f4987d9665..3509777e508 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyLocalClassifierAnalyzer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt @@ -1,59 +1,64 @@ /* -* 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 +package org.jetbrains.kotlin.types.expressions -import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer +import org.jetbrains.kotlin.resolve.DescriptorResolver +import org.jetbrains.kotlin.resolve.TypeResolver +import org.jetbrains.kotlin.resolve.AnnotationResolver import org.jetbrains.kotlin.context.GlobalContext import org.jetbrains.kotlin.resolve.scopes.WritableScope -import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.psi.JetClassOrObject +import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider import org.jetbrains.kotlin.types.DynamicTypesSettings import com.google.common.base.Predicates +import org.jetbrains.kotlin.resolve.TopDownAnalysisParameters +import org.jetbrains.kotlin.resolve.DescriptorUtils 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.storage.StorageManager +import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.resolve.lazy.data.JetClassInfoUtil +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProvider 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.resolve.lazy.declarations.PsiBasedClassMemberDeclarationProvider 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 +import org.jetbrains.kotlin.resolve.lazy.data.JetClassInfoUtil +import org.jetbrains.kotlin.resolve.scopes.JetScope +import org.jetbrains.kotlin.resolve.BindingTrace +import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver +import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo import com.intellij.psi.util.PsiTreeUtil import org.jetbrains.kotlin.resolve.lazy.LazyClassContext -public class LazyLocalClassifierAnalyzer( +public class LocalClassifierAnalyzer( val descriptorResolver: DescriptorResolver, val typeResolver: TypeResolver, val annotationResolver: AnnotationResolver -) : LocalClassifierAnalyzer() { - override fun processClassOrObject( +) { + fun processClassOrObject( globalContext: GlobalContext, scope: WritableScope?, context: ExpressionTypingContext, diff --git a/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java b/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java index 36c2b87dceb..785eeff1164 100644 --- a/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java +++ b/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java @@ -111,7 +111,7 @@ public class InjectorForTests { this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.controlStructureTypingUtils = new ControlStructureTypingUtils(getExpressionTypingServices()); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); - this.localClassifierAnalyzer = new LocalClassifierAnalyzer(); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(getDescriptorResolver(), getTypeResolver(), annotationResolver); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.callExpressionResolver = new CallExpressionResolver(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); diff --git a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt index 4bed75f8d15..bb729a88b1d 100644 --- a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt @@ -53,7 +53,10 @@ 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 +import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer +import org.jetbrains.kotlin.types.expressions.LocalClassDescriptorManager +import org.jetbrains.kotlin.types.expressions.DeclarationScopeProviderForLocalClassifierAnalyzer +import org.jetbrains.kotlin.types.expressions.LocalLazyDeclarationResolver // NOTE: After making changes, you need to re-generate the injectors. // To do that, you can run main in this file. @@ -111,7 +114,6 @@ private fun generatorForLazyTopDownAnalyzerBasic() = publicField() field() - field() } private fun generatorForLazyLocalClassifierAnalyzer() = @@ -128,7 +130,6 @@ private fun generatorForLazyLocalClassifierAnalyzer() = field() field() - field() field() field() } @@ -143,7 +144,6 @@ private fun generatorForLazyBodyResolve() = parameter() field(init = GivenExpression("analyzer.getModuleDescriptor()"), useAsContext = true) - field() publicField() } @@ -158,7 +158,6 @@ private fun generatorForTopDownAnalyzerForJs() = field() field() field() - field() } private fun generatorForTopDownAnalyzerForJvm() = @@ -223,7 +222,6 @@ private fun generatorForLazyResolveWithJava() = field() field() field() - field() field() } @@ -291,7 +289,6 @@ private fun generatorForLazyResolve() = field() field() - field() } private fun DependencyInjectorGenerator.commonForResolveSessionBased() { @@ -337,8 +334,6 @@ private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() { field() field(init = GivenExpression(javaClass().getName() + ".SERVICE.getInstance(project)")) - - field() } 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 03de807c94c..bb8b971cc67 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java @@ -30,7 +30,6 @@ import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer; import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel; import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider; import org.jetbrains.kotlin.types.DynamicTypesAllowed; -import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer; import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallResolver; import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver; @@ -39,14 +38,15 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents; import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils; 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.types.expressions.LocalClassifierAnalyzer; import org.jetbrains.kotlin.resolve.DescriptorResolver; import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver; 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.types.reflect.ReflectionTypes; +import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider; import org.jetbrains.kotlin.resolve.calls.CallCompleter; import org.jetbrains.kotlin.resolve.calls.CandidateResolver; @@ -87,7 +87,6 @@ public class InjectorForTopDownAnalyzerForJs { private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel; private final KotlinJsCheckerProvider kotlinJsCheckerProvider; private final DynamicTypesAllowed dynamicTypesAllowed; - private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; @@ -96,14 +95,15 @@ public class InjectorForTopDownAnalyzerForJs { private final ControlStructureTypingUtils controlStructureTypingUtils; private final ExpressionTypingUtils expressionTypingUtils; private final ForLoopConventionsChecker forLoopConventionsChecker; - private final ReflectionTypes reflectionTypes; - private final CallExpressionResolver callExpressionResolver; + private final LocalClassifierAnalyzer localClassifierAnalyzer; private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; + private final ReflectionTypes reflectionTypes; + private final CallExpressionResolver callExpressionResolver; private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; @@ -145,13 +145,7 @@ public class InjectorForTopDownAnalyzerForJs { this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel(); this.kotlinJsCheckerProvider = KotlinJsCheckerProvider.INSTANCE$; this.dynamicTypesAllowed = new DynamicTypesAllowed(); - 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(); @@ -159,9 +153,15 @@ public class InjectorForTopDownAnalyzerForJs { this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); + this.descriptorResolver = new DescriptorResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.lazinessToken = new LazinessToken(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesAllowed); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); - this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -242,7 +242,7 @@ public class InjectorForTopDownAnalyzerForJs { expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils); expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker); expressionTypingComponents.setGlobalContext(globalContext); - expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer); + expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); @@ -251,8 +251,6 @@ public class InjectorForTopDownAnalyzerForJs { forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils); forLoopConventionsChecker.setProject(project); - callExpressionResolver.setExpressionTypingServices(expressionTypingServices); - descriptorResolver.setAnnotationResolver(annotationResolver); descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); @@ -264,6 +262,8 @@ public class InjectorForTopDownAnalyzerForJs { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); + candidateResolver.setArgumentTypeResolver(argumentTypeResolver); jetImportsFactory.setProject(project);