diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java index a872121e095..3725e1553c0 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java @@ -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); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java index e08a07f9c27..d9bbf48882a 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java @@ -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); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java index 4e605c168d8..e7a23db9a6a 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java @@ -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); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt index 6f0d765af11..0674588273e 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt @@ -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 { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java index 045a46d4db6..3ae412aa617 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java @@ -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); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java index 7f09b97e489..01370383c55 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java @@ -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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java index 9a3d593f45f..5218e2c1d9e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java @@ -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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java index d3f6ae6c97e..4c30b1ccabe 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java @@ -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); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java index 0677c20bbc5..c8ed69d4d55 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java @@ -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); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AdditionalCheckerProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AdditionalCheckerProvider.kt index 412361630d7..a92008ebdf0 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AdditionalCheckerProvider.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AdditionalCheckerProvider.kt @@ -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, additionalCallCheckers: List, - additionalTypeCheckers: List + additionalTypeCheckers: List, + additionalSymbolUsageValidators: List ) { public val declarationCheckers: List = DEFAULT_DECLARATION_CHECKERS + additionalDeclarationCheckers - public val callCheckers: List = DEFAULT_CALL_CHECKERS + additionalCallCheckers - public val additionalTypeCheckers: List = 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()) {} } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java index 4a0f3aecedf..c9bc57cea67 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java @@ -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.newArrayList()), - new CompositeSymbolUsageValidator(), + SymbolUsageValidator.Empty, new AdditionalTypeChecker.Composite(Lists.newArrayList()), StatementFilter.NONE); ArgumentTypeResolver.updateNumberType(defaultType, argumentExpression, context); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java index d0744a471ec..bfba1a0773c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java @@ -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() { @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 valueParameters = function.getValueParameters(); List 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); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java index d0d2eb2a08d..95365bbdf35 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java @@ -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 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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java index 5c78d2de563..2201716b7f9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java @@ -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; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java index 4b2048e5025..a457e9d7e16 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java @@ -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 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, diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java index 972f399856a..9bec24d0f0d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java @@ -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; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java index 1fc5ed8b9b2..7ba30276148 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java @@ -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 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), diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java index 4a7408fdd82..c60d11883aa 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java @@ -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 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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/CompositeSymbolUsageValidator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/CompositeSymbolUsageValidator.kt deleted file mode 100644 index 981bc4781f3..00000000000 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/CompositeSymbolUsageValidator.kt +++ /dev/null @@ -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 { - - 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) } - } -} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DefaultSymbolUsageValidator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DefaultSymbolUsageValidator.kt deleted file mode 100644 index 13208cfaea9..00000000000 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DefaultSymbolUsageValidator.kt +++ /dev/null @@ -1,3 +0,0 @@ -package org.jetbrains.kotlin.resolve.validation - -object DefaultSymbolUsageValidator : CompositeSymbolUsageValidator(DeprecatedSymbolValidator()) \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/SymbolUsageValidator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/SymbolUsageValidator.kt index 2cd35f62959..9adebaa1eab 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/SymbolUsageValidator.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/SymbolUsageValidator.kt @@ -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 { + 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()) } - } \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java index bc357335fbb..37aefd809f6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java @@ -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 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(); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java index 763fd14cdba..137929a2775 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java @@ -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 resolveSpecialConstructionAsCall( @@ -77,7 +77,6 @@ public class ControlStructureTypingUtils { constructionName.toUpperCase(), argumentNames, isArgumentNullable); TracingStrategy tracing = createTracingForSpecialConstruction(call, constructionName, context); ResolutionCandidate resolutionCandidate = ResolutionCandidate.create(call, function); - CallResolver callResolver = expressionTypingServices.getCallResolver(); OverloadResolutionResults results = callResolver.resolveCallWithKnownCandidate( call, tracing, context, resolutionCandidate, dataFlowInfoForArguments); assert results.isSingleResult() : "Not single result after resolving one known candidate"; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java index 66dd6af69f6..79de70fe0c0 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java @@ -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)); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java index 64c94caa721..695f3763239 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java @@ -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; + } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java index e83cffd6166..d4412553719 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java @@ -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 block = ResolvePackage.filterStatements(getStatementFilter(), expression); + List 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() { - @Override - public Void apply(JetTypeReference reference) { - getTypeResolver().resolveType(context.scope, reference, context.trace, true); - return null; - } - }); - } - - public void resolveValueParameters( - @NotNull List valueParameters, - @NotNull List 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 valueParameters, - @NotNull List 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 checkers = expressionTypingComponents.additionalCheckerProvider.getCallCheckers(); - return new CompositeChecker(checkers); - } - - @NotNull - public SymbolUsageValidator getSymbolUsageValidator() { - return expressionTypingComponents.symbolUsageValidator; - } - - @NotNull - public AdditionalTypeChecker getAdditionalTypeChecker() { - List checkers = expressionTypingComponents.additionalCheckerProvider.getAdditionalTypeCheckers(); - return new AdditionalTypeChecker.Composite(checkers); - } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java index f69425de03c..ee22faf0bc5 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java @@ -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 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 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 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.emptyList(), name, callElement); - } - - @NotNull - public OverloadResolutionResults resolveFakeCall( - @NotNull ReceiverValue receiver, - @NotNull ExpressionTypingContext context, - @NotNull List valueArguments, - @NotNull Name name, - @NotNull JetExpression callElement - ) { - return makeAndResolveFakeCall(receiver, context, valueArguments, name, callElement).getSecond(); - } - - @NotNull - public Pair> makeAndResolveFakeCall( - @NotNull ReceiverValue receiver, - @NotNull ExpressionTypingContext context, - @NotNull List 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 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 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() { + } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java index be50b0ae400..51969c4eaa3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java @@ -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() { + @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; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FakeCallResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FakeCallResolver.kt new file mode 100644 index 00000000000..30093adf7da --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FakeCallResolver.kt @@ -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 { + val traceWithFakeArgumentInfo = TemporaryBindingTrace.create(context.trace, "trace to store fake argument for", name) + val fakeArguments = ArrayList() + 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 { + return resolveFakeCall(receiver, context, emptyList(), name, callElement) + } + + public fun resolveFakeCall( + receiver: ReceiverValue, + context: ExpressionTypingContext, + valueArguments: List, + name: Name, + callElement: JetExpression + ): OverloadResolutionResults { + return makeAndResolveFakeCall(receiver, context, valueArguments, name, callElement).second + } + + public fun makeAndResolveFakeCall( + receiver: ReceiverValue, + context: ExpressionTypingContext, + valueArguments: List, + name: Name, + callElement: JetExpression? + ): Pair> { + 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) + } + +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java index 5b5e15bd324..d3e70365fda 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java @@ -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> calls = - expressionTypingUtils.makeAndResolveFakeCall(loopRange, context, Collections.emptyList(), iterator, + fakeCallResolver.makeAndResolveFakeCall(loopRange, context, Collections.emptyList(), iterator, loopRange.getExpression()); OverloadResolutionResults 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 noneApplicable, @NotNull WritableSlice> resolvedCallKey ) { - OverloadResolutionResults nextResolutionResults = expressionTypingUtils.resolveFakeCall( + OverloadResolutionResults 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 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; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt index e4e4f36839f..b1c9dea919b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt @@ -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)) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/MultiDeclarationResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/MultiDeclarationResolver.kt new file mode 100644 index 00000000000..a30667a789d --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/MultiDeclarationResolver.kt @@ -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) + } +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.java index 919fb890588..4f1b8915431 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.java @@ -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)) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt new file mode 100644 index 00000000000..1ab4ded8b9f --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt @@ -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, + valueParameterDescriptors: List, + declaringScope: JetScope, + dataFlowInfo: DataFlowInfo, + trace: BindingTrace + ) { + resolveValueParameters(valueParameters, valueParameterDescriptors, + ExpressionTypingContext.newContext(additionalCheckerProvider, trace, declaringScope, + dataFlowInfo, TypeUtils.NO_EXPECTED_TYPE) + ) + } + + public fun resolveValueParameters( + valueParameters: List, + valueParameterDescriptors: List, + 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()) + } + } +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java b/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java index 69db6f3328d..ec947d0f35c 100644 --- a/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java +++ b/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java @@ -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; } diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java b/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java index a5788be9120..ee0957594d0 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java +++ b/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java @@ -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 functions = injector.getExpressionTypingUtils().resolveFakeCall( + OverloadResolutionResults functions = injector.getFakeCallResolver().resolveFakeCall( context, ReceiverValue.NO_RECEIVER, Name.identifier(name), null, parameterTypes); for (ResolvedCall resolvedCall : functions.getResultingCalls()) { diff --git a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt index f1bbc28291b..8e310f99480 100644 --- a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt @@ -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(useAsContext = true) parameter() parameter(name = "module", useAsContext = true) - parameter() + parameter(useAsContext = true) parameter() parameter() @@ -97,7 +96,6 @@ private fun generatorForLazyLocalClassifierAnalyzer() = field() field() field() - field() } private fun generatorForLazyBodyResolve() = @@ -106,11 +104,10 @@ private fun generatorForLazyBodyResolve() = parameter(useAsContext = true) parameter(name = "analyzer", useAsContext = true) parameter() - parameter() + parameter(useAsContext = true) parameter() field(init = GivenExpression("analyzer.getModuleDescriptor()"), useAsContext = true) - field() publicField() } @@ -121,7 +118,7 @@ private fun generatorForTopDownAnalyzerForJs() = publicField() - field() + field(useAsContext = true) field() } @@ -181,7 +178,7 @@ private fun generatorForLazyResolveWithJava() = field() field() - field() + field(useAsContext = true) } private fun generatorForReplWithJava() = @@ -203,8 +200,7 @@ private fun generatorForMacro() = field(useAsContext = true, init = GivenExpression("org.jetbrains.kotlin.context.ContextPackage.GlobalContext()")) - field() - field() + field(useAsContext = true) } private fun generatorForTests() = @@ -214,16 +210,14 @@ private fun generatorForTests() = publicField() publicField() - publicField() - publicField() publicField() + publicField() + publicField(name = "additionalCheckerProvider", useAsContext = true) + publicField() publicField() field(init = GivenExpression("org.jetbrains.kotlin.context.ContextPackage.GlobalContext()"), useAsContext = true) - - field() - field() } private fun generatorForBodyResolve() = @@ -232,11 +226,10 @@ private fun generatorForBodyResolve() = parameter(useAsContext = true) parameter() parameter(useAsContext = true) - parameter() + parameter(useAsContext = true) parameter() publicField() - field() } private fun generatorForLazyResolve() = @@ -246,14 +239,13 @@ private fun generatorForLazyResolve() = parameter(useAsContext = true) parameter() parameter() - parameter() + parameter(useAsContext = true) parameter() publicField() field() field() - field() } private fun DependencyInjectorGenerator.commonForResolveSessionBased() { @@ -265,7 +257,6 @@ private fun DependencyInjectorGenerator.commonForResolveSessionBased() { publicField() field() - field() } private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() { @@ -296,7 +287,7 @@ private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() { field() field() - field() + field(useAsContext = true) field(init = GivenExpression(javaClass().getName() + ".SERVICE.getInstance(project)")) } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArguments.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArguments.kt index cdf381b997f..ba11d2ccbf9 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArguments.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArguments.kt @@ -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) { diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt index 68e64e7d178..ba334c016e0 100644 --- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt +++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt @@ -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(), diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt index ba2f9cc9a5f..4e138b9785d 100644 --- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt +++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt @@ -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 diff --git a/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java b/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java index ac6431fa58c..1360f0f39f9 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java @@ -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); diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/KotlinJsCheckerProvider.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/KotlinJsCheckerProvider.kt index 053f35f9167..f40ecb637fa 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/KotlinJsCheckerProvider.kt +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/KotlinJsCheckerProvider.kt @@ -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() )