ModuleDescriptor stores a PlatformToKotlinClassMap

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

@@ -73,7 +73,7 @@ public class InjectorForJavaSemanticServices {
         this.bindingTrace = new org.jetbrains.jet.lang.resolve.BindingTraceContext();
         this.javaBridgeConfiguration = new JavaBridgeConfiguration();
         this.psiClassFinder = new PsiClassFinderImpl();
-        this.moduleDescriptor = new org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl(org.jetbrains.jet.lang.resolve.name.Name.special("<dummy>"), JavaBridgeConfiguration.ALL_JAVA_IMPORTS);
+        this.moduleDescriptor = new org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl(org.jetbrains.jet.lang.resolve.name.Name.special("<dummy>"), org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration.ALL_JAVA_IMPORTS, org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap.getInstance());
         this.project = project;
         this.psiDeclarationProviderFactory = new PsiDeclarationProviderFactory(getPsiClassFinder());
         this.javaTypeTransformer = new JavaTypeTransformer();

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

@@ -223,6 +223,6 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
 
     @NotNull
     public static ModuleDescriptorImpl createJavaModule(@NotNull String name) {
-        return new ModuleDescriptorImpl(Name.special(name), JavaBridgeConfiguration.ALL_JAVA_IMPORTS);
+        return new ModuleDescriptorImpl(Name.special(name), JavaBridgeConfiguration.ALL_JAVA_IMPORTS, JavaToKotlinClassMap.getInstance());
     }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java

@@ -52,7 +52,8 @@ public final class JavaNamespaceResolver {
 
     @NotNull
     public static final ModuleDescriptor FAKE_ROOT_MODULE = new ModuleDescriptorImpl(JavaDescriptorResolver.JAVA_ROOT,
-                                                                                     JavaBridgeConfiguration.ALL_JAVA_IMPORTS);
+                                                                                     JavaBridgeConfiguration.ALL_JAVA_IMPORTS,
+                                                                                     JavaToKotlinClassMap.getInstance());
     @NotNull
     private final Map<FqName, JavaBaseScope> resolvedNamespaceCache = Maps.newHashMap();
     @NotNull

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

@@ -35,13 +35,19 @@ public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements C
     private NamespaceDescriptor rootNamepsace;
     private ModuleConfiguration moduleConfiguration;
     private final List<ImportPath> defaultImports;
+    private final PlatformToKotlinClassMap platformToKotlinClassMap;
 
-    public ModuleDescriptorImpl(@NotNull Name name, @NotNull List<ImportPath> defaultImports) {
+    public ModuleDescriptorImpl(
+            @NotNull Name name,
+            @NotNull List<ImportPath> defaultImports,
+            @NotNull PlatformToKotlinClassMap platformToKotlinClassMap
+    ) {
         super(Collections.<AnnotationDescriptor>emptyList(), name);
         if (!name.isSpecial()) {
             throw new IllegalArgumentException("module name must be special: " + name);
         }
         this.defaultImports = defaultImports;
+        this.platformToKotlinClassMap = platformToKotlinClassMap;
     }
 
     public void setRootNamespace(@NotNull NamespaceDescriptor rootNs) {
@@ -77,7 +83,7 @@ public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements C
     @NotNull
     @Override
     public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
-        return getModuleConfiguration().getPlatformToKotlinClassMap();
+        return platformToKotlinClassMap;
     }
 
     @Inject

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

@@ -23,6 +23,7 @@ import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerBasic;
 import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.impl.*;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
@@ -187,7 +188,8 @@ public class TopDownAnalyzer {
             @NotNull JetClassOrObject object
     ) {
         ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<dummy for object>"),
-                                                                         Collections.<ImportPath>emptyList());
+                                                                         Collections.<ImportPath>emptyList(),
+                                                                         PlatformToKotlinClassMap.EMPTY);
         moduleDescriptor.setModuleConfiguration(ModuleConfiguration.EMPTY);
 
         TopDownAnalysisParameters topDownAnalysisParameters =

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

@@ -19,6 +19,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.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.*;
@@ -35,7 +36,11 @@ public class ErrorUtils {
 
     private static final ModuleDescriptor ERROR_MODULE;
     static {
-        ModuleDescriptorImpl module = new ModuleDescriptorImpl(Name.special("<ERROR MODULE>"), Collections.<ImportPath>emptyList());
+        ModuleDescriptorImpl module = new ModuleDescriptorImpl(
+                Name.special("<ERROR MODULE>"),
+                Collections.<ImportPath>emptyList(),
+                PlatformToKotlinClassMap.EMPTY
+        );
         module.setModuleConfiguration(ModuleConfiguration.EMPTY);
         ERROR_MODULE = module;
     }

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

@@ -170,7 +170,8 @@ public class KotlinBuiltIns {
 
     private KotlinBuiltIns(@NotNull Project project) {
         try {
-            this.builtInsModule = new ModuleDescriptorImpl(Name.special("<built-ins lazy module>"), DefaultModuleConfiguration.DEFAULT_JET_IMPORTS);
+            this.builtInsModule = new ModuleDescriptorImpl(Name.special("<built-ins lazy module>"), DefaultModuleConfiguration.DEFAULT_JET_IMPORTS,
+                                                           PlatformToKotlinClassMap.EMPTY);
             builtInsModule.setModuleConfiguration(SpecialModuleConfiguration.INSTANCE);
             this.analyzer = createLazyResolveSession(project);
 

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

@@ -40,7 +40,7 @@ import org.jetbrains.jet.codegen.forTestCompile.ForTestPackJdkAnnotations;
 import org.jetbrains.jet.config.CommonConfigurationKeys;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.lang.ModuleConfiguration;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.diagnostics.Errors;
@@ -564,7 +564,9 @@ public class JetTestUtils {
     }
 
     public static ModuleDescriptorImpl createEmptyModule(@NotNull String name) {
-        ModuleDescriptorImpl descriptor = new ModuleDescriptorImpl(Name.special(name), Collections.<ImportPath>emptyList());
+        ModuleDescriptorImpl descriptor = new ModuleDescriptorImpl(Name.special(name),
+                                                                   Collections.<ImportPath>emptyList(),
+                                                                   PlatformToKotlinClassMap.EMPTY);
         descriptor.setModuleConfiguration(ModuleConfiguration.EMPTY);
         return descriptor;
     }

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

@@ -32,12 +32,10 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetImportsFactory;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
-import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
+import org.jetbrains.jet.lang.resolve.java.*;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
-import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider;
+import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -182,9 +180,10 @@ public class GenerateInjectors {
         generator.addField(JavaBridgeConfiguration.class);
         generator.addPublicField(PsiClassFinderImpl.class);
         generator.addField(false, ModuleDescriptorImpl.class, null,
-                           new GivenExpression("new org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl(" +
+                           new GivenExpression("new " + ModuleDescriptorImpl.class.getCanonicalName() + "(" +
-                                               "org.jetbrains.jet.lang.resolve.name.Name.special(\"<dummy>\"), " +
+                                               Name.class.getCanonicalName() + ".special(\"<dummy>\"), " +
-                                               "JavaBridgeConfiguration.ALL_JAVA_IMPORTS)"));
+                                               JavaBridgeConfiguration.class.getCanonicalName() + ".ALL_JAVA_IMPORTS, " +
+                                               JavaToKotlinClassMap.class.getCanonicalName() + ".getInstance())"));
 
         // Parameters
         generator.addPublicParameter(Project.class);

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

@@ -45,6 +45,7 @@ import org.jetbrains.jet.asJava.LightClassUtil;
 import org.jetbrains.jet.codegen.AsmUtil;
 import org.jetbrains.jet.codegen.binding.PsiCodegenPredictor;
 import org.jetbrains.jet.lang.DefaultModuleConfiguration;
+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.ModuleDescriptorImpl;
@@ -221,7 +222,9 @@ public class JetSourceNavigationHelper {
                         return KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(fqName);
                     }
                 });
-        ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<library module>"), DefaultModuleConfiguration.DEFAULT_JET_IMPORTS);
+        ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<library module>"),
+                                                                         DefaultModuleConfiguration.DEFAULT_JET_IMPORTS,
+                                                                         PlatformToKotlinClassMap.EMPTY);
         moduleDescriptor.setModuleConfiguration(DefaultModuleConfiguration.createStandardConfiguration());
         KotlinCodeAnalyzer analyzer = new ResolveSession(
                 project,

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

@@ -35,6 +35,7 @@ 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.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
@@ -226,7 +227,7 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
 
         private FakeJetNamespaceDescriptor() {
             super(new NamespaceDescriptorImpl(
-                    new ModuleDescriptorImpl(Name.special("<fake_module>"), Collections.<ImportPath>emptyList())
+                    new ModuleDescriptorImpl(Name.special("<fake_module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY)
                             .setModuleConfiguration(ModuleConfiguration.EMPTY),
                   Collections.<AnnotationDescriptor>emptyList(), Name.special("<root>")), Collections.<AnnotationDescriptor>emptyList(),
                   KotlinBuiltIns.getInstance().getBuiltInsPackage().getName());

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

@@ -25,6 +25,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.analyzer.AnalyzerFacadeForEverything;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJs;
+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.psi.JetFile;
@@ -76,7 +77,7 @@ public final class AnalyzerFacadeForJS {
             boolean storeContextForBodiesResolve) {
         Project project = config.getProject();
 
-        ModuleDescriptorImpl owner = new ModuleDescriptorImpl(Name.special("<module>"), JsConfiguration.DEFAULT_IMPORT_PATHS);
+        ModuleDescriptorImpl owner = createJsModule("<module>");
 
         Predicate<PsiFile> completely = Predicates.and(notLibFiles(config.getLibFiles()), filesToAnalyzeCompletely);
 
@@ -142,8 +143,14 @@ public final class AnalyzerFacadeForJS {
         LockBasedStorageManager storageManager = new LockBasedStorageManager();
         FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(
                 storageManager, Config.withJsLibAdded(files, config), Predicates.<FqName>alwaysFalse());
-        ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("<lazy module>"), JsConfiguration.DEFAULT_IMPORT_PATHS);
+        ModuleDescriptorImpl lazyModule = createJsModule("<lazy module>");
         lazyModule.setModuleConfiguration(new JsConfiguration(null));
         return new ResolveSession(config.getProject(), storageManager, lazyModule, declarationProviderFactory);
     }
+
+    @NotNull
+    private static ModuleDescriptorImpl createJsModule(@NotNull String name) {
+        return new ModuleDescriptorImpl(Name.special(name), JsConfiguration.DEFAULT_IMPORT_PATHS, PlatformToKotlinClassMap.EMPTY);
+    }
+
 }