LazyTopDownAnalyzer does not depend on ResolveSession or ScopeProvider any more

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java

@@ -60,6 +60,7 @@ import org.jetbrains.kotlin.psi.JetScript;
 import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
 import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
 import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo;
 import org.jetbrains.kotlin.resolve.lazy.declarations.*;
@@ -99,6 +100,7 @@ public class ReplInterpreter {
 
     private final TopDownAnalysisContext topDownAnalysisContext;
     private final LazyTopDownAnalyzer topDownAnalyzer;
+    private final ResolveSession resolveSession;
     private final ScriptMutableDeclarationProviderFactory scriptDeclarationFactory;
 
     public ReplInterpreter(@NotNull Disposable disposable, @NotNull CompilerConfiguration configuration) {
@@ -141,6 +143,7 @@ public class ReplInterpreter {
 
         this.topDownAnalysisContext = new TopDownAnalysisContext(topDownAnalysisParameters);
         this.topDownAnalyzer = injector.getLazyTopDownAnalyzer();
+        this.resolveSession = injector.getResolveSession();
 
         module.initialize(new CompositePackageFragmentProvider(
                 Arrays.asList(
@@ -361,7 +364,7 @@ public class ReplInterpreter {
                 Collections.singletonList(psiFile));
 
         if (trace.get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, psiFile) == null) {
-            trace.record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, psiFile, topDownAnalyzer.getCodeAnalyzer().getPackageFragment(FqName.ROOT));
+            trace.record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, psiFile, resolveSession.getPackageFragment(FqName.ROOT));
         }
 
         boolean hasErrors = AnalyzerWithCompilerReport.reportDiagnostics(trace.getBindingContext().getDiagnostics(), messageCollector);

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

@@ -258,10 +258,13 @@ public class InjectorForReplWithJava {
 
         this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
         this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
-        this.lazyTopDownAnalyzer.setKotlinCodeAnalyzer(resolveSession);
+        this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
+        this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
+        this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
         this.lazyTopDownAnalyzer.setModuleDescriptor(module);
         this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
+        this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
         this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
 

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

@@ -257,10 +257,13 @@ public class InjectorForTopDownAnalyzerForJvm {
 
         this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
         this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
-        this.lazyTopDownAnalyzer.setKotlinCodeAnalyzer(resolveSession);
+        this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
+        this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
+        this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
         this.lazyTopDownAnalyzer.setModuleDescriptor(module);
         this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
+        this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
         this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
 

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

@@ -20,13 +20,17 @@ import com.intellij.openapi.project.Project;
 import org.jetbrains.kotlin.context.GlobalContext;
 import org.jetbrains.kotlin.storage.StorageManager;
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
+import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
 import org.jetbrains.kotlin.types.DynamicTypesSettings;
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
+import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
+import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
+import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
 import org.jetbrains.kotlin.resolve.BodyResolver;
 import org.jetbrains.kotlin.resolve.AnnotationResolver;
 import org.jetbrains.kotlin.resolve.calls.CallResolver;
@@ -71,13 +75,17 @@ public class InjectorForLazyBodyResolve {
     private final GlobalContext globalContext;
     private final StorageManager storageManager;
     private final KotlinCodeAnalyzer analyzer;
+    private final ModuleDescriptor moduleDescriptor;
+    private final ScopeProvider scopeProvider;
     private final BindingTrace bindingTrace;
     private final AdditionalCheckerProvider additionalCheckerProvider;
     private final DynamicTypesSettings dynamicTypesSettings;
-    private final ModuleDescriptor moduleDescriptor;
     private final KotlinBuiltIns kotlinBuiltIns;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
+    private final AdditionalFileScopeProvider additionalFileScopeProvider;
+    private final DeclarationScopeProviderImpl declarationScopeProvider;
+    private final LazyDeclarationResolver lazyDeclarationResolver;
     private final BodyResolver bodyResolver;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
@@ -124,13 +132,17 @@ public class InjectorForLazyBodyResolve {
         this.globalContext = globalContext;
         this.storageManager = globalContext.getStorageManager();
         this.analyzer = analyzer;
+        this.moduleDescriptor = analyzer.getModuleDescriptor();
+        this.scopeProvider = analyzer.getScopeProvider();
         this.bindingTrace = bindingTrace;
         this.additionalCheckerProvider = additionalCheckerProvider;
         this.dynamicTypesSettings = dynamicTypesSettings;
-        this.moduleDescriptor = analyzer.getModuleDescriptor();
         this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
         this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
         this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
+        this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
+        this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
+        this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
         this.bodyResolver = new BodyResolver();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
@@ -165,15 +177,26 @@ public class InjectorForLazyBodyResolve {
         this.overrideResolver = new OverrideResolver();
         this.varianceChecker = new VarianceChecker(bindingTrace);
 
+        scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
+        scopeProvider.setDeclarationScopeProvider(declarationScopeProvider);
+
         this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
         this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
-        this.lazyTopDownAnalyzer.setKotlinCodeAnalyzer(analyzer);
+        this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
+        this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
+        this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
         this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
         this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
+        this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(analyzer);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
         this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
 
+        declarationScopeProvider.setFileScopeProvider(scopeProvider);
+
+        lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
+        lazyDeclarationResolver.setTopLevelDescriptorProvider(analyzer);
+
         bodyResolver.setAnnotationResolver(annotationResolver);
         bodyResolver.setCallResolver(callResolver);
         bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);

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

@@ -196,10 +196,13 @@ public class InjectorForLazyTopDownAnalyzerBasic {
 
         this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
         this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
-        this.lazyTopDownAnalyzer.setKotlinCodeAnalyzer(resolveSession);
+        this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
+        this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
+        this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
         this.lazyTopDownAnalyzer.setModuleDescriptor(module);
         this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
+        this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
         this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.java

@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider;
-import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
+import org.jetbrains.kotlin.resolve.lazy.TopLevelDescriptorProvider;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor;
 import org.jetbrains.kotlin.resolve.resolveUtil.ResolveUtilPackage;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
@@ -435,14 +435,17 @@ public class DeclarationResolver {
         }
     }
 
-    public void checkRedeclarationsInPackages(@NotNull KotlinCodeAnalyzer resolveSession, @NotNull Multimap<FqName, JetElement> topLevelFqNames) {
+    public void checkRedeclarationsInPackages(
+            @NotNull TopLevelDescriptorProvider topLevelDescriptorProvider,
+            @NotNull Multimap<FqName, JetElement> topLevelFqNames
+    ) {
         for (Map.Entry<FqName, Collection<JetElement>> entry : topLevelFqNames.asMap().entrySet()) {
             FqName fqName = entry.getKey();
             Collection<JetElement> declarationsOrPackageDirectives = entry.getValue();
 
             if (fqName.isRoot()) continue;
 
-            Set<DeclarationDescriptor> descriptors = getTopLevelDescriptorsByFqName(resolveSession, fqName);
+            Set<DeclarationDescriptor> descriptors = getTopLevelDescriptorsByFqName(topLevelDescriptorProvider, fqName);
 
             if (descriptors.size() > 1) {
                 for (JetElement declarationOrPackageDirective : declarationsOrPackageDirectives) {
@@ -456,12 +459,15 @@ public class DeclarationResolver {
     }
 
     @NotNull
-    private static Set<DeclarationDescriptor> getTopLevelDescriptorsByFqName(@NotNull KotlinCodeAnalyzer resolveSession, @NotNull FqName fqName) {
+    private static Set<DeclarationDescriptor> getTopLevelDescriptorsByFqName(
+            @NotNull TopLevelDescriptorProvider topLevelDescriptorProvider,
+            @NotNull FqName fqName
+    ) {
         FqName parentFqName = fqName.parent();
 
         Set<DeclarationDescriptor> descriptors = new HashSet<DeclarationDescriptor>();
 
-        LazyPackageDescriptor parentFragment = resolveSession.getPackageFragment(parentFqName);
+        LazyPackageDescriptor parentFragment = topLevelDescriptorProvider.getPackageFragment(parentFqName);
         if (parentFragment != null) {
             // Filter out extension properties
             descriptors.addAll(
@@ -477,9 +483,9 @@ public class DeclarationResolver {
             );
         }
 
-        ContainerUtil.addIfNotNull(descriptors, resolveSession.getPackageFragment(fqName));
+        ContainerUtil.addIfNotNull(descriptors, topLevelDescriptorProvider.getPackageFragment(fqName));
 
-        descriptors.addAll(resolveSession.getTopLevelClassDescriptors(fqName));
+        descriptors.addAll(topLevelDescriptorProvider.getTopLevelClassDescriptors(fqName));
         return descriptors;
     }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.java

@@ -25,8 +25,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
+import org.jetbrains.kotlin.resolve.lazy.*;
-import org.jetbrains.kotlin.resolve.lazy.LazyFileScope;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor;
 import org.jetbrains.kotlin.resolve.resolveUtil.ResolveUtilPackage;
 import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
@@ -52,13 +51,34 @@ public class LazyTopDownAnalyzer {
 
     private ModuleDescriptor moduleDescriptor;
 
-    private KotlinCodeAnalyzer resolveSession;
+    private LazyDeclarationResolver lazyDeclarationResolver;
 
     private BodyResolver bodyResolver;
 
+    private TopLevelDescriptorProvider topLevelDescriptorProvider;
+
+    private FileScopeProvider fileScopeProvider;
+
+    private DeclarationScopeProvider declarationScopeProvider;
+
     @Inject
-    public void setKotlinCodeAnalyzer(@NotNull KotlinCodeAnalyzer kotlinCodeAnalyzer) {
+    public void setLazyDeclarationResolver(@NotNull LazyDeclarationResolver lazyDeclarationResolver) {
-        this.resolveSession = kotlinCodeAnalyzer;
+        this.lazyDeclarationResolver = lazyDeclarationResolver;
+    }
+
+    @Inject
+    public void setTopLevelDescriptorProvider(@NotNull TopLevelDescriptorProvider topLevelDescriptorProvider) {
+        this.topLevelDescriptorProvider = topLevelDescriptorProvider;
+    }
+
+    @Inject
+    public void setFileScopeProvider(@NotNull FileScopeProvider fileScopeProvider) {
+        this.fileScopeProvider = fileScopeProvider;
+    }
+
+    @Inject
+    public void setDeclarationScopeProvider(DeclarationScopeProviderImpl declarationScopeProvider) {
+        this.declarationScopeProvider = declarationScopeProvider;
     }
 
     @Inject
@@ -131,7 +151,7 @@ public class LazyTopDownAnalyzer {
                                 assert script != null;
 
                                 DescriptorResolver.registerFileInPackage(trace, file);
-                                c.getScripts().put(script, resolveSession.getScriptDescriptor(script));
+                                c.getScripts().put(script, topLevelDescriptorProvider.getScriptDescriptor(script));
                             }
                             else {
                                 JetPackageDirective packageDirective = file.getPackageDirective();
@@ -155,14 +175,14 @@ public class LazyTopDownAnalyzer {
 
                         @Override
                         public void visitImportDirective(@NotNull JetImportDirective importDirective) {
-                            LazyFileScope fileScope = resolveSession.getScopeProvider().getFileScope(
+                            LazyFileScope fileScope = (LazyFileScope) fileScopeProvider.getFileScope(
                                     importDirective.getContainingJetFile());
                             fileScope.forceResolveImport(importDirective);
                         }
 
                         private void visitClassOrObject(@NotNull JetClassOrObject classOrObject) {
                             ClassDescriptorWithResolutionScopes descriptor =
-                                    (ClassDescriptorWithResolutionScopes) resolveSession.getClassDescriptor(classOrObject);
+                                    (ClassDescriptorWithResolutionScopes) lazyDeclarationResolver.getClassDescriptor(classOrObject);
 
                             c.getDeclaredClasses().put(classOrObject, descriptor);
                             registerDeclarations(classOrObject.getDeclarations());
@@ -197,7 +217,7 @@ public class LazyTopDownAnalyzer {
                                 if (jetParameter.hasValOrVarNode()) {
                                     c.getPrimaryConstructorParameterProperties().put(
                                             jetParameter,
-                                            (PropertyDescriptor) resolveSession.resolveToDescriptor(jetParameter)
+                                            (PropertyDescriptor) lazyDeclarationResolver.resolveToDescriptor(jetParameter)
                                     );
                                 }
                             }
@@ -220,11 +240,11 @@ public class LazyTopDownAnalyzer {
 
                         @Override
                         public void visitAnonymousInitializer(@NotNull JetClassInitializer initializer) {
-                            registerScope(c, resolveSession, initializer);
+                            registerScope(c, initializer);
                             JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(initializer, JetClassOrObject.class);
                             c.getAnonymousInitializers().put(
                                     initializer,
-                                    (ClassDescriptorWithResolutionScopes) resolveSession.resolveToDescriptor(classOrObject)
+                                    (ClassDescriptorWithResolutionScopes) lazyDeclarationResolver.resolveToDescriptor(classOrObject)
                             );
                         }
 
@@ -251,13 +271,13 @@ public class LazyTopDownAnalyzer {
             );
         }
 
-        createFunctionDescriptors(c, resolveSession, functions);
+        createFunctionDescriptors(c, functions);
 
-        createPropertyDescriptors(c, resolveSession, topLevelFqNames, properties);
+        createPropertyDescriptors(c, topLevelFqNames, properties);
 
         resolveAllHeadersInClasses(c);
 
-        declarationResolver.checkRedeclarationsInPackages(resolveSession, topLevelFqNames);
+        declarationResolver.checkRedeclarationsInPackages(topLevelDescriptorProvider, topLevelFqNames);
         declarationResolver.checkRedeclarationsInInnerClassNames(c);
 
         ResolveUtilPackage.checkTraitRequirements(c.getDeclaredClasses(), trace);
@@ -266,7 +286,7 @@ public class LazyTopDownAnalyzer {
 
         varianceChecker.check(c);
 
-        declarationResolver.resolveAnnotationsOnFiles(c, resolveSession.getScopeProvider());
+        declarationResolver.resolveAnnotationsOnFiles(c, fileScopeProvider);
 
         overloadResolver.process(c);
 
@@ -281,47 +301,44 @@ public class LazyTopDownAnalyzer {
         }
     }
 
-    private static void createPropertyDescriptors(
+    private void createPropertyDescriptors(
             TopDownAnalysisContext c,
-            KotlinCodeAnalyzer resolveSession,
             Multimap<FqName, JetElement> topLevelFqNames,
             List<JetProperty> properties
     ) {
         for (JetProperty property : properties) {
-            PropertyDescriptor descriptor = (PropertyDescriptor) resolveSession.resolveToDescriptor(property);
+            PropertyDescriptor descriptor = (PropertyDescriptor) lazyDeclarationResolver.resolveToDescriptor(property);
 
             c.getProperties().put(property, descriptor);
             registerTopLevelFqName(topLevelFqNames, property, descriptor);
 
-            registerScope(c, resolveSession, property);
+            registerScope(c, property);
-            registerScope(c, resolveSession, property.getGetter());
+            registerScope(c, property.getGetter());
-            registerScope(c, resolveSession, property.getSetter());
+            registerScope(c, property.getSetter());
         }
     }
 
-    private static void createFunctionDescriptors(
+    private void createFunctionDescriptors(
             TopDownAnalysisContext c,
-            KotlinCodeAnalyzer resolveSession,
             List<JetNamedFunction> functions
     ) {
         for (JetNamedFunction function : functions) {
             c.getFunctions().put(
                     function,
-                    (SimpleFunctionDescriptor) resolveSession.resolveToDescriptor(function)
+                    (SimpleFunctionDescriptor) lazyDeclarationResolver.resolveToDescriptor(function)
             );
-            registerScope(c, resolveSession, function);
+            registerScope(c, function);
         }
     }
 
-    private static void registerScope(
+    private void registerScope(
             @NotNull TopDownAnalysisContext c,
-            @NotNull KotlinCodeAnalyzer resolveSession,
             @Nullable JetDeclaration declaration
     ) {
         if (declaration == null) return;
         c.registerDeclaringScope(
                 declaration,
-                resolveSession.getScopeProvider().getResolutionScopeForDeclaration(declaration)
+                declarationScopeProvider.getResolutionScopeForDeclaration(declaration)
         );
     }
 
@@ -337,11 +354,6 @@ public class LazyTopDownAnalyzer {
             }
         }
     }
-
-    @NotNull
-    public KotlinCodeAnalyzer getCodeAnalyzer() {
-        return resolveSession;
-    }
 }
 
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/KotlinCodeAnalyzer.java

@@ -34,10 +34,6 @@ public interface KotlinCodeAnalyzer extends TopLevelDescriptorProvider {
     @NotNull
     ModuleDescriptor getModuleDescriptor();
 
-    @NotNull
-    @ReadOnly
-    Collection<ClassDescriptor> getTopLevelClassDescriptors(@NotNull FqName fqName);
-
     @NotNull
     ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject);
 

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

@@ -113,7 +113,7 @@ private fun generatorForLazyBodyResolve() =
         generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyBodyResolve") {
             parameter<Project>()
             parameter<GlobalContext>(useAsContext = true)
-            parameter<KotlinCodeAnalyzer>(name = "analyzer")
+            parameter<KotlinCodeAnalyzer>(name = "analyzer", useAsContext = true)
             parameter<BindingTrace>()
             parameter<AdditionalCheckerProvider>()
             parameter<DynamicTypesSettings>()

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

@@ -196,10 +196,13 @@ public class InjectorForTopDownAnalyzerForJs {
 
         this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
         this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
-        this.lazyTopDownAnalyzer.setKotlinCodeAnalyzer(resolveSession);
+        this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
+        this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
+        this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
         this.lazyTopDownAnalyzer.setModuleDescriptor(module);
         this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
+        this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
         this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);