Refactoring: extract FunctionResolver from DescriptorResolver

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);

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);

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);

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);

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);

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);

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);

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);

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);

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<JetType>() {
-                                @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<TypeParameterDescriptorImpl> 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<ValueParameterDescriptor> 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<ValueParameterDescriptor> resolveValueParameters(
-            FunctionDescriptor functionDescriptor,
-            WritableScope parameterScope,
-            List<JetParameter> valueParameters,
-            BindingTrace trace
-    ) {
-        List<ValueParameterDescriptor> result = new ArrayList<ValueParameterDescriptor>();
-        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<TypeParameterDescriptor> typeParameters, @NotNull List<JetParameter> 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

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<TypeParameterDescriptor>,
+            valueParameters: List<JetParameter>,
+            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<JetParameter>,
+            trace: BindingTrace
+    ): List<ValueParameterDescriptor> {
+        val result = ArrayList<ValueParameterDescriptor>()
+        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)
+        }
+    }
+}

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.*
-import org.jetbrains.kotlin.resolve.TypeResolver
 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

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;
+    }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt

@@ -69,7 +69,7 @@ public abstract class AbstractLazyMemberScope<D : DeclarationDescriptor, DP : De
         val declarations = declarationProvider.getFunctionDeclarations(name)
         for (functionDeclaration in declarations) {
             val resolutionScope = getScopeForMemberDeclarationResolution(functionDeclaration)
-            result.add(c.descriptorResolver.resolveFunctionDescriptor(
+            result.add(c.functionDescriptorResolver.resolveFunctionDescriptor(
                     thisDescriptor,
                     resolutionScope,
                     functionDeclaration,

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt

@@ -280,7 +280,7 @@ public open class LazyClassMemberScope(
             if (!thisDescriptor.getKind().isSingleton() && !classOrObject.isObjectLiteral()) {
                 assert(classOrObject is JetClass) { "No JetClass for $thisDescriptor" }
                 classOrObject as JetClass
-                val constructor = c.descriptorResolver.resolvePrimaryConstructorDescriptor(
+                val constructor = c.functionDescriptorResolver.resolvePrimaryConstructorDescriptor(
                         thisDescriptor.getScopeForClassHeaderResolution(), thisDescriptor, classOrObject, trace)
                 constructor ?: return null
                 setDeferredReturnType(constructor)
@@ -302,7 +302,7 @@ public open class LazyClassMemberScope(
         if (classOrObject !is JetClass) return emptyList()
 
         return classOrObject.getSecondaryConstructors().map { constructor ->
-            val descriptor = c.descriptorResolver.resolveSecondaryConstructorDescriptor(
+            val descriptor = c.functionDescriptorResolver.resolveSecondaryConstructorDescriptor(
                     thisDescriptor.getScopeForSecondaryConstructorHeaderResolution(), thisDescriptor, constructor, trace
             )
             setDeferredReturnType(descriptor)

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;

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)
         }
 

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 {

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;
     }

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("<test_root>");
         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<JetDeclaration> 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);
 

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("<test_root>");
-    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);
     }
 }

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("<test_root>");
-    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);
     }
 }

generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt

@@ -220,6 +220,7 @@ private fun generatorForTests() =
             parameter<ModuleDescriptor>(useAsContext = true)
 
             publicField<DescriptorResolver>()
+            publicField<FunctionDescriptorResolver>()
             publicField<ExpressionTypingServices>()
             publicField<ExpressionTypingUtils>()
             publicField<TypeResolver>()

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);