ModuleDescriptor stores a ModuleConfiguration

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

@@ -95,6 +95,7 @@ public class ReplInterpreter {
                 true,
                 Collections.<AnalyzerScriptParameter>emptyList());
         injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module);
+        module.setModuleConfiguration(injector.getModuleConfiguration());
 
         List<URL> classpath = Lists.newArrayList();
 

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

@@ -92,7 +92,7 @@ public class InjectorForJavaDescriptorResolver {
         this.javaInnerClassResolver = new JavaInnerClassResolver();
         this.javaPropertyResolver = new JavaPropertyResolver();
 
-        javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices);
+        this.javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices);
 
         this.javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
         this.javaSemanticServices.setPsiClassFinder(psiClassFinder);
@@ -183,6 +183,10 @@ public class InjectorForJavaDescriptorResolver {
         return this.moduleDescriptor;
     }
     
+    public JavaBridgeConfiguration getJavaBridgeConfiguration() {
+        return this.javaBridgeConfiguration;
+    }
+    
     public JavaSemanticServices getJavaSemanticServices() {
         return this.javaSemanticServices;
     }

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

@@ -107,6 +107,8 @@ public class InjectorForJavaSemanticServices {
 
         this.psiClassFinder.setProject(project);
 
+        moduleDescriptor.setModuleConfiguration(javaBridgeConfiguration);
+
         javaTypeTransformer.setJavaSemanticServices(javaSemanticServices);
         javaTypeTransformer.setResolver(javaDescriptorResolver);
 

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

@@ -31,14 +31,13 @@ import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.DefaultModuleConfiguration;
 import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager;
-import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -83,7 +82,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
     @NotNull
     @Override
     public ResolveSession getLazyResolveSession(@NotNull Project fileProject, @NotNull Collection<JetFile> files) {
-        ModuleDescriptor javaModule = new ModuleDescriptorImpl(Name.special("<java module>"));
+        ModuleDescriptorImpl javaModule = new ModuleDescriptorImpl(Name.special("<java module>"));
 
         BindingTraceContext javaResolverTrace = new BindingTraceContext();
         InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(fileProject, javaResolverTrace, javaModule);
@@ -132,8 +131,10 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
                 return JavaToKotlinClassMap.getInstance();
             }
         };
+        javaModule.setModuleConfiguration(moduleConfiguration);
 
         ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("<lazy module>"));
+        lazyModule.setModuleConfiguration(moduleConfiguration);
 
         return new ResolveSession(fileProject, storageManager, lazyModule, moduleConfiguration, declarationProviderFactory, javaResolverTrace);
     }
@@ -208,6 +209,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
         InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(
                 project, topDownAnalysisParameters,
                 new ObservableBindingTrace(trace), owner);
+        owner.setModuleConfiguration(injector.getModuleConfiguration());
         try {
             injector.getTopDownAnalyzer().analyzeFiles(files, scriptParameters);
             BodiesResolveContext bodiesResolveContext = storeContextForBodiesResolve ?

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java

@@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.descriptors;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
@@ -28,6 +29,9 @@ public interface ModuleDescriptor extends DeclarationDescriptor, NamespaceDescri
 
     NamespaceDescriptor getRootNamespace();
 
+    @NotNull
+    ModuleConfiguration getModuleConfiguration();
+
     @NotNull
     @Override
     ModuleDescriptor substitute(@NotNull TypeSubstitutor substitutor);

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptorImpl.java

@@ -18,16 +18,19 @@ package org.jetbrains.jet.lang.descriptors;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
+import javax.inject.Inject;
 import java.util.Collections;
 
 public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements ClassOrNamespaceDescriptor, ModuleDescriptor {
     private NamespaceDescriptor rootNamepsace;
+    private ModuleConfiguration moduleConfiguration;
 
     public ModuleDescriptorImpl(@NotNull Name name) {
         super(Collections.<AnnotationDescriptor>emptyList(), name);
@@ -54,6 +57,18 @@ public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements C
         return rootNamepsace;
     }
 
+    @NotNull
+    @Override
+    public ModuleConfiguration getModuleConfiguration() {
+        return moduleConfiguration;
+    }
+
+    @Inject
+    public ModuleDescriptorImpl setModuleConfiguration(@NotNull ModuleConfiguration moduleConfiguration) {
+        this.moduleConfiguration = moduleConfiguration;
+        return this;
+    }
+
     public NamespaceDescriptorImpl getRootNamespaceDescriptorImpl() {
         return (NamespaceDescriptorImpl) rootNamepsace;
     }

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

@@ -187,6 +187,7 @@ public class TopDownAnalyzer {
             @NotNull JetClassOrObject object
     ) {
         ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<dummy for object>"));
+        moduleDescriptor.setModuleConfiguration(ModuleConfiguration.EMPTY);
 
         TopDownAnalysisParameters topDownAnalysisParameters =
                 new TopDownAnalysisParameters(Predicates.equalTo(object.getContainingFile()),

compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java

@@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.types;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.*;
@@ -31,7 +32,12 @@ import java.util.*;
 
 public class ErrorUtils {
 
-    private static final ModuleDescriptor ERROR_MODULE = new ModuleDescriptorImpl(Name.special("<ERROR MODULE>"));
+    private static final ModuleDescriptor ERROR_MODULE;
+    static {
+        ModuleDescriptorImpl module = new ModuleDescriptorImpl(Name.special("<ERROR MODULE>"));
+        module.setModuleConfiguration(ModuleConfiguration.EMPTY);
+        ERROR_MODULE = module;
+    }
 
 
     public static class ErrorScope implements JetScope {

compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java

@@ -171,6 +171,7 @@ public class KotlinBuiltIns {
     private KotlinBuiltIns(@NotNull Project project) {
         try {
             this.builtInsModule = new ModuleDescriptorImpl(Name.special("<built-ins lazy module>"));
+            builtInsModule.setModuleConfiguration(SpecialModuleConfiguration.INSTANCE);
             this.analyzer = createLazyResolveSession(project);
 
             this.functionClassesSet = computeIndexedClasses("Function", FUNCTION_TRAIT_COUNT);
@@ -228,7 +229,7 @@ public class KotlinBuiltIns {
                 project,
                 storageManager,
                 builtInsModule,
-                new SpecialModuleConfiguration(),
+                SpecialModuleConfiguration.INSTANCE,
                 new FileBasedDeclarationProviderFactory(storageManager, files),
                 ResolveSession.NO_ALIASES,
                 Predicates.in(Sets.newHashSet(new FqNameUnsafe("jet.Any"), new FqNameUnsafe("jet.Nothing"))),
@@ -258,6 +259,8 @@ public class KotlinBuiltIns {
 
     private static class SpecialModuleConfiguration implements ModuleConfiguration {
 
+        public static final ModuleConfiguration INSTANCE = new SpecialModuleConfiguration();
+
         private SpecialModuleConfiguration() {
         }
 

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

@@ -153,6 +153,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
                         Predicates.<PsiFile>alwaysFalse(), false, false, Collections.<AnalyzerScriptParameter>emptyList()),
                 trace,
                 moduleDescriptor);
+        moduleDescriptor.setModuleConfiguration(injectorForAnalyzer.getModuleConfiguration());
 
         injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(environment.getSourceFiles(), Collections.<AnalyzerScriptParameter>emptyList());
 

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

@@ -55,6 +55,7 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe
         Collection<JetFile> files = Lists.newArrayList(psiFile);
 
         ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("<lazy module>"));
+        lazyModule.setModuleConfiguration(injectorForTopDownAnalyzer.getModuleConfiguration());
         LockBasedStorageManager storageManager = new LockBasedStorageManager();
         final ResolveSession resolveSession = new ResolveSession(getProject(), storageManager, lazyModule, injectorForTopDownAnalyzer.getModuleConfiguration(),
                                                     new FileBasedDeclarationProviderFactory(storageManager, files));

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

@@ -63,6 +63,7 @@ public class LazyResolveTestUtil {
         ModuleDescriptorImpl eagerModuleForLazy = new ModuleDescriptorImpl(Name.special("<eager module for lazy>"));
 
         InjectorForTopDownAnalyzer tdaInjectorForLazy = createInjectorForTDA(eagerModuleForLazy, environment);
+        eagerModuleForLazy.setModuleConfiguration(tdaInjectorForLazy.getModuleConfiguration());
         // This line is required fro the 'jet' namespace to be filled in with functions
         tdaInjectorForLazy.getTopDownAnalyzer().analyzeFiles(
                 Collections.singletonList(JetPsiFactory.createFile(environment.getProject(), "")), Collections.<AnalyzerScriptParameter>emptyList());
@@ -81,6 +82,7 @@ public class LazyResolveTestUtil {
     public static ModuleDescriptor resolveEagerly(List<JetFile> files, JetCoreEnvironment environment) {
         ModuleDescriptorImpl module = new ModuleDescriptorImpl(Name.special("<test module>"));
         InjectorForTopDownAnalyzer injector = createInjectorForTDA(module, environment);
+        module.setModuleConfiguration(injector.getModuleConfiguration());
         injector.getTopDownAnalyzer().analyzeFiles(files, Collections.<AnalyzerScriptParameter>emptyList());
         return module;
     }
@@ -88,7 +90,7 @@ public class LazyResolveTestUtil {
     public static KotlinCodeAnalyzer resolveLazilyWithSession(List<JetFile> files, JetCoreEnvironment environment) {
         JetTestUtils.newTrace(environment);
 
-        ModuleDescriptor javaModule = new ModuleDescriptorImpl(Name.special("<java module>"));
+        ModuleDescriptorImpl javaModule = new ModuleDescriptorImpl(Name.special("<java module>"));
 
         Project project = environment.getProject();
         BindingTrace sharedTrace = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()).getTrace();
@@ -137,8 +139,10 @@ public class LazyResolveTestUtil {
                 return JavaToKotlinClassMap.getInstance();
             }
         };
+        javaModule.setModuleConfiguration(moduleConfiguration);
 
         ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("<lazy module>"));
+        lazyModule.setModuleConfiguration(moduleConfiguration);
         return new ResolveSession(project, storageManager, lazyModule, moduleConfiguration, declarationProviderFactory, sharedTrace);
     }
 

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

@@ -60,7 +60,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
     }
 
     public class JetDefaultModalityModifiersTestCase  {
-        private ModuleDescriptor root = new ModuleDescriptorImpl(Name.special("<test_root>"));
+        private ModuleDescriptorImpl root = new ModuleDescriptorImpl(Name.special("<test_root>"));
         private DescriptorResolver descriptorResolver;
         private JetScope scope;
 

generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java

@@ -120,7 +120,7 @@ public class GenerateInjectors {
         generator.addPublicParameter(ModuleDescriptor.class);
 
         // Fields
-        generator.addField(JavaBridgeConfiguration.class);
+        generator.addPublicField(JavaBridgeConfiguration.class);
         generator.addPublicField(JavaSemanticServices.class);
         generator.addPublicField(JavaDescriptorResolver.class);
         generator.addPublicField(PsiClassFinderImpl.class);

idea/src/org/jetbrains/jet/plugin/codeInsight/ktSignature/KotlinSignatureInJavaMarkerProvider.java

@@ -116,7 +116,10 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
         BindingContext bindingContext = declarationsCache.getBindingContext();
         DelegatingBindingTrace delegatingTrace = new DelegatingBindingTrace(bindingContext, "wrapped context of declarations cache");
 
-        return new InjectorForJavaDescriptorResolver(project, delegatingTrace, new ModuleDescriptorImpl(Name.special("<fake>")));
+        ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<fake>"));
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, delegatingTrace, moduleDescriptor);
+        moduleDescriptor.setModuleConfiguration(injector.getJavaBridgeConfiguration());
+        return injector;
     }
 
     @Nullable

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

@@ -221,10 +221,12 @@ public class JetSourceNavigationHelper {
                         return KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(fqName);
                     }
                 });
+        ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<library module>"));
+        moduleDescriptor.setModuleConfiguration(DefaultModuleConfiguration.createStandardConfiguration());
         KotlinCodeAnalyzer analyzer = new ResolveSession(
                 project,
                 storageManager,
-                new ModuleDescriptorImpl(Name.special("<library module>")),
+                moduleDescriptor,
                 DefaultModuleConfiguration.createStandardConfiguration(),
                 providerFactory);
 

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

@@ -34,6 +34,7 @@ import com.intellij.util.Function;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
@@ -224,9 +225,9 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
         private WritableScope memberScope;
 
         private FakeJetNamespaceDescriptor() {
-            super(new NamespaceDescriptorImpl(new ModuleDescriptorImpl(Name.special("<fake_module>")),
+            super(new NamespaceDescriptorImpl(
-                                              Collections.<AnnotationDescriptor>emptyList(), Name.special("<root>")),
+                    new ModuleDescriptorImpl(Name.special("<fake_module>")).setModuleConfiguration(ModuleConfiguration.EMPTY),
-                  Collections.<AnnotationDescriptor>emptyList(),
+                  Collections.<AnnotationDescriptor>emptyList(), Name.special("<root>")), Collections.<AnnotationDescriptor>emptyList(),
                   KotlinBuiltIns.getInstance().getBuiltInsPackage().getName());
         }
 

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

@@ -90,6 +90,7 @@ public final class AnalyzerFacadeForJS {
         InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs(
                 project, topDownAnalysisParameters, trace, owner,
                 new JsConfiguration(libraryBindingContext));
+        owner.setModuleConfiguration(injector.getModuleConfiguration());
         try {
             Collection<JetFile> allFiles = libraryBindingContext != null ?
                                            files :
@@ -144,6 +145,7 @@ public final class AnalyzerFacadeForJS {
         FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(
                 storageManager, Config.withJsLibAdded(files, config), Predicates.<FqName>alwaysFalse());
         ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("<lazy module>"));
-        return new ResolveSession(config.getProject(), storageManager, lazyModule, new JsConfiguration(null), declarationProviderFactory);
+        lazyModule.setModuleConfiguration(new JsConfiguration(null));
+        return new ResolveSession(config.getProject(), storageManager, lazyModule, lazyModule.getModuleConfiguration(), declarationProviderFactory);
     }
 }