Simplify KotlinToJavaTypesMap, use only one map

compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java

@@ -36,10 +36,7 @@ import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
 import org.jetbrains.kotlin.load.kotlin.nativeDeclarations.NativeDeclarationsPackage;
-import org.jetbrains.kotlin.name.FqName;
+import org.jetbrains.kotlin.name.*;
-import org.jetbrains.kotlin.name.FqNameUnsafe;
-import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.name.SpecialNames;
 import org.jetbrains.kotlin.psi.JetExpression;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.psi.JetFunctionLiteral;
@@ -54,6 +51,7 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
 import org.jetbrains.kotlin.resolve.constants.StringValue;
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes;
+import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature;
@@ -383,7 +381,17 @@ public class JetTypeMapper {
             return TypeUtils.isNullableType(type) ? boxType(asmType) : asmType;
         }
 
-        return fqName.isSafe() ? KotlinToJavaTypesMap.getInstance().getJavaAnalog(fqName.toSafe()) : null;
+        PrimitiveType arrayElementType = KotlinBuiltIns.getPrimitiveTypeByArrayClassFqName(fqName);
+        if (arrayElementType != null) {
+            return Type.getType("[" + JvmPrimitiveType.get(arrayElementType).getDesc());
+        }
+
+        ClassId classId = KotlinToJavaTypesMap.getInstance().mapKotlinFqNameToJava(fqName);
+        if (classId != null) {
+            return Type.getObjectType(JvmClassName.byClassId(classId).getInternalName());
+        }
+
+        return null;
     }
 
     @NotNull

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/TypeTransformingVisitor.java

@@ -25,7 +25,8 @@ import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.kotlin.load.java.components.TypeUsage;
-import org.jetbrains.kotlin.name.FqName;
+import org.jetbrains.kotlin.name.ClassId;
+import org.jetbrains.kotlin.name.FqNameUnsafe;
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
@@ -112,7 +113,7 @@ public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
         TypeConstructor originalTypeConstructor = originalType.getConstructor();
         ClassifierDescriptor declarationDescriptor = originalTypeConstructor.getDeclarationDescriptor();
         assert declarationDescriptor != null;
-        FqName originalClassFqName = DescriptorUtils.getFqNameSafe(declarationDescriptor);
+        FqNameUnsafe originalClassFqName = DescriptorUtils.getFqName(declarationDescriptor);
         ClassDescriptor classFromLibrary = getAutoTypeAnalogWithinBuiltins(originalClassFqName, qualifiedName);
         if (!isSameName(qualifiedName, originalClassFqName.asString()) && classFromLibrary == null) {
             throw new AlternativeSignatureMismatchException("Alternative signature type mismatch, expected: %s, actual: %s",
@@ -215,11 +216,14 @@ public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
     }
 
     @Nullable
-    private static ClassDescriptor getAutoTypeAnalogWithinBuiltins(@NotNull FqName originalClassFqName, @NotNull String qualifiedName) {
+    private static ClassDescriptor getAutoTypeAnalogWithinBuiltins(
-        FqName javaFqName = KotlinToJavaTypesMap.getInstance().getKotlinToJavaFqName(originalClassFqName);
+            @NotNull FqNameUnsafe originalClassFqName,
-        if (javaFqName == null) return null;
+            @NotNull String qualifiedName
+    ) {
+        ClassId javaClassId = KotlinToJavaTypesMap.getInstance().mapKotlinFqNameToJava(originalClassFqName);
+        if (javaClassId == null) return null;
 
-        Collection<ClassDescriptor> descriptors = JavaToKotlinClassMap.INSTANCE.mapPlatformClass(javaFqName);
+        Collection<ClassDescriptor> descriptors = JavaToKotlinClassMap.INSTANCE.mapPlatformClass(javaClassId.asSingleFqName());
         for (ClassDescriptor descriptor : descriptors) {
             String fqName = DescriptorUtils.getFqName(descriptor).asString();
             if (isSameName(qualifiedName, fqName)) {

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/types/KotlinToJavaTypesMap.java

@@ -19,14 +19,14 @@ package org.jetbrains.kotlin.resolve.jvm.types;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.builtins.PrimitiveType;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
+import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.FqName;
+import org.jetbrains.kotlin.name.FqNameUnsafe;
+import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMapBuilder;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.resolve.jvm.AsmTypes;
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType;
-import org.jetbrains.org.objectweb.asm.Type;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -42,8 +42,7 @@ public class KotlinToJavaTypesMap extends JavaToKotlinClassMapBuilder {
         return instance;
     }
 
-    private final Map<FqName, Type> asmTypes = new HashMap<FqName, Type>();
+    private final Map<FqNameUnsafe, ClassId> map = new HashMap<FqNameUnsafe, ClassId>();
-    private final Map<FqName, FqName> kotlinToJavaFqName = new HashMap<FqName, FqName>();
 
     private KotlinToJavaTypesMap() {
         init();
@@ -51,22 +50,14 @@ public class KotlinToJavaTypesMap extends JavaToKotlinClassMapBuilder {
     }
 
     private void initPrimitives() {
-        FqName builtInsFqName = KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME;
         for (JvmPrimitiveType type : JvmPrimitiveType.values()) {
-            PrimitiveType primitiveType = type.getPrimitiveType();
+            register(
-            FqName fqName = builtInsFqName.child(primitiveType.getTypeName());
+                    KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.child(type.getPrimitiveType().getTypeName()).toUnsafe(),
-
+                    ClassId.topLevel(type.getWrapperFqName())
-            register(fqName, type.getWrapperFqName(), Type.getType(type.getDesc()));
+            );
-
-            asmTypes.put(builtInsFqName.child(primitiveType.getArrayTypeName()), Type.getType("[" + type.getDesc()));
         }
     }
 
-    @Nullable
-    public Type getJavaAnalog(@NotNull FqName fqName) {
-        return asmTypes.get(fqName);
-    }
-
     /**
      * E.g.
      * kotlin.Throwable -> java.lang.Throwable
@@ -75,18 +66,14 @@ public class KotlinToJavaTypesMap extends JavaToKotlinClassMapBuilder {
      * kotlin.IntArray -> null
      */
     @Nullable
-    public FqName getKotlinToJavaFqName(@NotNull FqName fqName) {
+    public ClassId mapKotlinFqNameToJava(@NotNull FqNameUnsafe kotlinFqName) {
-        return kotlinToJavaFqName.get(fqName);
+        return map.get(kotlinFqName);
     }
 
     @Override
     protected void register(@NotNull Class<?> javaClass, @NotNull ClassDescriptor kotlinDescriptor, @NotNull Direction direction) {
         if (direction == Direction.BOTH || direction == Direction.KOTLIN_TO_JAVA) {
-            register(
+            register(DescriptorUtils.getFqName(kotlinDescriptor), computeClassId(javaClass));
-                    DescriptorUtils.getFqNameSafe(kotlinDescriptor),
-                    new FqName(javaClass.getCanonicalName()),
-                    AsmTypes.getType(javaClass)
-            );
         }
     }
 
@@ -100,8 +87,16 @@ public class KotlinToJavaTypesMap extends JavaToKotlinClassMapBuilder {
         register(javaClass, kotlinMutableDescriptor, Direction.BOTH);
     }
 
-    private void register(@NotNull FqName kotlinFqName, @NotNull FqName javaFqName, @NotNull Type asmType) {
+    private void register(@NotNull FqNameUnsafe kotlinFqName, @NotNull ClassId javaClassId) {
-        asmTypes.put(kotlinFqName, asmType);
+        map.put(kotlinFqName, javaClassId);
-        kotlinToJavaFqName.put(kotlinFqName, javaFqName);
+    }
+
+    @NotNull
+    private static ClassId computeClassId(@NotNull Class<?> clazz) {
+        assert !clazz.isPrimitive() && !clazz.isArray() : "Invalid class: " + clazz;
+        Class<?> outer = clazz.getDeclaringClass();
+        return outer == null
+               ? ClassId.topLevel(new FqName(clazz.getCanonicalName()))
+               : computeClassId(outer).createNestedClassId(Name.identifier(clazz.getSimpleName()));
     }
 }

core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java

@@ -166,13 +166,13 @@ public class KotlinBuiltIns {
         public final FqNameUnsafe kClass = new FqName("kotlin.reflect.KClass").toUnsafe();
 
         public final Map<FqNameUnsafe, PrimitiveType> fqNameToPrimitiveType;
-        public final Set<FqNameUnsafe> primitiveArrays;
+        public final Map<FqNameUnsafe, PrimitiveType> arrayClassFqNameToPrimitiveType;
         {
             fqNameToPrimitiveType = new HashMap<FqNameUnsafe, PrimitiveType>(0);
-            primitiveArrays = new HashSet<FqNameUnsafe>(0);
+            arrayClassFqNameToPrimitiveType = new HashMap<FqNameUnsafe, PrimitiveType>(0);
             for (PrimitiveType primitiveType : PrimitiveType.values()) {
                 fqNameToPrimitiveType.put(fqNameUnsafe(primitiveType.getTypeName().asString()), primitiveType);
-                primitiveArrays.add(fqNameUnsafe(primitiveType.getArrayTypeName().asString()));
+                arrayClassFqNameToPrimitiveType.put(fqNameUnsafe(primitiveType.getArrayTypeName().asString()), primitiveType);
             }
         }
 
@@ -582,7 +582,7 @@ public class KotlinBuiltIns {
     }
 
     /**
-     * @return <code>null</code> if not primitive
+     * @return {@code null} if not primitive
      */
     @Nullable
     public JetType getPrimitiveArrayJetTypeByPrimitiveJetType(@NotNull JetType jetType) {
@@ -594,6 +594,11 @@ public class KotlinBuiltIns {
         return FQ_NAMES.fqNameToPrimitiveType.get(primitiveClassFqName);
     }
 
+    @Nullable
+    public static PrimitiveType getPrimitiveTypeByArrayClassFqName(@NotNull FqNameUnsafe primitiveArrayClassFqName) {
+        return FQ_NAMES.arrayClassFqNameToPrimitiveType.get(primitiveArrayClassFqName);
+    }
+
     @NotNull
     public JetType getArrayType(@NotNull Variance projectionType, @NotNull JetType argument) {
         List<TypeProjectionImpl> types = Collections.singletonList(new TypeProjectionImpl(projectionType, argument));
@@ -682,7 +687,7 @@ public class KotlinBuiltIns {
 
     public static boolean isPrimitiveArray(@NotNull JetType type) {
         ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
-        return descriptor != null && FQ_NAMES.primitiveArrays.contains(DescriptorUtils.getFqName(descriptor));
+        return descriptor != null && getPrimitiveTypeByArrayClassFqName(DescriptorUtils.getFqName(descriptor)) != null;
     }
 
     public static boolean isPrimitiveType(@NotNull JetType type) {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/JetSourceNavigationHelper.java

@@ -50,8 +50,8 @@ import org.jetbrains.kotlin.idea.stubindex.JetFullClassNameIndex;
 import org.jetbrains.kotlin.idea.stubindex.JetTopLevelFunctionFqnNameIndex;
 import org.jetbrains.kotlin.idea.stubindex.JetTopLevelPropertyFqnNameIndex;
 import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.name.FqNameUnsafe;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.psi.*;
@@ -367,13 +367,12 @@ public class JetSourceNavigationHelper {
             assert className != null : "Class from BuiltIns should have a name";
             ClassDescriptor classDescriptor = KotlinBuiltIns.getInstance().getBuiltInClassByName(className);
 
-            FqNameUnsafe fqName = DescriptorUtils.getFqName(classDescriptor);
+            ClassId javaClassId = KotlinToJavaTypesMap.getInstance().mapKotlinFqNameToJava(DescriptorUtils.getFqName(classDescriptor));
-            if (fqName.isSafe()) {
+            if (javaClassId != null) {
-                FqName javaFqName = KotlinToJavaTypesMap.getInstance().getKotlinToJavaFqName(fqName.toSafe());
+                return JavaPsiFacade.getInstance(classOrObject.getProject()).findClass(
-                if (javaFqName != null) {
+                        javaClassId.asSingleFqName().asString(),
-                    return JavaPsiFacade.getInstance(classOrObject.getProject()).findClass(
+                        GlobalSearchScope.allScope(classOrObject.getProject())
-                            javaFqName.asString(), GlobalSearchScope.allScope(classOrObject.getProject()));
+                );
-                }
             }
         }
         return LightClassUtil.getPsiClass(classOrObject);

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt

@@ -90,9 +90,9 @@ class TypeInstantiationItems(
         if (!KotlinBuiltIns.isAny(classifier)) { // do not search inheritors of Any
             inheritanceSearchers.addInheritorSearcher(classifier, classifier, typeArgs, tail)
 
-            val javaAnalogFqName = KotlinToJavaTypesMap.getInstance().getKotlinToJavaFqName(DescriptorUtils.getFqNameSafe(classifier))
+            val javaClassId = KotlinToJavaTypesMap.getInstance().mapKotlinFqNameToJava(DescriptorUtils.getFqName(classifier))
-            if (javaAnalogFqName != null) {
+            if (javaClassId != null) {
-                val javaAnalog = moduleDescriptor.resolveTopLevelClass(javaAnalogFqName)
+                val javaAnalog = moduleDescriptor.resolveTopLevelClass(javaClassId.asSingleFqName())
                 if (javaAnalog != null) {
                     inheritanceSearchers.addInheritorSearcher(javaAnalog, classifier, typeArgs, tail)
                 }