Merge KotlinToJavaTypesMap into JavaToKotlinClassMap

Also use this new Kotlin->Java mapping in RuntimeTypeMapper instead of
inheriting directly from JavaToKotlinClassMapBuilder

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

@@ -37,6 +37,7 @@ 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.*;
+import org.jetbrains.kotlin.platform.JavaToKotlinClassMap;
 import org.jetbrains.kotlin.psi.JetExpression;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.psi.JetFunctionLiteral;
@@ -56,7 +57,6 @@ import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
-import org.jetbrains.kotlin.resolve.jvm.types.KotlinToJavaTypesMap;
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor;
 import org.jetbrains.kotlin.types.*;
 import org.jetbrains.org.objectweb.asm.Type;
@@ -386,7 +386,7 @@ public class JetTypeMapper {
             return Type.getType("[" + JvmPrimitiveType.get(arrayElementType).getDesc());
         }
 
-        ClassId classId = KotlinToJavaTypesMap.getInstance().mapKotlinFqNameToJava(fqName);
+        ClassId classId = JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(fqName);
         if (classId != null) {
             return Type.getObjectType(JvmClassName.byClassId(classId).getInternalName());
         }

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

@@ -33,7 +33,6 @@ import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.TypeResolver;
 import org.jetbrains.kotlin.resolve.jvm.JvmPackage;
-import org.jetbrains.kotlin.resolve.jvm.types.KotlinToJavaTypesMap;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.types.*;
 
@@ -220,7 +219,7 @@ public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
             @NotNull FqNameUnsafe originalClassFqName,
             @NotNull String qualifiedName
     ) {
-        ClassId javaClassId = KotlinToJavaTypesMap.getInstance().mapKotlinFqNameToJava(originalClassFqName);
+        ClassId javaClassId = JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(originalClassFqName);
         if (javaClassId == null) return null;
 
         Collection<ClassDescriptor> descriptors = JavaToKotlinClassMap.INSTANCE.mapPlatformClass(javaClassId.asSingleFqName());

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

@@ -1,75 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.jvm.types;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.descriptors.ClassDescriptor;
-import org.jetbrains.kotlin.name.ClassId;
-import org.jetbrains.kotlin.name.FqNameUnsafe;
-import org.jetbrains.kotlin.platform.JavaToKotlinClassMapBuilder;
-import org.jetbrains.kotlin.resolve.DescriptorUtils;
-
-import java.util.HashMap;
-import java.util.Map;
-
-public class KotlinToJavaTypesMap extends JavaToKotlinClassMapBuilder {
-    private static KotlinToJavaTypesMap instance = null;
-
-    @NotNull
-    public static KotlinToJavaTypesMap getInstance() {
-        if (instance == null) {
-            instance = new KotlinToJavaTypesMap();
-        }
-        return instance;
-    }
-
-    private final Map<FqNameUnsafe, ClassId> map = new HashMap<FqNameUnsafe, ClassId>();
-
-    private KotlinToJavaTypesMap() {
-        init();
-    }
-
-    /**
-     * E.g.
-     * kotlin.Throwable -> java.lang.Throwable
-     * kotlin.deprecated -> java.lang.Deprecated
-     * kotlin.Int -> java.lang.Integer
-     * kotlin.IntArray -> null
-     */
-    @Nullable
-    public ClassId mapKotlinFqNameToJava(@NotNull FqNameUnsafe kotlinFqName) {
-        return map.get(kotlinFqName);
-    }
-
-    @Override
-    protected void register(@NotNull ClassId javaClassId, @NotNull ClassDescriptor kotlinDescriptor, @NotNull Direction direction) {
-        if (direction == Direction.BOTH || direction == Direction.KOTLIN_TO_JAVA) {
-            map.put(DescriptorUtils.getFqName(kotlinDescriptor), javaClassId);
-        }
-    }
-
-    @Override
-    protected void register(
-            @NotNull ClassId javaClassId,
-            @NotNull ClassDescriptor kotlinDescriptor,
-            @NotNull ClassDescriptor kotlinMutableDescriptor
-    ) {
-        register(javaClassId, kotlinDescriptor, Direction.BOTH);
-        register(javaClassId, kotlinMutableDescriptor, Direction.BOTH);
-    }
-}

core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.java

@@ -31,27 +31,57 @@ import java.util.*;
 public class JavaToKotlinClassMap extends JavaToKotlinClassMapBuilder implements PlatformToKotlinClassMap {
     public static final JavaToKotlinClassMap INSTANCE = new JavaToKotlinClassMap();
 
-    private final Map<FqName, ClassDescriptor> classDescriptorMap = new HashMap<FqName, ClassDescriptor>();
+    private final Map<FqName, ClassDescriptor> javaToKotlin = new HashMap<FqName, ClassDescriptor>();
-    private final Map<FqName, ClassDescriptor> classDescriptorMapForCovariantPositions = new HashMap<FqName, ClassDescriptor>();
+    private final Map<FqName, ClassDescriptor> javaToKotlinCovariant = new HashMap<FqName, ClassDescriptor>();
+    private final Map<FqNameUnsafe, ClassId> kotlinToJava = new HashMap<FqNameUnsafe, ClassId>();
 
     private JavaToKotlinClassMap() {
         init();
     }
 
+    /**
+     * E.g.
+     * java.lang.String -> kotlin.String
+     * java.lang.Deprecated -> kotlin.deprecated
+     * java.lang.Integer -> kotlin.Int
+     * java.util.List -> kotlin.List
+     * java.lang.Void -> null
+     */
     @Nullable
     public ClassDescriptor mapJavaToKotlin(@NotNull FqName fqName) {
-        return classDescriptorMap.get(fqName);
+        return javaToKotlin.get(fqName);
     }
 
+    /**
+     * E.g.
+     * java.util.Collection -> kotlin.MutableCollection
+     * java.util.Map.Entry -> kotlin.MutableMap.MutableEntry
+     * java.lang.String -> null
+     */
     @Nullable
     public ClassDescriptor mapJavaToKotlinCovariant(@NotNull FqName fqName) {
-        return classDescriptorMapForCovariantPositions.get(fqName);
+        return javaToKotlinCovariant.get(fqName);
+    }
+
+    /**
+     * E.g.
+     * kotlin.Throwable -> java.lang.Throwable
+     * kotlin.Int -> java.lang.Integer
+     * kotlin.Nothing -> java.lang.Void
+     * kotlin.IntArray -> null
+     */
+    @Nullable
+    public ClassId mapKotlinToJava(@NotNull FqNameUnsafe kotlinFqName) {
+        return kotlinToJava.get(kotlinFqName);
     }
 
     @Override
     protected void register(@NotNull ClassId javaClassId, @NotNull ClassDescriptor kotlinDescriptor, @NotNull Direction direction) {
         if (direction == Direction.BOTH || direction == Direction.JAVA_TO_KOTLIN) {
-            register(javaClassId, kotlinDescriptor);
+            addJavaToKotlin(javaClassId, kotlinDescriptor);
+        }
+        if (direction == Direction.BOTH || direction == Direction.KOTLIN_TO_JAVA) {
+            addKotlinToJava(javaClassId, kotlinDescriptor);
         }
     }
 
@@ -61,16 +91,22 @@ public class JavaToKotlinClassMap extends JavaToKotlinClassMapBuilder implements
             @NotNull ClassDescriptor kotlinDescriptor,
             @NotNull ClassDescriptor kotlinMutableDescriptor
     ) {
-        register(javaClassId, kotlinDescriptor);
+        addJavaToKotlin(javaClassId, kotlinDescriptor);
-        registerCovariant(javaClassId, kotlinMutableDescriptor);
+        addJavaToKotlinCovariant(javaClassId, kotlinMutableDescriptor);
+        addKotlinToJava(javaClassId, kotlinDescriptor);
+        addKotlinToJava(javaClassId, kotlinMutableDescriptor);
     }
 
-    private void register(@NotNull ClassId javaClassId, @NotNull ClassDescriptor kotlinDescriptor) {
+    private void addJavaToKotlin(@NotNull ClassId javaClassId, @NotNull ClassDescriptor kotlinDescriptor) {
-        classDescriptorMap.put(javaClassId.asSingleFqName(), kotlinDescriptor);
+        javaToKotlin.put(javaClassId.asSingleFqName(), kotlinDescriptor);
     }
 
-    private void registerCovariant(@NotNull ClassId javaClassId, @NotNull ClassDescriptor kotlinDescriptor) {
+    private void addJavaToKotlinCovariant(@NotNull ClassId javaClassId, @NotNull ClassDescriptor kotlinDescriptor) {
-        classDescriptorMapForCovariantPositions.put(javaClassId.asSingleFqName(), kotlinDescriptor);
+        javaToKotlinCovariant.put(javaClassId.asSingleFqName(), kotlinDescriptor);
+    }
+
+    private void addKotlinToJava(@NotNull ClassId javaClassId, @NotNull ClassDescriptor kotlinDescriptor) {
+        kotlinToJava.put(DescriptorUtils.getFqName(kotlinDescriptor), javaClassId);
     }
 
     @NotNull
@@ -103,8 +139,8 @@ public class JavaToKotlinClassMap extends JavaToKotlinClassMapBuilder implements
         KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance();
 
         List<ClassDescriptor> result = new ArrayList<ClassDescriptor>();
-        result.addAll(classDescriptorMap.values());
+        result.addAll(javaToKotlin.values());
-        result.addAll(classDescriptorMapForCovariantPositions.values());
+        result.addAll(javaToKotlinCovariant.values());
 
         for (PrimitiveType type : PrimitiveType.values()) {
             result.add(builtIns.getPrimitiveArrayClassDescriptor(type));

core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt

@@ -23,11 +23,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.load.java.structure.reflect.classId
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.name.FqNameUnsafe
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
-import org.jetbrains.kotlin.platform.JavaToKotlinClassMapBuilder
-import org.jetbrains.kotlin.platform.JavaToKotlinClassMapBuilder.Direction.BOTH
-import org.jetbrains.kotlin.platform.JavaToKotlinClassMapBuilder.Direction.KOTLIN_TO_JAVA
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.classId
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
@@ -35,24 +31,7 @@ import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeUtils
 
-object RuntimeTypeMapper : JavaToKotlinClassMapBuilder() {
+object RuntimeTypeMapper {
-    private val kotlinFqNameToJvmDesc = linkedMapOf<FqNameUnsafe, String>()
-
-    init {
-        init()
-    }
-
-    override fun register(javaClassId: ClassId, kotlinDescriptor: ClassDescriptor, direction: JavaToKotlinClassMapBuilder.Direction) {
-        if (direction == BOTH || direction == KOTLIN_TO_JAVA) {
-            kotlinFqNameToJvmDesc[DescriptorUtils.getFqName(kotlinDescriptor)] = javaClassId.desc
-        }
-    }
-
-    override fun register(javaClassId: ClassId, kotlinDescriptor: ClassDescriptor, kotlinMutableDescriptor: ClassDescriptor) {
-        register(javaClassId, kotlinMutableDescriptor, JavaToKotlinClassMapBuilder.Direction.BOTH)
-        register(javaClassId, kotlinDescriptor, JavaToKotlinClassMapBuilder.Direction.BOTH)
-    }
-
     // TODO: this logic must be shared with JetTypeMapper
     fun mapTypeToJvmDesc(type: JetType): String {
         val classifier = type.getConstructor().getDeclarationDescriptor()
@@ -79,7 +58,7 @@ object RuntimeTypeMapper : JavaToKotlinClassMapBuilder() {
             return "[" + JvmPrimitiveType.get(primitiveType).getDesc()
         }
 
-        kotlinFqNameToJvmDesc[fqName]?.let { return it }
+        JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(fqName)?.let { return it.desc }
 
         if (classDescriptor.isCompanionObject()) {
             IntrinsicObjects.mapType(classDescriptor)?.let { fqName ->

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

@@ -53,6 +53,7 @@ import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.platform.JavaToKotlinClassMap;
 import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
@@ -60,7 +61,6 @@ import org.jetbrains.kotlin.resolve.BindingTraceContext;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
-import org.jetbrains.kotlin.resolve.jvm.types.KotlinToJavaTypesMap;
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
@@ -367,7 +367,7 @@ public class JetSourceNavigationHelper {
             assert className != null : "Class from BuiltIns should have a name";
             ClassDescriptor classDescriptor = KotlinBuiltIns.getInstance().getBuiltInClassByName(className);
 
-            ClassId javaClassId = KotlinToJavaTypesMap.getInstance().mapKotlinFqNameToJava(DescriptorUtils.getFqName(classDescriptor));
+            ClassId javaClassId = JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(DescriptorUtils.getFqName(classDescriptor));
             if (javaClassId != null) {
                 return JavaPsiFacade.getInstance(classOrObject.getProject()).findClass(
                         javaClassId.asSingleFqName().asString(),

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

@@ -37,6 +37,7 @@ import org.jetbrains.kotlin.idea.core.psiClassToDescriptor
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.makeNotNullable
 import org.jetbrains.kotlin.load.java.descriptors.SamConstructorDescriptor
+import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.psi.JetClassOrObject
 import org.jetbrains.kotlin.psi.JetDeclaration
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
@@ -45,7 +46,6 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.PossiblyBareType
 import org.jetbrains.kotlin.resolve.descriptorUtil.resolveTopLevelClass
-import org.jetbrains.kotlin.resolve.jvm.types.KotlinToJavaTypesMap
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
 import org.jetbrains.kotlin.utils.addIfNotNull
@@ -90,7 +90,7 @@ class TypeInstantiationItems(
         if (!KotlinBuiltIns.isAny(classifier)) { // do not search inheritors of Any
             inheritanceSearchers.addInheritorSearcher(classifier, classifier, typeArgs, tail)
 
-            val javaClassId = KotlinToJavaTypesMap.getInstance().mapKotlinFqNameToJava(DescriptorUtils.getFqName(classifier))
+            val javaClassId = JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(DescriptorUtils.getFqName(classifier))
             if (javaClassId != null) {
                 val javaAnalog = moduleDescriptor.resolveTopLevelClass(javaClassId.asSingleFqName())
                 if (javaAnalog != null) {