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

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

@@ -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;
     }

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

@@ -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;

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

@@ -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.initialize(new CompositePackageFragmentProvider(
-        module.addFragmentProvider(BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
+                Arrays.asList(injector.getTopDownAnalyzer().getPackageFragmentProvider(),
-        module.addFragmentProvider(BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
+                              injector.getJavaDescriptorResolver().getPackageFragmentProvider()
+                )
+        ));
+        module.addDependencyOnModule(module);
+        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
+        module.seal();
 
         List<URL> classpath = Lists.newArrayList();
 

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

@@ -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;
     }
 }

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

@@ -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.*;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
 
 public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
 
@@ -128,14 +125,19 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
                 declarationProviderFactory,
                 trace);
 
-        resolveWithJava.getModule().addFragmentProvider(
+        ModuleDescriptorImpl module = resolveWithJava.getModule();
-                DependencyKind.BINARIES, resolveWithJava.getJavaDescriptorResolver().getPackageFragmentProvider());
+        module.initialize(
+                new CompositePackageFragmentProvider(
+                        Arrays.asList(
+                                resolveWithJava.getResolveSession().getPackageFragmentProvider(),
+                                resolveWithJava.getJavaDescriptorResolver().getPackageFragmentProvider()
+                        )));
 
+        module.addDependencyOnModule(module);
         if (addBuiltIns) {
-            resolveWithJava.getModule().addFragmentProvider(
+            module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
-                    DependencyKind.BUILT_INS,
-                    KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
         }
+        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(
+                    additionalProviders.add(
-                            DependencyKind.SOURCES,
                             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 {

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

@@ -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.*;
-import java.util.Collections;
-import java.util.LinkedHashSet;
-import java.util.Set;
 
 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
+    @NotNull
-        ((ModuleDescriptorImpl) moduleDescriptor).addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
+    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;

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

@@ -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

compiler/tests/org/jetbrains/jet/JetTestUtils.java

@@ -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));
     }
 

compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java

@@ -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.addDependencyOnModule(modules.get(dependency));
-                module.addFragmentProvider(DependencyKind.BINARIES, modules.get(dependency).getPackageFragmentProvider());
             }
         }
         return modules;

compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java

@@ -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";

compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractSdkAnnotationsValidityTest.java

@@ -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();
 

compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java

@@ -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);
+        InjectorForJavaDescriptorResolver injector =
-        injector.getModule().addFragmentProvider(DependencyKind.BUILT_INS,
+                InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), trace, true);
-                                                 KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
+        ModuleDescriptorImpl module = injector.getModule();
-        PackageViewDescriptor packageView = injector.getModule().getPackage(TEST_PACKAGE_FQNAME);
+
+        CliLightClassGenerationSupport.getInstanceForCli(jetCoreEnvironment.getProject()).setModule(module);
+        PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME);
         assert packageView != null;
 
         return Pair.create(packageView, trace.getBindingContext());

compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java

@@ -168,8 +168,8 @@ public class ResolveDescriptorsFromExternalLibraries {
             }
         }
 
-        InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(
+        InjectorForJavaDescriptorResolver injector =
-                jetCoreEnvironment.getProject(), new BindingTraceContext());
+                InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), new BindingTraceContext(), false);
         ModuleDescriptor moduleDescriptor = injector.getModule();
 
         boolean hasErrors;

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java

@@ -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() {

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/JvmResolveUtil.java

@@ -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);
     }
 }

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java

@@ -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.getJavaDescriptorResolver().getPackageFragmentProvider());
-        injector.getTopDownAnalyzer().analyzeFiles(params, files);
         return injector.getModuleDescriptor();
     }
 

compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java

@@ -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);

compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java

@@ -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();
+        ModuleDescriptor module = javaDescriptorResolver.getModule();
-        module.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
         for (ImportPath defaultImport : module.getDefaultImports()) {
             writableScope.importScope(module.getPackage(defaultImport.fqnPart()).getMemberScope());
         }

core/descriptors/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorVisitor.java

@@ -16,6 +16,8 @@
 
 package org.jetbrains.jet.lang.descriptors;
 
+import kotlin.jvm.KotlinSignature;
+
 public interface DeclarationDescriptorVisitor<R, D> {
 
     R visitPackageFragmentDescriptor(PackageFragmentDescriptor descriptor, D data);
@@ -30,6 +32,7 @@ public interface DeclarationDescriptorVisitor<R, D> {
 
     R visitClassDescriptor(ClassDescriptor descriptor, D data);
 
+    @KotlinSignature("fun visitModuleDeclaration(descriptor: ModuleDescriptor, data: D): R")
     R visitModuleDeclaration(ModuleDescriptor descriptor, D data);
 
     R visitConstructorDescriptor(ConstructorDescriptor constructorDescriptor, D data);

core/descriptors/src/org/jetbrains/jet/lang/descriptors/DependencyKind.java

@@ -1,24 +0,0 @@
-/*
- * Copyright 2010-2014 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.jet.lang.descriptors;
-
-public enum DependencyKind {
-    // Using this class is supposed to be a temporary measure before we switch to full-blown support for module dependency ordering
-    SOURCES,
-    BUILT_INS,
-    BINARIES
-}

core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java

@@ -1,52 +0,0 @@
-/*
- * Copyright 2010-2013 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.jet.lang.descriptors;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
-import org.jetbrains.jet.lang.resolve.ImportPath;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.types.TypeSubstitutor;
-
-import java.util.List;
-
-public interface ModuleDescriptor extends DeclarationDescriptor {
-    @Override
-    @Nullable
-    DeclarationDescriptor getContainingDeclaration();
-
-    @NotNull
-    PackageFragmentProvider getPackageFragmentProvider();
-
-    @Nullable
-    PackageViewDescriptor getPackage(@NotNull FqName fqName);
-
-    @NotNull
-    List<ImportPath> getDefaultImports();
-
-    @NotNull
-    PlatformToKotlinClassMap getPlatformToKotlinClassMap();
-
-    @NotNull
-    @Override
-    ModuleDescriptor substitute(@NotNull TypeSubstitutor substitutor);
-
-    @Override
-    <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data);
-}

core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.descriptors
+
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap
+import org.jetbrains.jet.lang.resolve.ImportPath
+import org.jetbrains.jet.lang.resolve.name.FqName
+import org.jetbrains.jet.lang.types.TypeSubstitutor
+import org.jetbrains.jet.lang.descriptors.impl.PackageViewDescriptorImpl
+
+public trait ModuleDescriptor : DeclarationDescriptor {
+    override fun getContainingDeclaration(): DeclarationDescriptor? = null
+
+    public fun getPackageFragmentProvider(): PackageFragmentProvider
+
+    public fun getPackage(fqName: FqName): PackageViewDescriptor? {
+        val fragments = getPackageFragmentProvider().getPackageFragments(fqName)
+        return if (!fragments.isEmpty()) PackageViewDescriptorImpl(this, fqName, fragments) else null
+    }
+
+    public val defaultImports: List<ImportPath>
+
+    public val platformToKotlinClassMap: PlatformToKotlinClassMap
+
+    override fun substitute(substitutor: TypeSubstitutor): ModuleDescriptor {
+        return this
+    }
+
+    override fun <R, D> accept(visitor: DeclarationDescriptorVisitor<R, D>, data: D): R {
+        return visitor.visitModuleDeclaration(this, data)
+    }
+}

core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/ModuleDescriptorImpl.java

@@ -1,122 +0,0 @@
-/*
- * Copyright 2010-2013 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.jet.lang.descriptors.impl;
-
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.intellij.openapi.diagnostic.Logger;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
-import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
-import org.jetbrains.jet.lang.resolve.ImportPath;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.types.TypeSubstitutor;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements ModuleDescriptor {
-    private static final Logger LOG = Logger.getInstance(ModuleDescriptorImpl.class);
-
-    private final Map<DependencyKind, List<PackageFragmentProvider>> prioritizedFragmentProviders = Maps.newHashMap();
-    private final List<PackageFragmentProvider> fragmentProviders = Lists.newArrayList();
-    private final CompositePackageFragmentProvider packageFragmentProvider = new CompositePackageFragmentProvider(fragmentProviders);
-    private final List<ImportPath> defaultImports;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
-
-    public ModuleDescriptorImpl(
-            @NotNull Name name,
-            @NotNull List<ImportPath> defaultImports,
-            @NotNull PlatformToKotlinClassMap platformToKotlinClassMap
-    ) {
-        super(Annotations.EMPTY, name);
-        if (!name.isSpecial()) {
-            throw new IllegalArgumentException("module name must be special: " + name);
-        }
-        this.defaultImports = defaultImports;
-        this.platformToKotlinClassMap = platformToKotlinClassMap;
-    }
-
-    public void addFragmentProvider(@NotNull DependencyKind dependencyKind, @NotNull PackageFragmentProvider provider) {
-        if (fragmentProviders.contains(provider)) {
-            LOG.error("Trying to add already present fragment provider: " + provider);
-        }
-        List<PackageFragmentProvider> providers = prioritizedFragmentProviders.get(dependencyKind);
-        if (providers == null) {
-            providers = new ArrayList<PackageFragmentProvider>(1);
-            prioritizedFragmentProviders.put(dependencyKind, providers);
-        }
-        providers.add(provider);
-        buildProvidersList();
-    }
-
-    private void buildProvidersList() {
-        fragmentProviders.clear();
-        for (DependencyKind dependencyKind : DependencyKind.values()) {
-            List<PackageFragmentProvider> providers = prioritizedFragmentProviders.get(dependencyKind);
-            if (providers != null) {
-                fragmentProviders.addAll(providers);
-            }
-        }
-    }
-
-    @Override
-    @Nullable
-    public DeclarationDescriptor getContainingDeclaration() {
-        return null;
-    }
-
-    @NotNull
-    @Override
-    public PackageFragmentProvider getPackageFragmentProvider() {
-        return packageFragmentProvider;
-    }
-
-    @Nullable
-    @Override
-    public PackageViewDescriptor getPackage(@NotNull FqName fqName) {
-        List<PackageFragmentDescriptor> fragments = packageFragmentProvider.getPackageFragments(fqName);
-        return !fragments.isEmpty() ? new PackageViewDescriptorImpl(this, fqName, fragments) : null;
-    }
-
-    @NotNull
-    @Override
-    public List<ImportPath> getDefaultImports() {
-        return defaultImports;
-    }
-
-    @NotNull
-    @Override
-    public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
-        return platformToKotlinClassMap;
-    }
-
-    @NotNull
-    @Override
-    public ModuleDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
-        return this;
-    }
-
-    @Override
-    public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
-        return visitor.visitModuleDeclaration(this, data);
-    }
-}

core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/ModuleDescriptorImpl.kt

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.descriptors.impl
+
+import org.jetbrains.jet.lang.resolve.name.Name
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap
+import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider
+import java.util.ArrayList
+import org.jetbrains.jet.lang.resolve.ImportPath
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
+import kotlin.properties.Delegates
+
+public class ModuleDescriptorImpl(
+        moduleName: Name,
+        override val defaultImports: List<ImportPath>,
+        override val platformToKotlinClassMap: PlatformToKotlinClassMap
+) : DeclarationDescriptorImpl(Annotations.EMPTY, moduleName), ModuleDescriptor {
+    {
+        if (!moduleName.isSpecial()) {
+            throw IllegalArgumentException("Module name must be special: $moduleName")
+        }
+    }
+    private var isSealed = false
+
+    /*
+     * Sealed module cannot have its dependencies modified. Seal the module after you're done configuring it.
+     * Module will be sealed automatically as soon as you query its contents.
+     */
+    public fun seal() {
+        if (isSealed) return
+
+        assert(this in dependencies, "Module $id is not contained in his own dependencies, this is probably a misconfiguration")
+        isSealed = true
+    }
+
+    private val dependencies: MutableList<ModuleDescriptorImpl> = ArrayList()
+    private var packageFragmentProviderForModuleContent: PackageFragmentProvider? = null
+
+    private val packageFragmentProviderForWholeModuleWithDependencies by Delegates.lazy {
+        seal()
+        dependencies.forEach {
+            dependency ->
+            assert(dependency.isInitialized, "Dependency module ${dependency.id} was not initialized by the time contents of dependent module ${this.id} were queried")
+        }
+        CompositePackageFragmentProvider(dependencies.map {
+            it.packageFragmentProviderForModuleContent!!
+        })
+    }
+
+    private val isInitialized: Boolean
+        get() = packageFragmentProviderForModuleContent != null
+
+    public fun addDependencyOnModule(dependency: ModuleDescriptorImpl) {
+        assert(!isSealed, "Can't modify dependencies of sealed module $id")
+        assert(dependency !in dependencies, "Trying to add dependency on module ${dependency.id} a second time for module ${this.id}, this is probably a misconfiguration")
+        dependencies.add(dependency)
+    }
+
+    private val id: String
+        get() = getName().toString()
+
+    /*
+     * Call initialize() to set module contents. Uninitialized module cannot be queried for its contents.
+     * Initialize() and seal() can be called in any order.
+     */
+    public fun initialize(providerForModuleContent: PackageFragmentProvider) {
+        assert(!isInitialized, "Attempt to initialize module $id twice")
+        packageFragmentProviderForModuleContent = providerForModuleContent
+    }
+
+    override fun getPackageFragmentProvider() = packageFragmentProviderForWholeModuleWithDependencies
+}

core/descriptors/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java

@@ -109,7 +109,9 @@ public class KotlinBuiltIns {
                                                   Collections.<ImportPath>emptyList(),
                                                   PlatformToKotlinClassMap.EMPTY);
         builtinsPackageFragment = new BuiltinsPackageFragment(new LockBasedStorageManager(), builtInsModule);
-        builtInsModule.addFragmentProvider(DependencyKind.SOURCES, builtinsPackageFragment.getProvider());
+        builtInsModule.initialize(builtinsPackageFragment.getProvider());
+        builtInsModule.addDependencyOnModule(builtInsModule);
+        builtInsModule.seal();
 
         primitiveTypeToNullableJetType = new EnumMap<PrimitiveType, JetType>(PrimitiveType.class);
         primitiveTypeToArrayJetType = new EnumMap<PrimitiveType, JetType>(PrimitiveType.class);

idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt

@@ -58,6 +58,8 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
     private val moduleDescriptor =
             ModuleDescriptorImpl(Name.special("<module for building decompiled sources>"), listOf(), PlatformToKotlinClassMap.EMPTY)
 
+    private fun createDummyModule(name: String) = ModuleDescriptorImpl(Name.special("<$name>"), listOf(), PlatformToKotlinClassMap.EMPTY)
+
     override fun resolveTopLevelClass(classFqName: FqName) = deserializationContext.classDeserializer.deserializeClass(classFqName.toClassId())
 
     override fun resolveDeclarationsInPackage(packageFqName: FqName): Collection<DeclarationDescriptor> {
@@ -140,10 +142,17 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
     }
 
     {
-        moduleDescriptor.addFragmentProvider(DependencyKind.BUILT_INS,
+        moduleDescriptor.initialize(packageFragmentProvider)
-                                             KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider())
+        moduleDescriptor.addDependencyOnModule(moduleDescriptor)
-        moduleDescriptor.addFragmentProvider(DependencyKind.SOURCES, packageFragmentProvider)
+        moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule())
-        moduleDescriptor.addFragmentProvider(DependencyKind.BINARIES, PackageFragmentProviderForMissingDependencies(moduleDescriptor))
+        val moduleContainingMissingDependencies = createDummyModule("module containing missing dependencies for decompiled sources")
+        moduleContainingMissingDependencies.addDependencyOnModule(moduleContainingMissingDependencies)
+        moduleContainingMissingDependencies.initialize(
+                PackageFragmentProviderForMissingDependencies(moduleContainingMissingDependencies)
+        )
+        moduleDescriptor.addDependencyOnModule(moduleContainingMissingDependencies)
+        moduleDescriptor.seal()
+        moduleContainingMissingDependencies.seal()
     }
     val deserializationContext = DeserializationGlobalContext(storageManager, moduleDescriptor, classDataFinder, annotationLoader,
                                                               constantLoader, packageFragmentProvider)

idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java

@@ -44,7 +44,6 @@ import org.jetbrains.jet.di.InjectorForLazyResolve;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.DependencyKind;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
@@ -53,6 +52,7 @@ import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.java.mapping.KotlinToJavaTypesMap;
 import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
+import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
@@ -216,24 +216,7 @@ public class JetSourceNavigationHelper {
             }
         }
 
-        Project project = decompiledDeclaration.getProject();
+        KotlinCodeAnalyzer analyzer = createAnalyzer(candidates, decompiledDeclaration.getProject());
-        GlobalContextImpl globalContext = ContextPackage.GlobalContext();
-        FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(
-                globalContext.getStorageManager(),
-                getContainingFiles(candidates));
-
-        ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<library module>"),
-                                                                         AnalyzerFacadeForJVM.DEFAULT_IMPORTS,
-                                                                         PlatformToKotlinClassMap.EMPTY);
-
-        moduleDescriptor.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
-
-        KotlinCodeAnalyzer analyzer = new InjectorForLazyResolve(
-                project,
-                globalContext,
-                moduleDescriptor,
-                providerFactory,
-                new BindingTraceContext()).getResolveSession();
 
         for (JetNamedDeclaration candidate : candidates) {
             //noinspection unchecked
@@ -248,6 +231,36 @@ public class JetSourceNavigationHelper {
         return null;
     }
 
+    @NotNull
+    private static KotlinCodeAnalyzer createAnalyzer(
+            @NotNull Collection<JetNamedDeclaration> candidates,
+            @NotNull Project project
+    ) {
+        GlobalContextImpl globalContext = ContextPackage.GlobalContext();
+        FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(
+                globalContext.getStorageManager(),
+                getContainingFiles(candidates)
+        );
+
+        ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<library module>"),
+                                                                         AnalyzerFacadeForJVM.DEFAULT_IMPORTS,
+                                                                         PlatformToKotlinClassMap.EMPTY);
+
+        moduleDescriptor.addDependencyOnModule(moduleDescriptor);
+        moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
+        moduleDescriptor.seal();
+
+        ResolveSession resolveSession = new InjectorForLazyResolve(
+                project,
+                globalContext,
+                moduleDescriptor,
+                providerFactory,
+                new BindingTraceContext()).getResolveSession();
+
+        moduleDescriptor.initialize(resolveSession.getPackageFragmentProvider());
+        return resolveSession;
+    }
+
     @Nullable
     private static JetClassOrObject getSourceForNamedClassOrObject(@NotNull JetClassOrObject decompiledClassOrObject) {
         FqName classFqName = decompiledClassOrObject.getFqName();

idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java

@@ -102,6 +102,8 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
                         Predicates.<PsiFile>alwaysFalse(), true, false);
                 ModuleDescriptorImpl module = new ModuleDescriptorImpl(
                         Name.special("<fake_module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY);
+                module.addDependencyOnModule(module);
+                module.seal();
                 BindingTraceContext trace = new BindingTraceContext();
                 InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(
                         myProject, topDownAnalysisParameters, trace, module);

js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java

@@ -30,7 +30,6 @@ import org.jetbrains.jet.context.GlobalContextImpl;
 import org.jetbrains.jet.di.InjectorForLazyResolve;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJs;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
-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;
@@ -79,10 +78,13 @@ public final class AnalyzerFacadeForJS {
         TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.create(
                 globalContext.getStorageManager(), globalContext.getExceptionTracker(), completely, false, false);
 
+        owner.addDependencyOnModule(owner);
+        owner.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
         ModuleDescriptor libraryModule = config.getLibraryModule();
         if (libraryModule != null) {
-            owner.addFragmentProvider(DependencyKind.BINARIES, libraryModule.getPackageFragmentProvider()); // "import" analyzed library module
+            owner.addDependencyOnModule((ModuleDescriptorImpl) libraryModule); // "import" analyzed library module
         }
+        owner.seal();
 
         BindingContext libraryContext = config.getLibraryContext();
         BindingTrace trace = libraryContext == null
@@ -136,14 +138,18 @@ public final class AnalyzerFacadeForJS {
                         filesScope
                 );
         ModuleDescriptorImpl module = createJsModule("<lazy module>");
-        module.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
+        module.addDependencyOnModule(module);
+        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
+        module.seal();
 
-        return new InjectorForLazyResolve(
+        ResolveSession session = new InjectorForLazyResolve(
                 config.getProject(),
                 globalContext,
                 module,
                 declarationProviderFactory,
                 new BindingTraceContext()).getResolveSession();
+        module.initialize(session.getPackageFragmentProvider());
+        return session;
     }
 
     @NotNull

libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt

@@ -39,6 +39,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorUtils
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
 import org.junit.Assert
 import java.util.HashSet
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
 
 // this list is not designed to contain all packages, it is need for sanity check in case test code breaks
 private val PACKAGES_SHOULD_BE_VALIDATED = listOf("kotlin", "kotlin.concurrent", "kotlin.jvm") map { FqName(it) }
@@ -102,12 +103,15 @@ class NoInternalVisibilityInStdLibTest {
             configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, "../src/kotlin")
             configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, PathUtil.getJdkClassesRoots())
             val environment = JetCoreEnvironment.createForProduction(disposable, configuration)
+            val module = AnalyzerFacadeForJVM.createJavaModule("<module for validating std lib>")
+            module.addDependencyOnModule(module)
+            module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule())
             AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
                     environment.getProject(),
                     environment.getSourceFiles(),
                     BindingTraceContext(),
                     { true },
-                    AnalyzerFacadeForJVM.createJavaModule("<module for validating std lib>"),
+                    module,
                     null,
                     null
             ).getModuleDescriptor()