Replace ModuleDescriptorImpl implementation

Change the way modules are configured: Add dependencies on other modules instead of adding additional package fragment providers Refactor related code Drop DependencyKind Hide common new module creation in CliLightClassGenerationSupport
2014-07-30 16:45:02 +04:00
parent 145aa5a276
commit 8496c535aa
30 changed files with 326 additions and 297 deletions
@@ -42,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.util.slicedmap.WritableSlice;

 import java.util.Collection;
@@ -81,9 +82,19 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport
    }

    @NotNull
-    public ModuleDescriptorImpl getModule() {
+    public ModuleDescriptorImpl newModule() {
+        assert this.module == null : "module already configured: " + module;
+        module = AnalyzerFacadeForJVM.createJavaModule("<shared-module-for-cli-light-classes>");
+        module.addDependencyOnModule(module);
+        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
+        module.seal();
+        return module;
+    }
+
+    @NotNull
+    private ModuleDescriptorImpl getModule() {
        if (module == null) {
-            module = AnalyzerFacadeForJVM.createJavaModule("<module>");
+           return newModule();
        }
        return module;
    }
@@ -59,6 +59,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalCache;
 import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalCacheProvider;
 import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalPackage;
 import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.plugin.MainFunctionDetector;
 import org.jetbrains.jet.utils.KotlinPaths;

@@ -291,8 +292,7 @@ public class KotlinToJVMBytecodeCompiler {
                    public AnalyzeExhaust invoke() {
                        CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject());
                        BindingTrace sharedTrace = support.getTrace();
-                        ModuleDescriptorImpl sharedModule = support.getModule();
-
+                        ModuleDescriptorImpl sharedModule = support.newModule();
                        IncrementalCacheProvider incrementalCacheProvider = IncrementalCacheProvider.OBJECT$.getInstance();
                        File incrementalCacheBaseDir = environment.getConfiguration().get(JVMConfigurationKeys.INCREMENTAL_CACHE_BASE_DIR);
                        final IncrementalCache incrementalCache;
@@ -43,6 +43,7 @@ import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.CompositePackageFragmentProvider;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.PackageLikeBuilderDummy;
 import org.jetbrains.jet.lang.parsing.JetParserDefinition;
@@ -70,12 +71,12 @@ import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;

 import static org.jetbrains.jet.codegen.AsmUtil.asmTypeByFqNameWithoutInnerClasses;
 import static org.jetbrains.jet.codegen.binding.CodegenBinding.registerClassNameForScript;
-import static org.jetbrains.jet.lang.descriptors.DependencyKind.*;

 public class ReplInterpreter {

@@ -109,9 +110,14 @@ public class ReplInterpreter {
        );
        injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module);
        topDownAnalysisContext = new TopDownAnalysisContext(topDownAnalysisParameters);
-        module.addFragmentProvider(SOURCES, injector.getTopDownAnalyzer().getPackageFragmentProvider());
-        module.addFragmentProvider(BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
-        module.addFragmentProvider(BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
+        module.initialize(new CompositePackageFragmentProvider(
+                Arrays.asList(injector.getTopDownAnalyzer().getPackageFragmentProvider(),
+                              injector.getJavaDescriptorResolver().getPackageFragmentProvider()
+                )
+        ));
+        module.addDependencyOnModule(module);
+        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
+        module.seal();

        List<URL> classpath = Lists.newArrayList();

@@ -18,14 +18,25 @@ package org.jetbrains.jet.di;

 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.DependencyKind;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;

 public class InjectorForJavaDescriptorResolverUtil {
    @NotNull
-    public static InjectorForJavaDescriptorResolver create(@NotNull Project project, @NotNull BindingTrace bindingTrace) {
+    public static InjectorForJavaDescriptorResolver create(
+            @NotNull Project project,
+            @NotNull BindingTrace bindingTrace,
+            boolean dependendOnBuitlins
+    ) {
        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, bindingTrace);
-        injector.getModule().addFragmentProvider(DependencyKind.BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
+        ModuleDescriptorImpl module = injector.getModule();
+        module.initialize(injector.getJavaDescriptorResolver().getPackageFragmentProvider());
+        module.addDependencyOnModule(module);
+        if (dependendOnBuitlins) {
+            module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
+        }
+        module.seal();
        return injector;
    }
 }
@@ -32,7 +32,8 @@ import org.jetbrains.jet.context.GlobalContext;
 import org.jetbrains.jet.context.GlobalContextImpl;
 import org.jetbrains.jet.di.InjectorForLazyResolveWithJava;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
-import org.jetbrains.jet.lang.descriptors.DependencyKind;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
+import org.jetbrains.jet.lang.descriptors.impl.CompositePackageFragmentProvider;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
@@ -41,7 +42,6 @@ import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalCache;
-import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalCacheProvider;
 import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
@@ -49,10 +49,7 @@ import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFacto
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;

-import java.io.File;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;

 public enum AnalyzerFacadeForJVM implements AnalyzerFacade {

@@ -128,14 +125,19 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
                declarationProviderFactory,
                trace);

-        resolveWithJava.getModule().addFragmentProvider(
-                DependencyKind.BINARIES, resolveWithJava.getJavaDescriptorResolver().getPackageFragmentProvider());
+        ModuleDescriptorImpl module = resolveWithJava.getModule();
+        module.initialize(
+                new CompositePackageFragmentProvider(
+                        Arrays.asList(
+                                resolveWithJava.getResolveSession().getPackageFragmentProvider(),
+                                resolveWithJava.getJavaDescriptorResolver().getPackageFragmentProvider()
+                        )));

+        module.addDependencyOnModule(module);
        if (addBuiltIns) {
-            resolveWithJava.getModule().addFragmentProvider(
-                    DependencyKind.BUILT_INS,
-                    KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
+            module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
        }
+        module.seal();
        return new JvmSetup(resolveWithJava.getResolveSession(), resolveWithJava.getJavaDescriptorResolver());
    }

@@ -160,12 +162,11 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {

        InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module);
        try {
-            module.addFragmentProvider(DependencyKind.BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
+            List<PackageFragmentProvider> additionalProviders = new ArrayList<PackageFragmentProvider>();

            if (incrementalCache != null && moduleIds != null) {
                for (String moduleId : moduleIds) {
-                    module.addFragmentProvider(
-                            DependencyKind.SOURCES,
+                    additionalProviders.add(
                            new IncrementalPackageFragmentProvider(
                                    files, module, globalContext.getStorageManager(), injector.getDeserializationGlobalContextForJava(),
                                    incrementalCache, moduleId, injector.getJavaDescriptorResolver()
@@ -173,8 +174,9 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
                    );
                }
            }
+            additionalProviders.add(injector.getJavaDescriptorResolver().getPackageFragmentProvider());

-            injector.getTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, files);
+            injector.getTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, files, additionalProviders);
            return AnalyzeExhaust.success(trace.getBindingContext(), module);
        }
        finally {
@@ -38,14 +38,10 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext;
-import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.storage.LockBasedStorageManager;

 import javax.inject.Inject;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.LinkedHashSet;
-import java.util.Set;
+import java.util.*;

 public class TopDownAnalyzer {

@@ -253,16 +249,24 @@ public class TopDownAnalyzer {
    @NotNull
    public TopDownAnalysisContext analyzeFiles(
            @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
-            @NotNull Collection<JetFile> files
+            @NotNull Collection<JetFile> files,
+            @NotNull PackageFragmentProvider... additionalProviders
    ) {
-        ((ModuleDescriptorImpl) moduleDescriptor).addFragmentProvider(DependencyKind.SOURCES, packageFragmentProvider);
+        return analyzeFiles(topDownAnalysisParameters, files, Arrays.asList(additionalProviders));
+    }

-        // "depend on" builtins module
-        ((ModuleDescriptorImpl) moduleDescriptor).addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
+    @NotNull
+    public TopDownAnalysisContext analyzeFiles(
+            @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
+            @NotNull Collection<JetFile> files,
+            @NotNull List<PackageFragmentProvider> additionalProviders
+    ) {
+        CompositePackageFragmentProvider provider =
+                new CompositePackageFragmentProvider(KotlinPackage.plus(Arrays.asList(packageFragmentProvider), additionalProviders));
+        ((ModuleDescriptorImpl) moduleDescriptor).initialize(provider);

        // dummy builder is used because "root" is module descriptor,
        // packages added to module explicitly in
-
        TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters);
        doProcess(c, JetModuleUtil.getSubpackagesOfRootScope(moduleDescriptor), new PackageLikeBuilderDummy(), files);
        return c;
@@ -150,9 +150,6 @@ public class ResolveSession implements KotlinCodeAnalyzer {
            }
        };

-        // TODO: parameter modification
-        rootDescriptor.addFragmentProvider(DependencyKind.SOURCES, packageFragmentProvider);
-
        this.scriptDescriptors = storageManager.createMemoizedFunction(
                new Function1<JetScript, LazyScriptDescriptor>() {
                    @Override
@@ -50,7 +50,6 @@ import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.jet.config.CommonConfigurationKeys;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
-import org.jetbrains.jet.lang.descriptors.DependencyKind;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
@@ -845,7 +844,9 @@ public class JetTestUtils {
    public static MutablePackageFragmentDescriptor createTestPackageFragment(@NotNull Name testPackageName, @NotNull String moduleName) {
        ModuleDescriptorImpl module = AnalyzerFacadeForJVM.createJavaModule(moduleName);
        MutablePackageFragmentProvider provider = new MutablePackageFragmentProvider(module);
-        module.addFragmentProvider(DependencyKind.SOURCES, provider);
+        module.initialize(provider);
+        module.addDependencyOnModule(module);
+        module.seal();
        return provider.getOrCreateFragment(FqName.topLevel(testPackageName));
    }

@@ -26,7 +26,6 @@ import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport;
-import org.jetbrains.jet.lang.descriptors.DependencyKind;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.diagnostics.*;
 import org.jetbrains.jet.lang.psi.Call;
@@ -37,6 +36,7 @@ import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;

 import java.io.File;
 import java.util.*;
@@ -78,6 +78,14 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
                                           : supportTrace;
            moduleBindings.put(testModule, moduleTrace.getBindingContext());

+            if (module == null) {
+                module = support.newModule();
+            }
+            else {
+                module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
+                module.seal();
+            }
+
            // New JavaDescriptorResolver is created for each module, which is good because it emulates different Java libraries for each module,
            // albeit with same class names
            AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
@@ -85,7 +93,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
                    jetFiles,
                    moduleTrace,
                    Predicates.<PsiFile>alwaysTrue(),
-                    module == null ? support.getModule() : module,
+                    module,
                    null,
                    null
            );
@@ -119,9 +127,9 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
            if (testModule == null) continue;

            ModuleDescriptorImpl module = modules.get(testModule);
+            module.addDependencyOnModule(module);
            for (TestModule dependency : testModule.getDependencies()) {
-                // Adding other modules as BINARIES here, because in teh reduced dependency ordering model they are equal to binaries
-                module.addFragmentProvider(DependencyKind.BINARIES, modules.get(dependency).getPackageFragmentProvider());
+                module.addDependencyOnModule(modules.get(dependency));
            }
        }
        return modules;
@@ -36,7 +36,6 @@ import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClass
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.DependencyKind;
 import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -45,6 +44,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.storage.ExceptionTracker;
 import org.jetbrains.jet.storage.LockBasedStorageManager;
 import org.jetbrains.jet.test.TestCaseWithTmpdir;
@@ -158,7 +158,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
        // we need the same binding trace for resolve from Java and Kotlin
        CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject());
        BindingTrace trace = support.getTrace();
-        ModuleDescriptorImpl module = support.getModule();
+        ModuleDescriptorImpl module = support.newModule();

        TopDownAnalysisParameters parameters = TopDownAnalysisParameters.create(
                new LockBasedStorageManager(),
@@ -173,9 +173,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
                trace,
                module);

-        module.addFragmentProvider(DependencyKind.BINARIES, injectorForAnalyzer.getJavaDescriptorResolver().getPackageFragmentProvider());
-
-        injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(parameters, environment.getSourceFiles());
+        injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(
+                parameters, environment.getSourceFiles(),
+                injectorForAnalyzer.getJavaDescriptorResolver().getPackageFragmentProvider()
+        );

        PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME);
        assert packageView != null : "Test package not found";
@@ -71,7 +71,7 @@ public abstract class AbstractSdkAnnotationsValidityTest extends UsefulTestCase

                BindingTrace trace = new BindingTraceContext();
                InjectorForJavaDescriptorResolver injector =
-                        InjectorForJavaDescriptorResolverUtil.create(commonEnvironment.getProject(), trace);
+                        InjectorForJavaDescriptorResolverUtil.create(commonEnvironment.getProject(), trace, false);

                BindingContext bindingContext = trace.getBindingContext();

@@ -29,6 +29,7 @@ import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.TestJdkKind;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.cli.common.output.outputUtils.OutputUtilsPackage;
+import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.codegen.GenerationUtils;
 import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
@@ -36,8 +37,8 @@ import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil;
-import org.jetbrains.jet.lang.descriptors.DependencyKind;
 import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
@@ -92,10 +93,12 @@ public final class LoadDescriptorUtil {
        );
        JetCoreEnvironment jetCoreEnvironment = JetCoreEnvironment.createForTests(disposable, configuration);
        BindingTraceContext trace = new BindingTraceContext();
-        InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), trace);
-        injector.getModule().addFragmentProvider(DependencyKind.BUILT_INS,
-                                                 KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
-        PackageViewDescriptor packageView = injector.getModule().getPackage(TEST_PACKAGE_FQNAME);
+        InjectorForJavaDescriptorResolver injector =
+                InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), trace, true);
+        ModuleDescriptorImpl module = injector.getModule();
+
+        CliLightClassGenerationSupport.getInstanceForCli(jetCoreEnvironment.getProject()).setModule(module);
+        PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME);
        assert packageView != null;

        return Pair.create(packageView, trace.getBindingContext());
@@ -168,8 +168,8 @@ public class ResolveDescriptorsFromExternalLibraries {
            }
        }

-        InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(
-                jetCoreEnvironment.getProject(), new BindingTraceContext());
+        InjectorForJavaDescriptorResolver injector =
+                InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), new BindingTraceContext(), false);
        ModuleDescriptor moduleDescriptor = injector.getModule();

        boolean hasErrors;
@@ -63,12 +63,15 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe
        Collection<JetFile> files = Lists.newArrayList(psiFile);

        final ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule("<lazy module>");
-        lazyModule.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
+        lazyModule.addDependencyOnModule(lazyModule);
+        lazyModule.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
+        lazyModule.seal();
        GlobalContextImpl globalContext = ContextPackage.GlobalContext();
        final ResolveSession resolveSession = new InjectorForLazyResolve(
                getProject(), globalContext, lazyModule,
                new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), files),
                new BindingTraceContext()).getResolveSession();
+        lazyModule.initialize(resolveSession.getPackageFragmentProvider());

        final List<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();
        psiFile.accept(new JetVisitorVoid() {
@@ -22,10 +22,13 @@ import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
+import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;

 import java.util.Collection;
 import java.util.Collections;
@@ -73,8 +76,16 @@ public class JvmResolveUtil {
    ) {
        BindingTraceContext bindingTraceContext = new BindingTraceContext();

+        ModuleDescriptorImpl module = AnalyzerFacadeForJVM.createJavaModule("<module>");
+        module.addDependencyOnModule(module);
+        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
+        module.seal();
+        CliLightClassGenerationSupport lightClassGenerationSupport = CliLightClassGenerationSupport.getInstanceForCli(project);
+        if (lightClassGenerationSupport != null) {
+            lightClassGenerationSupport.setModule(module);
+        }
        return AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files, bindingTraceContext, filesToAnalyzeCompletely,
-                                                                    AnalyzerFacadeForJVM.createJavaModule("<module>"),
+                                                                    module,
                                                                    null, null);
    }
 }
@@ -28,7 +28,6 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.context.ContextPackage;
 import org.jetbrains.jet.context.GlobalContextImpl;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
-import org.jetbrains.jet.lang.descriptors.DependencyKind;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -37,6 +36,7 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.name.SpecialNames;
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;

 import java.util.List;
 import java.util.Set;
@@ -53,12 +53,11 @@ public class LazyResolveTestUtil {
                globalContext.getStorageManager(), globalContext.getExceptionTracker(), Predicates.<PsiFile>alwaysTrue(), false, false);
        CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject());
        BindingTrace sharedTrace = support.getTrace();
-        ModuleDescriptorImpl sharedModule = support.getModule();
+        ModuleDescriptorImpl sharedModule = support.newModule();

        InjectorForTopDownAnalyzerForJvm injector =
                new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, sharedTrace, sharedModule);
-        sharedModule.addFragmentProvider(DependencyKind.BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
-        injector.getTopDownAnalyzer().analyzeFiles(params, files);
+        injector.getTopDownAnalyzer().analyzeFiles(params, files, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
        return injector.getModuleDescriptor();
    }

@@ -115,7 +115,7 @@ public class JetExpectedResolveDataUtil {

    @NotNull
    private static PsiClass findClass(String qualifiedName, Project project) {
-        InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, new BindingTraceContext());
+        InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, new BindingTraceContext(), false);
        JavaClass javaClass = injector.getJavaClassFinder().findClass(new FqName(qualifiedName));
        Assert.assertNotNull("Class wasn't found: " + qualifiedName, javaClass);
        assertInstanceOf(javaClass, JavaClassImpl.class);
@@ -28,11 +28,9 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil;
 import org.jetbrains.jet.di.InjectorForTests;
-import org.jetbrains.jet.lang.descriptors.DependencyKind;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor;
-import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.ReceiverParameterDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
@@ -597,10 +595,10 @@ public class JetTypeCheckerTest extends JetLiteFixture {
    private WritableScopeImpl addImports(JetScope scope) {
        WritableScopeImpl writableScope = new WritableScopeImpl(
                scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "JetTypeCheckerTest.addImports");
-        InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(getProject(), new BindingTraceContext());
+        InjectorForJavaDescriptorResolver injector =
+                InjectorForJavaDescriptorResolverUtil.create(getProject(), new BindingTraceContext(), true);
        JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
-        ModuleDescriptorImpl module = (ModuleDescriptorImpl) javaDescriptorResolver.getModule();
-        module.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
+        ModuleDescriptor module = javaDescriptorResolver.getModule();
        for (ImportPath defaultImport : module.getDefaultImports()) {
            writableScope.importScope(module.getPackage(defaultImport.fqnPart()).getMemberScope());
        }