azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Got rid of non-lazy local classifier analyzer

Browse Source
This commit is contained in:
Andrey Breslav
2015-01-23 19:02:34 +03:00
parent c59cb09398
commit 6395fd819f
15 changed files with 219 additions and 324 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java
+16 -16
View File
@@ -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);
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java
+17 -17
View File
@@ -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);
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java
+16 -16
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java
+10 -10
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java
+42 -42
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java
+20 -21
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java
+15 -15
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java
+17 -17
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java
+1 -1
View File
@@ -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();
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerBasic.java
+10 -10
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.java
-104
View File
@@ -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.<PsiElement>singletonList(object)
);
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyLocalClassifierAnalyzer.kt → compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt
+34 -29
View File
@@ -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,
compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java
+1 -1
View File
@@ -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();
generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt
+4 -9
View File
@@ -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<LazyTopDownAnalyzerForTopLevel>()
field<AdditionalCheckerProvider.DefaultProvider>()
field<LazyLocalClassifierAnalyzer>()
}
private fun generatorForLazyLocalClassifierAnalyzer() =
@@ -128,7 +130,6 @@ private fun generatorForLazyLocalClassifierAnalyzer() =
field<NoTopLevelDescriptorProvider>()
field<NoFileScopeProvider>()
field<LazyLocalClassifierAnalyzer>()
field<DeclarationScopeProviderForLocalClassifierAnalyzer>()
field<LocalLazyDeclarationResolver>()
}
@@ -143,7 +144,6 @@ private fun generatorForLazyBodyResolve() =
parameter<DynamicTypesSettings>()
field<ModuleDescriptor>(init = GivenExpression("analyzer.getModuleDescriptor()"), useAsContext = true)
field<LazyLocalClassifierAnalyzer>()
publicField<LazyTopDownAnalyzer>()
}
@@ -158,7 +158,6 @@ private fun generatorForTopDownAnalyzerForJs() =
field<MutablePackageFragmentProvider>()
field<KotlinJsCheckerProvider>()
field<DynamicTypesAllowed>()
field<LazyLocalClassifierAnalyzer>()
}
private fun generatorForTopDownAnalyzerForJvm() =
@@ -223,7 +222,6 @@ private fun generatorForLazyResolveWithJava() =
field<JavaFlexibleTypeCapabilitiesProvider>()
field<LazyResolveToken>()
field<JavaLazyAnalyzerPostConstruct>()
field<LazyLocalClassifierAnalyzer>()
field<KotlinJvmCheckerProvider>()
}
@@ -291,7 +289,6 @@ private fun generatorForLazyResolve() =
field<ScopeProvider>()
field<LazyResolveToken>()
field<LazyLocalClassifierAnalyzer>()
}
private fun DependencyInjectorGenerator.commonForResolveSessionBased() {
@@ -337,8 +334,6 @@ private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() {
field<KotlinJvmCheckerProvider>()
field<VirtualFileFinder>(init = GivenExpression(javaClass<VirtualFileFinder>().getName() + ".SERVICE.getInstance(project)"))
field<LazyLocalClassifierAnalyzer>()
}
js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java
+16 -16
View File
@@ -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);