LazyLocalClassifierAnalyzer introduced

compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java

@@ -42,6 +42,7 @@ import org.jetbrains.kotlin.load.java.components.JavaSourceElementFactoryImpl;
 import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider;
 import org.jetbrains.kotlin.context.LazyResolveToken;
 import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct;
+import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
 import org.jetbrains.kotlin.resolve.AnnotationResolver;
 import org.jetbrains.kotlin.resolve.calls.CallResolver;
@@ -52,7 +53,6 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
 import org.jetbrains.kotlin.types.DynamicTypesSettings;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
 import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
 import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
 import org.jetbrains.kotlin.resolve.DescriptorResolver;
@@ -107,6 +107,7 @@ public class InjectorForLazyResolveWithJava {
     private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
     private final LazyResolveToken lazyResolveToken;
     private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
+    private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
     private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
@@ -117,7 +118,6 @@ public class InjectorForLazyResolveWithJava {
     private final DynamicTypesSettings dynamicTypesSettings;
     private final ExpressionTypingUtils expressionTypingUtils;
     private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
     private final ReflectionTypes reflectionTypes;
     private final CallExpressionResolver callExpressionResolver;
     private final DescriptorResolver descriptorResolver;
@@ -178,6 +178,7 @@ public class InjectorForLazyResolveWithJava {
         this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
         this.lazyResolveToken = new LazyResolveToken();
         this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
+        this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
         this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
@@ -188,7 +189,6 @@ public class InjectorForLazyResolveWithJava {
         this.dynamicTypesSettings = new DynamicTypesSettings();
         this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
         this.reflectionTypes = new ReflectionTypes(module);
         this.callExpressionResolver = new CallExpressionResolver();
         this.descriptorResolver = new DescriptorResolver();
@@ -272,7 +272,7 @@ public class InjectorForLazyResolveWithJava {
         expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
         expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
         expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
+        expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
         expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
         expressionTypingComponents.setReflectionTypes(reflectionTypes);
 

compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java

@@ -45,6 +45,7 @@ import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver;
 import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct;
 import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider;
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
+import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
 import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
 import org.jetbrains.kotlin.resolve.AnnotationResolver;
 import org.jetbrains.kotlin.resolve.calls.CallResolver;
@@ -55,7 +56,6 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
 import org.jetbrains.kotlin.types.DynamicTypesSettings;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
 import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
 import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
 import org.jetbrains.kotlin.resolve.DescriptorResolver;
@@ -122,6 +122,7 @@ public class InjectorForReplWithJava {
     private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
     private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
     private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider;
+    private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
     private final AdditionalFileScopeProvider additionalFileScopeProvider;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
@@ -132,7 +133,6 @@ public class InjectorForReplWithJava {
     private final DynamicTypesSettings dynamicTypesSettings;
     private final ExpressionTypingUtils expressionTypingUtils;
     private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
     private final ReflectionTypes reflectionTypes;
     private final CallExpressionResolver callExpressionResolver;
     private final DescriptorResolver descriptorResolver;
@@ -207,6 +207,7 @@ public class InjectorForReplWithJava {
         this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
         this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
         this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
+        this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
         this.additionalFileScopeProvider = additionalFileScopeProvider;
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
@@ -217,7 +218,6 @@ public class InjectorForReplWithJava {
         this.dynamicTypesSettings = new DynamicTypesSettings();
         this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
         this.reflectionTypes = new ReflectionTypes(module);
         this.callExpressionResolver = new CallExpressionResolver();
         this.descriptorResolver = new DescriptorResolver();
@@ -325,7 +325,7 @@ public class InjectorForReplWithJava {
         expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
         expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
         expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
+        expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
         expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
         expressionTypingComponents.setReflectionTypes(reflectionTypes);
 

compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java

@@ -45,6 +45,7 @@ import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver;
 import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct;
 import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider;
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
+import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
 import org.jetbrains.kotlin.resolve.AnnotationResolver;
 import org.jetbrains.kotlin.resolve.calls.CallResolver;
 import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
@@ -54,7 +55,6 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
 import org.jetbrains.kotlin.types.DynamicTypesSettings;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
 import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
 import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
 import org.jetbrains.kotlin.resolve.DescriptorResolver;
@@ -122,6 +122,7 @@ public class InjectorForTopDownAnalyzerForJvm {
     private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
     private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
     private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider;
+    private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
     private final ArgumentTypeResolver argumentTypeResolver;
@@ -131,7 +132,6 @@ public class InjectorForTopDownAnalyzerForJvm {
     private final DynamicTypesSettings dynamicTypesSettings;
     private final ExpressionTypingUtils expressionTypingUtils;
     private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
     private final ReflectionTypes reflectionTypes;
     private final CallExpressionResolver callExpressionResolver;
     private final DescriptorResolver descriptorResolver;
@@ -206,6 +206,7 @@ public class InjectorForTopDownAnalyzerForJvm {
         this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
         this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
         this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
+        this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -215,7 +216,6 @@ public class InjectorForTopDownAnalyzerForJvm {
         this.dynamicTypesSettings = new DynamicTypesSettings();
         this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
         this.reflectionTypes = new ReflectionTypes(module);
         this.callExpressionResolver = new CallExpressionResolver();
         this.descriptorResolver = new DescriptorResolver();
@@ -324,7 +324,7 @@ public class InjectorForTopDownAnalyzerForJvm {
         expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
         expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
         expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
+        expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
         expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
         expressionTypingComponents.setReflectionTypes(reflectionTypes);
 

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
 import org.jetbrains.kotlin.types.DynamicTypesSettings;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
+import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
 import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
 import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
@@ -40,7 +41,6 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
 import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
 import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
 import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
 import org.jetbrains.kotlin.resolve.DescriptorResolver;
@@ -82,6 +82,7 @@ public class InjectorForLazyBodyResolve {
     private final DynamicTypesSettings dynamicTypesSettings;
     private final KotlinBuiltIns kotlinBuiltIns;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
+    private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
     private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
     private final AdditionalFileScopeProvider additionalFileScopeProvider;
     private final DeclarationScopeProviderImpl declarationScopeProvider;
@@ -95,7 +96,6 @@ public class InjectorForLazyBodyResolve {
     private final ControlStructureTypingUtils controlStructureTypingUtils;
     private final ExpressionTypingUtils expressionTypingUtils;
     private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
     private final ReflectionTypes reflectionTypes;
     private final CallExpressionResolver callExpressionResolver;
     private final DescriptorResolver descriptorResolver;
@@ -139,6 +139,7 @@ public class InjectorForLazyBodyResolve {
         this.dynamicTypesSettings = dynamicTypesSettings;
         this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
         this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
+        this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
         this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
         this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
         this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
@@ -152,7 +153,6 @@ public class InjectorForLazyBodyResolve {
         this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
         this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
         this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
         this.callExpressionResolver = new CallExpressionResolver();
         this.descriptorResolver = new DescriptorResolver();
@@ -240,7 +240,7 @@ public class InjectorForLazyBodyResolve {
         expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
         expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
         expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
+        expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
         expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
         expressionTypingComponents.setReflectionTypes(reflectionTypes);
 

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java

@@ -0,0 +1,297 @@
+/*
+ * 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.di;
+
+import com.intellij.openapi.project.Project;
+import org.jetbrains.kotlin.context.GlobalContext;
+import org.jetbrains.kotlin.storage.StorageManager;
+import org.jetbrains.kotlin.resolve.BindingTrace;
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
+import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
+import org.jetbrains.kotlin.types.DynamicTypesSettings;
+import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
+import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider;
+import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider;
+import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
+import org.jetbrains.kotlin.resolve.BodyResolver;
+import org.jetbrains.kotlin.resolve.AnnotationResolver;
+import org.jetbrains.kotlin.resolve.calls.CallResolver;
+import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
+import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
+import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
+import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
+import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
+import org.jetbrains.kotlin.resolve.DescriptorResolver;
+import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
+import org.jetbrains.kotlin.resolve.TypeResolver;
+import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
+import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
+import org.jetbrains.kotlin.context.LazinessToken;
+import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
+import org.jetbrains.kotlin.resolve.calls.CallCompleter;
+import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
+import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
+import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer;
+import org.jetbrains.kotlin.resolve.DeclarationsChecker;
+import org.jetbrains.kotlin.resolve.ModifiersChecker;
+import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
+import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
+import org.jetbrains.kotlin.resolve.DeclarationResolver;
+import org.jetbrains.kotlin.resolve.ImportsResolver;
+import org.jetbrains.kotlin.psi.JetImportsFactory;
+import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
+import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
+import org.jetbrains.kotlin.resolve.OverloadResolver;
+import org.jetbrains.kotlin.resolve.OverrideResolver;
+import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
+import org.jetbrains.annotations.NotNull;
+import javax.annotation.PreDestroy;
+
+/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
+@SuppressWarnings("all")
+public class InjectorForLazyLocalClassifierAnalyzer {
+
+    private final Project project;
+    private final GlobalContext globalContext;
+    private final StorageManager storageManager;
+    private final BindingTrace bindingTrace;
+    private final ModuleDescriptor module;
+    private final KotlinBuiltIns kotlinBuiltIns;
+    private final PlatformToKotlinClassMap platformToKotlinClassMap;
+    private final AdditionalCheckerProvider additionalCheckerProvider;
+    private final DynamicTypesSettings dynamicTypesSettings;
+    private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
+    private final NoTopLevelDescriptorProvider noTopLevelDescriptorProvider;
+    private final NoFileScopeProvider noFileScopeProvider;
+    private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
+    private final BodyResolver bodyResolver;
+    private final AnnotationResolver annotationResolver;
+    private final CallResolver callResolver;
+    private final ArgumentTypeResolver argumentTypeResolver;
+    private final ExpressionTypingServices expressionTypingServices;
+    private final ExpressionTypingComponents expressionTypingComponents;
+    private final ControlStructureTypingUtils controlStructureTypingUtils;
+    private final ExpressionTypingUtils expressionTypingUtils;
+    private final ForLoopConventionsChecker forLoopConventionsChecker;
+    private final ReflectionTypes reflectionTypes;
+    private final CallExpressionResolver callExpressionResolver;
+    private final DescriptorResolver descriptorResolver;
+    private final DelegatedPropertyResolver delegatedPropertyResolver;
+    private final TypeResolver typeResolver;
+    private final QualifiedExpressionResolver qualifiedExpressionResolver;
+    private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
+    private final LazinessToken lazinessToken;
+    private final PartialBodyResolveProvider partialBodyResolveProvider;
+    private final CallCompleter callCompleter;
+    private final CandidateResolver candidateResolver;
+    private final TaskPrioritizer taskPrioritizer;
+    private final ControlFlowAnalyzer controlFlowAnalyzer;
+    private final DeclarationsChecker declarationsChecker;
+    private final ModifiersChecker modifiersChecker;
+    private final FunctionAnalyzerExtension functionAnalyzerExtension;
+    private final ScriptBodyResolver scriptBodyResolver;
+    private final DeclarationResolver declarationResolver;
+    private final ImportsResolver importsResolver;
+    private final JetImportsFactory jetImportsFactory;
+    private final DeclarationScopeProviderImpl declarationScopeProvider;
+    private final LazyDeclarationResolver lazyDeclarationResolver;
+    private final OverloadResolver overloadResolver;
+    private final OverrideResolver overrideResolver;
+    private final VarianceChecker varianceChecker;
+
+    public InjectorForLazyLocalClassifierAnalyzer(
+        @NotNull Project project,
+        @NotNull GlobalContext globalContext,
+        @NotNull BindingTrace bindingTrace,
+        @NotNull ModuleDescriptor module,
+        @NotNull AdditionalCheckerProvider additionalCheckerProvider,
+        @NotNull DynamicTypesSettings dynamicTypesSettings
+    ) {
+        this.project = project;
+        this.globalContext = globalContext;
+        this.storageManager = globalContext.getStorageManager();
+        this.bindingTrace = bindingTrace;
+        this.module = module;
+        this.kotlinBuiltIns = module.getBuiltIns();
+        this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
+        this.additionalCheckerProvider = additionalCheckerProvider;
+        this.dynamicTypesSettings = dynamicTypesSettings;
+        this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
+        this.noTopLevelDescriptorProvider = NoTopLevelDescriptorProvider.INSTANCE$;
+        this.noFileScopeProvider = NoFileScopeProvider.INSTANCE$;
+        this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
+        this.bodyResolver = new BodyResolver();
+        this.annotationResolver = new AnnotationResolver();
+        this.callResolver = new CallResolver();
+        this.argumentTypeResolver = new ArgumentTypeResolver();
+        this.expressionTypingComponents = new ExpressionTypingComponents();
+        this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
+        this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
+        this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
+        this.forLoopConventionsChecker = new ForLoopConventionsChecker();
+        this.reflectionTypes = new ReflectionTypes(module);
+        this.callExpressionResolver = new CallExpressionResolver();
+        this.descriptorResolver = new DescriptorResolver();
+        this.delegatedPropertyResolver = new DelegatedPropertyResolver();
+        this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
+        this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
+        this.lazinessToken = new LazinessToken();
+        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings);
+        this.partialBodyResolveProvider = new PartialBodyResolveProvider();
+        this.candidateResolver = new CandidateResolver();
+        this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
+        this.taskPrioritizer = new TaskPrioritizer(storageManager);
+        this.controlFlowAnalyzer = new ControlFlowAnalyzer();
+        this.declarationsChecker = new DeclarationsChecker();
+        this.modifiersChecker = new ModifiersChecker(bindingTrace, additionalCheckerProvider);
+        this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
+        this.scriptBodyResolver = new ScriptBodyResolver();
+        this.declarationResolver = new DeclarationResolver();
+        this.importsResolver = new ImportsResolver();
+        this.jetImportsFactory = new JetImportsFactory();
+        this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
+        this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
+        this.overloadResolver = new OverloadResolver();
+        this.overrideResolver = new OverrideResolver();
+        this.varianceChecker = new VarianceChecker(bindingTrace);
+
+        this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
+        this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
+        this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
+        this.lazyTopDownAnalyzer.setFileScopeProvider(noFileScopeProvider);
+        this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
+        this.lazyTopDownAnalyzer.setModuleDescriptor(module);
+        this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
+        this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
+        this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(noTopLevelDescriptorProvider);
+        this.lazyTopDownAnalyzer.setTrace(bindingTrace);
+        this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
+
+        bodyResolver.setAnnotationResolver(annotationResolver);
+        bodyResolver.setCallResolver(callResolver);
+        bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
+        bodyResolver.setDeclarationsChecker(declarationsChecker);
+        bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
+        bodyResolver.setExpressionTypingServices(expressionTypingServices);
+        bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
+        bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
+        bodyResolver.setTrace(bindingTrace);
+
+        annotationResolver.setCallResolver(callResolver);
+        annotationResolver.setStorageManager(storageManager);
+        annotationResolver.setTypeResolver(typeResolver);
+
+        callResolver.setArgumentTypeResolver(argumentTypeResolver);
+        callResolver.setCallCompleter(callCompleter);
+        callResolver.setCandidateResolver(candidateResolver);
+        callResolver.setExpressionTypingServices(expressionTypingServices);
+        callResolver.setTaskPrioritizer(taskPrioritizer);
+        callResolver.setTypeResolver(typeResolver);
+
+        argumentTypeResolver.setBuiltIns(kotlinBuiltIns);
+        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
+        argumentTypeResolver.setTypeResolver(typeResolver);
+
+        expressionTypingServices.setAnnotationResolver(annotationResolver);
+        expressionTypingServices.setBuiltIns(kotlinBuiltIns);
+        expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
+        expressionTypingServices.setCallResolver(callResolver);
+        expressionTypingServices.setDescriptorResolver(descriptorResolver);
+        expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider);
+        expressionTypingServices.setProject(project);
+        expressionTypingServices.setTypeResolver(typeResolver);
+
+        expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
+        expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
+        expressionTypingComponents.setCallResolver(callResolver);
+        expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
+        expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
+        expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
+        expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
+        expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
+        expressionTypingComponents.setGlobalContext(globalContext);
+        expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
+        expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
+        expressionTypingComponents.setReflectionTypes(reflectionTypes);
+
+        forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
+        forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices);
+        forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
+        forLoopConventionsChecker.setProject(project);
+
+        callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
+
+        descriptorResolver.setAnnotationResolver(annotationResolver);
+        descriptorResolver.setBuiltIns(kotlinBuiltIns);
+        descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
+        descriptorResolver.setExpressionTypingServices(expressionTypingServices);
+        descriptorResolver.setStorageManager(storageManager);
+        descriptorResolver.setTypeResolver(typeResolver);
+
+        delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
+        delegatedPropertyResolver.setCallResolver(callResolver);
+        delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
+
+        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
+
+        controlFlowAnalyzer.setTrace(bindingTrace);
+
+        declarationsChecker.setDescriptorResolver(descriptorResolver);
+        declarationsChecker.setModifiersChecker(modifiersChecker);
+        declarationsChecker.setTrace(bindingTrace);
+
+        functionAnalyzerExtension.setTrace(bindingTrace);
+
+        scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
+
+        declarationResolver.setAnnotationResolver(annotationResolver);
+        declarationResolver.setDescriptorResolver(descriptorResolver);
+        declarationResolver.setImportsResolver(importsResolver);
+        declarationResolver.setTrace(bindingTrace);
+
+        importsResolver.setImportsFactory(jetImportsFactory);
+        importsResolver.setModuleDescriptor(module);
+        importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
+        importsResolver.setTrace(bindingTrace);
+
+        jetImportsFactory.setProject(project);
+
+        declarationScopeProvider.setFileScopeProvider(noFileScopeProvider);
+
+        lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
+        lazyDeclarationResolver.setTopLevelDescriptorProvider(noTopLevelDescriptorProvider);
+
+        overloadResolver.setTrace(bindingTrace);
+
+        overrideResolver.setTrace(bindingTrace);
+
+    }
+
+    @PreDestroy
+    public void destroy() {
+    }
+
+    public LazyTopDownAnalyzer getLazyTopDownAnalyzer() {
+        return this.lazyTopDownAnalyzer;
+    }
+
+}

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java

@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.types.DynamicTypesSettings;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
 import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
 import org.jetbrains.kotlin.context.LazyResolveToken;
+import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
 import org.jetbrains.kotlin.resolve.AnnotationResolver;
 import org.jetbrains.kotlin.resolve.calls.CallResolver;
 import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
@@ -37,7 +38,6 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
 import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
 import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
 import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
 import org.jetbrains.kotlin.resolve.DescriptorResolver;
@@ -74,6 +74,7 @@ public class InjectorForLazyResolve {
     private final ResolveSession resolveSession;
     private final ScopeProvider scopeProvider;
     private final LazyResolveToken lazyResolveToken;
+    private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
     private final ArgumentTypeResolver argumentTypeResolver;
@@ -82,7 +83,6 @@ public class InjectorForLazyResolve {
     private final ControlStructureTypingUtils controlStructureTypingUtils;
     private final ExpressionTypingUtils expressionTypingUtils;
     private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
     private final ReflectionTypes reflectionTypes;
     private final CallExpressionResolver callExpressionResolver;
     private final DescriptorResolver descriptorResolver;
@@ -122,6 +122,7 @@ public class InjectorForLazyResolve {
         this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace);
         this.scopeProvider = new ScopeProvider(getResolveSession());
         this.lazyResolveToken = new LazyResolveToken();
+        this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -130,7 +131,6 @@ public class InjectorForLazyResolve {
         this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
         this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
         this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
         this.callExpressionResolver = new CallExpressionResolver();
         this.descriptorResolver = new DescriptorResolver();
@@ -193,7 +193,7 @@ public class InjectorForLazyResolve {
         expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
         expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
         expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
+        expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
         expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
         expressionTypingComponents.setReflectionTypes(reflectionTypes);
 

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java

@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
 import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider.DefaultProvider;
+import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
 import org.jetbrains.kotlin.resolve.AnnotationResolver;
 import org.jetbrains.kotlin.resolve.calls.CallResolver;
 import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
@@ -38,7 +39,6 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
 import org.jetbrains.kotlin.types.DynamicTypesSettings;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
 import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
 import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
 import org.jetbrains.kotlin.resolve.DescriptorResolver;
@@ -86,6 +86,7 @@ public class InjectorForLazyTopDownAnalyzerBasic {
     private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
     private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
     private final DefaultProvider defaultProvider;
+    private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
     private final ArgumentTypeResolver argumentTypeResolver;
@@ -95,7 +96,6 @@ public class InjectorForLazyTopDownAnalyzerBasic {
     private final DynamicTypesSettings dynamicTypesSettings;
     private final ExpressionTypingUtils expressionTypingUtils;
     private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
     private final ReflectionTypes reflectionTypes;
     private final CallExpressionResolver callExpressionResolver;
     private final DescriptorResolver descriptorResolver;
@@ -144,6 +144,7 @@ public class InjectorForLazyTopDownAnalyzerBasic {
         this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
         this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
         this.defaultProvider = DefaultProvider.INSTANCE$;
+        this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -153,7 +154,6 @@ public class InjectorForLazyTopDownAnalyzerBasic {
         this.dynamicTypesSettings = new DynamicTypesSettings();
         this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
         this.reflectionTypes = new ReflectionTypes(module);
         this.callExpressionResolver = new CallExpressionResolver();
         this.descriptorResolver = new DescriptorResolver();
@@ -242,7 +242,7 @@ public class InjectorForLazyTopDownAnalyzerBasic {
         expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
         expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
         expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
+        expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
         expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
         expressionTypingComponents.setReflectionTypes(reflectionTypes);
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyLocalClassifierAnalyzer.kt

@@ -0,0 +1,61 @@
+/*
+ * 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 org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer
+import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.resolve.scopes.WritableScope
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.types.DynamicTypesSettings
+import com.google.common.base.Predicates
+import org.jetbrains.kotlin.di.InjectorForLazyLocalClassifierAnalyzer
+
+public class LazyLocalClassifierAnalyzer : LocalClassifierAnalyzer() {
+    override fun processClassOrObject(
+            globalContext: GlobalContext,
+            scope: WritableScope?,
+            context: ExpressionTypingContext,
+            containingDeclaration: DeclarationDescriptor,
+            classOrObject: JetClassOrObject,
+            additionalCheckerProvider: AdditionalCheckerProvider,
+            dynamicTypesSettings: DynamicTypesSettings
+    ) {
+        val topDownAnalysisParameters = TopDownAnalysisParameters.create(
+                globalContext.storageManager,
+                globalContext.exceptionTracker,
+                Predicates.equalTo(classOrObject.getContainingFile()), false, true)
+
+        val c = TopDownAnalysisContext(topDownAnalysisParameters)
+        c.setOuterDataFlowInfo(context.dataFlowInfo)
+
+        val injector = InjectorForLazyLocalClassifierAnalyzer(
+                classOrObject.getProject(),
+                globalContext,
+                context.trace,
+                DescriptorUtils.getContainingModule(containingDeclaration),
+                additionalCheckerProvider,
+                dynamicTypesSettings
+        )
+
+        injector.getLazyTopDownAnalyzer().analyzeDeclarations(
+                topDownAnalysisParameters,
+                listOf(classOrObject)
+        )
+    }
+}

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt

@@ -21,4 +21,10 @@ import org.jetbrains.kotlin.resolve.scopes.JetScope
 
 public trait FileScopeProvider {
     fun getFileScope(jetFile: JetFile): JetScope
+}
+
+public object NoFileScopeProvider : FileScopeProvider {
+    override fun getFileScope(jetFile: JetFile): JetScope {
+        throw UnsupportedOperationException("Should not be called")
+    }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/TopLevelDescriptorProvider.kt

@@ -29,3 +29,19 @@ public trait TopLevelDescriptorProvider {
 
     fun getTopLevelClassDescriptors(fqName: FqName): Collection<ClassDescriptor>
 }
+
+public object NoTopLevelDescriptorProvider : TopLevelDescriptorProvider {
+    private fun shouldNotBeCalled(): Nothing = throw UnsupportedOperationException("Should not be called")
+
+    override fun getPackageFragment(fqName: FqName): LazyPackageDescriptor? {
+        shouldNotBeCalled()
+    }
+
+    override fun getScriptDescriptor(script: JetScript): ScriptDescriptor {
+        shouldNotBeCalled()
+    }
+
+    override fun getTopLevelClassDescriptors(fqName: FqName): Collection<ClassDescriptor> {
+        shouldNotBeCalled()
+    }
+}

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

@@ -51,6 +51,8 @@ import org.jetbrains.kotlin.resolve.lazy.ScopeProvider
 import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider
 import org.jetbrains.kotlin.types.DynamicTypesAllowed
 import org.jetbrains.kotlin.types.DynamicTypesSettings
+import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider
+import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider
 
 // NOTE: After making changes, you need to re-generate the injectors.
 //       To do that, you can run main in this file.
@@ -72,6 +74,7 @@ public fun createInjectorGenerators(): List<DependencyInjectorGenerator> =
         listOf(
                 generatorForTopDownAnalyzerBasic(),
                 generatorForLazyTopDownAnalyzerBasic(),
+                generatorForLazyLocalClassifierAnalyzer(),
                 generatorForTopDownAnalyzerForJvm(),
                 generatorForJavaDescriptorResolver(),
                 generatorForLazyResolveWithJava(),
@@ -107,6 +110,23 @@ private fun generatorForLazyTopDownAnalyzerBasic() =
             publicField<LazyTopDownAnalyzerForTopLevel>()
 
             field<AdditionalCheckerProvider.DefaultProvider>()
+            field<LazyLocalClassifierAnalyzer>()
+        }
+
+private fun generatorForLazyLocalClassifierAnalyzer() =
+        generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyLocalClassifierAnalyzer") {
+            parameter<Project>()
+            parameter<GlobalContext>(useAsContext = true)
+            parameter<BindingTrace>()
+            parameter<ModuleDescriptor>(name = "module", useAsContext = true)
+            parameter<AdditionalCheckerProvider>()
+            parameter<DynamicTypesSettings>()
+
+            publicField<LazyTopDownAnalyzer>()
+
+            field<NoTopLevelDescriptorProvider>()
+            field<NoFileScopeProvider>()
+            field<LazyLocalClassifierAnalyzer>()
         }
 
 private fun generatorForLazyBodyResolve() =
@@ -119,6 +139,7 @@ private fun generatorForLazyBodyResolve() =
             parameter<DynamicTypesSettings>()
 
             field<ModuleDescriptor>(init = GivenExpression("analyzer.getModuleDescriptor()"), useAsContext = true)
+            field<LazyLocalClassifierAnalyzer>()
 
             publicField<LazyTopDownAnalyzer>()
         }
@@ -133,6 +154,7 @@ private fun generatorForTopDownAnalyzerForJs() =
             field<MutablePackageFragmentProvider>()
             field<KotlinJsCheckerProvider>()
             field<DynamicTypesAllowed>()
+            field<LazyLocalClassifierAnalyzer>()
         }
 
 private fun generatorForTopDownAnalyzerForJvm() =
@@ -197,6 +219,7 @@ private fun generatorForLazyResolveWithJava() =
             field<JavaFlexibleTypeCapabilitiesProvider>()
             field<LazyResolveToken>()
             field<JavaLazyAnalyzerPostConstruct>()
+            field<LazyLocalClassifierAnalyzer>()
 
             field<KotlinJvmCheckerProvider>()
         }
@@ -261,9 +284,10 @@ private fun generatorForLazyResolve() =
             parameter<DynamicTypesSettings>()
 
             publicField<ResolveSession>()
-            field<ScopeProvider>()
 
+            field<ScopeProvider>()
             field<LazyResolveToken>()
+            field<LazyLocalClassifierAnalyzer>()
         }
 
 private fun DependencyInjectorGenerator.commonForResolveSessionBased() {
@@ -309,6 +333,8 @@ private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() {
     field<KotlinJvmCheckerProvider>()
 
     field<VirtualFileFinder>(init = GivenExpression(javaClass<VirtualFileFinder>().getName() + ".SERVICE.getInstance(project)"))
+
+    field<LazyLocalClassifierAnalyzer>()
 }
 
 

js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java

@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
 import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider;
 import org.jetbrains.kotlin.types.DynamicTypesAllowed;
+import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
 import org.jetbrains.kotlin.resolve.AnnotationResolver;
 import org.jetbrains.kotlin.resolve.calls.CallResolver;
 import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
@@ -38,7 +39,6 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
 import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
 import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
 import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
 import org.jetbrains.kotlin.resolve.DescriptorResolver;
@@ -87,6 +87,7 @@ public class InjectorForTopDownAnalyzerForJs {
     private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
     private final KotlinJsCheckerProvider kotlinJsCheckerProvider;
     private final DynamicTypesAllowed dynamicTypesAllowed;
+    private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
     private final ArgumentTypeResolver argumentTypeResolver;
@@ -95,7 +96,6 @@ public class InjectorForTopDownAnalyzerForJs {
     private final ControlStructureTypingUtils controlStructureTypingUtils;
     private final ExpressionTypingUtils expressionTypingUtils;
     private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
     private final ReflectionTypes reflectionTypes;
     private final CallExpressionResolver callExpressionResolver;
     private final DescriptorResolver descriptorResolver;
@@ -145,6 +145,7 @@ public class InjectorForTopDownAnalyzerForJs {
         this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
         this.kotlinJsCheckerProvider = KotlinJsCheckerProvider.INSTANCE$;
         this.dynamicTypesAllowed = new DynamicTypesAllowed();
+        this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -153,7 +154,6 @@ public class InjectorForTopDownAnalyzerForJs {
         this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
         this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
         this.reflectionTypes = new ReflectionTypes(module);
         this.callExpressionResolver = new CallExpressionResolver();
         this.descriptorResolver = new DescriptorResolver();
@@ -242,7 +242,7 @@ public class InjectorForTopDownAnalyzerForJs {
         expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
         expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
         expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
+        expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
         expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
         expressionTypingComponents.setReflectionTypes(reflectionTypes);