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

Refactor frontend components

Browse Source 
Make dependencies more explicit
Move components out of ExpressionTypingServices
Make ExpressionTypingUtils a true utility class, refactor stuff out
Extract new components: FakeCallResolver, MultiDeclarationResolver, ValueParameterResolver
This commit is contained in:
Pavel V. Talanov
2015-04-14 20:39:37 +03:00
parent 50ae8182b8
commit 1a5efacbf3
43 changed files with 1019 additions and 967 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java
+41 -35
View File
@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator;
import com.intellij.psi.search.GlobalSearchScope;
import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver;
import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver;
@@ -44,23 +43,26 @@ import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider;
import org.jetbrains.kotlin.context.LazyResolveToken;
import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct;
import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
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.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.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
@@ -93,7 +95,6 @@ public class InjectorForLazyResolveWithJava {
private final DeclarationProviderFactory declarationProviderFactory;
private final ResolveSession resolveSession;
private final ScopeProvider scopeProvider;
private final DefaultSymbolUsageValidator defaultSymbolUsageValidator;
private final GlobalSearchScope moduleContentScope;
private final ModuleClassResolver moduleClassResolver;
private final JavaDescriptorResolver javaDescriptorResolver;
@@ -111,23 +112,26 @@ public class InjectorForLazyResolveWithJava {
private final LazyResolveToken lazyResolveToken;
private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider;
private final SymbolUsageValidator symbolUsageValidator;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
private final ArgumentTypeResolver argumentTypeResolver;
private final ExpressionTypingServices expressionTypingServices;
private final ExpressionTypingComponents expressionTypingComponents;
private final CallExpressionResolver callExpressionResolver;
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final DynamicTypesSettings dynamicTypesSettings;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final DescriptorResolver descriptorResolver;
private final DelegatedPropertyResolver delegatedPropertyResolver;
private final TypeResolver typeResolver;
private final QualifiedExpressionResolver qualifiedExpressionResolver;
private final DynamicTypesSettings dynamicTypesSettings;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final FakeCallResolver fakeCallResolver;
private final FunctionDescriptorResolver functionDescriptorResolver;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final MultiDeclarationResolver multiDeclarationResolver;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final ValueParameterResolver valueParameterResolver;
private final StatementFilter statementFilter;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
@@ -163,7 +167,6 @@ public class InjectorForLazyResolveWithJava {
this.declarationProviderFactory = declarationProviderFactory;
this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
this.scopeProvider = new ScopeProvider(getResolveSession());
this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$;
this.moduleContentScope = moduleContentScope;
this.moduleClassResolver = moduleClassResolver;
this.javaClassFinder = new JavaClassFinderImpl();
@@ -185,22 +188,25 @@ public class InjectorForLazyResolveWithJava {
this.lazyResolveToken = new LazyResolveToken();
this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
this.symbolUsageValidator = kotlinJvmCheckerProvider.getSymbolUsageValidator();
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.callExpressionResolver = new CallExpressionResolver(callResolver);
this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
this.descriptorResolver = new DescriptorResolver();
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
this.dynamicTypesSettings = new DynamicTypesSettings();
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), javaFlexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.fakeCallResolver = new FakeCallResolver(project, callResolver);
this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.callExpressionResolver = new CallExpressionResolver();
this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
this.valueParameterResolver = new ValueParameterResolver(kotlinJvmCheckerProvider, expressionTypingServices);
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
@@ -250,6 +256,7 @@ public class InjectorForLazyResolveWithJava {
annotationResolver.setStorageManager(storageManager);
annotationResolver.setTypeResolver(typeResolver);
callResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
callResolver.setArgumentTypeResolver(argumentTypeResolver);
callResolver.setCallCompleter(callCompleter);
callResolver.setCandidateResolver(candidateResolver);
@@ -261,34 +268,29 @@ public class InjectorForLazyResolveWithJava {
argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
argumentTypeResolver.setTypeResolver(typeResolver);
expressionTypingServices.setAnnotationResolver(annotationResolver);
expressionTypingServices.setBuiltIns(kotlinBuiltIns);
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
expressionTypingComponents.setAnnotationResolver(annotationResolver);
expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
expressionTypingComponents.setCallResolver(callResolver);
expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
expressionTypingComponents.setDescriptorResolver(descriptorResolver);
expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator);
expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
expressionTypingComponents.setTypeResolver(typeResolver);
expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
forLoopConventionsChecker.setProject(project);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
descriptorResolver.setAnnotationResolver(annotationResolver);
descriptorResolver.setBuiltIns(kotlinBuiltIns);
@@ -297,13 +299,16 @@ public class InjectorForLazyResolveWithJava {
descriptorResolver.setStorageManager(storageManager);
descriptorResolver.setTypeResolver(typeResolver);
delegatedPropertyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
delegatedPropertyResolver.setCallResolver(callResolver);
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator);
qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
@@ -314,6 +319,7 @@ public class InjectorForLazyResolveWithJava {
declarationScopeProvider.setFileScopeProvider(scopeProvider);
scriptBodyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
deserializedDescriptorResolver.setComponents(deserializationComponentsForJava);
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java
+43 -35
View File
@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator;
import com.intellij.psi.search.GlobalSearchScope;
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
@@ -46,25 +45,28 @@ 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.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
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.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.TypeLazinessToken;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
@@ -104,7 +106,6 @@ public class InjectorForReplWithJava {
private final DeclarationProviderFactory declarationProviderFactory;
private final ResolveSession resolveSession;
private final ScopeProvider scopeProvider;
private final DefaultSymbolUsageValidator defaultSymbolUsageValidator;
private final GlobalSearchScope moduleContentScope;
private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
@@ -124,25 +125,28 @@ public class InjectorForReplWithJava {
private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider;
private final SymbolUsageValidator symbolUsageValidator;
private final AdditionalFileScopeProvider additionalFileScopeProvider;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
private final ArgumentTypeResolver argumentTypeResolver;
private final ExpressionTypingServices expressionTypingServices;
private final ExpressionTypingComponents expressionTypingComponents;
private final CallExpressionResolver callExpressionResolver;
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final DynamicTypesSettings dynamicTypesSettings;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final DescriptorResolver descriptorResolver;
private final DelegatedPropertyResolver delegatedPropertyResolver;
private final TypeResolver typeResolver;
private final QualifiedExpressionResolver qualifiedExpressionResolver;
private final TypeLazinessToken typeLazinessToken;
private final DynamicTypesSettings dynamicTypesSettings;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final FakeCallResolver fakeCallResolver;
private final FunctionDescriptorResolver functionDescriptorResolver;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final MultiDeclarationResolver multiDeclarationResolver;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final ValueParameterResolver valueParameterResolver;
private final StatementFilter statementFilter;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
@@ -185,7 +189,6 @@ public class InjectorForReplWithJava {
this.declarationProviderFactory = declarationProviderFactory;
this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
this.scopeProvider = new ScopeProvider(getResolveSession());
this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$;
this.moduleContentScope = moduleContentScope;
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
@@ -211,24 +214,27 @@ public class InjectorForReplWithJava {
this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
this.symbolUsageValidator = kotlinJvmCheckerProvider.getSymbolUsageValidator();
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.callExpressionResolver = new CallExpressionResolver(callResolver);
this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
this.descriptorResolver = new DescriptorResolver();
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
this.typeLazinessToken = new TypeLazinessToken();
this.dynamicTypesSettings = new DynamicTypesSettings();
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), javaFlexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.fakeCallResolver = new FakeCallResolver(project, callResolver);
this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.callExpressionResolver = new CallExpressionResolver();
this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
this.valueParameterResolver = new ValueParameterResolver(kotlinJvmCheckerProvider, expressionTypingServices);
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
@@ -300,6 +306,7 @@ public class InjectorForReplWithJava {
annotationResolver.setStorageManager(storageManager);
annotationResolver.setTypeResolver(typeResolver);
callResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
callResolver.setArgumentTypeResolver(argumentTypeResolver);
callResolver.setCallCompleter(callCompleter);
callResolver.setCandidateResolver(candidateResolver);
@@ -311,34 +318,29 @@ public class InjectorForReplWithJava {
argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
argumentTypeResolver.setTypeResolver(typeResolver);
expressionTypingServices.setAnnotationResolver(annotationResolver);
expressionTypingServices.setBuiltIns(kotlinBuiltIns);
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
expressionTypingComponents.setAnnotationResolver(annotationResolver);
expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
expressionTypingComponents.setCallResolver(callResolver);
expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
expressionTypingComponents.setDescriptorResolver(descriptorResolver);
expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator);
expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
expressionTypingComponents.setTypeResolver(typeResolver);
expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
forLoopConventionsChecker.setProject(project);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
descriptorResolver.setAnnotationResolver(annotationResolver);
descriptorResolver.setBuiltIns(kotlinBuiltIns);
@@ -347,13 +349,16 @@ public class InjectorForReplWithJava {
descriptorResolver.setStorageManager(storageManager);
descriptorResolver.setTypeResolver(typeResolver);
delegatedPropertyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
delegatedPropertyResolver.setCallResolver(callResolver);
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator);
qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
@@ -364,8 +369,10 @@ public class InjectorForReplWithJava {
declarationScopeProvider.setFileScopeProvider(scopeProvider);
scriptBodyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
bodyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
bodyResolver.setAnnotationResolver(annotationResolver);
bodyResolver.setCallResolver(callResolver);
bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
@@ -375,6 +382,7 @@ public class InjectorForReplWithJava {
bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
bodyResolver.setTrace(bindingTrace);
bodyResolver.setValueParameterResolver(valueParameterResolver);
controlFlowAnalyzer.setTrace(bindingTrace);
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java
+43 -35
View File
@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator;
import com.intellij.psi.search.GlobalSearchScope;
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
@@ -46,24 +45,27 @@ 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.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
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.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.TypeLazinessToken;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
@@ -104,7 +106,6 @@ public class InjectorForTopDownAnalyzerForJvm {
private final DeclarationProviderFactory declarationProviderFactory;
private final ResolveSession resolveSession;
private final ScopeProvider scopeProvider;
private final DefaultSymbolUsageValidator defaultSymbolUsageValidator;
private final GlobalSearchScope moduleContentScope;
private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
@@ -124,24 +125,27 @@ public class InjectorForTopDownAnalyzerForJvm {
private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider;
private final SymbolUsageValidator symbolUsageValidator;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
private final ArgumentTypeResolver argumentTypeResolver;
private final ExpressionTypingServices expressionTypingServices;
private final ExpressionTypingComponents expressionTypingComponents;
private final CallExpressionResolver callExpressionResolver;
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final DynamicTypesSettings dynamicTypesSettings;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final DescriptorResolver descriptorResolver;
private final DelegatedPropertyResolver delegatedPropertyResolver;
private final TypeResolver typeResolver;
private final QualifiedExpressionResolver qualifiedExpressionResolver;
private final TypeLazinessToken typeLazinessToken;
private final DynamicTypesSettings dynamicTypesSettings;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final FakeCallResolver fakeCallResolver;
private final FunctionDescriptorResolver functionDescriptorResolver;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final MultiDeclarationResolver multiDeclarationResolver;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final ValueParameterResolver valueParameterResolver;
private final StatementFilter statementFilter;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
@@ -184,7 +188,6 @@ public class InjectorForTopDownAnalyzerForJvm {
this.declarationProviderFactory = declarationProviderFactory;
this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
this.scopeProvider = new ScopeProvider(getResolveSession());
this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$;
this.moduleContentScope = moduleContentScope;
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
@@ -210,23 +213,26 @@ public class InjectorForTopDownAnalyzerForJvm {
this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
this.symbolUsageValidator = kotlinJvmCheckerProvider.getSymbolUsageValidator();
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.callExpressionResolver = new CallExpressionResolver(callResolver);
this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
this.descriptorResolver = new DescriptorResolver();
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
this.typeLazinessToken = new TypeLazinessToken();
this.dynamicTypesSettings = new DynamicTypesSettings();
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), javaFlexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.fakeCallResolver = new FakeCallResolver(project, callResolver);
this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.callExpressionResolver = new CallExpressionResolver();
this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
this.valueParameterResolver = new ValueParameterResolver(kotlinJvmCheckerProvider, expressionTypingServices);
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
@@ -299,6 +305,7 @@ public class InjectorForTopDownAnalyzerForJvm {
annotationResolver.setStorageManager(storageManager);
annotationResolver.setTypeResolver(typeResolver);
callResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
callResolver.setArgumentTypeResolver(argumentTypeResolver);
callResolver.setCallCompleter(callCompleter);
callResolver.setCandidateResolver(candidateResolver);
@@ -310,34 +317,29 @@ public class InjectorForTopDownAnalyzerForJvm {
argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
argumentTypeResolver.setTypeResolver(typeResolver);
expressionTypingServices.setAnnotationResolver(annotationResolver);
expressionTypingServices.setBuiltIns(kotlinBuiltIns);
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
expressionTypingComponents.setAnnotationResolver(annotationResolver);
expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
expressionTypingComponents.setCallResolver(callResolver);
expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
expressionTypingComponents.setDescriptorResolver(descriptorResolver);
expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator);
expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
expressionTypingComponents.setTypeResolver(typeResolver);
expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
forLoopConventionsChecker.setProject(project);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
descriptorResolver.setAnnotationResolver(annotationResolver);
descriptorResolver.setBuiltIns(kotlinBuiltIns);
@@ -346,13 +348,16 @@ public class InjectorForTopDownAnalyzerForJvm {
descriptorResolver.setStorageManager(storageManager);
descriptorResolver.setTypeResolver(typeResolver);
delegatedPropertyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
delegatedPropertyResolver.setCallResolver(callResolver);
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator);
qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
@@ -363,8 +368,10 @@ public class InjectorForTopDownAnalyzerForJvm {
declarationScopeProvider.setFileScopeProvider(scopeProvider);
scriptBodyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
bodyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
bodyResolver.setAnnotationResolver(annotationResolver);
bodyResolver.setCallResolver(callResolver);
bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
@@ -374,6 +381,7 @@ public class InjectorForTopDownAnalyzerForJvm {
bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
bodyResolver.setTrace(bindingTrace);
bodyResolver.setValueParameterResolver(valueParameterResolver);
controlFlowAnalyzer.setTrace(bindingTrace);
compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt
+2 -1
View File
@@ -57,7 +57,8 @@ public object KotlinJvmCheckerProvider : AdditionalCheckerProvider(
additionalCallCheckers = listOf(NeedSyntheticChecker(), JavaAnnotationCallChecker(),
JavaAnnotationMethodCallChecker(), TraitDefaultMethodCallChecker()),
additionalTypeCheckers = listOf(JavaNullabilityWarningsChecker())
additionalTypeCheckers = listOf(JavaNullabilityWarningsChecker()),
additionalSymbolUsageValidators = listOf()
)
public class LocalFunInlineChecker : DeclarationChecker {
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java
+43 -35
View File
@@ -24,28 +24,30 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.BodyResolver;
import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
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.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.TypeLazinessToken;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
@@ -69,28 +71,30 @@ public class InjectorForBodyResolve {
private final KotlinBuiltIns kotlinBuiltIns;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final AdditionalCheckerProvider additionalCheckerProvider;
private final SymbolUsageValidator symbolUsageValidator;
private final StatementFilter statementFilter;
private final BodyResolver bodyResolver;
private final DefaultSymbolUsageValidator defaultSymbolUsageValidator;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
private final ArgumentTypeResolver argumentTypeResolver;
private final ExpressionTypingServices expressionTypingServices;
private final ExpressionTypingComponents expressionTypingComponents;
private final CallExpressionResolver callExpressionResolver;
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final DynamicTypesSettings dynamicTypesSettings;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
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 TypeLazinessToken typeLazinessToken;
private final DynamicTypesSettings dynamicTypesSettings;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final FakeCallResolver fakeCallResolver;
private final FunctionDescriptorResolver functionDescriptorResolver;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final MultiDeclarationResolver multiDeclarationResolver;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final ValueParameterResolver valueParameterResolver;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
private final TaskPrioritizer taskPrioritizer;
@@ -116,28 +120,30 @@ public class InjectorForBodyResolve {
this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
this.additionalCheckerProvider = additionalCheckerProvider;
this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
this.statementFilter = statementFilter;
this.bodyResolver = new BodyResolver();
this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.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.callExpressionResolver = new CallExpressionResolver(callResolver);
this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
this.descriptorResolver = new DescriptorResolver();
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
this.typeLazinessToken = new TypeLazinessToken();
this.dynamicTypesSettings = new DynamicTypesSettings();
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.fakeCallResolver = new FakeCallResolver(project, callResolver);
this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
this.callExpressionResolver = new CallExpressionResolver();
this.valueParameterResolver = new ValueParameterResolver(additionalCheckerProvider, expressionTypingServices);
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
@@ -147,6 +153,7 @@ public class InjectorForBodyResolve {
this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
this.scriptBodyResolver = new ScriptBodyResolver();
this.bodyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
this.bodyResolver.setAnnotationResolver(annotationResolver);
this.bodyResolver.setCallResolver(callResolver);
this.bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
@@ -156,11 +163,13 @@ public class InjectorForBodyResolve {
this.bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
this.bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
this.bodyResolver.setTrace(bindingTrace);
this.bodyResolver.setValueParameterResolver(valueParameterResolver);
annotationResolver.setCallResolver(callResolver);
annotationResolver.setStorageManager(storageManager);
annotationResolver.setTypeResolver(typeResolver);
callResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
callResolver.setArgumentTypeResolver(argumentTypeResolver);
callResolver.setCallCompleter(callCompleter);
callResolver.setCandidateResolver(candidateResolver);
@@ -172,34 +181,29 @@ public class InjectorForBodyResolve {
argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
argumentTypeResolver.setTypeResolver(typeResolver);
expressionTypingServices.setAnnotationResolver(annotationResolver);
expressionTypingServices.setBuiltIns(kotlinBuiltIns);
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
expressionTypingComponents.setAnnotationResolver(annotationResolver);
expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
expressionTypingComponents.setCallResolver(callResolver);
expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
expressionTypingComponents.setDescriptorResolver(descriptorResolver);
expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator);
expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
expressionTypingComponents.setTypeResolver(typeResolver);
expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
forLoopConventionsChecker.setProject(project);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
descriptorResolver.setAnnotationResolver(annotationResolver);
descriptorResolver.setBuiltIns(kotlinBuiltIns);
@@ -208,13 +212,16 @@ public class InjectorForBodyResolve {
descriptorResolver.setStorageManager(storageManager);
descriptorResolver.setTypeResolver(typeResolver);
delegatedPropertyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
delegatedPropertyResolver.setCallResolver(callResolver);
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator);
qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
@@ -226,6 +233,7 @@ public class InjectorForBodyResolve {
functionAnalyzerExtension.setTrace(bindingTrace);
scriptBodyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
}
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java
+40 -32
View File
@@ -24,10 +24,10 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator;
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
@@ -39,19 +39,21 @@ import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
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.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.TypeLazinessToken;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
@@ -80,10 +82,10 @@ public class InjectorForLazyBodyResolve {
private final ScopeProvider scopeProvider;
private final BindingTrace bindingTrace;
private final AdditionalCheckerProvider additionalCheckerProvider;
private final SymbolUsageValidator symbolUsageValidator;
private final DynamicTypesSettings dynamicTypesSettings;
private final KotlinBuiltIns kotlinBuiltIns;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final DefaultSymbolUsageValidator defaultSymbolUsageValidator;
private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
private final AdditionalFileScopeProvider additionalFileScopeProvider;
private final DeclarationScopeProviderImpl declarationScopeProvider;
@@ -95,19 +97,21 @@ public class InjectorForLazyBodyResolve {
private final ArgumentTypeResolver argumentTypeResolver;
private final ExpressionTypingServices expressionTypingServices;
private final ExpressionTypingComponents expressionTypingComponents;
private final CallExpressionResolver callExpressionResolver;
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
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 TypeLazinessToken typeLazinessToken;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final FakeCallResolver fakeCallResolver;
private final FunctionDescriptorResolver functionDescriptorResolver;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final MultiDeclarationResolver multiDeclarationResolver;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final ValueParameterResolver valueParameterResolver;
private final StatementFilter statementFilter;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
@@ -138,10 +142,10 @@ public class InjectorForLazyBodyResolve {
this.scopeProvider = analyzer.getScopeProvider();
this.bindingTrace = bindingTrace;
this.additionalCheckerProvider = additionalCheckerProvider;
this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
this.dynamicTypesSettings = dynamicTypesSettings;
this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$;
this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
@@ -153,19 +157,21 @@ public class InjectorForLazyBodyResolve {
this.argumentTypeResolver = new ArgumentTypeResolver();
this.expressionTypingComponents = new ExpressionTypingComponents();
this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.callExpressionResolver = new CallExpressionResolver(callResolver);
this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
this.descriptorResolver = new DescriptorResolver();
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
this.typeLazinessToken = new TypeLazinessToken();
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.fakeCallResolver = new FakeCallResolver(project, callResolver);
this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
this.callExpressionResolver = new CallExpressionResolver();
this.valueParameterResolver = new ValueParameterResolver(additionalCheckerProvider, expressionTypingServices);
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
@@ -200,6 +206,7 @@ public class InjectorForLazyBodyResolve {
lazyTopDownAnalyzer.setTrace(bindingTrace);
lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
bodyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
bodyResolver.setAnnotationResolver(annotationResolver);
bodyResolver.setCallResolver(callResolver);
bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
@@ -209,11 +216,13 @@ public class InjectorForLazyBodyResolve {
bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
bodyResolver.setTrace(bindingTrace);
bodyResolver.setValueParameterResolver(valueParameterResolver);
annotationResolver.setCallResolver(callResolver);
annotationResolver.setStorageManager(storageManager);
annotationResolver.setTypeResolver(typeResolver);
callResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
callResolver.setArgumentTypeResolver(argumentTypeResolver);
callResolver.setCallCompleter(callCompleter);
callResolver.setCandidateResolver(candidateResolver);
@@ -225,34 +234,29 @@ public class InjectorForLazyBodyResolve {
argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
argumentTypeResolver.setTypeResolver(typeResolver);
expressionTypingServices.setAnnotationResolver(annotationResolver);
expressionTypingServices.setBuiltIns(kotlinBuiltIns);
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
expressionTypingComponents.setAnnotationResolver(annotationResolver);
expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
expressionTypingComponents.setCallResolver(callResolver);
expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
expressionTypingComponents.setDescriptorResolver(descriptorResolver);
expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator);
expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
expressionTypingComponents.setTypeResolver(typeResolver);
expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
forLoopConventionsChecker.setProject(project);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
descriptorResolver.setAnnotationResolver(annotationResolver);
descriptorResolver.setBuiltIns(kotlinBuiltIns);
@@ -261,13 +265,16 @@ public class InjectorForLazyBodyResolve {
descriptorResolver.setStorageManager(storageManager);
descriptorResolver.setTypeResolver(typeResolver);
delegatedPropertyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
delegatedPropertyResolver.setCallResolver(callResolver);
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator);
qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
@@ -279,6 +286,7 @@ public class InjectorForLazyBodyResolve {
functionAnalyzerExtension.setTrace(bindingTrace);
scriptBodyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
declarationResolver.setAnnotationResolver(annotationResolver);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java
+40 -32
View File
@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.LocalClassDescriptorHolder;
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
@@ -31,26 +32,27 @@ import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider;
import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider;
import org.jetbrains.kotlin.types.expressions.DeclarationScopeProviderForLocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.expressions.LocalLazyDeclarationResolver;
import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator;
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;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
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.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.TypeLazinessToken;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
@@ -79,6 +81,7 @@ public class InjectorForLazyLocalClassifierAnalyzer {
private final KotlinBuiltIns kotlinBuiltIns;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final AdditionalCheckerProvider additionalCheckerProvider;
private final SymbolUsageValidator symbolUsageValidator;
private final DynamicTypesSettings dynamicTypesSettings;
private final LocalClassDescriptorHolder localClassDescriptorHolder;
private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
@@ -86,26 +89,27 @@ public class InjectorForLazyLocalClassifierAnalyzer {
private final NoFileScopeProvider noFileScopeProvider;
private final DeclarationScopeProviderForLocalClassifierAnalyzer declarationScopeProviderForLocalClassifierAnalyzer;
private final LocalLazyDeclarationResolver localLazyDeclarationResolver;
private final DefaultSymbolUsageValidator defaultSymbolUsageValidator;
private final BodyResolver bodyResolver;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
private final ArgumentTypeResolver argumentTypeResolver;
private final ExpressionTypingServices expressionTypingServices;
private final ExpressionTypingComponents expressionTypingComponents;
private final CallExpressionResolver callExpressionResolver;
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
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 TypeLazinessToken typeLazinessToken;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final FakeCallResolver fakeCallResolver;
private final FunctionDescriptorResolver functionDescriptorResolver;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final MultiDeclarationResolver multiDeclarationResolver;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final ValueParameterResolver valueParameterResolver;
private final StatementFilter statementFilter;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
@@ -137,6 +141,7 @@ public class InjectorForLazyLocalClassifierAnalyzer {
this.kotlinBuiltIns = module.getBuiltIns();
this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
this.additionalCheckerProvider = additionalCheckerProvider;
this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
this.dynamicTypesSettings = dynamicTypesSettings;
this.localClassDescriptorHolder = localClassDescriptorHolder;
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
@@ -144,26 +149,27 @@ public class InjectorForLazyLocalClassifierAnalyzer {
this.noFileScopeProvider = NoFileScopeProvider.INSTANCE$;
this.localLazyDeclarationResolver = new LocalLazyDeclarationResolver(globalContext, bindingTrace, localClassDescriptorHolder);
this.declarationScopeProviderForLocalClassifierAnalyzer = new DeclarationScopeProviderForLocalClassifierAnalyzer(localLazyDeclarationResolver, localClassDescriptorHolder);
this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$;
this.bodyResolver = new BodyResolver();
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.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.callExpressionResolver = new CallExpressionResolver(callResolver);
this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
this.descriptorResolver = new DescriptorResolver();
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
this.typeLazinessToken = new TypeLazinessToken();
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.fakeCallResolver = new FakeCallResolver(project, callResolver);
this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
this.reflectionTypes = new ReflectionTypes(module);
this.callExpressionResolver = new CallExpressionResolver();
this.valueParameterResolver = new ValueParameterResolver(additionalCheckerProvider, expressionTypingServices);
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
@@ -195,6 +201,7 @@ public class InjectorForLazyLocalClassifierAnalyzer {
localLazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProviderForLocalClassifierAnalyzer);
localLazyDeclarationResolver.setTopLevelDescriptorProvider(noTopLevelDescriptorProvider);
bodyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
bodyResolver.setAnnotationResolver(annotationResolver);
bodyResolver.setCallResolver(callResolver);
bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
@@ -204,11 +211,13 @@ public class InjectorForLazyLocalClassifierAnalyzer {
bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
bodyResolver.setTrace(bindingTrace);
bodyResolver.setValueParameterResolver(valueParameterResolver);
annotationResolver.setCallResolver(callResolver);
annotationResolver.setStorageManager(storageManager);
annotationResolver.setTypeResolver(typeResolver);
callResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
callResolver.setArgumentTypeResolver(argumentTypeResolver);
callResolver.setCallCompleter(callCompleter);
callResolver.setCandidateResolver(candidateResolver);
@@ -220,34 +229,29 @@ public class InjectorForLazyLocalClassifierAnalyzer {
argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
argumentTypeResolver.setTypeResolver(typeResolver);
expressionTypingServices.setAnnotationResolver(annotationResolver);
expressionTypingServices.setBuiltIns(kotlinBuiltIns);
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
expressionTypingComponents.setAnnotationResolver(annotationResolver);
expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
expressionTypingComponents.setCallResolver(callResolver);
expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
expressionTypingComponents.setDescriptorResolver(descriptorResolver);
expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator);
expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
expressionTypingComponents.setTypeResolver(typeResolver);
expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
forLoopConventionsChecker.setProject(project);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
descriptorResolver.setAnnotationResolver(annotationResolver);
descriptorResolver.setBuiltIns(kotlinBuiltIns);
@@ -256,13 +260,16 @@ public class InjectorForLazyLocalClassifierAnalyzer {
descriptorResolver.setStorageManager(storageManager);
descriptorResolver.setTypeResolver(typeResolver);
delegatedPropertyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
delegatedPropertyResolver.setCallResolver(callResolver);
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator);
qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
@@ -274,6 +281,7 @@ public class InjectorForLazyLocalClassifierAnalyzer {
functionAnalyzerExtension.setTrace(bindingTrace);
scriptBodyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
declarationResolver.setAnnotationResolver(annotationResolver);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java
+38 -32
View File
@@ -25,28 +25,30 @@ import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
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.validation.DefaultSymbolUsageValidator;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
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.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.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
@@ -72,28 +74,30 @@ public class InjectorForLazyResolve {
private final DeclarationProviderFactory declarationProviderFactory;
private final BindingTrace bindingTrace;
private final AdditionalCheckerProvider additionalCheckerProvider;
private final SymbolUsageValidator symbolUsageValidator;
private final DynamicTypesSettings dynamicTypesSettings;
private final ResolveSession resolveSession;
private final ScopeProvider scopeProvider;
private final LazyResolveToken lazyResolveToken;
private final DefaultSymbolUsageValidator defaultSymbolUsageValidator;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
private final ArgumentTypeResolver argumentTypeResolver;
private final ExpressionTypingServices expressionTypingServices;
private final ExpressionTypingComponents expressionTypingComponents;
private final CallExpressionResolver callExpressionResolver;
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
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 ForLoopConventionsChecker forLoopConventionsChecker;
private final FakeCallResolver fakeCallResolver;
private final FunctionDescriptorResolver functionDescriptorResolver;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final MultiDeclarationResolver multiDeclarationResolver;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final ValueParameterResolver valueParameterResolver;
private final StatementFilter statementFilter;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
@@ -122,28 +126,30 @@ public class InjectorForLazyResolve {
this.declarationProviderFactory = declarationProviderFactory;
this.bindingTrace = bindingTrace;
this.additionalCheckerProvider = additionalCheckerProvider;
this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
this.dynamicTypesSettings = dynamicTypesSettings;
this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace);
this.scopeProvider = new ScopeProvider(getResolveSession());
this.lazyResolveToken = new LazyResolveToken();
this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.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.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.callExpressionResolver = new CallExpressionResolver(callResolver);
this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
this.descriptorResolver = new DescriptorResolver();
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.fakeCallResolver = new FakeCallResolver(project, callResolver);
this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
this.callExpressionResolver = new CallExpressionResolver();
this.valueParameterResolver = new ValueParameterResolver(additionalCheckerProvider, expressionTypingServices);
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
@@ -171,6 +177,7 @@ public class InjectorForLazyResolve {
annotationResolver.setStorageManager(storageManager);
annotationResolver.setTypeResolver(typeResolver);
callResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
callResolver.setArgumentTypeResolver(argumentTypeResolver);
callResolver.setCallCompleter(callCompleter);
callResolver.setCandidateResolver(candidateResolver);
@@ -182,34 +189,29 @@ public class InjectorForLazyResolve {
argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
argumentTypeResolver.setTypeResolver(typeResolver);
expressionTypingServices.setAnnotationResolver(annotationResolver);
expressionTypingServices.setBuiltIns(kotlinBuiltIns);
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
expressionTypingComponents.setAnnotationResolver(annotationResolver);
expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
expressionTypingComponents.setCallResolver(callResolver);
expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
expressionTypingComponents.setDescriptorResolver(descriptorResolver);
expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator);
expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
expressionTypingComponents.setTypeResolver(typeResolver);
expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
forLoopConventionsChecker.setProject(project);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
descriptorResolver.setAnnotationResolver(annotationResolver);
descriptorResolver.setBuiltIns(kotlinBuiltIns);
@@ -218,13 +220,16 @@ public class InjectorForLazyResolve {
descriptorResolver.setStorageManager(storageManager);
descriptorResolver.setTypeResolver(typeResolver);
delegatedPropertyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
delegatedPropertyResolver.setCallResolver(callResolver);
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator);
qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
@@ -235,6 +240,7 @@ public class InjectorForLazyResolve {
declarationScopeProvider.setFileScopeProvider(scopeProvider);
scriptBodyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
}
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java
+35 -30
View File
@@ -27,19 +27,21 @@ import org.jetbrains.kotlin.resolve.TypeResolver;
import org.jetbrains.kotlin.context.GlobalContext;
import org.jetbrains.kotlin.storage.StorageManager;
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider.DefaultProvider;
import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
import org.jetbrains.kotlin.resolve.DescriptorResolver;
import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.resolve.StatementFilter;
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.expressions.FakeCallResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
@@ -65,19 +67,21 @@ public class InjectorForMacros {
private final GlobalContext globalContext;
private final StorageManager storageManager;
private final DefaultProvider defaultProvider;
private final DefaultSymbolUsageValidator defaultSymbolUsageValidator;
private final SymbolUsageValidator symbolUsageValidator;
private final StatementFilter statementFilter;
private final AnnotationResolver annotationResolver;
private final CallExpressionResolver callExpressionResolver;
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final DescriptorResolver descriptorResolver;
private final DelegatedPropertyResolver delegatedPropertyResolver;
private final FunctionDescriptorResolver functionDescriptorResolver;
private final StatementFilter statementFilter;
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final DynamicTypesSettings dynamicTypesSettings;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final FakeCallResolver fakeCallResolver;
private final FunctionDescriptorResolver functionDescriptorResolver;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final MultiDeclarationResolver multiDeclarationResolver;
private final ReflectionTypes reflectionTypes;
private final ValueParameterResolver valueParameterResolver;
private final ArgumentTypeResolver argumentTypeResolver;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
@@ -106,46 +110,47 @@ public class InjectorForMacros {
this.dynamicTypesSettings = new DynamicTypesSettings();
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
this.defaultProvider = DefaultProvider.INSTANCE$;
this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$;
this.callExpressionResolver = new CallExpressionResolver();
this.symbolUsageValidator = defaultProvider.getSymbolUsageValidator();
this.statementFilter = new StatementFilter();
this.callExpressionResolver = new CallExpressionResolver(getCallResolver());
this.controlStructureTypingUtils = new ControlStructureTypingUtils(getCallResolver());
this.descriptorResolver = new DescriptorResolver();
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.functionDescriptorResolver = new FunctionDescriptorResolver(getTypeResolver(), descriptorResolver, annotationResolver, storageManager, getExpressionTypingServices(), kotlinBuiltIns);
this.statementFilter = new StatementFilter();
this.controlStructureTypingUtils = new ControlStructureTypingUtils(getExpressionTypingServices());
this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), getCallResolver(), kotlinBuiltIns);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.fakeCallResolver = new FakeCallResolver(project, getCallResolver());
this.functionDescriptorResolver = new FunctionDescriptorResolver(getTypeResolver(), descriptorResolver, annotationResolver, storageManager, getExpressionTypingServices(), kotlinBuiltIns);
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, getTypeResolver(), annotationResolver);
this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, getTypeResolver(), symbolUsageValidator);
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
this.valueParameterResolver = new ValueParameterResolver(defaultProvider, getExpressionTypingServices());
this.argumentTypeResolver = new ArgumentTypeResolver();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
this.expressionTypingServices.setAnnotationResolver(annotationResolver);
this.expressionTypingServices.setBuiltIns(kotlinBuiltIns);
this.expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
this.expressionTypingServices.setCallResolver(callResolver);
this.expressionTypingServices.setDescriptorResolver(descriptorResolver);
this.expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver);
this.expressionTypingServices.setProject(project);
this.expressionTypingServices.setStatementFilter(statementFilter);
this.expressionTypingServices.setTypeResolver(typeResolver);
this.expressionTypingComponents.setAdditionalCheckerProvider(defaultProvider);
this.expressionTypingComponents.setAnnotationResolver(annotationResolver);
this.expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
this.expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
this.expressionTypingComponents.setCallResolver(callResolver);
this.expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
this.expressionTypingComponents.setDescriptorResolver(descriptorResolver);
this.expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
this.expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
this.expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
this.expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
this.expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
this.expressionTypingComponents.setGlobalContext(globalContext);
this.expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
this.expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
this.expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
this.expressionTypingComponents.setReflectionTypes(reflectionTypes);
this.expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator);
this.expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
this.expressionTypingComponents.setTypeResolver(typeResolver);
this.expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
this.callResolver.setAdditionalCheckerProvider(defaultProvider);
this.callResolver.setArgumentTypeResolver(argumentTypeResolver);
this.callResolver.setCallCompleter(callCompleter);
this.callResolver.setCandidateResolver(candidateResolver);
@@ -166,14 +171,14 @@ public class InjectorForMacros {
descriptorResolver.setStorageManager(storageManager);
descriptorResolver.setTypeResolver(typeResolver);
delegatedPropertyResolver.setAdditionalCheckerProvider(defaultProvider);
delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
delegatedPropertyResolver.setCallResolver(callResolver);
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
forLoopConventionsChecker.setProject(project);
forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
argumentTypeResolver.setBuiltIns(kotlinBuiltIns);
argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
@@ -181,7 +186,7 @@ public class InjectorForMacros {
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator);
qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/AdditionalCheckerProvider.kt
+9 -4
View File
@@ -17,20 +17,25 @@
package org.jetbrains.kotlin.resolve
import org.jetbrains.kotlin.resolve.calls.checkers.*
import org.jetbrains.kotlin.resolve.validation.DeprecatedSymbolValidator
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
private val DEFAULT_DECLARATION_CHECKERS = listOf(DataClassAnnotationChecker())
private val DEFAULT_CALL_CHECKERS = listOf(CapturingInClosureChecker(), InlineCheckerWrapper(), ReifiedTypeParameterSubstitutionChecker())
private val DEFAULT_TYPE_CHECKERS = listOf(TypeApproximator())
private val DEFAULT_VALIDATORS = listOf(DeprecatedSymbolValidator())
public abstract class AdditionalCheckerProvider(
additionalDeclarationCheckers: List<DeclarationChecker>,
additionalCallCheckers: List<CallChecker>,
additionalTypeCheckers: List<AdditionalTypeChecker>
additionalTypeCheckers: List<AdditionalTypeChecker>,
additionalSymbolUsageValidators: List<SymbolUsageValidator>
) {
public val declarationCheckers: List<DeclarationChecker> = DEFAULT_DECLARATION_CHECKERS + additionalDeclarationCheckers
public val callCheckers: List<CallChecker> = DEFAULT_CALL_CHECKERS + additionalCallCheckers
public val additionalTypeCheckers: List<AdditionalTypeChecker> = DEFAULT_TYPE_CHECKERS + additionalTypeCheckers
public val callChecker: CallChecker = CompositeChecker(DEFAULT_CALL_CHECKERS + additionalCallCheckers)
public val typeChecker: AdditionalTypeChecker = AdditionalTypeChecker.Composite(DEFAULT_TYPE_CHECKERS + additionalTypeCheckers)
public val symbolUsageValidator: SymbolUsageValidator = SymbolUsageValidator.Composite(DEFAULT_VALIDATORS + additionalSymbolUsageValidators)
public object DefaultProvider : AdditionalCheckerProvider(listOf(), listOf(), listOf()) {}
public object DefaultProvider : AdditionalCheckerProvider(listOf(), listOf(), listOf(), listOf()) {}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java
+2 -2
View File
@@ -50,7 +50,7 @@ import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyAnnotationDescriptor;
import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyAnnotationsContextImpl;
import org.jetbrains.kotlin.resolve.scopes.JetScope;
import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
import org.jetbrains.kotlin.resolve.validation.CompositeSymbolUsageValidator;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.storage.StorageManager;
import org.jetbrains.kotlin.types.ErrorUtils;
import org.jetbrains.kotlin.types.JetType;
@@ -366,7 +366,7 @@ public class AnnotationResolver {
new SimpleResolutionContext(trace, JetScope.Empty.INSTANCE$, NO_EXPECTED_TYPE, DataFlowInfo.EMPTY,
ContextDependency.INDEPENDENT,
new CompositeChecker(Lists.<CallChecker>newArrayList()),
new CompositeSymbolUsageValidator(),
SymbolUsageValidator.Empty,
new AdditionalTypeChecker.Composite(Lists.<AdditionalTypeChecker>newArrayList()),
StatementFilter.NONE);
ArgumentTypeResolver.updateNumberType(defaultType, argumentExpression, context);
compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
+18 -5
View File
@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
import org.jetbrains.kotlin.types.*;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
import org.jetbrains.kotlin.util.Box;
import org.jetbrains.kotlin.util.ReenteringLazyValueComputationException;
import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
@@ -61,6 +62,8 @@ public class BodyResolver {
private AnnotationResolver annotationResolver;
private DelegatedPropertyResolver delegatedPropertyResolver;
private FunctionAnalyzerExtension functionAnalyzerExtension;
private AdditionalCheckerProvider additionalCheckerProvider;
private ValueParameterResolver valueParameterResolver;
@Inject
public void setScriptBodyResolverResolver(@NotNull ScriptBodyResolver scriptBodyResolverResolver) {
@@ -107,6 +110,16 @@ public class BodyResolver {
this.functionAnalyzerExtension = functionAnalyzerExtension;
}
@Inject
public void setAdditionalCheckerProvider(AdditionalCheckerProvider additionalCheckerProvider) {
this.additionalCheckerProvider = additionalCheckerProvider;
}
@Inject
public void setValueParameterResolver(ValueParameterResolver valueParameterResolver) {
this.valueParameterResolver = valueParameterResolver;
}
private void resolveBehaviorDeclarationBodies(@NotNull BodiesResolveContext c) {
resolveDelegationSpecifierLists(c);
@@ -148,7 +161,7 @@ public class BodyResolver {
) {
AnnotationResolver.resolveAnnotationsArguments(constructor.getModifierList(), trace);
final CallChecker callChecker = new ConstructorHeaderCallChecker(descriptor, expressionTypingServices.getCallChecker());
final CallChecker callChecker = new ConstructorHeaderCallChecker(descriptor, additionalCheckerProvider.getCallChecker());
resolveFunctionBody(c, trace, constructor, descriptor, declaringScope,
new Function1<JetScope, DataFlowInfo>() {
@Override
@@ -497,7 +510,7 @@ public class BodyResolver {
if (unsubstitutedPrimaryConstructor != null) {
WritableScope parameterScope = getPrimaryConstructorParametersScope(classDescriptor.getScopeForClassHeaderResolution(), unsubstitutedPrimaryConstructor);
expressionTypingServices.resolveValueParameters(klass.getPrimaryConstructorParameters(), unsubstitutedPrimaryConstructor.getValueParameters(),
valueParameterResolver.resolveValueParameters(klass.getPrimaryConstructorParameters(), unsubstitutedPrimaryConstructor.getValueParameters(),
parameterScope, c.getOuterDataFlowInfo(), trace);
}
}
@@ -729,10 +742,10 @@ public class BodyResolver {
List<JetParameter> valueParameters = function.getValueParameters();
List<ValueParameterDescriptor> valueParameterDescriptors = functionDescriptor.getValueParameters();
expressionTypingServices.resolveValueParameters(
valueParameterResolver.resolveValueParameters(
valueParameters, valueParameterDescriptors,
ExpressionTypingContext.newContext(
expressionTypingServices, trace, innerScope, c.getOuterDataFlowInfo(), NO_EXPECTED_TYPE, callChecker)
additionalCheckerProvider, trace, innerScope, c.getOuterDataFlowInfo(), NO_EXPECTED_TYPE, callChecker)
);
DataFlowInfo dataFlowInfo = null;
@@ -761,7 +774,7 @@ public class BodyResolver {
JetScope scope = getPrimaryConstructorParametersScope(declaringScope, constructorDescriptor);
expressionTypingServices.resolveValueParameters(valueParameters, valueParameterDescriptors, scope,
valueParameterResolver.resolveValueParameters(valueParameters, valueParameterDescriptors, scope,
c.getOuterDataFlowInfo(), trace);
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java
+13 -7
View File
@@ -55,12 +55,13 @@ import static org.jetbrains.kotlin.types.TypeUtils.noExpectedType;
import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.createFakeExpressionOfType;
public class DelegatedPropertyResolver {
public static final Name PROPERTY_DELEGATED_FUNCTION_NAME = Name.identifier("propertyDelegated");
private ExpressionTypingServices expressionTypingServices;
private CallResolver callResolver;
private KotlinBuiltIns builtIns;
public static final Name PROPERTY_DELEGATED_FUNCTION_NAME = Name.identifier("propertyDelegated");
private AdditionalCheckerProvider additionalCheckerProvider;
@Inject
public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
@@ -77,6 +78,11 @@ public class DelegatedPropertyResolver {
this.builtIns = builtIns;
}
@Inject
public void setAdditionalCheckerProvider(AdditionalCheckerProvider additionalCheckerProvider) {
this.additionalCheckerProvider = additionalCheckerProvider;
}
@Nullable
public JetType getDelegatedPropertyGetMethodReturnType(
@NotNull PropertyDescriptor propertyDescriptor,
@@ -142,7 +148,7 @@ public class DelegatedPropertyResolver {
) {
TemporaryBindingTrace traceToResolvePDMethod = TemporaryBindingTrace.create(trace, "Trace to resolve propertyDelegated method in delegated property");
ExpressionTypingContext context = ExpressionTypingContext.newContext(
expressionTypingServices, traceToResolvePDMethod, scope,
additionalCheckerProvider, traceToResolvePDMethod, scope,
DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE);
List<JetExpression> arguments = Lists.newArrayList();
@@ -216,7 +222,7 @@ public class DelegatedPropertyResolver {
JetPropertyDelegate delegate = property.getDelegate();
if (delegate != null) {
PsiElement byKeyword = delegate.getByKeywordNode().getPsi();
expressionTypingServices.getSymbolUsageValidator().validateCall(resultingCall.getResultingDescriptor(), trace, byKeyword);
additionalCheckerProvider.getSymbolUsageValidator().validateCall(resultingCall.getResultingDescriptor(), trace, byKeyword);
}
}
trace.record(DELEGATED_PROPERTY_RESOLVED_CALL, accessor, resultingCall);
@@ -239,7 +245,7 @@ public class DelegatedPropertyResolver {
? propertyDescriptor.getType() : TypeUtils.NO_EXPECTED_TYPE;
ExpressionTypingContext context = ExpressionTypingContext.newContext(
expressionTypingServices, trace, scope,
additionalCheckerProvider, trace, scope,
DataFlowInfo.EMPTY, expectedType);
boolean hasThis = propertyDescriptor.getExtensionReceiverParameter() != null || propertyDescriptor.getDispatchReceiverParameter() != null;
@@ -251,7 +257,7 @@ public class DelegatedPropertyResolver {
arguments.add(createExpressionForPropertyMetadata(psiFactory, propertyDescriptor));
if (!isGet) {
JetReferenceExpression fakeArgument = (JetReferenceExpression) createFakeExpressionOfType(expressionTypingServices.getProject(), trace,
JetReferenceExpression fakeArgument = (JetReferenceExpression) createFakeExpressionOfType(delegateExpression.getProject(), trace,
"fakeArgument" + arguments.size(),
propertyDescriptor.getType());
arguments.add(fakeArgument);
compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java
+2 -4
View File
@@ -29,11 +29,9 @@ import org.jetbrains.kotlin.descriptors.*;
import org.jetbrains.kotlin.diagnostics.Errors;
import org.jetbrains.kotlin.name.Name;
import org.jetbrains.kotlin.psi.*;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.scopes.AbstractScopeAdapter;
import org.jetbrains.kotlin.resolve.scopes.JetScope;
import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
import org.jetbrains.kotlin.resolve.validation.CompositeSymbolUsageValidator;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import javax.inject.Inject;
@@ -44,7 +42,7 @@ import java.util.Set;
import static org.jetbrains.kotlin.diagnostics.Errors.*;
public class QualifiedExpressionResolver {
private SymbolUsageValidator symbolUsageValidator = new CompositeSymbolUsageValidator();
private SymbolUsageValidator symbolUsageValidator = SymbolUsageValidator.Empty;
/**
* @deprecated Instance of this class should be obtained from the Injector
@@ -54,7 +52,7 @@ public class QualifiedExpressionResolver {
}
@Inject
public void setSymbolUsageValidator(SymbolUsageValidator symbolUsageValidator) {
public void setSymbolUsageValidator(@NotNull SymbolUsageValidator symbolUsageValidator) {
this.symbolUsageValidator = symbolUsageValidator;
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java
+6 -1
View File
@@ -37,12 +37,17 @@ import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
public class ScriptBodyResolver {
private ExpressionTypingServices expressionTypingServices;
private AdditionalCheckerProvider additionalCheckerProvider;
@Inject
public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
this.expressionTypingServices = expressionTypingServices;
}
@Inject
public void setAdditionalCheckerProvider(AdditionalCheckerProvider additionalCheckerProvider) {
this.additionalCheckerProvider = additionalCheckerProvider;
}
public void resolveScriptBodies(@NotNull BodiesResolveContext c) {
for (Map.Entry<JetScript, ScriptDescriptor> e : c.getScripts().entrySet()) {
@@ -59,7 +64,7 @@ public class ScriptBodyResolver {
) {
// Resolve all contents of the script
ExpressionTypingContext context = ExpressionTypingContext.newContext(
expressionTypingServices,
additionalCheckerProvider,
trace,
scriptDescriptor.getScopeForBodyResolution(),
DataFlowInfo.EMPTY,
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java
+1 -1
View File
@@ -253,7 +253,7 @@ public class ArgumentTypeResolver {
@Nullable JetType defaultValue
) {
if (returnTypeRef != null) {
return expressionTypingServices.getTypeResolver().resolveType(scope, returnTypeRef, trace, true);
return typeResolver.resolveType(scope, returnTypeRef, trace, true);
}
return defaultValue;
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java
+7 -3
View File
@@ -58,7 +58,13 @@ import static org.jetbrains.kotlin.resolve.scopes.receivers.ReceiversPackage.res
import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
public class CallExpressionResolver {
@NotNull
private final CallResolver callResolver;
public CallExpressionResolver(@NotNull CallResolver callResolver) {
this.callResolver = callResolver;
}
private ExpressionTypingServices expressionTypingServices;
@Inject
@@ -72,7 +78,6 @@ public class CallExpressionResolver {
@NotNull ResolutionContext context, @NotNull CheckValueArgumentsMode checkArguments,
@NotNull boolean[] result
) {
CallResolver callResolver = expressionTypingServices.getCallResolver();
OverloadResolutionResults<FunctionDescriptor> results = callResolver.resolveFunctionCall(
BasicCallResolutionContext.create(context, call, checkArguments));
if (!results.isNothing()) {
@@ -90,7 +95,6 @@ public class CallExpressionResolver {
) {
TemporaryTraceAndCache temporaryForVariable = TemporaryTraceAndCache.create(
context, "trace to resolve as local variable or property", nameExpression);
CallResolver callResolver = expressionTypingServices.getCallResolver();
Call call = CallMaker.makePropertyCall(receiver, callOperationNode, nameExpression);
BasicCallResolutionContext contextForVariable = BasicCallResolutionContext.create(
context.replaceTraceAndCache(temporaryForVariable),
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
+9 -8
View File
@@ -63,18 +63,13 @@ import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
@SuppressWarnings("RedundantTypeArguments")
public class CallResolver {
@NotNull
private ExpressionTypingServices expressionTypingServices;
@NotNull
private TypeResolver typeResolver;
@NotNull
private CandidateResolver candidateResolver;
@NotNull
private ArgumentTypeResolver argumentTypeResolver;
@NotNull
private CallCompleter callCompleter;
@NotNull
private TaskPrioritizer taskPrioritizer;
private AdditionalCheckerProvider additionalCheckerProvider;
@Inject
public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
@@ -106,6 +101,11 @@ public class CallResolver {
this.taskPrioritizer = taskPrioritizer;
}
@Inject
public void setAdditionalCheckerProvider(AdditionalCheckerProvider additionalCheckerProvider) {
this.additionalCheckerProvider = additionalCheckerProvider;
}
@NotNull
public OverloadResolutionResults<VariableDescriptor> resolveSimpleProperty(@NotNull BasicCallResolutionContext context) {
JetExpression calleeExpression = context.call.getCalleeExpression();
@@ -232,7 +232,8 @@ public class CallResolver {
return resolveFunctionCall(
BasicCallResolutionContext.create(
trace, scope, call, expectedType, dataFlowInfo, ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED,
expressionTypingServices.getCallChecker(), expressionTypingServices.getSymbolUsageValidator(), expressionTypingServices.getAdditionalTypeChecker(), isAnnotationContext)
additionalCheckerProvider.getCallChecker(), additionalCheckerProvider.getSymbolUsageValidator(),
additionalCheckerProvider.getTypeChecker(), isAnnotationContext)
);
}
@@ -312,7 +313,7 @@ public class CallResolver {
CallMaker.makeCall(ReceiverValue.NO_RECEIVER, null, call),
NO_EXPECTED_TYPE,
dataFlowInfo, ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED,
callChecker, expressionTypingServices.getSymbolUsageValidator(), expressionTypingServices.getAdditionalTypeChecker(), false);
callChecker, additionalCheckerProvider.getSymbolUsageValidator(), additionalCheckerProvider.getTypeChecker(), false);
if (call.getCalleeExpression() == null) return checkArgumentTypesAndFail(context);
compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/CompositeSymbolUsageValidator.kt
-20
View File
@@ -1,20 +0,0 @@
package org.jetbrains.kotlin.resolve.validation
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.descriptors.CallableDescriptor
import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
import org.jetbrains.kotlin.resolve.BindingTrace
import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
public open class CompositeSymbolUsageValidator(val validators: List<SymbolUsageValidator>) : SymbolUsageValidator {
constructor(vararg validator : SymbolUsageValidator) : this(validator.toList()) {}
override fun validateCall(targetDescriptor: CallableDescriptor, trace: BindingTrace, element: PsiElement) {
validators.forEach { it.validateCall(targetDescriptor, trace, element) }
}
override fun validateTypeUsage(targetDescriptor: ClassifierDescriptor, trace: BindingTrace, element: PsiElement) {
validators.forEach { it.validateTypeUsage(targetDescriptor, trace, element) }
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DefaultSymbolUsageValidator.kt
-3
View File
@@ -1,3 +0,0 @@
package org.jetbrains.kotlin.resolve.validation
object DefaultSymbolUsageValidator : CompositeSymbolUsageValidator(DeprecatedSymbolValidator())
compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/SymbolUsageValidator.kt
+14 -5
View File
@@ -4,16 +4,25 @@ import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.descriptors.CallableDescriptor
import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
import org.jetbrains.kotlin.resolve.BindingTrace
import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
import kotlin.platform.platformStatic
public trait SymbolUsageValidator {
fun validateTypeUsage(targetDescriptor: ClassifierDescriptor, trace: BindingTrace, element: PsiElement) {
public fun validateTypeUsage(targetDescriptor: ClassifierDescriptor, trace: BindingTrace, element: PsiElement) { }
public fun validateCall(targetDescriptor: CallableDescriptor, trace: BindingTrace, element: PsiElement) { }
public open class Composite(val validators: List<SymbolUsageValidator>) : SymbolUsageValidator {
override fun validateCall(targetDescriptor: CallableDescriptor, trace: BindingTrace, element: PsiElement) {
validators.forEach { it.validateCall(targetDescriptor, trace, element) }
}
override fun validateTypeUsage(targetDescriptor: ClassifierDescriptor, trace: BindingTrace, element: PsiElement) {
validators.forEach { it.validateTypeUsage(targetDescriptor, trace, element) }
}
}
fun validateCall(targetDescriptor: CallableDescriptor, trace: BindingTrace, element: PsiElement) {
companion object {
val Empty: SymbolUsageValidator = Composite(listOf())
}
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
+55 -16
View File
@@ -25,6 +25,7 @@ import kotlin.Function1;
import kotlin.KotlinPackage;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.JetNodeTypes;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.descriptors.*;
import org.jetbrains.kotlin.descriptors.annotations.Annotations;
@@ -103,7 +104,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
public JetTypeInfo visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression, ExpressionTypingContext context) {
// TODO : other members
// TODO : type substitutions???
CallExpressionResolver callExpressionResolver = components.expressionTypingServices.getCallExpressionResolver();
CallExpressionResolver callExpressionResolver = components.callExpressionResolver;
JetTypeInfo typeInfo = callExpressionResolver.getSimpleNameExpressionTypeInfo(expression, NO_RECEIVER, null, context);
return DataFlowUtils.checkType(typeInfo, expression, context); // TODO : Extensions to this
}
@@ -126,7 +127,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
boolean hasError = compileTimeConstantChecker.checkConstantExpressionType(value, expression, context.expectedType);
if (hasError) {
IElementType elementType = expression.getNode().getElementType();
return TypeInfoFactoryPackage.createTypeInfo(components.expressionTypingUtils.getDefaultType(elementType), context);
return TypeInfoFactoryPackage.createTypeInfo(getDefaultType(elementType), context);
}
}
@@ -134,6 +135,29 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
return createCompileTimeConstantTypeInfo(value, expression, context);
}
@NotNull
public JetType getDefaultType(IElementType constantType) {
KotlinBuiltIns builtIns = components.builtIns;
if (constantType == JetNodeTypes.INTEGER_CONSTANT) {
return builtIns.getIntType();
}
else if (constantType == JetNodeTypes.FLOAT_CONSTANT) {
return builtIns.getDoubleType();
}
else if (constantType == JetNodeTypes.BOOLEAN_CONSTANT) {
return builtIns.getBooleanType();
}
else if (constantType == JetNodeTypes.CHARACTER_CONSTANT) {
return builtIns.getCharType();
}
else if (constantType == JetNodeTypes.NULL) {
return builtIns.getNullableNothingType();
}
else {
throw new IllegalArgumentException("Unsupported constant type: " + constantType);
}
}
@Override
public JetTypeInfo visitBinaryWithTypeRHSExpression(@NotNull JetBinaryExpressionWithTypeRHS expression, ExpressionTypingContext context) {
ExpressionTypingContext contextWithNoExpectedType =
@@ -148,8 +172,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
boolean allowBareTypes = BARE_TYPES_ALLOWED.contains(operationType);
TypeResolutionContext typeResolutionContext = new TypeResolutionContext(context.scope, context.trace, true, allowBareTypes);
PossiblyBareType possiblyBareTarget = components.expressionTypingServices.getTypeResolver().resolvePossiblyBareType(
typeResolutionContext, right);
PossiblyBareType possiblyBareTarget = components.typeResolver.resolvePossiblyBareType(typeResolutionContext, right);
if (operationType == JetTokens.COLON) {
// We do not allow bare types on static assertions, because static assertions provide an expected type for their argument,
@@ -286,7 +309,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
private JetTypeInfo errorInSuper(JetSuperExpression expression, ExpressionTypingContext context) {
JetTypeReference superTypeQualifier = expression.getSuperTypeQualifier();
if (superTypeQualifier != null) {
components.expressionTypingServices.getTypeResolver().resolveType(context.scope, superTypeQualifier, context.trace, true);
components.typeResolver.resolveType(context.scope, superTypeQualifier, context.trace, true);
}
return TypeInfoFactoryPackage.noTypeInfo(context);
}
@@ -312,15 +335,15 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
JetUserType userType = (JetUserType) typeElement;
// This may be just a superclass name even if the superclass is generic
if (userType.getTypeArguments().isEmpty()) {
classifierCandidate = components.expressionTypingServices.getTypeResolver().resolveClass(context.scope, userType, context.trace);
classifierCandidate = components.typeResolver.resolveClass(context.scope, userType, context.trace);
}
else {
supertype = components.expressionTypingServices.getTypeResolver().resolveType(context.scope, superTypeQualifier, context.trace, true);
supertype = components.typeResolver.resolveType(context.scope, superTypeQualifier, context.trace, true);
redundantTypeArguments = userType.getTypeArgumentList();
}
}
else {
supertype = components.expressionTypingServices.getTypeResolver().resolveType(context.scope, superTypeQualifier, context.trace, true);
supertype = components.typeResolver.resolveType(context.scope, superTypeQualifier, context.trace, true);
}
if (supertype != null) {
@@ -478,7 +501,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
TypeResolutionContext context =
new TypeResolutionContext(c.scope, c.trace, /* checkBounds = */ false, /* allowBareTypes = */ true);
PossiblyBareType possiblyBareType =
components.expressionTypingServices.getTypeResolver().resolvePossiblyBareType(context, typeReference);
components.typeResolver.resolvePossiblyBareType(context, typeReference);
JetType type = null;
if (possiblyBareType.isBare()) {
@@ -546,7 +569,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
JetType receiverType =
typeReference == null
? null
: components.expressionTypingServices.getTypeResolver().resolveType(c.scope, typeReference, c.trace, false);
: components.typeResolver.resolveType(c.scope, typeReference, c.trace, false);
JetSimpleNameExpression callableReference = expression.getCallableReference();
if (callableReference.getReferencedName().isEmpty()) {
@@ -784,7 +807,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
BasicCallResolutionContext callResolutionContext = BasicCallResolutionContext.create(
context.replaceTraceAndCache(temporaryTrace).replaceExpectedType(NO_EXPECTED_TYPE), call, CheckValueArgumentsMode.DISABLED);
OverloadResolutionResults<CallableDescriptor> results =
components.expressionTypingServices.getCallResolver().resolveCallForMember(reference, callResolutionContext);
components.callResolver.resolveCallForMember(reference, callResolutionContext);
if (!results.isNothing()) {
temporaryTrace.commit();
result[0] = true;
@@ -799,13 +822,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
@Override
public JetTypeInfo visitQualifiedExpression(@NotNull JetQualifiedExpression expression, ExpressionTypingContext context) {
CallExpressionResolver callExpressionResolver = components.expressionTypingServices.getCallExpressionResolver();
CallExpressionResolver callExpressionResolver = components.callExpressionResolver;
return callExpressionResolver.getQualifiedExpressionTypeInfo(expression, context);
}
@Override
public JetTypeInfo visitCallExpression(@NotNull JetCallExpression expression, ExpressionTypingContext context) {
CallExpressionResolver callExpressionResolver = components.expressionTypingServices.getCallExpressionResolver();
CallExpressionResolver callExpressionResolver = components.callExpressionResolver;
return callExpressionResolver.getCallExpressionTypeInfo(expression, NO_RECEIVER, null, context);
}
@@ -1162,7 +1185,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
if (resolutionResults.isSuccess()) {
FunctionDescriptor equals = resolutionResults.getResultingCall().getResultingDescriptor();
if (components.expressionTypingUtils.ensureBooleanResult(operationSign, OperatorConventions.EQUALS, equals.getReturnType(),
if (ensureBooleanResult(operationSign, OperatorConventions.EQUALS, equals.getReturnType(),
context)) {
ensureNonemptyIntersectionOfOperandTypes(expression, context);
}
@@ -1302,7 +1325,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
operationSign,
OperatorConventions.CONTAINS);
JetType containsType = OverloadResolutionResultsUtil.getResultingType(resolutionResult, context.contextDependency);
components.expressionTypingUtils.ensureBooleanResult(operationSign, OperatorConventions.CONTAINS, containsType, context);
ensureBooleanResult(operationSign, OperatorConventions.CONTAINS, containsType, context);
if (left != null) {
dataFlowInfo = facade.getTypeInfo(left, contextWithDataFlow).getDataFlowInfo().and(dataFlowInfo);
@@ -1317,6 +1340,22 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
}
}
private boolean ensureBooleanResult(JetExpression operationSign, Name name, JetType resultType, ExpressionTypingContext context) {
return ensureBooleanResultWithCustomSubject(operationSign, resultType, "'" + name + "'", context);
}
private boolean ensureBooleanResultWithCustomSubject(JetExpression operationSign, JetType resultType, String subjectName, ExpressionTypingContext context) {
if (resultType != null) {
// TODO : Relax?
if (!components.builtIns.isBooleanOrSubtype(resultType)) {
context.trace.report(RESULT_TYPE_MISMATCH.on(operationSign, subjectName, components.builtIns.getBooleanType(), resultType));
return false;
}
}
return true;
}
private void ensureNonemptyIntersectionOfOperandTypes(JetBinaryExpression expression, final ExpressionTypingContext context) {
JetExpression left = expression.getLeft();
if (left == null) return;
@@ -1460,7 +1499,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
}
public JetTypeInfo visitAnnotatedExpression(JetAnnotatedExpression expression, ExpressionTypingContext context, boolean isStatement) {
components.expressionTypingServices.getAnnotationResolver().resolveAnnotationsWithArguments(
components.annotationResolver.resolveAnnotationsWithArguments(
context.scope, expression.getAnnotationEntries(), context.trace);
JetExpression baseExpression = expression.getBaseExpression();
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java
+3 -4
View File
@@ -59,10 +59,10 @@ import static org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.Co
public class ControlStructureTypingUtils {
private static final Logger LOG = Logger.getInstance(ControlStructureTypingUtils.class);
private final ExpressionTypingServices expressionTypingServices;
private final CallResolver callResolver;
public ControlStructureTypingUtils(@NotNull ExpressionTypingServices expressionTypingServices) {
this.expressionTypingServices = expressionTypingServices;
public ControlStructureTypingUtils(@NotNull CallResolver callResolver) {
this.callResolver = callResolver;
}
/*package*/ ResolvedCall<FunctionDescriptor> resolveSpecialConstructionAsCall(
@@ -77,7 +77,6 @@ public class ControlStructureTypingUtils {
constructionName.toUpperCase(), argumentNames, isArgumentNullable);
TracingStrategy tracing = createTracingForSpecialConstruction(call, constructionName, context);
ResolutionCandidate<CallableDescriptor> resolutionCandidate = ResolutionCandidate.<CallableDescriptor>create(call, function);
CallResolver callResolver = expressionTypingServices.getCallResolver();
OverloadResolutionResults<FunctionDescriptor> results = callResolver.resolveCallWithKnownCandidate(
call, tracing, context, resolutionCandidate, dataFlowInfoForArguments);
assert results.isSingleResult() : "Not single result after resolving one known candidate";
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java
+6 -5
View File
@@ -395,8 +395,9 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
if (multiParameter != null && loopRange != null) {
JetType elementType = expectedParameterType == null ? ErrorUtils.createErrorType("Loop range has no type") : expectedParameterType;
TransientReceiver iteratorNextAsReceiver = new TransientReceiver(elementType);
components.expressionTypingUtils.defineLocalVariablesFromMultiDeclaration(loopScope, multiParameter, iteratorNextAsReceiver,
loopRange, context);
components.multiDeclarationResolver.defineLocalVariablesFromMultiDeclaration(
loopScope, multiParameter, iteratorNextAsReceiver, loopRange, context
);
}
}
@@ -425,7 +426,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
JetTypeReference typeReference = loopParameter.getTypeReference();
VariableDescriptor variableDescriptor;
if (typeReference != null) {
variableDescriptor = components.expressionTypingServices.getDescriptorResolver().resolveLocalVariableDescriptor(context.scope, loopParameter, context.trace);
variableDescriptor = components.descriptorResolver.resolveLocalVariableDescriptor(context.scope, loopParameter, context.trace);
JetType actualParameterType = variableDescriptor.getType();
if (expectedParameterType != null &&
!JetTypeChecker.DEFAULT.isSubtypeOf(expectedParameterType, actualParameterType)) {
@@ -436,7 +437,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
if (expectedParameterType == null) {
expectedParameterType = ErrorUtils.createErrorType("Error");
}
variableDescriptor = components.expressionTypingServices.getDescriptorResolver().resolveLocalVariableDescriptor(loopParameter, expectedParameterType, context.trace, context.scope);
variableDescriptor = components.descriptorResolver.resolveLocalVariableDescriptor(loopParameter, expectedParameterType, context.trace, context.scope);
}
{
@@ -465,7 +466,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
DescriptorResolver.checkParameterHasNoValOrVar(context.trace, catchParameter, VAL_OR_VAR_ON_CATCH_PARAMETER);
DescriptorResolver.checkParameterHasNoModifier(context.trace, catchParameter);
VariableDescriptor variableDescriptor = components.expressionTypingServices.getDescriptorResolver().resolveLocalVariableDescriptor(
VariableDescriptor variableDescriptor = components.descriptorResolver.resolveLocalVariableDescriptor(
context.scope, catchParameter, context.trace);
JetType throwableType = components.builtIns.getThrowable().getDefaultType();
DataFlowUtils.checkType(variableDescriptor.getType(), catchParameter, context.replaceExpectedType(throwableType));
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java
+49 -7
View File
@@ -20,7 +20,8 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.context.GlobalContext;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
import org.jetbrains.kotlin.resolve.*;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
@@ -33,7 +34,6 @@ public class ExpressionTypingComponents {
/*package*/ ExpressionTypingServices expressionTypingServices;
/*package*/ CallResolver callResolver;
/*package*/ PlatformToKotlinClassMap platformToKotlinClassMap;
/*package*/ ExpressionTypingUtils expressionTypingUtils;
/*package*/ ControlStructureTypingUtils controlStructureTypingUtils;
/*package*/ ForLoopConventionsChecker forLoopConventionsChecker;
/*package*/ ReflectionTypes reflectionTypes;
@@ -42,6 +42,13 @@ public class ExpressionTypingComponents {
/*package*/ DynamicTypesSettings dynamicTypesSettings;
/*package*/ KotlinBuiltIns builtIns;
/*package*/ LocalClassifierAnalyzer localClassifierAnalyzer;
/*package*/ FunctionDescriptorResolver functionDescriptorResolver;
/*package*/ CallExpressionResolver callExpressionResolver;
/*package*/ DescriptorResolver descriptorResolver;
/*package*/ TypeResolver typeResolver;
/*package*/ AnnotationResolver annotationResolver;
/*package*/ ValueParameterResolver valueParameterResolver;
/*package*/ MultiDeclarationResolver multiDeclarationResolver;
@Inject
public void setGlobalContext(@NotNull GlobalContext globalContext) {
@@ -63,11 +70,6 @@ public class ExpressionTypingComponents {
this.platformToKotlinClassMap = platformToKotlinClassMap;
}
@Inject
public void setExpressionTypingUtils(@NotNull ExpressionTypingUtils expressionTypingUtils) {
this.expressionTypingUtils = expressionTypingUtils;
}
@Inject
public void setControlStructureTypingUtils(@NotNull ControlStructureTypingUtils controlStructureTypingUtils) {
this.controlStructureTypingUtils = controlStructureTypingUtils;
@@ -108,8 +110,48 @@ public class ExpressionTypingComponents {
this.localClassifierAnalyzer = localClassifierAnalyzer;
}
@Inject
public void setFunctionDescriptorResolver(FunctionDescriptorResolver functionDescriptorResolver) {
this.functionDescriptorResolver = functionDescriptorResolver;
}
@Inject
public void setCallExpressionResolver(CallExpressionResolver callExpressionResolver) {
this.callExpressionResolver = callExpressionResolver;
}
@Inject
public void setDescriptorResolver(DescriptorResolver descriptorResolver) {
this.descriptorResolver = descriptorResolver;
}
@Inject
public void setTypeResolver(TypeResolver typeResolver) {
this.typeResolver = typeResolver;
}
@Inject
public void setAnnotationResolver(AnnotationResolver annotationResolver) {
this.annotationResolver = annotationResolver;
}
@Inject
public void setValueParameterResolver(ValueParameterResolver valueParameterResolver) {
this.valueParameterResolver = valueParameterResolver;
}
@Inject
public void setMultiDeclarationResolver(MultiDeclarationResolver multiDeclarationResolver) {
this.multiDeclarationResolver = multiDeclarationResolver;
}
@NotNull
public ForLoopConventionsChecker getForLoopConventionsChecker() {
return forLoopConventionsChecker;
}
@NotNull
public AdditionalCheckerProvider getAdditionalCheckerProvider() {
return additionalCheckerProvider;
}
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java
+7 -6
View File
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.types.expressions;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker;
@@ -36,18 +37,18 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
@NotNull
public static ExpressionTypingContext newContext(
@NotNull ExpressionTypingServices expressionTypingServices,
@NotNull AdditionalCheckerProvider additionalCheckerProvider,
@NotNull BindingTrace trace,
@NotNull JetScope scope,
@NotNull DataFlowInfo dataFlowInfo,
@NotNull JetType expectedType
) {
return newContext(expressionTypingServices, trace, scope, dataFlowInfo, expectedType, null);
return newContext(additionalCheckerProvider, trace, scope, dataFlowInfo, expectedType, null);
}
@NotNull
public static ExpressionTypingContext newContext(
@NotNull ExpressionTypingServices expressionTypingServices,
@NotNull AdditionalCheckerProvider additionalCheckerProvider,
@NotNull BindingTrace trace,
@NotNull JetScope scope,
@NotNull DataFlowInfo dataFlowInfo,
@@ -56,9 +57,9 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
) {
return newContext(trace, scope, dataFlowInfo, expectedType,
ContextDependency.INDEPENDENT, new ResolutionResultsCacheImpl(),
callChecker != null ? callChecker : expressionTypingServices.getCallChecker(),
expressionTypingServices.getSymbolUsageValidator(),
expressionTypingServices.getAdditionalTypeChecker(),
callChecker != null ? callChecker : additionalCheckerProvider.getCallChecker(),
additionalCheckerProvider.getSymbolUsageValidator(),
additionalCheckerProvider.getTypeChecker(),
StatementFilter.NONE, false);
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java
+13 -184
View File
@@ -16,8 +16,6 @@
package org.jetbrains.kotlin.types.expressions;
import com.google.common.base.Function;
import com.intellij.openapi.project.Project;
import com.intellij.psi.tree.IElementType;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -26,23 +24,15 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
import org.jetbrains.kotlin.descriptors.ScriptDescriptor;
import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
import org.jetbrains.kotlin.lexer.JetTokens;
import org.jetbrains.kotlin.psi.*;
import org.jetbrains.kotlin.resolve.*;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker;
import org.jetbrains.kotlin.resolve.calls.checkers.CompositeChecker;
import org.jetbrains.kotlin.resolve.calls.context.ContextDependency;
import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext;
import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
import org.jetbrains.kotlin.resolve.scopes.JetScope;
import org.jetbrains.kotlin.resolve.scopes.WritableScope;
import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.types.ErrorUtils;
import org.jetbrains.kotlin.types.JetType;
import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryPackage;
@@ -51,111 +41,22 @@ import javax.inject.Inject;
import java.util.Iterator;
import java.util.List;
import static org.jetbrains.kotlin.types.TypeUtils.*;
import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
import static org.jetbrains.kotlin.types.TypeUtils.UNIT_EXPECTED_TYPE;
import static org.jetbrains.kotlin.types.expressions.CoercionStrategy.COERCION_TO_UNIT;
public class ExpressionTypingServices {
@NotNull
private final ExpressionTypingFacade expressionTypingFacade;
@NotNull
private final ExpressionTypingComponents expressionTypingComponents;
private Project project;
private CallResolver callResolver;
private CallExpressionResolver callExpressionResolver;
private DescriptorResolver descriptorResolver;
private FunctionDescriptorResolver functionDescriptorResolver;
private TypeResolver typeResolver;
private AnnotationResolver annotationResolver;
private StatementFilter statementFilter;
private KotlinBuiltIns builtIns;
@NotNull
public Project getProject() {
return project;
}
@Inject
public void setProject(@NotNull Project project) {
this.project = project;
}
@NotNull
public CallResolver getCallResolver() {
return callResolver;
}
@Inject
public void setCallResolver(@NotNull CallResolver callResolver) {
this.callResolver = callResolver;
}
@NotNull
public CallExpressionResolver getCallExpressionResolver() {
return callExpressionResolver;
}
@Inject
public void setCallExpressionResolver(@NotNull CallExpressionResolver callExpressionResolver) {
this.callExpressionResolver = callExpressionResolver;
}
@NotNull
public DescriptorResolver getDescriptorResolver() {
return descriptorResolver;
}
@Inject
public void setDescriptorResolver(@NotNull DescriptorResolver descriptorResolver) {
this.descriptorResolver = descriptorResolver;
}
@NotNull
public FunctionDescriptorResolver getFunctionDescriptorResolver() {
return functionDescriptorResolver;
}
@Inject
public void setFunctionDescriptorResolver(FunctionDescriptorResolver functionDescriptorResolver) {
this.functionDescriptorResolver = functionDescriptorResolver;
}
@NotNull
public TypeResolver getTypeResolver() {
return typeResolver;
}
@Inject
public void setTypeResolver(@NotNull TypeResolver typeResolver) {
this.typeResolver = typeResolver;
}
@NotNull
public AnnotationResolver getAnnotationResolver() {
return annotationResolver;
}
@Inject
public void setAnnotationResolver(@NotNull AnnotationResolver annotationResolver) {
this.annotationResolver = annotationResolver;
}
@NotNull
private StatementFilter getStatementFilter() {
return statementFilter;
}
@Inject
public void setStatementFilter(@NotNull StatementFilter statementFilter) {
this.statementFilter = statementFilter;
}
@Inject
public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) {
this.builtIns = builtIns;
}
public ExpressionTypingServices(@NotNull ExpressionTypingComponents components) {
this.expressionTypingComponents = components;
this.expressionTypingFacade = ExpressionTypingVisitorDispatcher.create(components);
@@ -181,7 +82,9 @@ public class ExpressionTypingServices {
@NotNull DataFlowInfo dataFlowInfo,
@NotNull BindingTrace trace
) {
ExpressionTypingContext context = ExpressionTypingContext.newContext(this, trace, scope, dataFlowInfo, expectedType);
ExpressionTypingContext context = ExpressionTypingContext.newContext(
expressionTypingComponents.additionalCheckerProvider, trace, scope, dataFlowInfo, expectedType
);
return expressionTypingFacade.getTypeInfo(expression, context);
}
@@ -218,7 +121,8 @@ public class ExpressionTypingServices {
}
}
checkFunctionReturnType(function, ExpressionTypingContext.newContext(
this, trace, functionInnerScope, dataFlowInfo, expectedReturnType != null ? expectedReturnType : NO_EXPECTED_TYPE
expressionTypingComponents.additionalCheckerProvider, trace,
functionInnerScope, dataFlowInfo, expectedReturnType != null ? expectedReturnType : NO_EXPECTED_TYPE
));
}
@@ -246,7 +150,7 @@ public class ExpressionTypingServices {
@NotNull CoercionStrategy coercionStrategyForLastExpression,
@NotNull ExpressionTypingContext context
) {
List<JetElement> block = ResolvePackage.filterStatements(getStatementFilter(), expression);
List<JetElement> block = ResolvePackage.filterStatements(statementFilter, expression);
// SCRIPT: get code descriptor for script declaration
DeclarationDescriptor containingDescriptor = context.scope.getContainingDeclaration();
@@ -263,11 +167,11 @@ public class ExpressionTypingServices {
JetTypeInfo r;
if (block.isEmpty()) {
r = TypeInfoFactoryPackage.createCheckedTypeInfo(builtIns.getUnitType(), context, expression);
r = TypeInfoFactoryPackage.createCheckedTypeInfo(expressionTypingComponents.builtIns.getUnitType(), context, expression);
}
else {
r = getBlockReturnedTypeWithWritableScope(scope, block, coercionStrategyForLastExpression,
context.replaceStatementFilter(getStatementFilter()));
context.replaceStatementFilter(statementFilter));
}
scope.changeLockLevel(WritableScope.LockLevel.READING);
@@ -291,7 +195,7 @@ public class ExpressionTypingServices {
JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(outerScope, functionDescriptor, trace);
ExpressionTypingContext context = ExpressionTypingContext.newContext(
this, trace, functionInnerScope, dataFlowInfo, NO_EXPECTED_TYPE
expressionTypingComponents.additionalCheckerProvider, trace, functionInnerScope, dataFlowInfo, NO_EXPECTED_TYPE
);
JetTypeInfo typeInfo = expressionTypingFacade.getTypeInfo(bodyExpression, context, function.hasBlockBody());
@@ -316,7 +220,7 @@ public class ExpressionTypingServices {
@NotNull ExpressionTypingContext context
) {
if (block.isEmpty()) {
return TypeInfoFactoryPackage.createTypeInfo(builtIns.getUnitType(), context);
return TypeInfoFactoryPackage.createTypeInfo(expressionTypingComponents.builtIns.getUnitType(), context);
}
ExpressionTypingInternals blockLevelVisitor = ExpressionTypingVisitorDispatcher.createForBlock(expressionTypingComponents, scope);
@@ -392,84 +296,9 @@ public class ExpressionTypingServices {
if (mightBeUnit) {
// ExpressionTypingVisitorForStatements should return only null or Unit for declarations and assignments
assert result.getType() == null || KotlinBuiltIns.isUnit(result.getType());
result = result.replaceType(builtIns.getUnitType()).replaceDataFlowInfo(context.dataFlowInfo);
result = result.replaceType(expressionTypingComponents.builtIns.getUnitType()).replaceDataFlowInfo(context.dataFlowInfo);
}
}
return result;
}
@Nullable
public JetExpression deparenthesizeWithTypeResolution(
@Nullable JetExpression expression,
@NotNull final ExpressionTypingContext context
) {
return JetPsiUtil.deparenthesizeWithResolutionStrategy(expression, true, new Function<JetTypeReference, Void>() {
@Override
public Void apply(JetTypeReference reference) {
getTypeResolver().resolveType(context.scope, reference, context.trace, true);
return null;
}
});
}
public void resolveValueParameters(
@NotNull List<JetParameter> valueParameters,
@NotNull List<ValueParameterDescriptor> valueParameterDescriptors,
@NotNull JetScope declaringScope,
@NotNull DataFlowInfo dataFlowInfo,
@NotNull BindingTrace trace
) {
resolveValueParameters(
valueParameters, valueParameterDescriptors,
ExpressionTypingContext.newContext(this, trace, declaringScope, dataFlowInfo, NO_EXPECTED_TYPE));
}
public void resolveValueParameters(
@NotNull List<JetParameter> valueParameters,
@NotNull List<ValueParameterDescriptor> valueParameterDescriptors,
@NotNull ExpressionTypingContext context
) {
for (int i = 0; i < valueParameters.size(); i++) {
ValueParameterDescriptor valueParameterDescriptor = valueParameterDescriptors.get(i);
JetParameter jetParameter = valueParameters.get(i);
AnnotationResolver.resolveAnnotationsArguments(jetParameter.getModifierList(), context.trace);
resolveDefaultValue(valueParameterDescriptor, jetParameter, context);
}
}
private void resolveDefaultValue(
@NotNull ValueParameterDescriptor valueParameterDescriptor,
@NotNull JetParameter jetParameter,
@NotNull ExpressionTypingContext context
) {
if (valueParameterDescriptor.hasDefaultValue()) {
JetExpression defaultValue = jetParameter.getDefaultValue();
if (defaultValue != null) {
getTypeInfo(defaultValue, context.replaceExpectedType(valueParameterDescriptor.getType()));
if (DescriptorUtils.isAnnotationClass(DescriptorResolver.getContainingClass(context.scope))) {
ConstantExpressionEvaluator.evaluate(
defaultValue, context.trace, valueParameterDescriptor.getType());
}
}
}
}
@NotNull
public CallChecker getCallChecker() {
List<CallChecker> checkers = expressionTypingComponents.additionalCheckerProvider.getCallCheckers();
return new CompositeChecker(checkers);
}
@NotNull
public SymbolUsageValidator getSymbolUsageValidator() {
return expressionTypingComponents.symbolUsageValidator;
}
@NotNull
public AdditionalTypeChecker getAdditionalTypeChecker() {
List<AdditionalTypeChecker> checkers = expressionTypingComponents.additionalCheckerProvider.getAdditionalTypeCheckers();
return new AdditionalTypeChecker.Composite(checkers);
}
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java
+25 -198
View File
@@ -16,65 +16,36 @@
package org.jetbrains.kotlin.types.expressions;
import com.google.common.collect.Lists;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Pair;
import com.intellij.psi.PsiElement;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.util.PsiTreeUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.JetNodeTypes;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.descriptors.*;
import org.jetbrains.kotlin.diagnostics.Diagnostic;
import org.jetbrains.kotlin.diagnostics.DiagnosticFactory;
import org.jetbrains.kotlin.diagnostics.Errors;
import org.jetbrains.kotlin.lexer.JetTokens;
import org.jetbrains.kotlin.name.Name;
import org.jetbrains.kotlin.psi.*;
import org.jetbrains.kotlin.resolve.*;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults;
import org.jetbrains.kotlin.resolve.calls.util.CallMaker;
import org.jetbrains.kotlin.resolve.dataClassUtils.DataClassUtilsPackage;
import org.jetbrains.kotlin.resolve.scopes.WritableScope;
import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
import org.jetbrains.kotlin.resolve.scopes.receivers.ClassReceiver;
import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
import org.jetbrains.kotlin.types.ErrorUtils;
import org.jetbrains.kotlin.types.JetType;
import org.jetbrains.kotlin.types.TypeUtils;
import org.jetbrains.kotlin.types.checker.JetTypeChecker;
import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryPackage;
import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static org.jetbrains.kotlin.diagnostics.Errors.*;
import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
import static org.jetbrains.kotlin.resolve.BindingContext.*;
import static org.jetbrains.kotlin.types.TypeUtils.noExpectedType;
import static org.jetbrains.kotlin.resolve.BindingContext.PROCESSED;
public class ExpressionTypingUtils {
private final ExpressionTypingServices expressionTypingServices;
private final CallResolver callResolver;
private final KotlinBuiltIns builtIns;
public ExpressionTypingUtils(
@NotNull ExpressionTypingServices expressionTypingServices,
@NotNull CallResolver resolver,
@NotNull KotlinBuiltIns builtIns
) {
this.expressionTypingServices = expressionTypingServices;
this.callResolver = resolver;
this.builtIns = builtIns;
}
@NotNull
public static ReceiverValue normalizeReceiverValueForVisibility(@NotNull ReceiverValue receiverValue, @NotNull BindingContext trace) {
if (receiverValue instanceof ExpressionReceiver) {
@@ -88,7 +59,7 @@ public class ExpressionTypingUtils {
}
if (referenceExpression != null) {
DeclarationDescriptor descriptor = trace.get(BindingContext.REFERENCE_TARGET, referenceExpression);
DeclarationDescriptor descriptor = trace.get(BindingContext.REFERENCE_TARGET, referenceExpression);
if (descriptor instanceof ClassDescriptor) {
return new ClassReceiver((ClassDescriptor) descriptor.getOriginal());
}
@@ -98,18 +69,26 @@ public class ExpressionTypingUtils {
}
@Nullable
protected static ExpressionReceiver getExpressionReceiver(@NotNull JetExpression expression, @Nullable JetType type) {
public static ExpressionReceiver getExpressionReceiver(@NotNull JetExpression expression, @Nullable JetType type) {
if (type == null) return null;
return new ExpressionReceiver(expression, type);
}
@Nullable
protected static ExpressionReceiver getExpressionReceiver(@NotNull ExpressionTypingFacade facade, @NotNull JetExpression expression, ExpressionTypingContext context) {
public static ExpressionReceiver getExpressionReceiver(
@NotNull ExpressionTypingFacade facade,
@NotNull JetExpression expression,
ExpressionTypingContext context
) {
return getExpressionReceiver(expression, facade.getTypeInfo(expression, context).getType());
}
@NotNull
protected static ExpressionReceiver safeGetExpressionReceiver(@NotNull ExpressionTypingFacade facade, @NotNull JetExpression expression, ExpressionTypingContext context) {
public static ExpressionReceiver safeGetExpressionReceiver(
@NotNull ExpressionTypingFacade facade,
@NotNull JetExpression expression,
ExpressionTypingContext context
) {
JetType type = safeGetType(facade.safeGetTypeInfo(expression, context));
return new ExpressionReceiver(expression, type);
}
@@ -129,62 +108,6 @@ public class ExpressionTypingUtils {
return scope;
}
public boolean ensureBooleanResult(JetExpression operationSign, Name name, JetType resultType, ExpressionTypingContext context) {
return ensureBooleanResultWithCustomSubject(operationSign, resultType, "'" + name + "'", context);
}
private boolean ensureBooleanResultWithCustomSubject(JetExpression operationSign, JetType resultType, String subjectName, ExpressionTypingContext context) {
if (resultType != null) {
// TODO : Relax?
if (!builtIns.isBooleanOrSubtype(resultType)) {
context.trace.report(RESULT_TYPE_MISMATCH.on(operationSign, subjectName, builtIns.getBooleanType(), resultType));
return false;
}
}
return true;
}
@NotNull
public JetType getDefaultType(IElementType constantType) {
if (constantType == JetNodeTypes.INTEGER_CONSTANT) {
return builtIns.getIntType();
}
else if (constantType == JetNodeTypes.FLOAT_CONSTANT) {
return builtIns.getDoubleType();
}
else if (constantType == JetNodeTypes.BOOLEAN_CONSTANT) {
return builtIns.getBooleanType();
}
else if (constantType == JetNodeTypes.CHARACTER_CONSTANT) {
return builtIns.getCharType();
}
else if (constantType == JetNodeTypes.NULL) {
return builtIns.getNullableNothingType();
}
else {
throw new IllegalArgumentException("Unsupported constant type: " + constantType);
}
}
@NotNull
public OverloadResolutionResults<FunctionDescriptor> resolveFakeCall(
@NotNull ExpressionTypingContext context,
@NotNull ReceiverValue receiver,
@NotNull Name name,
@Nullable JetExpression callElement,
@NotNull JetType... argumentTypes
) {
TemporaryBindingTrace traceWithFakeArgumentInfo = TemporaryBindingTrace.create(context.trace, "trace to store fake argument for",
name);
List<JetExpression> fakeArguments = Lists.newArrayList();
for (JetType type : argumentTypes) {
fakeArguments.add(createFakeExpressionOfType(expressionTypingServices.getProject(), traceWithFakeArgumentInfo,
"fakeArgument" + fakeArguments.size(), type));
}
return makeAndResolveFakeCall(receiver, context.replaceBindingTrace(traceWithFakeArgumentInfo), fakeArguments, name,
callElement).getSecond();
}
public static JetExpression createFakeExpressionOfType(
@NotNull Project project,
@NotNull BindingTrace trace,
@@ -197,103 +120,11 @@ public class ExpressionTypingUtils {
return fakeExpression;
}
@NotNull
public OverloadResolutionResults<FunctionDescriptor> resolveFakeCall(
public static void checkVariableShadowing(
@NotNull ExpressionTypingContext context,
@NotNull ReceiverValue receiver,
@NotNull Name name,
@NotNull JetExpression callElement
@NotNull VariableDescriptor variableDescriptor,
@Nullable VariableDescriptor oldDescriptor
) {
return resolveFakeCall(receiver, context, Collections.<JetExpression>emptyList(), name, callElement);
}
@NotNull
public OverloadResolutionResults<FunctionDescriptor> resolveFakeCall(
@NotNull ReceiverValue receiver,
@NotNull ExpressionTypingContext context,
@NotNull List<JetExpression> valueArguments,
@NotNull Name name,
@NotNull JetExpression callElement
) {
return makeAndResolveFakeCall(receiver, context, valueArguments, name, callElement).getSecond();
}
@NotNull
public Pair<Call, OverloadResolutionResults<FunctionDescriptor>> makeAndResolveFakeCall(
@NotNull ReceiverValue receiver,
@NotNull ExpressionTypingContext context,
@NotNull List<JetExpression> valueArguments,
@NotNull Name name,
@Nullable JetExpression callElement
) {
final JetReferenceExpression fake = JetPsiFactory(expressionTypingServices.getProject()).createSimpleName("fake");
TemporaryBindingTrace fakeTrace = TemporaryBindingTrace.create(context.trace, "trace to resolve fake call for", name);
Call call = CallMaker.makeCallWithExpressions(callElement != null ? callElement : fake, receiver, null, fake, valueArguments);
OverloadResolutionResults<FunctionDescriptor> results =
callResolver.resolveCallWithGivenName(context.replaceBindingTrace(fakeTrace), call, fake, name);
if (results.isSuccess()) {
fakeTrace.commit(new TraceEntryFilter() {
@Override
public boolean accept(@Nullable WritableSlice<?, ?> slice, Object key) {
// excluding all entries related to fake expression
return key != fake;
}
}, true);
}
return Pair.create(call, results);
}
public void defineLocalVariablesFromMultiDeclaration(
@NotNull WritableScope writableScope,
@NotNull JetMultiDeclaration multiDeclaration,
@NotNull ReceiverValue receiver,
@NotNull JetExpression reportErrorsOn,
@NotNull ExpressionTypingContext context
) {
int componentIndex = 1;
for (JetMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
Name componentName = DataClassUtilsPackage.createComponentName(componentIndex);
componentIndex++;
JetType expectedType = getExpectedTypeForComponent(context, entry);
OverloadResolutionResults<FunctionDescriptor> results =
resolveFakeCall(context.replaceExpectedType(expectedType), receiver, componentName, entry);
JetType componentType = null;
if (results.isSuccess()) {
context.trace.record(COMPONENT_RESOLVED_CALL, entry, results.getResultingCall());
FunctionDescriptor componentFunction = results.getResultingDescriptor();
expressionTypingServices.getSymbolUsageValidator().validateCall(componentFunction, context.trace, entry);
componentType = componentFunction.getReturnType();
if (componentType != null && !noExpectedType(expectedType)
&& !JetTypeChecker.DEFAULT.isSubtypeOf(componentType, expectedType)) {
context.trace.report(
COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH.on(reportErrorsOn, componentName, componentType, expectedType));
}
}
else if (results.isAmbiguity()) {
context.trace.report(COMPONENT_FUNCTION_AMBIGUITY.on(reportErrorsOn, componentName, results.getResultingCalls()));
}
else {
context.trace.report(COMPONENT_FUNCTION_MISSING.on(reportErrorsOn, componentName, receiver.getType()));
}
if (componentType == null) {
componentType = ErrorUtils.createErrorType(componentName + "() return type");
}
VariableDescriptor variableDescriptor = expressionTypingServices.getDescriptorResolver().
resolveLocalVariableDescriptorWithType(writableScope, entry, componentType, context.trace);
VariableDescriptor olderVariable = writableScope.getLocalVariable(variableDescriptor.getName());
checkVariableShadowing(context, variableDescriptor, olderVariable);
writableScope.addVariableDescriptor(variableDescriptor);
}
}
public static void checkVariableShadowing(@NotNull ExpressionTypingContext context, @NotNull VariableDescriptor variableDescriptor, VariableDescriptor oldDescriptor) {
if (oldDescriptor != null && isLocal(variableDescriptor.getContainingDeclaration(), oldDescriptor)) {
PsiElement declaration = DescriptorToSourceUtils.descriptorToDeclaration(variableDescriptor);
if (declaration != null) {
@@ -302,25 +133,18 @@ public class ExpressionTypingUtils {
}
}
@NotNull
private JetType getExpectedTypeForComponent(ExpressionTypingContext context, JetMultiDeclarationEntry entry) {
JetTypeReference entryTypeRef = entry.getTypeReference();
if (entryTypeRef != null) {
return expressionTypingServices.getTypeResolver().resolveType(context.scope, entryTypeRef, context.trace, true);
}
else {
return TypeUtils.NO_EXPECTED_TYPE;
}
}
public static ObservableBindingTrace makeTraceInterceptingTypeMismatch(@NotNull BindingTrace trace, @NotNull final JetElement expressionToWatch, @NotNull final boolean[] mismatchFound) {
public static ObservableBindingTrace makeTraceInterceptingTypeMismatch(
@NotNull BindingTrace trace,
@NotNull final JetElement expressionToWatch,
@NotNull final boolean[] mismatchFound
) {
return new ObservableBindingTrace(trace) {
@Override
public void report(@NotNull Diagnostic diagnostic) {
DiagnosticFactory<?> factory = diagnostic.getFactory();
if ((factory == TYPE_MISMATCH || factory == CONSTANT_EXPECTED_TYPE_MISMATCH || factory == NULL_FOR_NONNULL_TYPE)
&& diagnostic.getPsiElement() == expressionToWatch) {
&& diagnostic.getPsiElement() == expressionToWatch) {
mismatchFound[0] = true;
}
if (TYPE_INFERENCE_ERRORS.contains(factory) &&
@@ -409,4 +233,7 @@ public class ExpressionTypingUtils {
}
return true;
}
private ExpressionTypingUtils() {
}
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java
+13 -5
View File
@@ -16,6 +16,7 @@
package org.jetbrains.kotlin.types.expressions;
import com.google.common.base.Function;
import com.google.common.collect.Sets;
import com.intellij.psi.tree.IElementType;
import org.jetbrains.annotations.NotNull;
@@ -50,6 +51,7 @@ import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryPac
import java.util.Collection;
import static org.jetbrains.kotlin.diagnostics.Errors.*;
import static org.jetbrains.kotlin.psi.JetPsiUtil.deparenthesizeWithResolutionStrategy;
import static org.jetbrains.kotlin.resolve.BindingContext.AMBIGUOUS_REFERENCE_TARGET;
import static org.jetbrains.kotlin.resolve.BindingContext.VARIABLE_REASSIGNMENT;
import static org.jetbrains.kotlin.resolve.calls.context.ContextDependency.INDEPENDENT;
@@ -132,7 +134,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
AnnotationResolver.reportUnsupportedAnnotationForTypeParameter(typeParameter, context.trace);
}
VariableDescriptor propertyDescriptor = components.expressionTypingServices.getDescriptorResolver().
VariableDescriptor propertyDescriptor = components.descriptorResolver.
resolveLocalVariableDescriptor(scope, property, context.dataFlowInfo, context.trace);
JetExpression initializer = property.getInitializer();
JetTypeInfo typeInfo;
@@ -170,7 +172,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
@Override
public JetTypeInfo visitMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration, ExpressionTypingContext context) {
components.expressionTypingServices.getAnnotationResolver().resolveAnnotationsWithArguments(
components.annotationResolver.resolveAnnotationsWithArguments(
scope, multiDeclaration.getModifierList(), context.trace);
JetExpression initializer = multiDeclaration.getInitializer();
@@ -184,7 +186,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
if (expressionReceiver == null) {
return TypeInfoFactoryPackage.noTypeInfo(context);
}
components.expressionTypingUtils.defineLocalVariablesFromMultiDeclaration(scope, multiDeclaration, expressionReceiver, initializer, context);
components.multiDeclarationResolver.defineLocalVariablesFromMultiDeclaration(scope, multiDeclaration, expressionReceiver, initializer, context);
return typeInfo.replaceType(DataFlowUtils.checkStatementType(multiDeclaration, context));
}
@@ -332,10 +334,16 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
@NotNull
protected JetTypeInfo visitAssignment(JetBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
ExpressionTypingContext context =
final ExpressionTypingContext context =
contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceScope(scope).replaceContextDependency(INDEPENDENT);
JetExpression leftOperand = expression.getLeft();
JetExpression left = components.expressionTypingServices.deparenthesizeWithTypeResolution(leftOperand, context);
JetExpression left = deparenthesizeWithResolutionStrategy(leftOperand, true, new Function<JetTypeReference, Void>() {
@Override
public Void apply(JetTypeReference reference) {
components.typeResolver.resolveType(context.scope, reference, context.trace, true);
return null;
}
});
JetExpression right = expression.getRight();
if (left instanceof JetArrayAccessExpression) {
JetArrayAccessExpression arrayAccessExpression = (JetArrayAccessExpression) left;
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FakeCallResolver.kt
+94
View File
@@ -0,0 +1,94 @@
/*
* 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.collect.Lists
import com.intellij.openapi.project.Project
import org.jetbrains.kotlin.descriptors.FunctionDescriptor
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.Call
import org.jetbrains.kotlin.psi.JetExpression
import org.jetbrains.kotlin.psi.JetPsiFactory
import org.jetbrains.kotlin.resolve.TemporaryBindingTrace
import org.jetbrains.kotlin.resolve.TraceEntryFilter
import org.jetbrains.kotlin.resolve.calls.CallResolver
import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults
import org.jetbrains.kotlin.resolve.calls.util.CallMaker
import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
import org.jetbrains.kotlin.types.JetType
import org.jetbrains.kotlin.util.slicedMap.WritableSlice
import java.util.*
public class FakeCallResolver(
private val project: Project,
private val callResolver: CallResolver
) {
public fun resolveFakeCall(
context: ExpressionTypingContext,
receiver: ReceiverValue,
name: Name,
callElement: JetExpression?,
vararg argumentTypes: JetType
): OverloadResolutionResults<FunctionDescriptor> {
val traceWithFakeArgumentInfo = TemporaryBindingTrace.create(context.trace, "trace to store fake argument for", name)
val fakeArguments = ArrayList<JetExpression>()
for (type in argumentTypes) {
fakeArguments.add(ExpressionTypingUtils.createFakeExpressionOfType(project, traceWithFakeArgumentInfo, "fakeArgument" + fakeArguments.size(), type))
}
return makeAndResolveFakeCall(receiver, context.replaceBindingTrace(traceWithFakeArgumentInfo), fakeArguments, name, callElement).second
}
public fun resolveFakeCall(
context: ExpressionTypingContext,
receiver: ReceiverValue,
name: Name,
callElement: JetExpression
): OverloadResolutionResults<FunctionDescriptor> {
return resolveFakeCall(receiver, context, emptyList(), name, callElement)
}
public fun resolveFakeCall(
receiver: ReceiverValue,
context: ExpressionTypingContext,
valueArguments: List<JetExpression>,
name: Name,
callElement: JetExpression
): OverloadResolutionResults<FunctionDescriptor> {
return makeAndResolveFakeCall(receiver, context, valueArguments, name, callElement).second
}
public fun makeAndResolveFakeCall(
receiver: ReceiverValue,
context: ExpressionTypingContext,
valueArguments: List<JetExpression>,
name: Name,
callElement: JetExpression?
): Pair<Call, OverloadResolutionResults<FunctionDescriptor>> {
val fake = JetPsiFactory(project).createSimpleName("fake")
val fakeTrace = TemporaryBindingTrace.create(context.trace, "trace to resolve fake call for", name)
val call = CallMaker.makeCallWithExpressions(callElement ?: fake, receiver, null, fake, valueArguments)
val results = callResolver.resolveCallWithGivenName(context.replaceBindingTrace(fakeTrace), call, fake, name)
if (results.isSuccess()) {
fakeTrace.commit({ _, key ->
// excluding all entries related to fake expression
key != fake
}, true)
}
return Pair(call, results)
}
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java
+18 -24
View File
@@ -16,8 +16,7 @@
package org.jetbrains.kotlin.types.expressions;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Pair;
import kotlin.Pair;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
@@ -30,6 +29,7 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults;
import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.types.JetType;
import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
@@ -41,31 +41,25 @@ import static org.jetbrains.kotlin.resolve.BindingContext.*;
public class ForLoopConventionsChecker {
private Project project;
private ExpressionTypingServices expressionTypingServices;
private ExpressionTypingUtils expressionTypingUtils;
private KotlinBuiltIns builtIns;
@Inject
public void setProject(@NotNull Project project) {
this.project = project;
}
@Inject
public void setExpressionTypingUtils(@NotNull ExpressionTypingUtils expressionTypingUtils) {
this.expressionTypingUtils = expressionTypingUtils;
}
@Inject
public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
this.expressionTypingServices = expressionTypingServices;
}
private SymbolUsageValidator symbolUsageValidator;
private FakeCallResolver fakeCallResolver;
@Inject
public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) {
this.builtIns = builtIns;
}
@Inject
public void setFakeCallResolver(@NotNull FakeCallResolver fakeCallResolver) {
this.fakeCallResolver = fakeCallResolver;
}
@Inject
public void setSymbolUsageValidator(SymbolUsageValidator symbolUsageValidator) {
this.symbolUsageValidator = symbolUsageValidator;
}
@Nullable
public JetType checkIterableConvention(@NotNull ExpressionReceiver loopRange, ExpressionTypingContext context) {
JetExpression loopRangeExpression = loopRange.getExpression();
@@ -73,7 +67,7 @@ public class ForLoopConventionsChecker {
// Make a fake call loopRange.iterator(), and try to resolve it
Name iterator = Name.identifier("iterator");
Pair<Call, OverloadResolutionResults<FunctionDescriptor>> calls =
expressionTypingUtils.makeAndResolveFakeCall(loopRange, context, Collections.<JetExpression>emptyList(), iterator,
fakeCallResolver.makeAndResolveFakeCall(loopRange, context, Collections.<JetExpression>emptyList(), iterator,
loopRange.getExpression());
OverloadResolutionResults<FunctionDescriptor> iteratorResolutionResults = calls.getSecond();
@@ -82,7 +76,7 @@ public class ForLoopConventionsChecker {
context.trace.record(LOOP_RANGE_ITERATOR_RESOLVED_CALL, loopRangeExpression, iteratorResolvedCall);
FunctionDescriptor iteratorFunction = iteratorResolvedCall.getResultingDescriptor();
expressionTypingServices.getSymbolUsageValidator().validateCall(iteratorFunction, context.trace, loopRangeExpression);
symbolUsageValidator.validateCall(iteratorFunction, context.trace, loopRangeExpression);
JetType iteratorType = iteratorFunction.getReturnType();
JetType hasNextType = checkConventionForIterator(context, loopRangeExpression, iteratorType, "hasNext",
@@ -117,7 +111,7 @@ public class ForLoopConventionsChecker {
@NotNull DiagnosticFactory1<JetExpression, JetType> noneApplicable,
@NotNull WritableSlice<JetExpression, ResolvedCall<FunctionDescriptor>> resolvedCallKey
) {
OverloadResolutionResults<FunctionDescriptor> nextResolutionResults = expressionTypingUtils.resolveFakeCall(
OverloadResolutionResults<FunctionDescriptor> nextResolutionResults = fakeCallResolver.resolveFakeCall(
context, new TransientReceiver(iteratorType), Name.identifier(name), loopRangeExpression);
if (nextResolutionResults.isAmbiguity()) {
context.trace.report(ambiguity.on(loopRangeExpression, iteratorType));
@@ -133,7 +127,7 @@ public class ForLoopConventionsChecker {
ResolvedCall<FunctionDescriptor> resolvedCall = nextResolutionResults.getResultingCall();
context.trace.record(resolvedCallKey, loopRangeExpression, resolvedCall);
FunctionDescriptor functionDescriptor = resolvedCall.getResultingDescriptor();
expressionTypingServices.getSymbolUsageValidator().validateCall(functionDescriptor, context.trace, loopRangeExpression);
symbolUsageValidator.validateCall(functionDescriptor, context.trace, loopRangeExpression);
return functionDescriptor.getReturnType();
}
return null;
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt
+17 -17
View File
@@ -18,23 +18,20 @@ package org.jetbrains.kotlin.types.expressions
import com.google.common.collect.Lists
import org.jetbrains.kotlin.builtins.KotlinBuiltIns
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
import org.jetbrains.kotlin.descriptors.annotations.Annotations
import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor
import org.jetbrains.kotlin.descriptors.impl.FunctionDescriptorImpl
import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
import org.jetbrains.kotlin.diagnostics.Errors.*
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.resolve.*
import org.jetbrains.kotlin.resolve.BindingContext.AUTO_CREATED_IT
import org.jetbrains.kotlin.resolve.BindingContext.EXPECTED_RETURN_TYPE
import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
import org.jetbrains.kotlin.resolve.scopes.WritableScope
import org.jetbrains.kotlin.resolve.source.toSourceElement
import org.jetbrains.kotlin.types.*
import org.jetbrains.kotlin.types.CommonSupertypes
import org.jetbrains.kotlin.types.JetType
import org.jetbrains.kotlin.types.TypeUtils.CANT_INFER_FUNCTION_PARAM_TYPE
import org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE
import org.jetbrains.kotlin.types.TypeUtils.noExpectedType
@@ -72,11 +69,9 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
}
}
val services = components.expressionTypingServices
val functionDescriptor: SimpleFunctionDescriptor
if (isStatement) {
functionDescriptor = services.getFunctionDescriptorResolver().resolveFunctionDescriptor(
functionDescriptor = components.functionDescriptorResolver.resolveFunctionDescriptor(
context.scope.getContainingDeclaration(), context.scope, function, context.trace, context.dataFlowInfo)
assert(statementScope != null) {
"statementScope must be not null for function: " + function.getName() + " at location " + DiagnosticUtils.atLocation(function)
@@ -84,15 +79,20 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
statementScope!!.addFunctionDescriptor(functionDescriptor)
}
else {
functionDescriptor = services.getFunctionDescriptorResolver().resolveFunctionExpressionDescriptor(
context.scope.getContainingDeclaration(), context.scope, function, context.trace, context.dataFlowInfo, context.expectedType)
functionDescriptor = components.functionDescriptorResolver.resolveFunctionExpressionDescriptor(
context.scope.getContainingDeclaration(), context.scope, function,
context.trace, context.dataFlowInfo, context.expectedType
)
}
val functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(context.scope, functionDescriptor, context.trace)
services.checkFunctionReturnType(functionInnerScope, function, functionDescriptor, context.dataFlowInfo, null, context.trace)
components.expressionTypingServices.checkFunctionReturnType(
functionInnerScope, function, functionDescriptor, context.dataFlowInfo, null, context.trace
)
services.resolveValueParameters(function.getValueParameters(), functionDescriptor.getValueParameters(), context.scope,
context.dataFlowInfo, context.trace);
components.valueParameterResolver.resolveValueParameters(
function.getValueParameters(), functionDescriptor.getValueParameters(), context.scope, context.dataFlowInfo, context.trace
)
ModifiersChecker.create(context.trace, components.additionalCheckerProvider)
.checkModifiersForLocalDeclaration(function, functionDescriptor)
@@ -153,7 +153,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
val functionLiteral = expression.getFunctionLiteral()
val functionDescriptor = AnonymousFunctionDescriptor(context.scope.getContainingDeclaration(), Annotations.EMPTY,
CallableMemberDescriptor.Kind.DECLARATION, functionLiteral.toSourceElement())
components.expressionTypingServices.getFunctionDescriptorResolver().
components.functionDescriptorResolver.
initializeFunctionDescriptorAndExplicitReturnType(context.scope.getContainingDeclaration(), context.scope, functionLiteral,
functionDescriptor, context.trace, context.expectedType)
BindingContextUtils.recordFunctionDeclarationToDescriptor(context.trace, functionLiteral, functionDescriptor)
@@ -185,7 +185,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
): JetType? {
val functionLiteral = expression.getFunctionLiteral()
val declaredReturnType = functionLiteral.getTypeReference()?.let {
val type = components.expressionTypingServices.getTypeResolver().resolveType(context.scope, it, context.trace, true)
val type = components.typeResolver.resolveType(context.scope, it, context.trace, true)
if (expectedReturnType != null && !JetTypeChecker.DEFAULT.isSubtypeOf(type, expectedReturnType)) {
context.trace.report(EXPECTED_RETURN_TYPE_MISMATCH.on(it, expectedReturnType))
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/MultiDeclarationResolver.kt
+88
View File
@@ -0,0 +1,88 @@
/*
* 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 org.jetbrains.kotlin.diagnostics.Errors
import org.jetbrains.kotlin.psi.JetExpression
import org.jetbrains.kotlin.psi.JetMultiDeclaration
import org.jetbrains.kotlin.psi.JetMultiDeclarationEntry
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.DescriptorResolver
import org.jetbrains.kotlin.resolve.TypeResolver
import org.jetbrains.kotlin.resolve.dataClassUtils.createComponentName
import org.jetbrains.kotlin.resolve.scopes.WritableScope
import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
import org.jetbrains.kotlin.types.ErrorUtils
import org.jetbrains.kotlin.types.JetType
import org.jetbrains.kotlin.types.TypeUtils
import org.jetbrains.kotlin.types.checker.JetTypeChecker
public class MultiDeclarationResolver(
private val fakeCallResolver: FakeCallResolver,
private val descriptorResolver: DescriptorResolver,
private val typeResolver: TypeResolver,
private val symbolUsageValidator: SymbolUsageValidator
) {
public fun defineLocalVariablesFromMultiDeclaration(
writableScope: WritableScope,
multiDeclaration: JetMultiDeclaration,
receiver: ReceiverValue,
reportErrorsOn: JetExpression,
context: ExpressionTypingContext
) {
for ((componentIndex, entry) in multiDeclaration.getEntries().withIndex()) {
val componentName = createComponentName(componentIndex + 1)
val expectedType = getExpectedTypeForComponent(context, entry)
val results = fakeCallResolver.resolveFakeCall(context.replaceExpectedType(expectedType), receiver, componentName, entry)
var componentType: JetType? = null
if (results.isSuccess()) {
context.trace.record(BindingContext.COMPONENT_RESOLVED_CALL, entry, results.getResultingCall())
val functionDescriptor = results.getResultingDescriptor()
symbolUsageValidator.validateCall(functionDescriptor, context.trace, entry)
componentType = functionDescriptor.getReturnType()
if (componentType != null && !TypeUtils.noExpectedType(expectedType) && !JetTypeChecker.DEFAULT.isSubtypeOf(componentType, expectedType)) {
context.trace.report(Errors.COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH.on(reportErrorsOn, componentName, componentType, expectedType))
}
}
else if (results.isAmbiguity()) {
context.trace.report(Errors.COMPONENT_FUNCTION_AMBIGUITY.on(reportErrorsOn, componentName, results.getResultingCalls()))
}
else {
context.trace.report(Errors.COMPONENT_FUNCTION_MISSING.on(reportErrorsOn, componentName, receiver.getType()))
}
if (componentType == null) {
componentType = ErrorUtils.createErrorType("$componentName() return type")
}
val variableDescriptor = descriptorResolver.resolveLocalVariableDescriptorWithType(writableScope, entry, componentType, context.trace)
val olderVariable = writableScope.getLocalVariable(variableDescriptor.getName())
ExpressionTypingUtils.checkVariableShadowing(context, variableDescriptor, olderVariable)
writableScope.addVariableDescriptor(variableDescriptor)
}
}
private fun getExpectedTypeForComponent(context: ExpressionTypingContext, entry: JetMultiDeclarationEntry): JetType {
val entryTypeRef = entry.getTypeReference() ?: return TypeUtils.NO_EXPECTED_TYPE
return typeResolver.resolveType(context.scope, entryTypeRef, context.trace, true)
}
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.java
+1 -1
View File
@@ -290,7 +290,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
return noChange(context);
}
TypeResolutionContext typeResolutionContext = new TypeResolutionContext(context.scope, context.trace, true, /*allowBareTypes=*/ true);
PossiblyBareType possiblyBareTarget = components.expressionTypingServices.getTypeResolver().resolvePossiblyBareType(typeResolutionContext, typeReferenceAfterIs);
PossiblyBareType possiblyBareTarget = components.typeResolver.resolvePossiblyBareType(typeResolutionContext, typeReferenceAfterIs);
JetType targetType = TypeReconstructionUtil.reconstructBareType(typeReferenceAfterIs, possiblyBareTarget, subjectType, context.trace);
if (TypesPackage.isDynamic(targetType)) {
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt
+70
View File
@@ -0,0 +1,70 @@
/*
* 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 org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
import org.jetbrains.kotlin.psi.JetParameter
import org.jetbrains.kotlin.resolve.*
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
import org.jetbrains.kotlin.resolve.scopes.JetScope
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
import org.jetbrains.kotlin.types.TypeUtils
public class ValueParameterResolver(
private val additionalCheckerProvider: AdditionalCheckerProvider,
private val expressionTypingServices: ExpressionTypingServices
) {
public fun resolveValueParameters(
valueParameters: List<JetParameter>,
valueParameterDescriptors: List<ValueParameterDescriptor>,
declaringScope: JetScope,
dataFlowInfo: DataFlowInfo,
trace: BindingTrace
) {
resolveValueParameters(valueParameters, valueParameterDescriptors,
ExpressionTypingContext.newContext(additionalCheckerProvider, trace, declaringScope,
dataFlowInfo, TypeUtils.NO_EXPECTED_TYPE)
)
}
public fun resolveValueParameters(
valueParameters: List<JetParameter>,
valueParameterDescriptors: List<ValueParameterDescriptor>,
context: ExpressionTypingContext
) {
for ((descriptor, parameter) in valueParameterDescriptors zip valueParameters) {
AnnotationResolver.resolveAnnotationsArguments(parameter.getModifierList(), context.trace)
resolveDefaultValue(descriptor, parameter, context)
}
}
private fun resolveDefaultValue(
valueParameterDescriptor: ValueParameterDescriptor,
jetParameter: JetParameter,
context: ExpressionTypingContext
) {
if (!valueParameterDescriptor.hasDefaultValue()) {
return
}
val defaultValue = jetParameter.getDefaultValue() ?: return
expressionTypingServices.getTypeInfo(defaultValue, context.replaceExpectedType(valueParameterDescriptor.getType()))
if (DescriptorUtils.isAnnotationClass(DescriptorResolver.getContainingClass(context.scope))) {
ConstantExpressionEvaluator.evaluate(defaultValue, context.trace, valueParameterDescriptor.getType())
}
}
}
compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java
+63 -54
View File
@@ -22,14 +22,14 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.DescriptorResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
import org.jetbrains.kotlin.resolve.TypeResolver;
import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
import org.jetbrains.kotlin.context.GlobalContext;
import org.jetbrains.kotlin.storage.StorageManager;
import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
@@ -37,16 +37,18 @@ 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.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
import org.jetbrains.kotlin.context.TypeLazinessToken;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.annotations.NotNull;
import javax.annotation.PreDestroy;
@@ -60,14 +62,14 @@ public class InjectorForTests {
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final DescriptorResolver descriptorResolver;
private final FunctionDescriptorResolver functionDescriptorResolver;
private final ExpressionTypingServices expressionTypingServices;
private final ExpressionTypingUtils expressionTypingUtils;
private final TypeResolver typeResolver;
private final FakeCallResolver fakeCallResolver;
private final KotlinJvmCheckerProvider additionalCheckerProvider;
private final SymbolUsageValidator symbolUsageValidator;
private final ExpressionTypingServices expressionTypingServices;
private final QualifiedExpressionResolver qualifiedExpressionResolver;
private final GlobalContext globalContext;
private final StorageManager storageManager;
private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider;
private final DefaultSymbolUsageValidator defaultSymbolUsageValidator;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
private final ArgumentTypeResolver argumentTypeResolver;
@@ -75,16 +77,18 @@ public class InjectorForTests {
private final CandidateResolver candidateResolver;
private final TaskPrioritizer taskPrioritizer;
private final DelegatedPropertyResolver delegatedPropertyResolver;
private final ExpressionTypingComponents expressionTypingComponents;
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final DynamicTypesSettings dynamicTypesSettings;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final StatementFilter statementFilter;
private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
private final TypeLazinessToken typeLazinessToken;
private final DynamicTypesSettings dynamicTypesSettings;
private final ExpressionTypingComponents expressionTypingComponents;
private final CallExpressionResolver callExpressionResolver;
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final MultiDeclarationResolver multiDeclarationResolver;
private final ReflectionTypes reflectionTypes;
private final ValueParameterResolver valueParameterResolver;
private final StatementFilter statementFilter;
public InjectorForTests(
@NotNull Project project,
@@ -107,19 +111,21 @@ public class InjectorForTests {
this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
this.functionDescriptorResolver = new FunctionDescriptorResolver(getTypeResolver(), getDescriptorResolver(), annotationResolver, storageManager, getExpressionTypingServices(), kotlinBuiltIns);
this.callResolver = new CallResolver();
this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), callResolver, kotlinBuiltIns);
this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$;
this.fakeCallResolver = new FakeCallResolver(project, callResolver);
this.additionalCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
this.argumentTypeResolver = new ArgumentTypeResolver();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.controlStructureTypingUtils = new ControlStructureTypingUtils(getExpressionTypingServices());
this.callExpressionResolver = new CallExpressionResolver(callResolver);
this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(getDescriptorResolver(), getFunctionDescriptorResolver(), getTypeResolver(), annotationResolver);
this.multiDeclarationResolver = new MultiDeclarationResolver(getFakeCallResolver(), getDescriptorResolver(), getTypeResolver(), symbolUsageValidator);
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
this.callExpressionResolver = new CallExpressionResolver();
this.valueParameterResolver = new ValueParameterResolver(getAdditionalCheckerProvider(), getExpressionTypingServices());
this.statementFilter = new StatementFilter();
this.descriptorResolver.setAnnotationResolver(annotationResolver);
@@ -129,22 +135,15 @@ public class InjectorForTests {
this.descriptorResolver.setStorageManager(storageManager);
this.descriptorResolver.setTypeResolver(typeResolver);
this.expressionTypingServices.setAnnotationResolver(annotationResolver);
this.expressionTypingServices.setBuiltIns(kotlinBuiltIns);
this.expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
this.expressionTypingServices.setCallResolver(callResolver);
this.expressionTypingServices.setDescriptorResolver(descriptorResolver);
this.expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver);
this.expressionTypingServices.setProject(project);
this.expressionTypingServices.setStatementFilter(statementFilter);
this.expressionTypingServices.setTypeResolver(typeResolver);
this.qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator);
this.qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
annotationResolver.setCallResolver(callResolver);
annotationResolver.setStorageManager(storageManager);
annotationResolver.setTypeResolver(typeResolver);
callResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
callResolver.setArgumentTypeResolver(argumentTypeResolver);
callResolver.setCallCompleter(callCompleter);
callResolver.setCandidateResolver(candidateResolver);
@@ -158,31 +157,37 @@ public class InjectorForTests {
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
delegatedPropertyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
delegatedPropertyResolver.setCallResolver(callResolver);
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
expressionTypingComponents.setAnnotationResolver(annotationResolver);
expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
expressionTypingComponents.setCallResolver(callResolver);
expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
expressionTypingComponents.setDescriptorResolver(descriptorResolver);
expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
forLoopConventionsChecker.setProject(project);
expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
expressionTypingComponents.setTypeResolver(typeResolver);
expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
}
@PreDestroy
@@ -197,18 +202,22 @@ public class InjectorForTests {
return this.functionDescriptorResolver;
}
public ExpressionTypingServices getExpressionTypingServices() {
return this.expressionTypingServices;
}
public ExpressionTypingUtils getExpressionTypingUtils() {
return this.expressionTypingUtils;
}
public TypeResolver getTypeResolver() {
return this.typeResolver;
}
public FakeCallResolver getFakeCallResolver() {
return this.fakeCallResolver;
}
public KotlinJvmCheckerProvider getAdditionalCheckerProvider() {
return this.additionalCheckerProvider;
}
public ExpressionTypingServices getExpressionTypingServices() {
return this.expressionTypingServices;
}
public QualifiedExpressionResolver getQualifiedExpressionResolver() {
return this.qualifiedExpressionResolver;
}
compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java
+2 -4
View File
@@ -34,7 +34,6 @@ import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.types.JetType;
import org.jetbrains.kotlin.types.TypeUtils;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import java.util.Arrays;
import java.util.HashMap;
@@ -128,13 +127,12 @@ public class JetExpectedResolveDataUtil {
) {
ModuleDescriptor emptyModule = JetTestUtils.createEmptyModule();
InjectorForTests injector = new InjectorForTests(project, emptyModule);
ExpressionTypingServices expressionTypingServices = injector.getExpressionTypingServices();
ExpressionTypingContext context = ExpressionTypingContext.newContext(
expressionTypingServices, new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(),
injector.getAdditionalCheckerProvider(), new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(),
DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE);
OverloadResolutionResults<FunctionDescriptor> functions = injector.getExpressionTypingUtils().resolveFakeCall(
OverloadResolutionResults<FunctionDescriptor> functions = injector.getFakeCallResolver().resolveFakeCall(
context, ReceiverValue.NO_RECEIVER, Name.identifier(name), null, parameterTypes);
for (ResolvedCall<? extends FunctionDescriptor> resolvedCall : functions.getResultingCalls()) {
generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt
+11 -20
View File
@@ -44,7 +44,6 @@ import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct
import org.jetbrains.kotlin.resolve.lazy.*
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator
import org.jetbrains.kotlin.storage.LockBasedStorageManager
import org.jetbrains.kotlin.types.DynamicTypesAllowed
import org.jetbrains.kotlin.types.DynamicTypesSettings
@@ -87,7 +86,7 @@ private fun generatorForLazyLocalClassifierAnalyzer() =
parameter<GlobalContext>(useAsContext = true)
parameter<BindingTrace>()
parameter<ModuleDescriptor>(name = "module", useAsContext = true)
parameter<AdditionalCheckerProvider>()
parameter<AdditionalCheckerProvider>(useAsContext = true)
parameter<DynamicTypesSettings>()
parameter<LocalClassDescriptorHolder>()
@@ -97,7 +96,6 @@ private fun generatorForLazyLocalClassifierAnalyzer() =
field<NoFileScopeProvider>()
field<DeclarationScopeProviderForLocalClassifierAnalyzer>()
field<LocalLazyDeclarationResolver>()
field<DefaultSymbolUsageValidator>()
}
private fun generatorForLazyBodyResolve() =
@@ -106,11 +104,10 @@ private fun generatorForLazyBodyResolve() =
parameter<GlobalContext>(useAsContext = true)
parameter<KotlinCodeAnalyzer>(name = "analyzer", useAsContext = true)
parameter<BindingTrace>()
parameter<AdditionalCheckerProvider>()
parameter<AdditionalCheckerProvider>(useAsContext = true)
parameter<DynamicTypesSettings>()
field<ModuleDescriptor>(init = GivenExpression("analyzer.getModuleDescriptor()"), useAsContext = true)
field<DefaultSymbolUsageValidator>()
publicField<LazyTopDownAnalyzerForTopLevel>()
}
@@ -121,7 +118,7 @@ private fun generatorForTopDownAnalyzerForJs() =
publicField<LazyTopDownAnalyzerForTopLevel>()
field<KotlinJsCheckerProvider>()
field<KotlinJsCheckerProvider>(useAsContext = true)
field<DynamicTypesAllowed>()
}
@@ -181,7 +178,7 @@ private fun generatorForLazyResolveWithJava() =
field<LazyResolveToken>()
field<JavaLazyAnalyzerPostConstruct>()
field<KotlinJvmCheckerProvider>()
field<KotlinJvmCheckerProvider>(useAsContext = true)
}
private fun generatorForReplWithJava() =
@@ -203,8 +200,7 @@ private fun generatorForMacro() =
field<GlobalContext>(useAsContext = true,
init = GivenExpression("org.jetbrains.kotlin.context.ContextPackage.GlobalContext()"))
field<AdditionalCheckerProvider.DefaultProvider>()
field<DefaultSymbolUsageValidator>()
field<AdditionalCheckerProvider.DefaultProvider>(useAsContext = true)
}
private fun generatorForTests() =
@@ -214,16 +210,14 @@ private fun generatorForTests() =
publicField<DescriptorResolver>()
publicField<FunctionDescriptorResolver>()
publicField<ExpressionTypingServices>()
publicField<ExpressionTypingUtils>()
publicField<TypeResolver>()
publicField<FakeCallResolver>()
publicField<KotlinJvmCheckerProvider>(name = "additionalCheckerProvider", useAsContext = true)
publicField<ExpressionTypingServices>()
publicField<QualifiedExpressionResolver>()
field<GlobalContext>(init = GivenExpression("org.jetbrains.kotlin.context.ContextPackage.GlobalContext()"),
useAsContext = true)
field<KotlinJvmCheckerProvider>()
field<DefaultSymbolUsageValidator>()
}
private fun generatorForBodyResolve() =
@@ -232,11 +226,10 @@ private fun generatorForBodyResolve() =
parameter<GlobalContext>(useAsContext = true)
parameter<BindingTrace>()
parameter<ModuleDescriptor>(useAsContext = true)
parameter<AdditionalCheckerProvider>()
parameter<AdditionalCheckerProvider>(useAsContext = true)
parameter<StatementFilter>()
publicField<BodyResolver>()
field<DefaultSymbolUsageValidator>()
}
private fun generatorForLazyResolve() =
@@ -246,14 +239,13 @@ private fun generatorForLazyResolve() =
parameter<ModuleDescriptorImpl>(useAsContext = true)
parameter<DeclarationProviderFactory>()
parameter<BindingTrace>()
parameter<AdditionalCheckerProvider>()
parameter<AdditionalCheckerProvider>(useAsContext = true)
parameter<DynamicTypesSettings>()
publicField<ResolveSession>()
field<ScopeProvider>()
field<LazyResolveToken>()
field<DefaultSymbolUsageValidator>()
}
private fun DependencyInjectorGenerator.commonForResolveSessionBased() {
@@ -265,7 +257,6 @@ private fun DependencyInjectorGenerator.commonForResolveSessionBased() {
publicField<ResolveSession>()
field<ScopeProvider>()
field<DefaultSymbolUsageValidator>()
}
private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() {
@@ -296,7 +287,7 @@ private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() {
field<JavaLazyAnalyzerPostConstruct>()
field<JavaFlexibleTypeCapabilitiesProvider>()
field<KotlinJvmCheckerProvider>()
field<KotlinJvmCheckerProvider>(useAsContext = true)
field<VirtualFileFinder>(init = GivenExpression(javaClass<VirtualFileFinder>().getName() + ".SERVICE.getInstance(project)"))
}
idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArguments.kt
+5 -5
View File
@@ -72,15 +72,15 @@ public class RemoveExplicitTypeArguments : JetSelfTargetingOffsetIndependentInte
TypeUtils.NO_EXPECTED_TYPE
}
val dataFlow = context.getDataFlowInfo(callExpression)
val resolutionResults = injector.getExpressionTypingServices()?.getCallResolver()?.resolveFunctionCall(
val resolutionResults = injector.getCallResolver().resolveFunctionCall(
BindingTraceContext(), scope, untypedCall, jType, dataFlow, false)
assert (resolutionResults?.isSingleResult() ?: true) { "Removing type arguments changed resolve for: " +
"${callExpression.getTextWithLocation()} to ${resolutionResults?.getResultCode()}" }
assert (resolutionResults.isSingleResult()) { "Removing type arguments changed resolve for: " +
"${callExpression.getTextWithLocation()} to ${resolutionResults.getResultCode()}" }
val args = originalCall.getTypeArguments()
val newArgs = resolutionResults?.getResultingCall()?.getTypeArguments()
val newArgs = resolutionResults.getResultingCall().getTypeArguments()
return args == newArgs?.mapValues { approximateFlexibleTypes(it.getValue(), false) }
return args == newArgs.mapValues { approximateFlexibleTypes(it.getValue(), false) }
}
private class CallWithoutTypeArgs(call: Call) : DelegatingCall(call) {
idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt
+29 -53
View File
@@ -16,62 +16,38 @@
package org.jetbrains.kotlin.idea.completion
import org.jetbrains.kotlin.psi.JetExpression
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.psi.JetValueArgument
import org.jetbrains.kotlin.psi.JetValueArgumentList
import org.jetbrains.kotlin.psi.JetCallExpression
import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
import com.intellij.lang.ASTNode
import org.jetbrains.kotlin.psi.JetQualifiedExpression
import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
import org.jetbrains.kotlin.resolve.calls.util.CallMaker
import org.jetbrains.kotlin.resolve.calls.context.ContextDependency
import org.jetbrains.kotlin.resolve.calls.context.CheckValueArgumentsMode
import org.jetbrains.kotlin.resolve.calls.checkers.CompositeChecker
import org.jetbrains.kotlin.di.InjectorForMacros
import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults
import org.jetbrains.kotlin.descriptors.FunctionDescriptor
import java.util.HashSet
import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
import org.jetbrains.kotlin.types.JetType
import org.jetbrains.kotlin.psi.JetBinaryExpression
import org.jetbrains.kotlin.lexer.JetTokens
import org.jetbrains.kotlin.psi.JetIfExpression
import org.jetbrains.kotlin.builtins.KotlinBuiltIns
import org.jetbrains.kotlin.psi.JetContainerNode
import org.jetbrains.kotlin.resolve.calls.callUtil.noErrorsInValueArguments
import org.jetbrains.kotlin.descriptors.Visibilities
import org.jetbrains.kotlin.psi.JetBlockExpression
import org.jetbrains.kotlin.idea.util.makeNotNullable
import org.jetbrains.kotlin.psi.JetWhenConditionWithExpression
import org.jetbrains.kotlin.psi.JetWhenEntry
import org.jetbrains.kotlin.psi.JetWhenExpression
import org.jetbrains.kotlin.psi.JetCallElement
import org.jetbrains.kotlin.types.TypeUtils
import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
import org.jetbrains.kotlin.psi.JetPrefixExpression
import org.jetbrains.kotlin.resolve.calls.util.DelegatingCall
import org.jetbrains.kotlin.psi.JetFunctionLiteralArgument
import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
import org.jetbrains.kotlin.psi.JetSimpleNameExpression
import org.jetbrains.kotlin.psi.JetArrayAccessExpression
import org.jetbrains.kotlin.psi.JetProperty
import org.jetbrains.kotlin.psi.JetDeclarationWithBody
import org.jetbrains.kotlin.psi.JetReturnExpression
import org.jetbrains.kotlin.resolve.bindingContextUtil.getTargetFunctionDescriptor
import org.jetbrains.kotlin.idea.completion.smart.toList
import org.jetbrains.kotlin.descriptors.PropertyGetterDescriptor
import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
import org.jetbrains.kotlin.descriptors.VariableDescriptor
import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.di.InjectorForMacros
import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
import org.jetbrains.kotlin.idea.completion.smart.toList
import org.jetbrains.kotlin.idea.util.makeNotNullable
import org.jetbrains.kotlin.lexer.JetTokens
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
import org.jetbrains.kotlin.resolve.bindingContextUtil.getTargetFunctionDescriptor
import org.jetbrains.kotlin.resolve.calls.callUtil.noErrorsInValueArguments
import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.resolve.validation.CompositeSymbolUsageValidator
import org.jetbrains.kotlin.resolve.calls.checkers.CompositeChecker
import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
import org.jetbrains.kotlin.resolve.calls.context.CheckValueArgumentsMode
import org.jetbrains.kotlin.resolve.calls.context.ContextDependency
import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults
import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus
import org.jetbrains.kotlin.resolve.calls.util.CallMaker
import org.jetbrains.kotlin.resolve.calls.util.DelegatingCall
import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
import org.jetbrains.kotlin.types.JetType
import org.jetbrains.kotlin.types.TypeUtils
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
import java.util.HashSet
enum class Tail {
COMMA
@@ -174,7 +150,7 @@ class ExpectedInfos(
val bindingTrace = DelegatingBindingTrace(bindingContext, "Temporary trace for completion")
val context = BasicCallResolutionContext.create(bindingTrace, resolutionScope, call, expectedType, dataFlowInfo,
ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED,
CompositeChecker(listOf()), CompositeSymbolUsageValidator(), AdditionalTypeChecker.Composite(listOf()), false)
CompositeChecker(listOf()), SymbolUsageValidator.Empty, AdditionalTypeChecker.Composite(listOf()), false)
val callResolutionContext = context.replaceCollectAllCandidates(true)
val callResolver = InjectorForMacros(
callElement.getProject(),
idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt
+2 -1
View File
@@ -57,7 +57,8 @@ public class IterableTypesDetector(
val expression = JetPsiFactory(project).createExpression("fake")
val expressionReceiver = ExpressionReceiver(expression, type.type)
val context = ExpressionTypingContext.newContext(injector.getExpressionTypingServices(), BindingTraceContext(), scope, DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE)
val context = ExpressionTypingContext.newContext(injector.getExpressionTypingComponents().getAdditionalCheckerProvider(),
BindingTraceContext(), scope, DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE)
val elementType = injector.getExpressionTypingComponents().getForLoopConventionsChecker().checkIterableConvention(expressionReceiver, context)
if (elementType == null) return false
return loopVarType == null || FuzzyType(elementType, type.freeParameters).checkIsSubtypeOf(loopVarType) != null
js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java
+40 -32
View File
@@ -26,28 +26,30 @@ import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator;
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.types.DynamicTypesAllowed;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
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.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.TypeLazinessToken;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
@@ -84,28 +86,30 @@ public class InjectorForTopDownAnalyzerForJs {
private final DeclarationProviderFactory declarationProviderFactory;
private final ResolveSession resolveSession;
private final ScopeProvider scopeProvider;
private final DefaultSymbolUsageValidator defaultSymbolUsageValidator;
private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
private final KotlinJsCheckerProvider kotlinJsCheckerProvider;
private final SymbolUsageValidator symbolUsageValidator;
private final DynamicTypesAllowed dynamicTypesAllowed;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
private final ArgumentTypeResolver argumentTypeResolver;
private final ExpressionTypingServices expressionTypingServices;
private final ExpressionTypingComponents expressionTypingComponents;
private final CallExpressionResolver callExpressionResolver;
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
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 TypeLazinessToken typeLazinessToken;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final FakeCallResolver fakeCallResolver;
private final FunctionDescriptorResolver functionDescriptorResolver;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final MultiDeclarationResolver multiDeclarationResolver;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final ValueParameterResolver valueParameterResolver;
private final StatementFilter statementFilter;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
@@ -143,28 +147,30 @@ public class InjectorForTopDownAnalyzerForJs {
this.declarationProviderFactory = declarationProviderFactory;
this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
this.scopeProvider = new ScopeProvider(getResolveSession());
this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$;
this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
this.kotlinJsCheckerProvider = KotlinJsCheckerProvider.INSTANCE$;
this.symbolUsageValidator = kotlinJsCheckerProvider.getSymbolUsageValidator();
this.dynamicTypesAllowed = new DynamicTypesAllowed();
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.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.callExpressionResolver = new CallExpressionResolver(callResolver);
this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
this.descriptorResolver = new DescriptorResolver();
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
this.typeLazinessToken = new TypeLazinessToken();
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesAllowed);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.fakeCallResolver = new FakeCallResolver(project, callResolver);
this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
this.reflectionTypes = new ReflectionTypes(getModule());
this.callExpressionResolver = new CallExpressionResolver();
this.valueParameterResolver = new ValueParameterResolver(kotlinJsCheckerProvider, expressionTypingServices);
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
@@ -205,6 +211,7 @@ public class InjectorForTopDownAnalyzerForJs {
annotationResolver.setStorageManager(storageManager);
annotationResolver.setTypeResolver(typeResolver);
callResolver.setAdditionalCheckerProvider(kotlinJsCheckerProvider);
callResolver.setArgumentTypeResolver(argumentTypeResolver);
callResolver.setCallCompleter(callCompleter);
callResolver.setCandidateResolver(candidateResolver);
@@ -216,34 +223,29 @@ public class InjectorForTopDownAnalyzerForJs {
argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
argumentTypeResolver.setTypeResolver(typeResolver);
expressionTypingServices.setAnnotationResolver(annotationResolver);
expressionTypingServices.setBuiltIns(kotlinBuiltIns);
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(kotlinJsCheckerProvider);
expressionTypingComponents.setAnnotationResolver(annotationResolver);
expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
expressionTypingComponents.setCallResolver(callResolver);
expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
expressionTypingComponents.setDescriptorResolver(descriptorResolver);
expressionTypingComponents.setDynamicTypesSettings(dynamicTypesAllowed);
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator);
expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
expressionTypingComponents.setTypeResolver(typeResolver);
expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
forLoopConventionsChecker.setProject(project);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
descriptorResolver.setAnnotationResolver(annotationResolver);
descriptorResolver.setBuiltIns(kotlinBuiltIns);
@@ -252,13 +254,16 @@ public class InjectorForTopDownAnalyzerForJs {
descriptorResolver.setStorageManager(storageManager);
descriptorResolver.setTypeResolver(typeResolver);
delegatedPropertyResolver.setAdditionalCheckerProvider(kotlinJsCheckerProvider);
delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
delegatedPropertyResolver.setCallResolver(callResolver);
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator);
qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
@@ -269,6 +274,7 @@ public class InjectorForTopDownAnalyzerForJs {
declarationScopeProvider.setFileScopeProvider(scopeProvider);
scriptBodyResolver.setAdditionalCheckerProvider(kotlinJsCheckerProvider);
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
@@ -283,6 +289,7 @@ public class InjectorForTopDownAnalyzerForJs {
lazyTopDownAnalyzer.setTrace(bindingTrace);
lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
bodyResolver.setAdditionalCheckerProvider(kotlinJsCheckerProvider);
bodyResolver.setAnnotationResolver(annotationResolver);
bodyResolver.setCallResolver(callResolver);
bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
@@ -292,6 +299,7 @@ public class InjectorForTopDownAnalyzerForJs {
bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
bodyResolver.setTrace(bindingTrace);
bodyResolver.setValueParameterResolver(valueParameterResolver);
controlFlowAnalyzer.setTrace(bindingTrace);
js/js.frontend/src/org/jetbrains/kotlin/js/resolve/KotlinJsCheckerProvider.kt
+2 -1
View File
@@ -22,5 +22,6 @@ import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
public object KotlinJsCheckerProvider : AdditionalCheckerProvider(
additionalDeclarationCheckers = listOf(NativeInvokeChecker(), NativeGetterChecker(), NativeSetterChecker(), ClassDeclarationChecker()),
additionalCallCheckers = listOf(JsCallChecker()),
additionalTypeCheckers = listOf()
additionalTypeCheckers = listOf(),
additionalSymbolUsageValidators = listOf()
)