From 072a9f4977f81b0ee5243900bab818276fca0bc9 Mon Sep 17 00:00:00 2001 From: Stanislav Erokhin Date: Thu, 12 Mar 2015 16:01:32 +0300 Subject: [PATCH] Refactoring: extract FunctionResolver from DescriptorResolver --- .../di/InjectorForLazyResolveWithJava.java | 7 +- .../kotlin/di/InjectorForReplWithJava.java | 7 +- .../di/InjectorForTopDownAnalyzerForJvm.java | 7 +- .../kotlin/di/InjectorForBodyResolve.java | 6 +- .../kotlin/di/InjectorForLazyBodyResolve.java | 6 +- ...njectorForLazyLocalClassifierAnalyzer.java | 6 +- .../kotlin/di/InjectorForLazyResolve.java | 7 +- .../InjectorForLazyTopDownAnalyzerBasic.java | 7 +- .../kotlin/di/InjectorForMacros.java | 6 +- .../kotlin/resolve/DescriptorResolver.java | 245 +-------------- .../resolve/FunctionDescriptorResolver.kt | 279 ++++++++++++++++++ .../kotlin/resolve/lazy/LazyClassContext.kt | 6 +- .../kotlin/resolve/lazy/ResolveSession.java | 12 + .../descriptors/AbstractLazyMemberScope.kt | 2 +- .../lazy/descriptors/LazyClassMemberScope.kt | 4 +- .../expressions/ExpressionTypingServices.java | 11 + .../expressions/FunctionsTypingVisitor.kt | 4 +- .../expressions/LocalClassifierAnalyzer.kt | 12 +- .../jetbrains/kotlin/di/InjectorForTests.java | 18 +- .../JetDefaultModalityModifiersTest.java | 5 +- .../kotlin/types/JetOverloadTest.java | 10 +- .../kotlin/types/JetOverridingTest.java | 10 +- .../generators/injectors/GenerateInjectors.kt | 1 + .../di/InjectorForTopDownAnalyzerForJs.java | 7 +- 24 files changed, 399 insertions(+), 286 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt 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 c80374fc0ea..b202e1e382a 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java @@ -57,6 +57,7 @@ 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.FunctionDescriptorResolver; import org.jetbrains.kotlin.types.reflect.ReflectionTypes; import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.StatementFilter; @@ -122,6 +123,7 @@ public class InjectorForLazyResolveWithJava { private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; + private final FunctionDescriptorResolver functionDescriptorResolver; private final ReflectionTypes reflectionTypes; private final CallExpressionResolver callExpressionResolver; private final StatementFilter statementFilter; @@ -191,7 +193,8 @@ public class InjectorForLazyResolveWithJava { this.descriptorResolver = new DescriptorResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), javaFlexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings); - this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(getModule()); this.callExpressionResolver = new CallExpressionResolver(); @@ -210,6 +213,7 @@ public class InjectorForLazyResolveWithJava { this.resolveSession.setAnnotationResolve(annotationResolver); this.resolveSession.setDescriptorResolver(descriptorResolver); + this.resolveSession.setFunctionDescriptorResolver(functionDescriptorResolver); this.resolveSession.setJetImportFactory(jetImportsFactory); this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver); this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver); @@ -259,6 +263,7 @@ public class InjectorForLazyResolveWithJava { expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); + expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver); expressionTypingServices.setProject(project); expressionTypingServices.setStatementFilter(statementFilter); expressionTypingServices.setTypeResolver(typeResolver); 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 6eb8fefd1dd..c3d08d2a0d0 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java @@ -61,6 +61,7 @@ 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.resolve.FunctionDescriptorResolver; import org.jetbrains.kotlin.types.reflect.ReflectionTypes; import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.StatementFilter; @@ -137,6 +138,7 @@ public class InjectorForReplWithJava { private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final TypeLazinessToken typeLazinessToken; + private final FunctionDescriptorResolver functionDescriptorResolver; private final ReflectionTypes reflectionTypes; private final CallExpressionResolver callExpressionResolver; private final StatementFilter statementFilter; @@ -219,7 +221,8 @@ public class InjectorForReplWithJava { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.typeLazinessToken = new TypeLazinessToken(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), javaFlexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings); - this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(getModule()); this.callExpressionResolver = new CallExpressionResolver(); @@ -243,6 +246,7 @@ public class InjectorForReplWithJava { this.resolveSession.setAnnotationResolve(annotationResolver); this.resolveSession.setDescriptorResolver(descriptorResolver); + this.resolveSession.setFunctionDescriptorResolver(functionDescriptorResolver); this.resolveSession.setJetImportFactory(jetImportsFactory); this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver); this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver); @@ -309,6 +313,7 @@ public class InjectorForReplWithJava { expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); + expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver); expressionTypingServices.setProject(project); expressionTypingServices.setStatementFilter(statementFilter); expressionTypingServices.setTypeResolver(typeResolver); 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 654e41e0d25..d31bb229ef9 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java @@ -60,6 +60,7 @@ 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.resolve.FunctionDescriptorResolver; import org.jetbrains.kotlin.types.reflect.ReflectionTypes; import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.StatementFilter; @@ -136,6 +137,7 @@ public class InjectorForTopDownAnalyzerForJvm { private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final TypeLazinessToken typeLazinessToken; + private final FunctionDescriptorResolver functionDescriptorResolver; private final ReflectionTypes reflectionTypes; private final CallExpressionResolver callExpressionResolver; private final StatementFilter statementFilter; @@ -217,7 +219,8 @@ public class InjectorForTopDownAnalyzerForJvm { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.typeLazinessToken = new TypeLazinessToken(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), javaFlexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings); - this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(getModule()); this.callExpressionResolver = new CallExpressionResolver(); @@ -242,6 +245,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.resolveSession.setAnnotationResolve(annotationResolver); this.resolveSession.setDescriptorResolver(descriptorResolver); + this.resolveSession.setFunctionDescriptorResolver(functionDescriptorResolver); this.resolveSession.setJetImportFactory(jetImportsFactory); this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver); this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver); @@ -308,6 +312,7 @@ public class InjectorForTopDownAnalyzerForJvm { expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); + expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver); expressionTypingServices.setProject(project); expressionTypingServices.setStatementFilter(statementFilter); expressionTypingServices.setTypeResolver(typeResolver); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java index 780af11a8ca..b3b3f432adb 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java @@ -42,6 +42,7 @@ 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.resolve.FunctionDescriptorResolver; import org.jetbrains.kotlin.types.reflect.ReflectionTypes; import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.calls.CallCompleter; @@ -85,6 +86,7 @@ public class InjectorForBodyResolve { private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final TypeLazinessToken typeLazinessToken; + private final FunctionDescriptorResolver functionDescriptorResolver; private final ReflectionTypes reflectionTypes; private final CallExpressionResolver callExpressionResolver; private final CallCompleter callCompleter; @@ -128,7 +130,8 @@ public class InjectorForBodyResolve { this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.typeLazinessToken = new TypeLazinessToken(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings); - this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.callExpressionResolver = new CallExpressionResolver(); @@ -171,6 +174,7 @@ public class InjectorForBodyResolve { expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); + expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver); expressionTypingServices.setProject(project); expressionTypingServices.setStatementFilter(statementFilter); expressionTypingServices.setTypeResolver(typeResolver); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java index 16e58a9b036..4c4aad55129 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java @@ -48,6 +48,7 @@ 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.resolve.FunctionDescriptorResolver; import org.jetbrains.kotlin.types.reflect.ReflectionTypes; import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.StatementFilter; @@ -102,6 +103,7 @@ public class InjectorForLazyBodyResolve { private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final TypeLazinessToken typeLazinessToken; + private final FunctionDescriptorResolver functionDescriptorResolver; private final ReflectionTypes reflectionTypes; private final CallExpressionResolver callExpressionResolver; private final StatementFilter statementFilter; @@ -156,7 +158,8 @@ public class InjectorForLazyBodyResolve { this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.typeLazinessToken = new TypeLazinessToken(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings); - this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.callExpressionResolver = new CallExpressionResolver(); @@ -224,6 +227,7 @@ public class InjectorForLazyBodyResolve { expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); + expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver); expressionTypingServices.setProject(project); expressionTypingServices.setStatementFilter(statementFilter); expressionTypingServices.setTypeResolver(typeResolver); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java index 3854a4f5785..7c7c5a312de 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java @@ -47,6 +47,7 @@ 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.resolve.FunctionDescriptorResolver; import org.jetbrains.kotlin.types.reflect.ReflectionTypes; import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.StatementFilter; @@ -100,6 +101,7 @@ public class InjectorForLazyLocalClassifierAnalyzer { private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final TypeLazinessToken typeLazinessToken; + private final FunctionDescriptorResolver functionDescriptorResolver; private final ReflectionTypes reflectionTypes; private final CallExpressionResolver callExpressionResolver; private final StatementFilter statementFilter; @@ -154,7 +156,8 @@ public class InjectorForLazyLocalClassifierAnalyzer { this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.typeLazinessToken = new TypeLazinessToken(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings); - this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); @@ -219,6 +222,7 @@ public class InjectorForLazyLocalClassifierAnalyzer { expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); + expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver); expressionTypingServices.setProject(project); expressionTypingServices.setStatementFilter(statementFilter); expressionTypingServices.setTypeResolver(typeResolver); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java index 9c4b6feccbe..f3785c86f28 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java @@ -43,6 +43,7 @@ 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.resolve.FunctionDescriptorResolver; import org.jetbrains.kotlin.types.reflect.ReflectionTypes; import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.StatementFilter; @@ -88,6 +89,7 @@ public class InjectorForLazyResolve { private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; + private final FunctionDescriptorResolver functionDescriptorResolver; private final ReflectionTypes reflectionTypes; private final CallExpressionResolver callExpressionResolver; private final StatementFilter statementFilter; @@ -134,7 +136,8 @@ public class InjectorForLazyResolve { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings); - this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.callExpressionResolver = new CallExpressionResolver(); @@ -150,6 +153,7 @@ public class InjectorForLazyResolve { this.resolveSession.setAnnotationResolve(annotationResolver); this.resolveSession.setDescriptorResolver(descriptorResolver); + this.resolveSession.setFunctionDescriptorResolver(functionDescriptorResolver); this.resolveSession.setJetImportFactory(jetImportsFactory); this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver); this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver); @@ -180,6 +184,7 @@ public class InjectorForLazyResolve { expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); + expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver); expressionTypingServices.setProject(project); expressionTypingServices.setStatementFilter(statementFilter); expressionTypingServices.setTypeResolver(typeResolver); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java index e154b06ee3c..9143cf4586c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java @@ -44,6 +44,7 @@ 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.resolve.FunctionDescriptorResolver; import org.jetbrains.kotlin.types.reflect.ReflectionTypes; import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.StatementFilter; @@ -100,6 +101,7 @@ public class InjectorForLazyTopDownAnalyzerBasic { private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final TypeLazinessToken typeLazinessToken; + private final FunctionDescriptorResolver functionDescriptorResolver; private final ReflectionTypes reflectionTypes; private final CallExpressionResolver callExpressionResolver; private final StatementFilter statementFilter; @@ -155,7 +157,8 @@ public class InjectorForLazyTopDownAnalyzerBasic { this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.typeLazinessToken = new TypeLazinessToken(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings); - this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(getModule()); this.callExpressionResolver = new CallExpressionResolver(); @@ -181,6 +184,7 @@ public class InjectorForLazyTopDownAnalyzerBasic { this.resolveSession.setAnnotationResolve(annotationResolver); this.resolveSession.setDescriptorResolver(descriptorResolver); + this.resolveSession.setFunctionDescriptorResolver(functionDescriptorResolver); this.resolveSession.setJetImportFactory(jetImportsFactory); this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver); this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver); @@ -214,6 +218,7 @@ public class InjectorForLazyTopDownAnalyzerBasic { expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); + expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver); expressionTypingServices.setProject(project); expressionTypingServices.setStatementFilter(statementFilter); expressionTypingServices.setTypeResolver(typeResolver); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java index 06eb2bf9d42..6ae8aa60240 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java @@ -31,6 +31,7 @@ import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; 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; @@ -67,6 +68,7 @@ public class InjectorForMacros { private final CallExpressionResolver callExpressionResolver; private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; + private final FunctionDescriptorResolver functionDescriptorResolver; private final StatementFilter statementFilter; private final ControlStructureTypingUtils controlStructureTypingUtils; private final DynamicTypesSettings dynamicTypesSettings; @@ -105,11 +107,12 @@ public class InjectorForMacros { this.callExpressionResolver = new CallExpressionResolver(); 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.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, getTypeResolver(), annotationResolver); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, getTypeResolver(), annotationResolver); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.argumentTypeResolver = new ArgumentTypeResolver(); this.candidateResolver = new CandidateResolver(); @@ -121,6 +124,7 @@ public class InjectorForMacros { 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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java index 5d5558fd7c7..3aabf9c466f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java @@ -29,7 +29,6 @@ import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.annotations.Annotations; import org.jetbrains.kotlin.descriptors.impl.*; import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1; -import org.jetbrains.kotlin.diagnostics.DiagnosticUtils; import org.jetbrains.kotlin.lexer.JetKeywordToken; import org.jetbrains.kotlin.lexer.JetModifierKeywordToken; import org.jetbrains.kotlin.lexer.JetTokens; @@ -229,136 +228,6 @@ public class DescriptorResolver { } } - @NotNull - public SimpleFunctionDescriptor resolveFunctionDescriptor( - @NotNull DeclarationDescriptor containingDescriptor, - @NotNull JetScope scope, - @NotNull JetNamedFunction function, - @NotNull BindingTrace trace, - @NotNull DataFlowInfo dataFlowInfo - ) { - if (function.getName() == null) { - trace.report(FUNCTION_DECLARATION_WITH_NO_NAME.on(function)); - } - SimpleFunctionDescriptorImpl functionDescriptor = SimpleFunctionDescriptorImpl.create( - containingDescriptor, - annotationResolver.resolveAnnotationsWithArguments(scope, function.getModifierList(), trace), - function.getNameAsSafeName(), - CallableMemberDescriptor.Kind.DECLARATION, - toSourceElement(function) - ); - initializeFunctionDescriptorAndExplicitReturnType(containingDescriptor, scope, function, functionDescriptor, trace); - initializeFunctionReturnTypeBasedOnFunctionBody(scope, function, functionDescriptor, trace, dataFlowInfo); - BindingContextUtils.recordFunctionDeclarationToDescriptor(trace, function, functionDescriptor); - return functionDescriptor; - } - - @NotNull - public SimpleFunctionDescriptor resolveFunctionExpressionDescriptor( - @NotNull DeclarationDescriptor containingDescriptor, - @NotNull JetScope scope, - @NotNull JetNamedFunction function, - @NotNull BindingTrace trace, - @NotNull DataFlowInfo dataFlowInfo - ) { - FunctionExpressionDescriptor functionDescriptor = new FunctionExpressionDescriptor( - containingDescriptor, - annotationResolver.resolveAnnotationsWithArguments(scope, function.getModifierList(), trace), - function.getNameAsSafeName(), - CallableMemberDescriptor.Kind.DECLARATION, - toSourceElement(function) - ); - initializeFunctionDescriptorAndExplicitReturnType(containingDescriptor, scope, function, functionDescriptor, trace); - initializeFunctionReturnTypeBasedOnFunctionBody(scope, function, functionDescriptor, trace, dataFlowInfo); - BindingContextUtils.recordFunctionDeclarationToDescriptor(trace, function, functionDescriptor); - return functionDescriptor; - } - - private void initializeFunctionReturnTypeBasedOnFunctionBody( - @NotNull final JetScope scope, - @NotNull final JetNamedFunction function, - @NotNull final SimpleFunctionDescriptorImpl functionDescriptor, - @NotNull final BindingTrace trace, - @NotNull final DataFlowInfo dataFlowInfo - ) { - if (functionDescriptor.getReturnType() != null) return; - assert function.getTypeReference() == null : "Return type must be initialized early for function: " - + function.getText() + ", at: " - + DiagnosticUtils.atLocation(function); - JetType returnType; - if (function.hasBlockBody()) { - returnType = builtIns.getUnitType(); - } - else if (function.hasBody()) { - returnType = - DeferredType.createRecursionIntolerant( - storageManager, - trace, - new Function0() { - @Override - public JetType invoke() { - JetType type = expressionTypingServices - .getBodyExpressionType(trace, scope, dataFlowInfo, function, functionDescriptor); - return transformAnonymousTypeIfNeeded(functionDescriptor, function, type, trace); - } - }); - } - else { - returnType = ErrorUtils.createErrorType("No type, no body"); - } - functionDescriptor.setReturnType(returnType); - } - - @NotNull - private void initializeFunctionDescriptorAndExplicitReturnType( - @NotNull DeclarationDescriptor containingDescriptor, - @NotNull JetScope scope, - @NotNull JetFunction function, - @NotNull SimpleFunctionDescriptorImpl functionDescriptor, - @NotNull BindingTrace trace - ) { - - WritableScope innerScope = new WritableScopeImpl(scope, functionDescriptor, new TraceBasedRedeclarationHandler(trace), - "Function descriptor header scope"); - innerScope.addLabeledDeclaration(functionDescriptor); - - List typeParameterDescriptors = - resolveTypeParametersForCallableDescriptor(functionDescriptor, innerScope, function.getTypeParameters(), trace); - innerScope.changeLockLevel(WritableScope.LockLevel.BOTH); - resolveGenericBounds(function, functionDescriptor, innerScope, typeParameterDescriptors, trace); - - JetType receiverType = null; - JetTypeReference receiverTypeRef = function.getReceiverTypeReference(); - if (receiverTypeRef != null) { - receiverType = typeResolver.resolveType(innerScope, receiverTypeRef, trace, true); - } - - List valueParameterDescriptors = - resolveValueParameters(functionDescriptor, innerScope, function.getValueParameters(), trace); - - innerScope.changeLockLevel(WritableScope.LockLevel.READING); - - JetTypeReference returnTypeRef = function.getTypeReference(); - JetType returnType = null; - if (returnTypeRef != null) { - returnType = typeResolver.resolveType(innerScope, returnTypeRef, trace, true); - } - - Modality modality = resolveModalityFromModifiers(function, getDefaultModality(containingDescriptor, function.hasBody())); - Visibility visibility = resolveVisibilityFromModifiers(function, getDefaultVisibility(function, containingDescriptor)); - functionDescriptor.initialize( - receiverType, - getDispatchReceiverParameterIfNeeded(containingDescriptor), - typeParameterDescriptors, - valueParameterDescriptors, - returnType, - modality, - visibility - ); - } - - - @NotNull public static SimpleFunctionDescriptor createComponentFunctionDescriptor( int parameterIndex, @@ -471,42 +340,6 @@ public class DescriptorResolver { return defaultModality; } - @NotNull - private List resolveValueParameters( - FunctionDescriptor functionDescriptor, - WritableScope parameterScope, - List valueParameters, - BindingTrace trace - ) { - List result = new ArrayList(); - for (int i = 0; i < valueParameters.size(); i++) { - JetParameter valueParameter = valueParameters.get(i); - JetTypeReference typeReference = valueParameter.getTypeReference(); - - JetType type; - if (typeReference == null) { - trace.report(VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION.on(valueParameter)); - type = ErrorUtils.createErrorType("Type annotation was missing"); - } - else { - type = typeResolver.resolveType(parameterScope, typeReference, trace, true); - } - - if (!(functionDescriptor instanceof ConstructorDescriptor)) { - checkParameterHasNoValOrVar(trace, valueParameter, VAL_OR_VAR_ON_FUN_PARAMETER); - checkParameterHasNoModifier(trace, valueParameter); - } else { - checkConstructorParameterHasNoModifier(trace, valueParameter); - } - - ValueParameterDescriptor valueParameterDescriptor = - resolveValueParameterDescriptor(parameterScope, functionDescriptor, valueParameter, i, type, trace); - parameterScope.addVariableDescriptor(valueParameterDescriptor); - result.add(valueParameterDescriptor); - } - return result; - } - @NotNull public ValueParameterDescriptorImpl resolveValueParameterDescriptor( JetScope scope, DeclarationDescriptor declarationDescriptor, @@ -1100,7 +933,7 @@ public class DescriptorResolver { } @Nullable - private static JetType transformAnonymousTypeIfNeeded( + /*package*/ static JetType transformAnonymousTypeIfNeeded( @NotNull DeclarationDescriptorWithVisibility descriptor, @NotNull JetNamedDeclaration declaration, @NotNull JetType type, @@ -1243,72 +1076,6 @@ public class DescriptorResolver { return getterDescriptor; } - @NotNull - private ConstructorDescriptorImpl createConstructorDescriptor( - @NotNull JetScope scope, - @NotNull ClassDescriptor classDescriptor, - boolean isPrimary, - @Nullable JetModifierList modifierList, - @NotNull JetDeclaration declarationToTrace, - List typeParameters, @NotNull List valueParameters, BindingTrace trace - ) { - ConstructorDescriptorImpl constructorDescriptor = ConstructorDescriptorImpl.create( - classDescriptor, - annotationResolver.resolveAnnotationsWithoutArguments(scope, modifierList, trace), - isPrimary, - toSourceElement(declarationToTrace) - ); - trace.record(BindingContext.CONSTRUCTOR, declarationToTrace, constructorDescriptor); - WritableScopeImpl parameterScope = new WritableScopeImpl( - scope, constructorDescriptor, new TraceBasedRedeclarationHandler(trace), "Scope with value parameters of a constructor"); - parameterScope.changeLockLevel(WritableScope.LockLevel.BOTH); - ConstructorDescriptorImpl constructor = constructorDescriptor.initialize( - typeParameters, - resolveValueParameters(constructorDescriptor, parameterScope, valueParameters, trace), - resolveVisibilityFromModifiers(modifierList, getDefaultConstructorVisibility(classDescriptor)) - ); - if (isAnnotationClass(classDescriptor)) { - CompileTimeConstantUtils.checkConstructorParametersType(valueParameters, trace); - } - return constructor; - } - - @Nullable - public ConstructorDescriptorImpl resolvePrimaryConstructorDescriptor( - @NotNull JetScope scope, - @NotNull ClassDescriptor classDescriptor, - @NotNull JetClass classElement, - BindingTrace trace - ) { - if (classDescriptor.getKind() == ClassKind.ENUM_ENTRY || !classElement.hasPrimaryConstructor()) return null; - return createConstructorDescriptor( - scope, - classDescriptor, - true, - classElement.getPrimaryConstructorModifierList(), - classElement, - classDescriptor.getTypeConstructor().getParameters(), classElement.getPrimaryConstructorParameters(), trace); - } - - @NotNull - public ConstructorDescriptorImpl resolveSecondaryConstructorDescriptor( - @NotNull JetScope scope, - @NotNull ClassDescriptor classDescriptor, - @NotNull JetSecondaryConstructor constructor, - @NotNull BindingTrace trace - ) { - return createConstructorDescriptor( - scope, - classDescriptor, - false, - constructor.getModifierList(), - constructor, - classDescriptor.getTypeConstructor().getParameters(), - constructor.getValueParameters(), - trace - ); - } - @NotNull public PropertyDescriptor resolvePrimaryConstructorParameterToAProperty( @NotNull ClassDescriptor classDescriptor, @@ -1457,16 +1224,6 @@ public class DescriptorResolver { } } - private static void checkConstructorParameterHasNoModifier( - @NotNull BindingTrace trace, - @NotNull JetParameter parameter - ) { - // If is not a property, then it must have no modifier - if (!parameter.hasValOrVarNode()) { - checkParameterHasNoModifier(trace, parameter); - } - } - public static void checkParameterHasNoModifier( @NotNull BindingTrace trace, @NotNull JetParameter parameter diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt new file mode 100644 index 00000000000..f545156ecf3 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt @@ -0,0 +1,279 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.resolve + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.impl.ConstructorDescriptorImpl +import org.jetbrains.kotlin.descriptors.impl.FunctionExpressionDescriptor +import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl +import org.jetbrains.kotlin.diagnostics.DiagnosticUtils +import org.jetbrains.kotlin.diagnostics.Errors.* +import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.resolve.scopes.JetScope +import org.jetbrains.kotlin.resolve.ModifiersChecker.* +import org.jetbrains.kotlin.resolve.DescriptorUtils.* +import org.jetbrains.kotlin.resolve.DescriptorResolver.* +import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo +import org.jetbrains.kotlin.resolve.scopes.WritableScope +import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl +import org.jetbrains.kotlin.resolve.source.toSourceElement +import org.jetbrains.kotlin.storage.StorageManager +import org.jetbrains.kotlin.types.DeferredType +import org.jetbrains.kotlin.types.ErrorUtils +import org.jetbrains.kotlin.types.JetType +import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices +import java.util.ArrayList + +class FunctionDescriptorResolver( + val typeResolver: TypeResolver, + val descriptorResolver: DescriptorResolver, + val annotationResolver: AnnotationResolver, + val storageManager: StorageManager, + val expressionTypingServices: ExpressionTypingServices, + val builtIns: KotlinBuiltIns +) { + public fun resolveFunctionDescriptor( + containingDescriptor: DeclarationDescriptor, + scope: JetScope, + function: JetNamedFunction, + trace: BindingTrace, + dataFlowInfo: DataFlowInfo + ): SimpleFunctionDescriptor { + if (function.getName() == null) { + trace.report(FUNCTION_DECLARATION_WITH_NO_NAME.on(function)) + } + val functionDescriptor = SimpleFunctionDescriptorImpl.create( + containingDescriptor, + annotationResolver.resolveAnnotationsWithArguments(scope, function.getModifierList(), trace), + function.getNameAsSafeName(), + CallableMemberDescriptor.Kind.DECLARATION, + function.toSourceElement() + ) + initializeFunctionDescriptorAndExplicitReturnType(containingDescriptor, scope, function, functionDescriptor, trace) + initializeFunctionReturnTypeBasedOnFunctionBody(scope, function, functionDescriptor, trace, dataFlowInfo) + BindingContextUtils.recordFunctionDeclarationToDescriptor(trace, function, functionDescriptor) + return functionDescriptor + } + + public fun resolveFunctionExpressionDescriptor( + containingDescriptor: DeclarationDescriptor, + scope: JetScope, + function: JetNamedFunction, + trace: BindingTrace, + dataFlowInfo: DataFlowInfo + ): SimpleFunctionDescriptor { + val functionDescriptor = FunctionExpressionDescriptor( + containingDescriptor, + annotationResolver.resolveAnnotationsWithArguments(scope, function.getModifierList(), trace), + function.getNameAsSafeName(), + CallableMemberDescriptor.Kind.DECLARATION, + function.toSourceElement() + ) + initializeFunctionDescriptorAndExplicitReturnType(containingDescriptor, scope, function, functionDescriptor, trace) + initializeFunctionReturnTypeBasedOnFunctionBody(scope, function, functionDescriptor, trace, dataFlowInfo) + BindingContextUtils.recordFunctionDeclarationToDescriptor(trace, function, functionDescriptor) + return functionDescriptor + } + + private fun initializeFunctionReturnTypeBasedOnFunctionBody( + scope: JetScope, + function: JetNamedFunction, + functionDescriptor: SimpleFunctionDescriptorImpl, + trace: BindingTrace, + dataFlowInfo: DataFlowInfo + ) { + if (functionDescriptor.getReturnType() != null) return + assert(function.getTypeReference() == null) { + "Return type must be initialized early for function: " + function.getText() + ", at: " + DiagnosticUtils.atLocation(function) } + + val returnType = if (function.hasBlockBody()) { + builtIns.getUnitType() + } + else if (function.hasBody()) { + DeferredType.createRecursionIntolerant(storageManager, trace) { + val type = expressionTypingServices.getBodyExpressionType(trace, scope, dataFlowInfo, function, functionDescriptor) + transformAnonymousTypeIfNeeded(functionDescriptor, function, type, trace) + } + } + else { + ErrorUtils.createErrorType("No type, no body") + } + functionDescriptor.setReturnType(returnType) + } + + private fun initializeFunctionDescriptorAndExplicitReturnType( + containingDescriptor: DeclarationDescriptor, + scope: JetScope, + function: JetFunction, + functionDescriptor: SimpleFunctionDescriptorImpl, + trace: BindingTrace + ) { + val innerScope = WritableScopeImpl(scope, functionDescriptor, TraceBasedRedeclarationHandler(trace), "Function descriptor header scope") + innerScope.addLabeledDeclaration(functionDescriptor) + + val typeParameterDescriptors = descriptorResolver. + resolveTypeParametersForCallableDescriptor(functionDescriptor, innerScope, function.getTypeParameters(), trace) + innerScope.changeLockLevel(WritableScope.LockLevel.BOTH) + descriptorResolver.resolveGenericBounds(function, functionDescriptor, innerScope, typeParameterDescriptors, trace) + + val receiverTypeRef = function.getReceiverTypeReference() + val receiverType = if (receiverTypeRef != null) { + typeResolver.resolveType(innerScope, receiverTypeRef, trace, true) + } else null + + val valueParameterDescriptors = resolveValueParameters(functionDescriptor, innerScope, function.getValueParameters(), trace) + + innerScope.changeLockLevel(WritableScope.LockLevel.READING) + + val returnTypeRef = function.getTypeReference() + val returnType = if (returnTypeRef != null) { + typeResolver.resolveType(innerScope, returnTypeRef, trace, true) + } else null + + val modality = resolveModalityFromModifiers(function, getDefaultModality(containingDescriptor, function.hasBody())) + val visibility = resolveVisibilityFromModifiers(function, getDefaultVisibility(function, containingDescriptor)) + functionDescriptor.initialize( + receiverType, + getDispatchReceiverParameterIfNeeded(containingDescriptor), + typeParameterDescriptors, + valueParameterDescriptors, + returnType, + modality, + visibility + ) + } + + public fun resolvePrimaryConstructorDescriptor( + scope: JetScope, + classDescriptor: ClassDescriptor, + classElement: JetClass, + trace: BindingTrace + ): ConstructorDescriptorImpl? { + if (classDescriptor.getKind() == ClassKind.ENUM_ENTRY || !classElement.hasPrimaryConstructor()) return null + return createConstructorDescriptor( + scope, + classDescriptor, + true, + classElement.getPrimaryConstructorModifierList(), + classElement, + classDescriptor.getTypeConstructor().getParameters(), + classElement.getPrimaryConstructorParameters(), + trace + ) + } + + public fun resolveSecondaryConstructorDescriptor( + scope: JetScope, + classDescriptor: ClassDescriptor, + constructor: JetSecondaryConstructor, + trace: BindingTrace + ): ConstructorDescriptorImpl { + return createConstructorDescriptor( + scope, + classDescriptor, + false, + constructor.getModifierList(), + constructor, + classDescriptor.getTypeConstructor().getParameters(), + constructor.getValueParameters(), + trace + ) + } + + private fun createConstructorDescriptor( + scope: JetScope, + classDescriptor: ClassDescriptor, + isPrimary: Boolean, + modifierList: JetModifierList?, + declarationToTrace: JetDeclaration, + typeParameters: List, + valueParameters: List, + trace: BindingTrace + ): ConstructorDescriptorImpl { + val constructorDescriptor = ConstructorDescriptorImpl.create( + classDescriptor, + annotationResolver.resolveAnnotationsWithoutArguments(scope, modifierList, trace), + isPrimary, + declarationToTrace.toSourceElement() + ) + trace.record(BindingContext.CONSTRUCTOR, declarationToTrace, constructorDescriptor) + val parameterScope = WritableScopeImpl( + scope, + constructorDescriptor, + TraceBasedRedeclarationHandler(trace), + "Scope with value parameters of a constructor" + ) + parameterScope.changeLockLevel(WritableScope.LockLevel.BOTH) + val constructor = constructorDescriptor.initialize( + typeParameters, + resolveValueParameters(constructorDescriptor, parameterScope, valueParameters, trace), + resolveVisibilityFromModifiers( + modifierList, + DescriptorUtils.getDefaultConstructorVisibility(classDescriptor) + ) + ) + if (DescriptorUtils.isAnnotationClass(classDescriptor)) { + CompileTimeConstantUtils.checkConstructorParametersType(valueParameters, trace) + } + return constructor + } + + private fun resolveValueParameters( + functionDescriptor: FunctionDescriptor, + parameterScope: WritableScope, + valueParameters: List, + trace: BindingTrace + ): List { + val result = ArrayList() + for (i in valueParameters.indices) { + val valueParameter = valueParameters.get(i) + val typeReference = valueParameter.getTypeReference() + + val type: JetType + if (typeReference == null) { + trace.report(VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION.on(valueParameter)) + type = ErrorUtils.createErrorType("Type annotation was missing") + } + else { + type = typeResolver.resolveType(parameterScope, typeReference, trace, true) + } + + if (functionDescriptor !is ConstructorDescriptor) { + DescriptorResolver.checkParameterHasNoValOrVar(trace, valueParameter, VAL_OR_VAR_ON_FUN_PARAMETER) + DescriptorResolver.checkParameterHasNoModifier(trace, valueParameter) + } + else { + checkConstructorParameterHasNoModifier(trace, valueParameter) + } + + val valueParameterDescriptor = descriptorResolver.resolveValueParameterDescriptor(parameterScope, functionDescriptor, + valueParameter, i, type, trace) + parameterScope.addVariableDescriptor(valueParameterDescriptor) + result.add(valueParameterDescriptor) + } + return result + } + + private fun checkConstructorParameterHasNoModifier(trace: BindingTrace, parameter: JetParameter) { + // If is not a property, then it must have no modifier + if (!parameter.hasValOrVarNode()) { + DescriptorResolver.checkParameterHasNoModifier(trace, parameter) + } + } +} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt index 209dc3da598..d065190ae6e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt @@ -17,12 +17,9 @@ package org.jetbrains.kotlin.resolve.lazy import org.jetbrains.kotlin.storage.StorageManager -import org.jetbrains.kotlin.resolve.BindingTrace import org.jetbrains.kotlin.descriptors.ModuleDescriptor -import org.jetbrains.kotlin.resolve.DescriptorResolver -import org.jetbrains.kotlin.resolve.TypeResolver +import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory -import org.jetbrains.kotlin.resolve.AnnotationResolver public trait LazyClassContext { val scopeProvider: DeclarationScopeProvider @@ -31,6 +28,7 @@ public trait LazyClassContext { val trace: BindingTrace val moduleDescriptor: ModuleDescriptor val descriptorResolver: DescriptorResolver + val functionDescriptorResolver: FunctionDescriptorResolver val typeResolver: TypeResolver val declarationProviderFactory: DeclarationProviderFactory val annotationResolver: AnnotationResolver diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java index af0408bb40f..0103d3e9a28 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java @@ -70,6 +70,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext { private JetImportsFactory jetImportFactory; private AnnotationResolver annotationResolve; private DescriptorResolver descriptorResolver; + private FunctionDescriptorResolver functionDescriptorResolver; private TypeResolver typeResolver; private QualifiedExpressionResolver qualifiedExpressionResolver; private ScriptBodyResolver scriptBodyResolver; @@ -90,6 +91,11 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext { this.descriptorResolver = descriptorResolver; } + @Inject + public void setFunctionDescriptorResolver(FunctionDescriptorResolver functionDescriptorResolver) { + this.functionDescriptorResolver = functionDescriptorResolver; + } + @Inject public void setTypeResolver(TypeResolver typeResolver) { this.typeResolver = typeResolver; @@ -381,4 +387,10 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext { public QualifiedExpressionResolver getQualifiedExpressionResolver() { return qualifiedExpressionResolver; } + + @NotNull + @Override + public FunctionDescriptorResolver getFunctionDescriptorResolver() { + return functionDescriptorResolver; + } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt index 2e2e3f3416d..87a9f7a73ff 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt @@ -69,7 +69,7 @@ public abstract class AbstractLazyMemberScope - val descriptor = c.descriptorResolver.resolveSecondaryConstructorDescriptor( + val descriptor = c.functionDescriptorResolver.resolveSecondaryConstructorDescriptor( thisDescriptor.getScopeForSecondaryConstructorHeaderResolution(), thisDescriptor, constructor, trace ) setDeferredReturnType(descriptor) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java index ad05be46cb4..0b8038d08cb 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java @@ -64,6 +64,7 @@ public class ExpressionTypingServices { private CallResolver callResolver; private CallExpressionResolver callExpressionResolver; private DescriptorResolver descriptorResolver; + private FunctionDescriptorResolver functionDescriptorResolver; private TypeResolver typeResolver; private AnnotationResolver annotationResolver; private StatementFilter statementFilter; @@ -109,6 +110,16 @@ public class ExpressionTypingServices { this.descriptorResolver = descriptorResolver; } + @NotNull + public FunctionDescriptorResolver getFunctionDescriptorResolver() { + return functionDescriptorResolver; + } + + @Inject + public void setFunctionDescriptorResolver(FunctionDescriptorResolver functionDescriptorResolver) { + this.functionDescriptorResolver = functionDescriptorResolver; + } + @NotNull public TypeResolver getTypeResolver() { return typeResolver; 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 fa0758f3e61..7fe019742b1 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt @@ -74,7 +74,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express val functionDescriptor: SimpleFunctionDescriptor if (isStatement) { - functionDescriptor = services.getDescriptorResolver().resolveFunctionDescriptor( + functionDescriptor = services.getFunctionDescriptorResolver().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) @@ -82,7 +82,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express statementScope!!.addFunctionDescriptor(functionDescriptor) } else { - functionDescriptor = services.getDescriptorResolver().resolveFunctionExpressionDescriptor( + functionDescriptor = services.getFunctionDescriptorResolver().resolveFunctionExpressionDescriptor( context.scope.getContainingDeclaration(), context.scope, function, context.trace, context.dataFlowInfo) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt index 0a095c7c108..ceb0bbea82d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt @@ -16,18 +16,12 @@ package org.jetbrains.kotlin.types.expressions -import org.jetbrains.kotlin.resolve.DescriptorResolver -import org.jetbrains.kotlin.resolve.TypeResolver -import org.jetbrains.kotlin.resolve.AnnotationResolver import org.jetbrains.kotlin.context.GlobalContext import org.jetbrains.kotlin.resolve.scopes.WritableScope import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.psi.JetClassOrObject -import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider import org.jetbrains.kotlin.types.DynamicTypesSettings import com.google.common.base.Predicates -import org.jetbrains.kotlin.resolve.TopDownAnalysisParameters -import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.di.InjectorForLazyLocalClassifierAnalyzer import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.descriptors.ModuleDescriptor @@ -46,15 +40,16 @@ import org.jetbrains.kotlin.psi.psiUtil.isObjectLiteral import org.jetbrains.kotlin.name.SpecialNames import org.jetbrains.kotlin.resolve.lazy.data.JetClassInfoUtil import org.jetbrains.kotlin.resolve.scopes.JetScope -import org.jetbrains.kotlin.resolve.BindingTrace import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo import com.intellij.psi.util.PsiTreeUtil +import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.resolve.lazy.LazyClassContext public class LocalClassifierAnalyzer( val descriptorResolver: DescriptorResolver, + val funcionDescriptorResolver: FunctionDescriptorResolver, val typeResolver: TypeResolver, val annotationResolver: AnnotationResolver ) { @@ -85,6 +80,7 @@ public class LocalClassifierAnalyzer( context, moduleDescriptor, descriptorResolver, + funcionDescriptorResolver, typeResolver, annotationResolver ) @@ -106,6 +102,7 @@ class LocalClassDescriptorHolder( val expressionTypingContext: ExpressionTypingContext, val moduleDescriptor: ModuleDescriptor, val descriptorResolver: DescriptorResolver, + val functionDescriptorResolver: FunctionDescriptorResolver, val typeResolver: TypeResolver, val annotationResolver: AnnotationResolver ) { @@ -125,6 +122,7 @@ class LocalClassDescriptorHolder( override val trace = expressionTypingContext.trace override val moduleDescriptor = this@LocalClassDescriptorHolder.moduleDescriptor override val descriptorResolver = this@LocalClassDescriptorHolder.descriptorResolver + override val functionDescriptorResolver = this@LocalClassDescriptorHolder.functionDescriptorResolver override val typeResolver = this@LocalClassDescriptorHolder.typeResolver override val declarationProviderFactory = object : DeclarationProviderFactory { override fun getClassMemberDeclarationProvider(classLikeInfo: JetClassLikeInfo): ClassMemberDeclarationProvider { diff --git a/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java b/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java index ad643793b32..5408a24dc3f 100644 --- a/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java +++ b/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java @@ -21,6 +21,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor; 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; @@ -57,6 +58,7 @@ public class InjectorForTests { private final KotlinBuiltIns kotlinBuiltIns; private final PlatformToKotlinClassMap platformToKotlinClassMap; private final DescriptorResolver descriptorResolver; + private final FunctionDescriptorResolver functionDescriptorResolver; private final ExpressionTypingServices expressionTypingServices; private final ExpressionTypingUtils expressionTypingUtils; private final TypeResolver typeResolver; @@ -91,10 +93,6 @@ public class InjectorForTests { this.kotlinBuiltIns = moduleDescriptor.getBuiltIns(); this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); this.descriptorResolver = new DescriptorResolver(); - this.expressionTypingComponents = new ExpressionTypingComponents(); - this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); - this.callResolver = new CallResolver(); - this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), callResolver, kotlinBuiltIns); this.annotationResolver = new AnnotationResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); @@ -103,6 +101,11 @@ public class InjectorForTests { this.typeLazinessToken = new TypeLazinessToken(); this.dynamicTypesSettings = new DynamicTypesSettings(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings); + this.expressionTypingComponents = new ExpressionTypingComponents(); + 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.argumentTypeResolver = new ArgumentTypeResolver(); this.candidateResolver = new CandidateResolver(); @@ -111,7 +114,7 @@ public class InjectorForTests { this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.controlStructureTypingUtils = new ControlStructureTypingUtils(getExpressionTypingServices()); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); - this.localClassifierAnalyzer = new LocalClassifierAnalyzer(getDescriptorResolver(), getTypeResolver(), annotationResolver); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(getDescriptorResolver(), getFunctionDescriptorResolver(), getTypeResolver(), annotationResolver); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.callExpressionResolver = new CallExpressionResolver(); this.statementFilter = new StatementFilter(); @@ -128,6 +131,7 @@ public class InjectorForTests { 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); @@ -183,6 +187,10 @@ public class InjectorForTests { return this.descriptorResolver; } + public FunctionDescriptorResolver getFunctionDescriptorResolver() { + return this.functionDescriptorResolver; + } + public ExpressionTypingServices getExpressionTypingServices() { return this.expressionTypingServices; } diff --git a/compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java b/compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java index 29934404ba9..9c0c09598b2 100644 --- a/compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java +++ b/compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java @@ -30,6 +30,7 @@ import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider; import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.BindingTraceContext; import org.jetbrains.kotlin.resolve.DescriptorResolver; +import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver; import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil; import org.jetbrains.kotlin.resolve.lazy.ResolveSession; @@ -70,11 +71,13 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { public class JetDefaultModalityModifiersTestCase { private final ModuleDescriptorImpl root = JetTestUtils.createEmptyModule(""); private DescriptorResolver descriptorResolver; + private FunctionDescriptorResolver functionDescriptorResolver; private JetScope scope; public void setUp() throws Exception { InjectorForTests injector = new InjectorForTests(getProject(), root); descriptorResolver = injector.getDescriptorResolver(); + functionDescriptorResolver = injector.getFunctionDescriptorResolver(); scope = createScope(KotlinBuiltIns.getInstance().getBuiltInsPackageScope()); } @@ -128,7 +131,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { List declarations = aClass.getDeclarations(); JetNamedFunction function = (JetNamedFunction) declarations.get(0); - SimpleFunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(classDescriptor, scope, function, + SimpleFunctionDescriptor functionDescriptor = functionDescriptorResolver.resolveFunctionDescriptor(classDescriptor, scope, function, JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY); diff --git a/compiler/tests/org/jetbrains/kotlin/types/JetOverloadTest.java b/compiler/tests/org/jetbrains/kotlin/types/JetOverloadTest.java index 78fb8f6f0e1..544828bef34 100644 --- a/compiler/tests/org/jetbrains/kotlin/types/JetOverloadTest.java +++ b/compiler/tests/org/jetbrains/kotlin/types/JetOverloadTest.java @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor; import org.jetbrains.kotlin.descriptors.ModuleDescriptor; import org.jetbrains.kotlin.di.InjectorForTests; import org.jetbrains.kotlin.psi.JetNamedFunction; -import org.jetbrains.kotlin.resolve.DescriptorResolver; +import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver; import org.jetbrains.kotlin.resolve.OverloadUtil; import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; import org.jetbrains.kotlin.test.ConfigurationKind; @@ -34,7 +34,7 @@ import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory; public class JetOverloadTest extends JetLiteFixture { private final ModuleDescriptor root = JetTestUtils.createEmptyModule(""); - private DescriptorResolver descriptorResolver; + private FunctionDescriptorResolver functionDescriptorResolver; @Override protected JetCoreEnvironment createEnvironment() { @@ -45,12 +45,12 @@ public class JetOverloadTest extends JetLiteFixture { public void setUp() throws Exception { super.setUp(); InjectorForTests injector = new InjectorForTests(getProject(), root); - descriptorResolver = injector.getDescriptorResolver(); + functionDescriptorResolver = injector.getFunctionDescriptorResolver(); } @Override protected void tearDown() throws Exception { - descriptorResolver = null; + functionDescriptorResolver = null; super.tearDown(); } @@ -173,7 +173,7 @@ public class JetOverloadTest extends JetLiteFixture { private FunctionDescriptor makeFunction(String funDecl) { JetNamedFunction function = JetPsiFactory(getProject()).createFunction(funDecl); - return descriptorResolver.resolveFunctionDescriptor(root, KotlinBuiltIns.getInstance().getBuiltInsPackageScope(), function, + return functionDescriptorResolver.resolveFunctionDescriptor(root, KotlinBuiltIns.getInstance().getBuiltInsPackageScope(), function, JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY); } } diff --git a/compiler/tests/org/jetbrains/kotlin/types/JetOverridingTest.java b/compiler/tests/org/jetbrains/kotlin/types/JetOverridingTest.java index d1c955ec56b..63cef48bdf5 100644 --- a/compiler/tests/org/jetbrains/kotlin/types/JetOverridingTest.java +++ b/compiler/tests/org/jetbrains/kotlin/types/JetOverridingTest.java @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor; import org.jetbrains.kotlin.descriptors.ModuleDescriptor; import org.jetbrains.kotlin.di.InjectorForTests; import org.jetbrains.kotlin.psi.JetNamedFunction; -import org.jetbrains.kotlin.resolve.DescriptorResolver; +import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver; import org.jetbrains.kotlin.resolve.OverridingUtil; import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; import org.jetbrains.kotlin.test.ConfigurationKind; @@ -34,7 +34,7 @@ import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory; public class JetOverridingTest extends JetLiteFixture { private final ModuleDescriptor root = JetTestUtils.createEmptyModule(""); - private DescriptorResolver descriptorResolver; + private FunctionDescriptorResolver functionDescriptorResolver; @Override protected JetCoreEnvironment createEnvironment() { @@ -45,12 +45,12 @@ public class JetOverridingTest extends JetLiteFixture { public void setUp() throws Exception { super.setUp(); InjectorForTests injector = new InjectorForTests(getProject(), root); - descriptorResolver = injector.getDescriptorResolver(); + functionDescriptorResolver = injector.getFunctionDescriptorResolver(); } @Override protected void tearDown() throws Exception { - descriptorResolver = null; + functionDescriptorResolver = null; super.tearDown(); } @@ -164,7 +164,7 @@ public class JetOverridingTest extends JetLiteFixture { private FunctionDescriptor makeFunction(String funDecl) { JetNamedFunction function = JetPsiFactory(getProject()).createFunction(funDecl); - return descriptorResolver.resolveFunctionDescriptor(root, KotlinBuiltIns.getInstance().getBuiltInsPackageScope(), function, + return functionDescriptorResolver.resolveFunctionDescriptor(root, KotlinBuiltIns.getInstance().getBuiltInsPackageScope(), function, JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY); } } diff --git a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt index 4d0b1d156cc..43bc9b84c3b 100644 --- a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt @@ -220,6 +220,7 @@ private fun generatorForTests() = parameter(useAsContext = true) publicField() + publicField() publicField() publicField() publicField() 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 d6108895c98..57e7771124a 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java @@ -44,6 +44,7 @@ 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.resolve.FunctionDescriptorResolver; import org.jetbrains.kotlin.types.reflect.ReflectionTypes; import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.StatementFilter; @@ -100,6 +101,7 @@ public class InjectorForTopDownAnalyzerForJs { private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final TypeLazinessToken typeLazinessToken; + private final FunctionDescriptorResolver functionDescriptorResolver; private final ReflectionTypes reflectionTypes; private final CallExpressionResolver callExpressionResolver; private final StatementFilter statementFilter; @@ -155,7 +157,8 @@ public class InjectorForTopDownAnalyzerForJs { this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.typeLazinessToken = new TypeLazinessToken(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesAllowed); - this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); + this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns); + this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.reflectionTypes = new ReflectionTypes(getModule()); this.callExpressionResolver = new CallExpressionResolver(); @@ -181,6 +184,7 @@ public class InjectorForTopDownAnalyzerForJs { this.resolveSession.setAnnotationResolve(annotationResolver); this.resolveSession.setDescriptorResolver(descriptorResolver); + this.resolveSession.setFunctionDescriptorResolver(functionDescriptorResolver); this.resolveSession.setJetImportFactory(jetImportsFactory); this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver); this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver); @@ -214,6 +218,7 @@ public class InjectorForTopDownAnalyzerForJs { expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); + expressionTypingServices.setFunctionDescriptorResolver(functionDescriptorResolver); expressionTypingServices.setProject(project); expressionTypingServices.setStatementFilter(statementFilter); expressionTypingServices.setTypeResolver(typeResolver);