introduced interface PlatformToKotlinClassMap

changed method in ModuleConfiguration (now it returns PlatformToKotlinClassMap)
JavaToKotlinTypesMap implements PlatformToKotlinClassMap
'importAllUnderDeclaration' in Importer uses PlatformToKotlinClassMap

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

@@ -20,22 +20,20 @@ import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.DefaultModuleConfiguration;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.ModuleConfiguration;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetImportDirective;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.ImportPath;
-import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 
 import javax.annotation.PostConstruct;
 import javax.inject.Inject;
 import java.util.Collection;
-import java.util.Collections;
 
 /**
  * @author abreslav
@@ -91,15 +89,7 @@ public class JavaBridgeConfiguration implements ModuleConfiguration {
 
     @NotNull
     @Override
-    public Collection<ClassDescriptor> getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName) {
+    public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
-        return getKotlinAnalogsForJavaStandardClasses(classOrPackageName);
+        return JavaToKotlinClassMap.getInstance();
-    }
-
-    @NotNull
-    public static Collection<ClassDescriptor> getKotlinAnalogsForJavaStandardClasses(@NotNull FqNameUnsafe classOrPackageName) {
-        if (classOrPackageName.isSafe()) {
-            return JavaToKotlinTypesMap.getInstance().getAllKotlinAnalogs(classOrPackageName.toSafe());
-        }
-        return Collections.emptyList();
     }
 }

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

@@ -19,8 +19,12 @@ package org.jetbrains.jet.lang.resolve.java;
 import com.google.common.collect.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
@@ -32,13 +36,13 @@ import java.util.*;
 /**
  * @author svtk
  */
-public class JavaToKotlinTypesMap {
+public class JavaToKotlinClassMap implements PlatformToKotlinClassMap {
-    private static JavaToKotlinTypesMap instance = null;
+    private static JavaToKotlinClassMap instance = null;
 
     @NotNull
-    public static JavaToKotlinTypesMap getInstance() {
+    public static JavaToKotlinClassMap getInstance() {
         if (instance == null) {
-            instance = new JavaToKotlinTypesMap();
+            instance = new JavaToKotlinClassMap();
         }
         return instance;
     }
@@ -48,7 +52,7 @@ public class JavaToKotlinTypesMap {
     private final Map<String, JetType> primitiveTypesMap = Maps.newHashMap();
     private final Multimap<FqName, ClassDescriptor> packagesWithMappedClasses = HashMultimap.create();
 
-    private JavaToKotlinTypesMap() {
+    private JavaToKotlinClassMap() {
         init();
         initPrimitives();
     }
@@ -107,12 +111,12 @@ public class JavaToKotlinTypesMap {
     }
 
     @Nullable
-    public JetType getPrimitiveKotlinAnalog(@NotNull String name) {
+    public JetType mapPrimitiveKotlinClass(@NotNull String name) {
         return primitiveTypesMap.get(name);
     }
 
     @Nullable
-    public ClassDescriptor getKotlinAnalog(@NotNull FqName fqName, @NotNull JavaTypeTransformer.TypeUsage typeUsage) {
+    public ClassDescriptor mapKotlinClass(@NotNull FqName fqName, @NotNull JavaTypeTransformer.TypeUsage typeUsage) {
         if (typeUsage == JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_COVARIANT
                 || typeUsage == JavaTypeTransformer.TypeUsage.SUPERTYPE) {
             ClassDescriptor descriptor = classDescriptorMapForCovariantPositions.get(fqName);
@@ -145,14 +149,17 @@ public class JavaToKotlinTypesMap {
         packagesWithMappedClasses.put(javaClassName.parent(), kotlinDescriptor);
     }
 
+    @Override
     @NotNull
-    public Collection<ClassDescriptor> getAllKotlinAnalogs(@NotNull FqName fqName) {
+    public Collection<ClassDescriptor> mapPlatformClass(@NotNull ClassDescriptor classDescriptor) {
+        FqNameUnsafe className = DescriptorUtils.getFQName(classDescriptor);
+        if (!className.isSafe()) {
+            return Collections.emptyList();
+        }
+        FqName fqName = className.toSafe();
         ClassDescriptor kotlinAnalog = classDescriptorMap.get(fqName);
         ClassDescriptor kotlinCovariantAnalog = classDescriptorMapForCovariantPositions.get(fqName);
-        if (kotlinAnalog == null && kotlinCovariantAnalog == null) {
+        List<ClassDescriptor> descriptors = Lists.newArrayList();
-            return packagesWithMappedClasses.get(fqName);
-        }
-        ArrayList<ClassDescriptor> descriptors = Lists.newArrayList();
         if (kotlinAnalog != null) {
             descriptors.add(kotlinAnalog);
         }
@@ -161,4 +168,14 @@ public class JavaToKotlinTypesMap {
         }
         return descriptors;
     }
+
+    @Override
+    @NotNull
+    public Collection<ClassDescriptor> mapPlatformClassesInside(@NotNull DeclarationDescriptor containingDeclaration) {
+        FqNameUnsafe fqName = DescriptorUtils.getFQName(containingDeclaration);
+        if (!fqName.isSafe()) {
+            return Collections.emptyList();
+        }
+        return packagesWithMappedClasses.get(fqName.toSafe());
+    }
 }

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

@@ -26,9 +26,7 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
-import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
-import org.jetbrains.jet.lang.types.lang.PrimitiveType;
 import org.jetbrains.jet.rt.signature.JetSignatureReader;
 
 import javax.inject.Inject;
@@ -149,8 +147,8 @@ public class JavaTypeTransformer {
                     // 'L extends List<T>' in Java is a List<T> in Kotlin, not a List<T?>
                     boolean nullable = !EnumSet.of(SUPERTYPE_ARGUMENT, SUPERTYPE).contains(howThisTypeIsUsed);
 
-                    ClassDescriptor classData = JavaToKotlinTypesMap.getInstance().getKotlinAnalog(new FqName(psiClass.getQualifiedName()),
+                    ClassDescriptor classData = JavaToKotlinClassMap.getInstance().mapKotlinClass(new FqName(psiClass.getQualifiedName()),
-                                                                                        howThisTypeIsUsed);
+                                                                                                    howThisTypeIsUsed);
 
                     if (classData == null) {
                         classData = resolver.resolveClass(new FqName(psiClass.getQualifiedName()), DescriptorSearchRule.INCLUDE_KOTLIN);
@@ -197,7 +195,7 @@ public class JavaTypeTransformer {
             @Override
             public JetType visitPrimitiveType(PsiPrimitiveType primitiveType) {
                 String canonicalText = primitiveType.getCanonicalText();
-                JetType type = JavaToKotlinTypesMap.getInstance().getPrimitiveKotlinAnalog(canonicalText);
+                JetType type = JavaToKotlinClassMap.getInstance().mapPrimitiveKotlinClass(canonicalText);
                 assert type != null : canonicalText;
                 return type;
             }
@@ -206,7 +204,7 @@ public class JavaTypeTransformer {
             public JetType visitArrayType(PsiArrayType arrayType) {
                 PsiType componentType = arrayType.getComponentType();
                 if (componentType instanceof PsiPrimitiveType) {
-                    JetType jetType = JavaToKotlinTypesMap.getInstance().getPrimitiveKotlinAnalog("[" + componentType.getCanonicalText());
+                    JetType jetType = JavaToKotlinClassMap.getInstance().mapPrimitiveKotlinClass("[" + componentType.getCanonicalText());
                     if (jetType != null)
                         return TypeUtils.makeNullable(jetType);
                 }

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

@@ -95,7 +95,8 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd
         
         this.classDescriptor = null;
         if (!forceReal) {
-            classDescriptor = JavaToKotlinTypesMap.getInstance().getKotlinAnalog(ourName, JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_INVARIANT);
+            classDescriptor = JavaToKotlinClassMap.getInstance().mapKotlinClass(ourName,
+                                                                                  JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_INVARIANT);
         }
 
         if (classDescriptor == null) {

compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java

@@ -18,18 +18,16 @@ package org.jetbrains.jet.analyzer;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.ModuleConfiguration;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetImportDirective;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.BodiesResolveContext;
-import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 
 import java.util.Collection;
-import java.util.Collections;
 
 /**
  * @author Stepan Koltsov
@@ -46,8 +44,8 @@ public class AnalyzeExhaust {
 
         @NotNull
         @Override
-        public Collection<ClassDescriptor> getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName) {
+        public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
-            return Collections.emptyList();
+            return PlatformToKotlinClassMap.EMPTY;
         }
 
         @Override

compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java

@@ -18,20 +18,17 @@ package org.jetbrains.jet.lang;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetImportDirective;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.ImportPath;
-import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
 
 import java.util.Collection;
-import java.util.Collections;
 
 /**
  * @author svtk
@@ -76,7 +73,7 @@ public class DefaultModuleConfiguration implements ModuleConfiguration {
 
     @NotNull
     @Override
-    public Collection<ClassDescriptor> getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName) {
+    public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
-        return Collections.emptyList();
+        return PlatformToKotlinClassMap.EMPTY;
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/ModuleConfiguration.java

@@ -17,15 +17,12 @@
 package org.jetbrains.jet.lang;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetImportDirective;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 
 import java.util.Collection;
-import java.util.Collections;
 
 /**
  * @author abreslav
@@ -42,8 +39,8 @@ public interface ModuleConfiguration {
 
         @NotNull
         @Override
-        public Collection<ClassDescriptor> getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName) {
+        public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
-            return Collections.emptyList();
+            return PlatformToKotlinClassMap.EMPTY;
         }
 
         @Override
@@ -61,5 +58,5 @@ public interface ModuleConfiguration {
     void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope);
 
     @NotNull
-    Collection<ClassDescriptor> getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName);
+    PlatformToKotlinClassMap getPlatformToKotlinClassMap();
 }

compiler/frontend/src/org/jetbrains/jet/lang/PlatformToKotlinClassMap.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2012 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;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+* @author svtk
+*/
+public interface PlatformToKotlinClassMap {
+    PlatformToKotlinClassMap EMPTY = new PlatformToKotlinClassMap() {
+        @NotNull
+        @Override
+        public Collection<ClassDescriptor> mapPlatformClass(@NotNull ClassDescriptor classDescriptor) {
+            return Collections.emptyList();
+        }
+
+        @NotNull
+        @Override
+        public Collection<ClassDescriptor> mapPlatformClassesInside(@NotNull DeclarationDescriptor containingDeclaration) {
+            return Collections.emptyList();
+        }
+    };
+
+    @NotNull
+    Collection<ClassDescriptor> mapPlatformClass(@NotNull ClassDescriptor classDescriptor);
+
+    @NotNull
+    Collection<ClassDescriptor> mapPlatformClassesInside(@NotNull DeclarationDescriptor containingDeclaration);
+}

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

@@ -21,12 +21,14 @@ import com.google.common.collect.Lists;
 import com.intellij.openapi.util.Pair;
 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.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.FilteringScope;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 
+import java.util.Collection;
 import java.util.List;
 
 /**
@@ -34,13 +36,13 @@ import java.util.List;
  */
 /*package*/ interface Importer {
 
-    void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @Nullable Predicate<DeclarationDescriptor> isNotHiddenByKotlinAnalog);
+    void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap);
 
     void addAliasImport(@NotNull DeclarationDescriptor descriptor, @NotNull Name aliasName);
 
     Importer DO_NOTHING = new Importer() {
         @Override
-        public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, Predicate<DeclarationDescriptor> isNotHiddenByKotlinAnalog) {
+        public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) {
         }
 
         @Override
@@ -56,8 +58,8 @@ import java.util.List;
         }
 
         @Override
-        public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @Nullable Predicate<DeclarationDescriptor> isNotHiddenByKotlinAnalog) {
+        public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) {
-            importAllUnderDeclaration(descriptor, isNotHiddenByKotlinAnalog);
+            importAllUnderDeclaration(descriptor, platformToKotlinClassMap);
         }
 
         @Override
@@ -65,7 +67,29 @@ import java.util.List;
             importDeclarationAlias(descriptor, aliasName);
         }
 
-        protected void importAllUnderDeclaration(@NotNull DeclarationDescriptor descriptor, @Nullable Predicate<DeclarationDescriptor> isNotHiddenByKotlinAnalog) {
+        @NotNull
+        private static JetScope createFilteringScope(
+                @NotNull JetScope scope,
+                @NotNull DeclarationDescriptor descriptor,
+                @NotNull PlatformToKotlinClassMap platformToKotlinClassMap
+        ) {
+            final Collection<ClassDescriptor> kotlinAnalogsForClassesInside = platformToKotlinClassMap.mapPlatformClassesInside(
+                    descriptor);
+            if (kotlinAnalogsForClassesInside.isEmpty()) return scope;
+            return new FilteringScope(scope, new Predicate<DeclarationDescriptor>() {
+                @Override
+                public boolean apply(DeclarationDescriptor descriptor) {
+                    for (ClassDescriptor kotlinAnalog : kotlinAnalogsForClassesInside) {
+                        if (kotlinAnalog.getName().equals(descriptor.getName())) {
+                            return false;
+                        }
+                    }
+                    return true;
+                }
+            });
+        }
+
+        protected void importAllUnderDeclaration(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) {
             JetScope scopeToImport = null;
             if (descriptor instanceof NamespaceDescriptor) {
                 scopeToImport = ((NamespaceDescriptor) descriptor).getMemberScope();
@@ -79,10 +103,7 @@ import java.util.List;
                 }
             }
             if (scopeToImport != null) {
-                if (isNotHiddenByKotlinAnalog != null) {
+                namespaceScope.importScope(createFilteringScope(scopeToImport, descriptor, platformToKotlinClassMap));
-                    scopeToImport = new FilteringScope(scopeToImport, isNotHiddenByKotlinAnalog);
-                }
-                namespaceScope.importScope(scopeToImport);
             }
         }
 
@@ -105,8 +126,8 @@ import java.util.List;
 
     class DelayedImporter extends StandardImporter {
         private interface DelayedImportEntry {}
-        private static class AllUnderImportEntry extends Pair<DeclarationDescriptor, Predicate<DeclarationDescriptor>> implements DelayedImportEntry {
+        private static class AllUnderImportEntry extends Pair<DeclarationDescriptor, PlatformToKotlinClassMap> implements DelayedImportEntry {
-            public AllUnderImportEntry(@NotNull DeclarationDescriptor first, @Nullable Predicate<DeclarationDescriptor> second) {
+            public AllUnderImportEntry(@NotNull DeclarationDescriptor first, @Nullable PlatformToKotlinClassMap second) {
                 super(first, second);
             }
         }
@@ -123,8 +144,8 @@ import java.util.List;
         }
 
         @Override
-        public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @Nullable Predicate<DeclarationDescriptor> isNotHiddenByKotlinAnalog) {
+        public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) {
-            imports.add(new AllUnderImportEntry(descriptor, isNotHiddenByKotlinAnalog));
+            imports.add(new AllUnderImportEntry(descriptor, platformToKotlinClassMap));
         }
 
         @Override

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

@@ -19,10 +19,10 @@ package org.jetbrains.jet.lang.resolve;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
@@ -124,7 +124,9 @@ public class ImportsResolver {
                 resolvedDirectives.put(importDirective, descriptors.iterator().next());
             }
             for (DeclarationDescriptor descriptor : descriptors) {
-                reportHasKotlinAnalog(onlyClasses, configuration, trace, importDirective, descriptor);
+                JetExpression importedReference = importDirective.getImportedReference();
+                if (onlyClasses || importedReference == null) continue;
+                reportPlatformClassMappedToKotlin(configuration, trace, importedReference, descriptor);
             }
         }
         delayedImporter.processImports();
@@ -136,19 +138,18 @@ public class ImportsResolver {
         }
     }
 
-    private static void reportHasKotlinAnalog(
+    public static void reportPlatformClassMappedToKotlin(
-            boolean onlyClasses,
             @NotNull ModuleConfiguration configuration,
             @NotNull BindingTrace trace,
-            @NotNull JetImportDirective importDirective,
+            @NotNull JetElement element,
             @NotNull DeclarationDescriptor descriptor
     ) {
-        if (!(descriptor instanceof ClassDescriptor) || onlyClasses) return;
+        if (!(descriptor instanceof ClassDescriptor)) return;
-        FqNameUnsafe fqName = DescriptorUtils.getFQName(descriptor);
+
-        Collection<ClassDescriptor> kotlinAnalogs = configuration.getKotlinAnalogs(fqName);
+        PlatformToKotlinClassMap platformToKotlinMap = configuration.getPlatformToKotlinClassMap();
-        JetExpression importedReference = importDirective.getImportedReference();
+        Collection<ClassDescriptor> kotlinAnalogsForClass = platformToKotlinMap.mapPlatformClass((ClassDescriptor) descriptor);
-        if (importedReference != null && !kotlinAnalogs.isEmpty()) {
+        if (!kotlinAnalogsForClass.isEmpty()) {
-            trace.report(CLASS_HAS_KOTLIN_ANALOG.on(importedReference, kotlinAnalogs));
+            trace.report(CLASS_HAS_KOTLIN_ANALOG.on(element, kotlinAnalogsForClass));
         }
     }
 

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

@@ -85,7 +85,7 @@ public class QualifiedExpressionResolver {
             }
 
             for (DeclarationDescriptor descriptor : descriptors) {
-                importer.addAllUnderImport(descriptor, DescriptorUtils.createIsNotHiddenByKotlinAnalogPredicate(descriptor, moduleConfiguration));
+                importer.addAllUnderImport(descriptor, moduleConfiguration.getPlatformToKotlinClassMap());
             }
             return Collections.emptyList();
         }

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

@@ -37,7 +37,6 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
-import static org.jetbrains.jet.lang.diagnostics.Errors.CLASS_HAS_KOTLIN_ANALOG;
 import static org.jetbrains.jet.lang.diagnostics.Errors.UNSUPPORTED;
 import static org.jetbrains.jet.lang.diagnostics.Errors.WRONG_NUMBER_OF_TYPE_ARGUMENTS;
 
@@ -289,10 +288,7 @@ public class TypeResolver {
         Collection<? extends DeclarationDescriptor> descriptors = qualifiedExpressionResolver.lookupDescriptorsForUserType(userType, scope, trace);
         for (DeclarationDescriptor descriptor : descriptors) {
             if (descriptor instanceof ClassifierDescriptor) {
-                Collection<ClassDescriptor> kotlinAnalogs = moduleConfiguration.getKotlinAnalogs(DescriptorUtils.getFQName(descriptor));
+                ImportsResolver.reportPlatformClassMappedToKotlin(moduleConfiguration, trace, userType, descriptor);
-                if (!kotlinAnalogs.isEmpty()) {
-                    trace.report(CLASS_HAS_KOTLIN_ANALOG.on(userType, kotlinAnalogs));
-                }
                 return (ClassifierDescriptor) descriptor;
             }
         }

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

@@ -25,9 +25,8 @@ import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
-import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
+import org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap;
-import org.jetbrains.jet.lang.resolve.java.JavaToKotlinTypesMap;
 import org.jetbrains.jet.test.util.NamespaceComparator;
 import org.jetbrains.jet.lang.DefaultModuleConfiguration;
 import org.jetbrains.jet.lang.ModuleConfiguration;
@@ -48,7 +47,6 @@ import org.junit.Test;
 import java.io.File;
 import java.io.IOException;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
@@ -121,8 +119,8 @@ public class LazyResolveBuiltinClassesTest extends KotlinTestWithEnvironment {
 
         @NotNull
         @Override
-        public Collection<ClassDescriptor> getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName) {
+        public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
-            return JavaBridgeConfiguration.getKotlinAnalogsForJavaStandardClasses(classOrPackageName);
+            return JavaToKotlinClassMap.getInstance();
         }
     }
 }

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

@@ -28,15 +28,14 @@ import org.jetbrains.jet.di.InjectorForTopDownAnalyzer;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.DefaultModuleConfiguration;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.ModuleConfiguration;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
@@ -118,8 +117,8 @@ public class LazyResolveTestUtil {
 
             @NotNull
             @Override
-            public Collection<ClassDescriptor> getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName) {
+            public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
-                return JavaBridgeConfiguration.getKotlinAnalogsForJavaStandardClasses(classOrPackageName);
+                return JavaToKotlinClassMap.getInstance();
             }
         };
 

idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java

@@ -37,8 +37,8 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.DefaultModuleConfiguration;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.ModuleConfiguration;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
@@ -51,7 +51,6 @@ import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.lazy.FileBasedDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
@@ -243,8 +242,8 @@ public final class AnalyzerFacadeWithCache {
             
             @NotNull
             @Override
-            public Collection<ClassDescriptor> getKotlinAnalogs(@NotNull FqNameUnsafe className) {
+            public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
-                return Collections.emptyList();
+                return PlatformToKotlinClassMap.EMPTY;
             }
         };
 

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

@@ -21,8 +21,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.DefaultModuleConfiguration;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.ModuleConfiguration;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetImportDirective;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
@@ -31,13 +31,11 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
 
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
 
 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isRootNamespace;
@@ -108,7 +106,7 @@ public final class JsConfiguration implements ModuleConfiguration {
 
     @NotNull
     @Override
-    public Collection<ClassDescriptor> getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName) {
+    public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
-        return Collections.emptyList();
+        return PlatformToKotlinClassMap.EMPTY;
     }
 }