LTDA: Injector with lazy TDA for JVM target

- REPL is broken
 - Tests for Kotlin - Java - Kotlin hierarchy may fail

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

@@ -19,6 +19,7 @@ package org.jetbrains.jet.di;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.context.GlobalContext;
 import org.jetbrains.jet.storage.StorageManager;
+import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
@@ -56,7 +57,6 @@ 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.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -67,6 +67,7 @@ public class InjectorForLazyBodyResolve {
     private final Project project;
     private final GlobalContext globalContext;
     private final StorageManager storageManager;
+    private final KotlinCodeAnalyzer analyzer;
     private final BindingTrace bindingTrace;
     private final AdditionalCheckerProvider additionalCheckerProvider;
     private final ModuleDescriptor moduleDescriptor;
@@ -115,6 +116,7 @@ public class InjectorForLazyBodyResolve {
         this.project = project;
         this.globalContext = globalContext;
         this.storageManager = globalContext.getStorageManager();
+        this.analyzer = analyzer;
         this.bindingTrace = bindingTrace;
         this.additionalCheckerProvider = additionalCheckerProvider;
         this.moduleDescriptor = analyzer.getModuleDescriptor();
@@ -155,6 +157,7 @@ public class InjectorForLazyBodyResolve {
 
         this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
         this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
+        this.lazyTopDownAnalyzer.setKotlinCodeAnalyzer(analyzer);
         this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
         this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);

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

@@ -23,7 +23,6 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
-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.BodyResolver;
@@ -74,7 +73,6 @@ public class InjectorForTopDownAnalyzerBasic {
     private final ModuleDescriptor moduleDescriptor;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final TopDownAnalyzer topDownAnalyzer;
-    private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
     private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
     private final AdditionalCheckerProvider additionalCheckerProvider;
     private final BodyResolver bodyResolver;
@@ -126,7 +124,6 @@ public class InjectorForTopDownAnalyzerBasic {
         this.moduleDescriptor = moduleDescriptor;
         this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
         this.topDownAnalyzer = new TopDownAnalyzer();
-        this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
         this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor());
         this.additionalCheckerProvider = additionalCheckerProvider;
         this.bodyResolver = new BodyResolver();
@@ -167,7 +164,6 @@ public class InjectorForTopDownAnalyzerBasic {
         this.topDownAnalyzer.setAdditionalCheckerProvider(additionalCheckerProvider);
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
         this.topDownAnalyzer.setDeclarationResolver(declarationResolver);
-        this.topDownAnalyzer.setLazyTopDownAnalyzer(lazyTopDownAnalyzer);
         this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor);
         this.topDownAnalyzer.setOverloadResolver(overloadResolver);
         this.topDownAnalyzer.setOverrideResolver(overrideResolver);
@@ -176,13 +172,6 @@ public class InjectorForTopDownAnalyzerBasic {
         this.topDownAnalyzer.setTrace(bindingTrace);
         this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
 
-        this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
-        this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
-        this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
-        this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
-        this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
-        this.lazyTopDownAnalyzer.setTrace(bindingTrace);
-
         bodyResolver.setAnnotationResolver(annotationResolver);
         bodyResolver.setCallResolver(callResolver);
         bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
@@ -292,8 +281,4 @@ public class InjectorForTopDownAnalyzerBasic {
         return this.topDownAnalyzer;
     }
 
-    public LazyTopDownAnalyzer getLazyTopDownAnalyzer() {
-        return this.lazyTopDownAnalyzer;
-    }
-
 }

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

@@ -77,6 +77,7 @@ public class LazyTopDownAnalyzer {
     @NotNull
     private BodyResolver bodyResolver = null;
 
+    @Inject
     public void setKotlinCodeAnalyzer(@NotNull KotlinCodeAnalyzer kotlinCodeAnalyzer) {
         this.resolveSession = kotlinCodeAnalyzer;
     }
@@ -113,36 +114,23 @@ public class LazyTopDownAnalyzer {
 
     @NotNull
     public TopDownAnalysisContext analyzeFiles(
-            @NotNull Project project,
             @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
             @NotNull Collection<JetFile> files,
-            @NotNull List<? extends PackageFragmentProvider> additionalProviders,
-            AdditionalCheckerProvider additionalCheckerProvider
+            @NotNull List<? extends PackageFragmentProvider> additionalProviders
     ) {
-        TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters);
+        PackageFragmentProvider provider;
+        if (additionalProviders.isEmpty()) {
+            provider = resolveSession.getPackageFragmentProvider();
+        }
+        else {
+            provider = new CompositePackageFragmentProvider(KotlinPackage.plus(
+                    Arrays.asList(resolveSession.getPackageFragmentProvider()),
+                    additionalProviders));
+        }
 
-        ResolveSession resolveSession = new InjectorForLazyResolve(
-                project,
-                new GlobalContextImpl((LockBasedStorageManager) c.getStorageManager(), c.getExceptionTracker()), // TODO
-                (ModuleDescriptorImpl) moduleDescriptor, // TODO
-                new FileBasedDeclarationProviderFactory(c.getStorageManager(), files),
-                trace,
-                additionalCheckerProvider
-        ).getResolveSession();
+        ((ModuleDescriptorImpl) resolveSession.getModuleDescriptor()).initialize(provider);
 
-        CompositePackageFragmentProvider provider =
-                new CompositePackageFragmentProvider(KotlinPackage.plus(Arrays.asList(resolveSession.getPackageFragmentProvider()), additionalProviders));
-
-        ((ModuleDescriptorImpl) moduleDescriptor).initialize(provider);
-
-        setKotlinCodeAnalyzer(resolveSession);
-
-        analyzeDeclarations(
-                c.getTopDownAnalysisParameters(),
-                files
-        );
-
-        return c;
+        return analyzeDeclarations(topDownAnalysisParameters, files);
     }
 
     @NotNull

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

@@ -58,9 +58,6 @@ public class TopDownAnalyzer {
     @NotNull
     private Project project;
 
-    @NotNull
-    private LazyTopDownAnalyzer lazyTopDownAnalyzer;
-
     @Inject
     public void setTrace(@NotNull BindingTrace trace) {
         this.trace = trace;
@@ -106,11 +103,6 @@ public class TopDownAnalyzer {
         this.project = project;
     }
 
-    @Inject
-    public void setLazyTopDownAnalyzer(@NotNull LazyTopDownAnalyzer lazyTopDownAnalyzer) {
-        this.lazyTopDownAnalyzer = lazyTopDownAnalyzer;
-    }
-
     @Inject
     public void setAdditionalCheckerProvider(@NotNull AdditionalCheckerProvider additionalCheckerProvider) {
         this.additionalCheckerProvider = additionalCheckerProvider;
@@ -185,10 +177,7 @@ public class TopDownAnalyzer {
             @NotNull Collection<JetFile> files,
             @NotNull List<PackageFragmentProvider> additionalProviders
     ) {
-        if (topDownAnalysisParameters.isLazy()) {
-            return lazyTopDownAnalyzer.analyzeFiles(
-                    project, topDownAnalysisParameters, files, additionalProviders, additionalCheckerProvider);
-        }
+        assert !topDownAnalysisParameters.isLazy() : "Lazy resolve must be disabled for this method";
 
         TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters);
         CompositePackageFragmentProvider provider =
@@ -208,7 +197,6 @@ public class TopDownAnalyzer {
     public MutablePackageFragmentProvider getPackageFragmentProvider() {
         return packageFragmentProvider;
     }
-
 }
 
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java

@@ -19,10 +19,7 @@ package org.jetbrains.jet.lang.resolve.lazy;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.ReadOnly;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
+import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetScript;
@@ -64,4 +61,7 @@ public interface KotlinCodeAnalyzer {
      * Use this method when laziness plays against you, e.g. when lazy descriptors may be accessed in a multi-threaded setting
      */
     void forceResolveAll();
+
+    @NotNull
+    PackageFragmentProvider getPackageFragmentProvider();
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java

@@ -178,6 +178,7 @@ public class ResolveSession implements KotlinCodeAnalyzer {
         });
     }
 
+    @Override
     @NotNull
     public PackageFragmentProvider getPackageFragmentProvider() {
         return packageFragmentProvider;