LTDA: Add the temp ability to build with eager resolve

Compiler should be executed with -Dlazy.tda=false parameter

REPL won't work with this option

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java

@@ -258,7 +258,7 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport
         public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
             V value = super.get(slice, key);
 
-            if (value == null) {
+            if (value == null && TopDownAnalysisParameters.LAZY) {
                 if (BindingContext.FUNCTION == slice || BindingContext.VARIABLE == slice) {
                     if (key instanceof JetDeclaration) {
                         JetDeclaration jetDeclaration = (JetDeclaration) key;

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

@@ -38,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationRe
 import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaPropertyInitializerEvaluatorImpl;
 import org.jetbrains.jet.lang.resolve.java.sam.SamConversionResolverImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSourceElementFactoryImpl;
+import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.SingleModuleClassResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaLazyAnalyzerPostConstruct;
 import org.jetbrains.jet.lang.resolve.java.JavaFlexibleTypeCapabilitiesProvider;
@@ -73,6 +74,9 @@ import org.jetbrains.jet.lang.resolve.ImportsResolver;
 import org.jetbrains.jet.lang.psi.JetImportsFactory;
 import org.jetbrains.jet.lang.resolve.OverloadResolver;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
+import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
+import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
+import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
@@ -108,6 +112,7 @@ public class InjectorForTopDownAnalyzerForJvm {
     private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator;
     private final SamConversionResolverImpl samConversionResolver;
     private final JavaSourceElementFactoryImpl javaSourceElementFactory;
+    private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
     private final SingleModuleClassResolver singleModuleClassResolver;
     private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
     private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
@@ -143,6 +148,9 @@ public class InjectorForTopDownAnalyzerForJvm {
     private final JetImportsFactory jetImportsFactory;
     private final OverloadResolver overloadResolver;
     private final OverrideResolver overrideResolver;
+    private final TopDownAnalyzer topDownAnalyzer;
+    private final TypeHierarchyResolver typeHierarchyResolver;
+    private final ScriptHeaderResolver scriptHeaderResolver;
     private final ScopeProvider scopeProvider;
     private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
     private final GlobalJavaResolverContext globalJavaResolverContext;
@@ -186,6 +194,7 @@ public class InjectorForTopDownAnalyzerForJvm {
         this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
         this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(module, storageManager, virtualFileFinder, traceBasedErrorReporter);
         this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, module, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
+        this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(module);
         this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
         this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
         this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider.INSTANCE$;
@@ -220,6 +229,9 @@ public class InjectorForTopDownAnalyzerForJvm {
         this.jetImportsFactory = new JetImportsFactory();
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
+        this.topDownAnalyzer = new TopDownAnalyzer();
+        this.typeHierarchyResolver = new TypeHierarchyResolver();
+        this.scriptHeaderResolver = new ScriptHeaderResolver();
         this.scopeProvider = new ScopeProvider(getResolveSession());
 
         this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
@@ -228,6 +240,7 @@ public class InjectorForTopDownAnalyzerForJvm {
         this.lazyTopDownAnalyzer.setModuleDescriptor(module);
         this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
+        this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
 
         this.resolveSession.setAnnotationResolve(annotationResolver);
@@ -345,6 +358,23 @@ public class InjectorForTopDownAnalyzerForJvm {
 
         overrideResolver.setTrace(bindingTrace);
 
+        topDownAnalyzer.setBodyResolver(bodyResolver);
+        topDownAnalyzer.setDeclarationResolver(declarationResolver);
+        topDownAnalyzer.setModuleDescriptor(module);
+        topDownAnalyzer.setOverloadResolver(overloadResolver);
+        topDownAnalyzer.setOverrideResolver(overrideResolver);
+        topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
+
+        typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
+        typeHierarchyResolver.setImportsResolver(importsResolver);
+        typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
+        typeHierarchyResolver.setTrace(bindingTrace);
+
+        scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        scriptHeaderResolver.setTrace(bindingTrace);
+
         deserializedDescriptorResolver.setComponents(deserializationComponentsForJava);
 
         javaClassFinder.initialize();

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

@@ -57,6 +57,10 @@ import org.jetbrains.jet.lang.resolve.ImportsResolver;
 import org.jetbrains.jet.lang.psi.JetImportsFactory;
 import org.jetbrains.jet.lang.resolve.OverloadResolver;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
+import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
+import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
+import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
+import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -105,6 +109,10 @@ public class InjectorForLazyBodyResolve {
     private final JetImportsFactory jetImportsFactory;
     private final OverloadResolver overloadResolver;
     private final OverrideResolver overrideResolver;
+    private final TopDownAnalyzer topDownAnalyzer;
+    private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
+    private final TypeHierarchyResolver typeHierarchyResolver;
+    private final ScriptHeaderResolver scriptHeaderResolver;
 
     public InjectorForLazyBodyResolve(
         @NotNull Project project,
@@ -154,6 +162,10 @@ public class InjectorForLazyBodyResolve {
         this.jetImportsFactory = new JetImportsFactory();
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
+        this.topDownAnalyzer = new TopDownAnalyzer();
+        this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(moduleDescriptor);
+        this.typeHierarchyResolver = new TypeHierarchyResolver();
+        this.scriptHeaderResolver = new ScriptHeaderResolver();
 
         this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
         this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
@@ -161,6 +173,7 @@ public class InjectorForLazyBodyResolve {
         this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
         this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
+        this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
 
         bodyResolver.setAnnotationResolver(annotationResolver);
@@ -249,6 +262,23 @@ public class InjectorForLazyBodyResolve {
 
         overrideResolver.setTrace(bindingTrace);
 
+        topDownAnalyzer.setBodyResolver(bodyResolver);
+        topDownAnalyzer.setDeclarationResolver(declarationResolver);
+        topDownAnalyzer.setModuleDescriptor(moduleDescriptor);
+        topDownAnalyzer.setOverloadResolver(overloadResolver);
+        topDownAnalyzer.setOverrideResolver(overrideResolver);
+        topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
+
+        typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
+        typeHierarchyResolver.setImportsResolver(importsResolver);
+        typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
+        typeHierarchyResolver.setTrace(bindingTrace);
+
+        scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        scriptHeaderResolver.setTrace(bindingTrace);
+
     }
 
     @PreDestroy

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

@@ -59,6 +59,10 @@ import org.jetbrains.jet.lang.resolve.DeclarationResolver;
 import org.jetbrains.jet.lang.resolve.ImportsResolver;
 import org.jetbrains.jet.lang.resolve.OverloadResolver;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
+import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
+import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
+import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
+import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -109,6 +113,10 @@ public class InjectorForLazyTopDownAnalyzerBasic {
     private final ImportsResolver importsResolver;
     private final OverloadResolver overloadResolver;
     private final OverrideResolver overrideResolver;
+    private final TopDownAnalyzer topDownAnalyzer;
+    private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
+    private final TypeHierarchyResolver typeHierarchyResolver;
+    private final ScriptHeaderResolver scriptHeaderResolver;
 
     public InjectorForLazyTopDownAnalyzerBasic(
         @NotNull Project project,
@@ -160,6 +168,10 @@ public class InjectorForLazyTopDownAnalyzerBasic {
         this.importsResolver = new ImportsResolver();
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
+        this.topDownAnalyzer = new TopDownAnalyzer();
+        this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(moduleDescriptor);
+        this.typeHierarchyResolver = new TypeHierarchyResolver();
+        this.scriptHeaderResolver = new ScriptHeaderResolver();
 
         this.resolveSession.setAnnotationResolve(annotationResolver);
         this.resolveSession.setDescriptorResolver(descriptorResolver);
@@ -175,6 +187,7 @@ public class InjectorForLazyTopDownAnalyzerBasic {
         this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
         this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
+        this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
 
         annotationResolver.setCallResolver(callResolver);
@@ -263,6 +276,23 @@ public class InjectorForLazyTopDownAnalyzerBasic {
 
         overrideResolver.setTrace(bindingTrace);
 
+        topDownAnalyzer.setBodyResolver(bodyResolver);
+        topDownAnalyzer.setDeclarationResolver(declarationResolver);
+        topDownAnalyzer.setModuleDescriptor(moduleDescriptor);
+        topDownAnalyzer.setOverloadResolver(overloadResolver);
+        topDownAnalyzer.setOverrideResolver(overrideResolver);
+        topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
+
+        typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
+        typeHierarchyResolver.setImportsResolver(importsResolver);
+        typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
+        typeHierarchyResolver.setTrace(bindingTrace);
+
+        scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        scriptHeaderResolver.setTrace(bindingTrace);
+
     }
 
     @PreDestroy

compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java

@@ -161,15 +161,12 @@ public class InjectorForTopDownAnalyzerBasic {
         this.typeHierarchyResolver = new TypeHierarchyResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
 
-        this.topDownAnalyzer.setAdditionalCheckerProvider(additionalCheckerProvider);
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
         this.topDownAnalyzer.setDeclarationResolver(declarationResolver);
         this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor);
         this.topDownAnalyzer.setOverloadResolver(overloadResolver);
         this.topDownAnalyzer.setOverrideResolver(overrideResolver);
         this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
-        this.topDownAnalyzer.setProject(project);
-        this.topDownAnalyzer.setTrace(bindingTrace);
         this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
 
         bodyResolver.setAnnotationResolver(annotationResolver);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java

@@ -18,7 +18,6 @@ package org.jetbrains.jet.lang.resolve;
 
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.Multimap;
-import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.util.PsiTreeUtil;
 import kotlin.KotlinPackage;
@@ -72,6 +71,10 @@ public class LazyTopDownAnalyzer {
     @NotNull
     private BodyResolver bodyResolver = null;
 
+    @SuppressWarnings("ConstantConditions")
+    @NotNull
+    private TopDownAnalyzer topDownAnalyzer = null;
+
     @Inject
     public void setKotlinCodeAnalyzer(@NotNull KotlinCodeAnalyzer kotlinCodeAnalyzer) {
         this.resolveSession = kotlinCodeAnalyzer;
@@ -107,12 +110,23 @@ public class LazyTopDownAnalyzer {
         this.bodyResolver = bodyResolver;
     }
 
+    @Inject
+    public void setTopDownAnalyzer(@NotNull TopDownAnalyzer topDownAnalyzer) {
+        this.topDownAnalyzer = topDownAnalyzer;
+    }
+
     @NotNull
     public TopDownAnalysisContext analyzeFiles(
             @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
             @NotNull Collection<JetFile> files,
             @NotNull List<? extends PackageFragmentProvider> additionalProviders
     ) {
+        if (!topDownAnalysisParameters.isLazy()) {
+            return topDownAnalyzer.analyzeFiles(
+                    topDownAnalysisParameters, files,
+                    additionalProviders.toArray(new PackageFragmentProvider[additionalProviders.size()]));
+        }
+        
         PackageFragmentProvider provider;
         if (additionalProviders.isEmpty()) {
             provider = resolveSession.getPackageFragmentProvider();

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java

@@ -28,7 +28,8 @@ import org.jetbrains.jet.storage.StorageManager;
  * Various junk that cannot be placed into context (yet).
  */
 public class TopDownAnalysisParameters extends LazinessToken implements GlobalContext {
-    private static boolean LAZY;
+    @Deprecated
+    public static final boolean LAZY;
 
     static {
         LAZY = !"false".equals(System.getProperty("lazy.tda"));

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java

@@ -17,12 +17,9 @@
 package org.jetbrains.jet.lang.resolve;
 
 import com.google.common.collect.Sets;
-import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
-import kotlin.Function1;
 import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptorWithResolutionScopes;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
@@ -33,34 +30,36 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 
 import javax.inject.Inject;
-import java.util.*;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
 
+@Deprecated
 public class TopDownAnalyzer {
 
-    @NotNull
+    @SuppressWarnings("NullableProblems") @NotNull
-    private BindingTrace trace;
-    @NotNull
     private DeclarationResolver declarationResolver;
-    @NotNull
-    private TypeHierarchyResolver typeHierarchyResolver;
-    @NotNull
-    private OverrideResolver overrideResolver;
-    @NotNull
-    private OverloadResolver overloadResolver;
-    @NotNull
-    private ModuleDescriptor moduleDescriptor;
-    @NotNull
-    private MutablePackageFragmentProvider packageFragmentProvider;
-    @NotNull
-    private BodyResolver bodyResolver;
-    @NotNull
-    private AdditionalCheckerProvider additionalCheckerProvider;
-    @NotNull
-    private Project project;
 
-    @Inject
+    @SuppressWarnings("NullableProblems") @NotNull
-    public void setTrace(@NotNull BindingTrace trace) {
+    private TypeHierarchyResolver typeHierarchyResolver;
-        this.trace = trace;
+
+    @SuppressWarnings("NullableProblems") @NotNull
+    private OverrideResolver overrideResolver;
+
+    @SuppressWarnings("NullableProblems") @NotNull
+    private OverloadResolver overloadResolver;
+
+    @SuppressWarnings("NullableProblems") @NotNull
+    private ModuleDescriptor moduleDescriptor;
+
+    @SuppressWarnings("NullableProblems") @NotNull
+    private MutablePackageFragmentProvider packageFragmentProvider;
+
+    @SuppressWarnings("NullableProblems") @NotNull
+    private BodyResolver bodyResolver;
+
+    public TopDownAnalyzer() {
     }
 
     @Inject
@@ -98,16 +97,6 @@ public class TopDownAnalyzer {
         this.bodyResolver = bodyResolver;
     }
 
-    @Inject
-    public void setProject(@NotNull Project project) {
-        this.project = project;
-    }
-
-    @Inject
-    public void setAdditionalCheckerProvider(@NotNull AdditionalCheckerProvider additionalCheckerProvider) {
-        this.additionalCheckerProvider = additionalCheckerProvider;
-    }
-
     public void doProcess(
             @NotNull TopDownAnalysisContext c,
             @NotNull JetScope outerScope,
@@ -129,19 +118,10 @@ public class TopDownAnalyzer {
         }
 
         c.debug("Exit");
+        //noinspection UseOfSystemOutOrSystemErr
         c.printDebugOutput(System.out);
     }
 
-    private static Collection<JetFile> getFiles(Collection<? extends PsiElement> declarations) {
-        return new LinkedHashSet<JetFile>(KotlinPackage.map(declarations, new Function1<PsiElement, JetFile>() {
-            @Nullable
-            @Override
-            public JetFile invoke(PsiElement element) {
-                return (JetFile) element.getContainingFile();
-            }
-        }));
-    }
-
     private void lockScopes(@NotNull TopDownAnalysisContext c) {
         for (ClassDescriptorWithResolutionScopes mutableClassDescriptor : c.getDeclaredClasses().values()) {
             ((MutableClassDescriptor) mutableClassDescriptor).lockScopes();
@@ -177,6 +157,7 @@ public class TopDownAnalyzer {
             @NotNull Collection<JetFile> files,
             @NotNull List<PackageFragmentProvider> additionalProviders
     ) {
+        //noinspection deprecation
         assert !topDownAnalysisParameters.isLazy() : "Lazy resolve must be disabled for this method";
 
         TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters);

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

@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer;
+import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
@@ -59,6 +60,9 @@ import org.jetbrains.jet.lang.resolve.DeclarationResolver;
 import org.jetbrains.jet.lang.resolve.ImportsResolver;
 import org.jetbrains.jet.lang.resolve.OverloadResolver;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
+import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
+import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
+import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -75,6 +79,7 @@ public class InjectorForTopDownAnalyzerForJs {
     private final DeclarationProviderFactory declarationProviderFactory;
     private final ResolveSession resolveSession;
     private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
+    private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
     private final AdditionalCheckerProvider additionalCheckerProvider;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
@@ -109,6 +114,9 @@ public class InjectorForTopDownAnalyzerForJs {
     private final ImportsResolver importsResolver;
     private final OverloadResolver overloadResolver;
     private final OverrideResolver overrideResolver;
+    private final TopDownAnalyzer topDownAnalyzer;
+    private final TypeHierarchyResolver typeHierarchyResolver;
+    private final ScriptHeaderResolver scriptHeaderResolver;
 
     public InjectorForTopDownAnalyzerForJs(
         @NotNull Project project,
@@ -126,6 +134,7 @@ public class InjectorForTopDownAnalyzerForJs {
         this.declarationProviderFactory = declarationProviderFactory;
         this.resolveSession = new ResolveSession(project, globalContext, module, declarationProviderFactory, bindingTrace);
         this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
+        this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(module);
         this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider.Empty.INSTANCE$;
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
@@ -160,6 +169,9 @@ public class InjectorForTopDownAnalyzerForJs {
         this.importsResolver = new ImportsResolver();
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
+        this.topDownAnalyzer = new TopDownAnalyzer();
+        this.typeHierarchyResolver = new TypeHierarchyResolver();
+        this.scriptHeaderResolver = new ScriptHeaderResolver();
 
         this.resolveSession.setAnnotationResolve(annotationResolver);
         this.resolveSession.setDescriptorResolver(descriptorResolver);
@@ -175,6 +187,7 @@ public class InjectorForTopDownAnalyzerForJs {
         this.lazyTopDownAnalyzer.setModuleDescriptor(module);
         this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
+        this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
 
         annotationResolver.setCallResolver(callResolver);
@@ -263,6 +276,23 @@ public class InjectorForTopDownAnalyzerForJs {
 
         overrideResolver.setTrace(bindingTrace);
 
+        topDownAnalyzer.setBodyResolver(bodyResolver);
+        topDownAnalyzer.setDeclarationResolver(declarationResolver);
+        topDownAnalyzer.setModuleDescriptor(module);
+        topDownAnalyzer.setOverloadResolver(overloadResolver);
+        topDownAnalyzer.setOverrideResolver(overrideResolver);
+        topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
+
+        typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
+        typeHierarchyResolver.setImportsResolver(importsResolver);
+        typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
+        typeHierarchyResolver.setTrace(bindingTrace);
+
+        scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        scriptHeaderResolver.setTrace(bindingTrace);
+
     }
 
     @PreDestroy