Delete AsmUtil.fqNameByAsmTypeUnsafe, refactor KotlinToJavaTypesMap

compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java

@@ -677,12 +677,6 @@ public class AsmUtil {
         return lastSlash < 0 ? internalName : internalName.substring(lastSlash + 1);
     }
 
-    // WARNING: this method works incorrectly for classes with dollars in their names
-    @NotNull
-    public static FqName fqNameByAsmTypeUnsafe(@NotNull Type asmType) {
-        return JvmClassName.byInternalName(asmType.getInternalName()).getFqName();
-    }
-
     @NotNull
     public static Type asmTypeByFqNameWithoutInnerClasses(@NotNull FqName fqName) {
         return Type.getObjectType(JvmClassName.byFqNameWithoutInnerClasses(fqName).getInternalName());

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

@@ -39,6 +39,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.calls.util.ExpressionAsFunctionDescriptor;
 import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.mapping.KotlinToJavaTypesMap;
+import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -259,9 +260,10 @@ public class JetTypeMapper extends BindingTraceAware {
         Type known = null;
         DeclarationDescriptor descriptor = jetType.getConstructor().getDeclarationDescriptor();
 
-        if (mapBuiltinsToJava) {
+        if (mapBuiltinsToJava && descriptor instanceof ClassDescriptor) {
-            if (descriptor instanceof ClassDescriptor) {
+            FqNameUnsafe className = DescriptorUtils.getFQName(descriptor);
-                known = KotlinToJavaTypesMap.getInstance().getJavaAnalog(jetType);
+            if (className.isSafe()) {
+                known = KotlinToJavaTypesMap.getInstance().getJavaAnalog(className.toSafe(), jetType.isNullable());
             }
         }
 

compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java

@@ -67,7 +67,7 @@ import java.net.URLClassLoader;
 import java.util.Collections;
 import java.util.List;
 
-import static org.jetbrains.jet.codegen.AsmUtil.fqNameByAsmTypeUnsafe;
+import static org.jetbrains.jet.codegen.AsmUtil.asmTypeByFqNameWithoutInnerClasses;
 
 public class ReplInterpreter {
 
@@ -184,7 +184,8 @@ public class ReplInterpreter {
     public LineResult eval(@NotNull String line) {
         ++lineNumber;
 
-        Type scriptClassType = Type.getObjectType("Line" + lineNumber);
+        FqName scriptFqName = new FqName("Line" + lineNumber);
+        Type scriptClassType = asmTypeByFqNameWithoutInnerClasses(scriptFqName);
 
         StringBuilder fullText = new StringBuilder();
         for (String prevLine : previousIncompleteLines) {
@@ -239,7 +240,7 @@ public class ReplInterpreter {
         }
 
         try {
-            Class<?> scriptClass = classLoader.loadClass(fqNameByAsmTypeUnsafe(scriptClassType).asString());
+            Class<?> scriptClass = classLoader.loadClass(scriptFqName.asString());
 
             Class<?>[] constructorParams = new Class<?>[earlierLines.size()];
             Object[] constructorArgs = new Object[earlierLines.size()];

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java

@@ -19,7 +19,6 @@ package org.jetbrains.jet.lang.resolve.java.kotlinSignature;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
-import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
@@ -27,10 +26,10 @@ import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
-import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.java.mapping.KotlinToJavaTypesMap;
 import org.jetbrains.jet.lang.resolve.java.resolver.TypeUsage;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -106,10 +105,11 @@ public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
         TypeConstructor originalTypeConstructor = originalType.getConstructor();
         ClassifierDescriptor declarationDescriptor = originalTypeConstructor.getDeclarationDescriptor();
         assert declarationDescriptor != null;
-        String fqName = DescriptorUtils.getFQName(declarationDescriptor).toSafe().asString();
+        FqName originalClassFqName = DescriptorUtils.getFQName(declarationDescriptor).toSafe();
-        ClassDescriptor classFromLibrary = getAutoTypeAnalogWithinBuiltins(qualifiedName);
+        ClassDescriptor classFromLibrary = getAutoTypeAnalogWithinBuiltins(originalClassFqName, qualifiedName);
-        if (!isSameName(qualifiedName, fqName) && classFromLibrary == null) {
+        if (!isSameName(qualifiedName, originalClassFqName.asString()) && classFromLibrary == null) {
-            throw new AlternativeSignatureMismatchException("Alternative signature type mismatch, expected: %s, actual: %s", qualifiedName, fqName);
+            throw new AlternativeSignatureMismatchException("Alternative signature type mismatch, expected: %s, actual: %s",
+                                                            qualifiedName, originalClassFqName);
         }
 
         TypeConstructor typeConstructor;
@@ -206,11 +206,11 @@ public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
     }
 
     @Nullable
-    private ClassDescriptor getAutoTypeAnalogWithinBuiltins(String qualifiedName) {
+    private static ClassDescriptor getAutoTypeAnalogWithinBuiltins(@NotNull FqName originalClassFqName, @NotNull String qualifiedName) {
-        Type javaAnalog = KotlinToJavaTypesMap.getInstance().getJavaAnalog(originalType);
+        FqName javaFqName = KotlinToJavaTypesMap.getInstance().getKotlinToJavaFqName(originalClassFqName);
-        if (javaAnalog == null || javaAnalog.getSort() != Type.OBJECT)  return null;
+        if (javaFqName == null) return null;
-        Collection<ClassDescriptor> descriptors =
+
-                JavaToKotlinClassMap.getInstance().mapPlatformClass(JvmClassName.byInternalName(javaAnalog.getInternalName()).getFqName());
+        Collection<ClassDescriptor> descriptors = JavaToKotlinClassMap.getInstance().mapPlatformClass(javaFqName);
         for (ClassDescriptor descriptor : descriptors) {
             String fqName = DescriptorUtils.getFQName(descriptor).asString();
             if (isSameName(qualifiedName, fqName)) {

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/mapping/KotlinToJavaTypesMap.java

@@ -20,14 +20,12 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
 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.KotlinBuiltIns;
 import org.jetbrains.jet.lang.types.lang.PrimitiveType;
 
@@ -49,6 +47,7 @@ public class KotlinToJavaTypesMap extends JavaToKotlinClassMapBuilder {
 
     private final Map<FqName, Type> asmTypes = new HashMap<FqName, Type>();
     private final Map<FqName, Type> asmNullableTypes = new HashMap<FqName, Type>();
+    private final Map<FqName, FqName> kotlinToJavaFqName = new HashMap<FqName, FqName>();
 
     private KotlinToJavaTypesMap() {
         init();
@@ -64,21 +63,17 @@ public class KotlinToJavaTypesMap extends JavaToKotlinClassMapBuilder {
 
             register(fqName, asmType);
 
-            JvmClassName wrapperName = JvmClassName.byFqNameWithoutInnerClasses(jvmPrimitiveType.getWrapperFqName());
+            FqName wrapperFqName = jvmPrimitiveType.getWrapperFqName();
-            registerNullable(fqName, Type.getObjectType(wrapperName.getInternalName()));
+            registerNullable(fqName, Type.getObjectType(JvmClassName.byFqNameWithoutInnerClasses(wrapperFqName).getInternalName()));
+            registerFqName(fqName, wrapperFqName);
 
             register(builtInsFqName.child(primitiveType.getArrayTypeName()), Type.getType("[" + asmType.getDescriptor()));
         }
     }
 
     @Nullable
-    public Type getJavaAnalog(@NotNull JetType jetType) {
+    public Type getJavaAnalog(@NotNull FqName fqName, boolean isNullable) {
-        ClassifierDescriptor classifier = jetType.getConstructor().getDeclarationDescriptor();
+        if (isNullable) {
-        assert classifier != null;
-        FqNameUnsafe className = DescriptorUtils.getFQName(classifier);
-        if (!className.isSafe()) return null;
-        FqName fqName = className.toSafe();
-        if (jetType.isNullable()) {
             Type nullableType = asmNullableTypes.get(fqName);
             if (nullableType != null) {
                 return nullableType;
@@ -87,10 +82,26 @@ public class KotlinToJavaTypesMap extends JavaToKotlinClassMapBuilder {
         return asmTypes.get(fqName);
     }
 
+    /**
+     * E.g.
+     * jet.Throwable -> java.lang.Throwable
+     * jet.Deprecated -> java.lang.annotation.Deprecated
+     * jet.Int -> java.lang.Integer
+     * jet.IntArray -> null
+     */
+    @Nullable
+    public FqName getKotlinToJavaFqName(@NotNull FqName fqName) {
+        return kotlinToJavaFqName.get(fqName);
+    }
+
     @Override
     protected void register(@NotNull Class<?> javaClass, @NotNull ClassDescriptor kotlinDescriptor, @NotNull Direction direction) {
         if (direction == Direction.BOTH || direction == Direction.KOTLIN_TO_JAVA) {
-            register(kotlinDescriptor, AsmTypeConstants.getType(javaClass));
+            FqNameUnsafe fqNameUnsafe = DescriptorUtils.getFQName(kotlinDescriptor);
+            assert fqNameUnsafe.isSafe() : "FQ name of a mapped class should be safe: " + fqNameUnsafe;
+            FqName fqName = fqNameUnsafe.toSafe();
+            register(fqName, AsmTypeConstants.getType(javaClass));
+            registerFqName(fqName, new FqName(javaClass.getCanonicalName()));
         }
     }
 
@@ -107,12 +118,6 @@ public class KotlinToJavaTypesMap extends JavaToKotlinClassMapBuilder {
         }
     }
 
-    private void register(@NotNull ClassDescriptor kotlinDescriptor, @NotNull Type javaType) {
-        FqNameUnsafe fqName = DescriptorUtils.getFQName(kotlinDescriptor);
-        assert fqName.isSafe();
-        register(fqName.toSafe(), javaType);
-    }
-
     private void register(@NotNull FqName fqName, @NotNull Type type) {
         asmTypes.put(fqName, type);
     }
@@ -120,4 +125,8 @@ public class KotlinToJavaTypesMap extends JavaToKotlinClassMapBuilder {
     private void registerNullable(@NotNull FqName fqName, @NotNull Type nullableType) {
         asmNullableTypes.put(fqName, nullableType);
     }
+
+    private void registerFqName(@NotNull FqName kotlinFqName, @NotNull FqName javaFqName) {
+        kotlinToJavaFqName.put(kotlinFqName, javaFqName);
+    }
 }

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

@@ -40,9 +40,7 @@ import gnu.trove.THashSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
-import org.jetbrains.asm4.Type;
 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;
@@ -50,6 +48,7 @@ import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.java.mapping.KotlinToJavaTypesMap;
 import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
@@ -57,8 +56,8 @@ import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedLazyResolveStorageManager;
 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.types.TypeUtils;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.stubindex.JetFullClassNameIndex;
@@ -70,7 +69,6 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 
-import static org.jetbrains.jet.codegen.AsmUtil.fqNameByAsmTypeUnsafe;
 import static org.jetbrains.jet.plugin.libraries.MemberMatching.*;
 
 public class JetSourceNavigationHelper {
@@ -352,24 +350,17 @@ public class JetSourceNavigationHelper {
             Name className = classOrObject.getNameAsName();
             assert className != null : "Class from BuiltIns should have a name";
             ClassDescriptor classDescriptor = KotlinBuiltIns.getInstance().getBuiltInClassByName(className);
-            Type javaAnalog = KotlinToJavaTypesMap.getInstance().getJavaAnalog(classDescriptor.getDefaultType());
+
-            if (javaAnalog != null) {
+            FqNameUnsafe fqName = DescriptorUtils.getFQName(classDescriptor);
-                if (AsmUtil.isPrimitive(javaAnalog)) {
+            if (fqName.isSafe()) {
-                    javaAnalog = KotlinToJavaTypesMap.getInstance().getJavaAnalog(TypeUtils.makeNullable(classDescriptor.getDefaultType()));
+                FqName javaFqName = KotlinToJavaTypesMap.getInstance().getKotlinToJavaFqName(fqName.toSafe());
-                    assert javaAnalog != null : "Java analog should exists for primitive nullable type";
+                if (javaFqName != null) {
+                    return JavaPsiFacade.getInstance(classOrObject.getProject()).findClass(
+                            javaFqName.asString(), GlobalSearchScope.allScope(classOrObject.getProject()));
                 }
-                if (javaAnalog.getSort() != Type.OBJECT) {
-                    return null;
-                }
-                String fqName = fqNameByAsmTypeUnsafe(javaAnalog).asString();
-                return JavaPsiFacade.getInstance(classOrObject.getProject()).
-                        findClass(fqName, GlobalSearchScope.allScope(classOrObject.getProject()));
             }
         }
-        if (!JetPsiUtil.isLocalClass(classOrObject)) {
+        return JetPsiUtil.isLocalClass(classOrObject) ? null : LightClassUtil.getPsiClass(classOrObject);
-            return LightClassUtil.getPsiClass(classOrObject);
-        }
-        return null;
     }
 
     @Nullable