introduced interface PlatformToKotlinClassMap

changed method in ModuleConfiguration (now it returns PlatformToKotlinClassMap) JavaToKotlinTypesMap implements PlatformToKotlinClassMap 'importAllUnderDeclaration' in Importer uses PlatformToKotlinClassMap
2012-09-07 18:19:04 +04:00
parent c0dc1e6742
commit 3bd79fa701
16 changed files with 156 additions and 97 deletions
@@ -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) {
-        return getKotlinAnalogsForJavaStandardClasses(classOrPackageName);
-    }
-
-    @NotNull
-    public static Collection<ClassDescriptor> getKotlinAnalogsForJavaStandardClasses(@NotNull FqNameUnsafe classOrPackageName) {
-        if (classOrPackageName.isSafe()) {
-            return JavaToKotlinTypesMap.getInstance().getAllKotlinAnalogs(classOrPackageName.toSafe());
-        }
-        return Collections.emptyList();
+    public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
+        return JavaToKotlinClassMap.getInstance();
    }
 }
@@ -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 {
-    private static JavaToKotlinTypesMap instance = null;
+public class JavaToKotlinClassMap implements PlatformToKotlinClassMap {
+    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) {
-            return packagesWithMappedClasses.get(fqName);
-        }
-        ArrayList<ClassDescriptor> descriptors = Lists.newArrayList();
+        List<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());
+    }
 }
@@ -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()),
-                                                                                        howThisTypeIsUsed);
+                    ClassDescriptor classData = JavaToKotlinClassMap.getInstance().mapKotlinClass(new FqName(psiClass.getQualifiedName()),
+                                                                                                    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);
                }
@@ -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) {