Remove JavaToKotlinClassMap dependency on built-ins instance

compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java

@@ -21,7 +21,6 @@ import org.jetbrains.kotlin.builtins.CompanionObjectMapping;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.load.java.JvmAbi;
-import org.jetbrains.kotlin.platform.JvmBuiltIns;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.org.objectweb.asm.Type;
 
@@ -29,7 +28,7 @@ import static org.jetbrains.kotlin.resolve.DescriptorUtils.isNonCompanionObject;
 
 public class FieldInfo {
 
-    private static final CompanionObjectMapping COMPANION_OBJECT_MAPPING = new CompanionObjectMapping(JvmBuiltIns.getInstance());
+    private static final CompanionObjectMapping COMPANION_OBJECT_MAPPING = new CompanionObjectMapping();
 
     @NotNull
     public static FieldInfo createForSingleton(@NotNull ClassDescriptor classDescriptor, @NotNull KotlinTypeMapper typeMapper) {

compiler/light-classes/src/org/jetbrains/kotlin/asJava/KtLightClassForExplicitDeclaration.kt

@@ -48,6 +48,7 @@ import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub
 import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import java.util.*
 import javax.swing.Icon
@@ -456,7 +457,10 @@ open class KtLightClassForExplicitDeclaration(
             if (qualifiedName == DescriptorUtils.getFqName(classDescriptor).asString()) return true
 
             val fqName = FqNameUnsafe(qualifiedName)
-            val mappedDescriptor = if (fqName.isSafe()) JavaToKotlinClassMap.INSTANCE.mapJavaToKotlin(fqName.toSafe()) else null
+            val mappedDescriptor =
+                    if (fqName.isSafe)
+                        JavaToKotlinClassMap.INSTANCE.mapJavaToKotlin(fqName.toSafe(), classDescriptor.builtIns)
+                    else null
             val mappedQName = if (mappedDescriptor == null) null else DescriptorUtils.getFqName(mappedDescriptor).asString()
             if (qualifiedName == mappedQName) return true
 

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt

@@ -49,7 +49,7 @@ class LazyJavaAnnotationDescriptor(
 
     private val type = c.storageManager.createLazyValue {
         val fqName = fqName() ?: return@createLazyValue ErrorUtils.createErrorType("No fqName: $javaAnnotation")
-        val annotationClass = JavaToKotlinClassMap.INSTANCE.mapJavaToKotlin(fqName)
+        val annotationClass = JavaToKotlinClassMap.INSTANCE.mapJavaToKotlin(fqName, c.module.builtIns)
                               ?: javaAnnotation.resolve()?.let { javaClass -> c.components.moduleClassResolver.resolveClass(javaClass) }
                               ?: createTypeForMissingDependencies(fqName)
         annotationClass.defaultType

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt

@@ -36,6 +36,7 @@ import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.Flexibility.SpecificityRelation
 import org.jetbrains.kotlin.types.Variance.*
+import org.jetbrains.kotlin.types.typeUtil.builtIns
 import org.jetbrains.kotlin.types.typeUtil.createProjection
 import org.jetbrains.kotlin.types.typeUtil.replaceAnnotations
 import org.jetbrains.kotlin.types.typeUtil.replaceArgumentsWithStarProjections
@@ -143,13 +144,13 @@ class LazyJavaTypeResolver(
 
                 // This case has to be checked before isMarkedReadOnly/isMarkedMutable, because those two are slow
                 // not mapped, we don't care about being marked mutable/read-only
-                javaToKotlin.mapPlatformClass(fqName).isEmpty() -> attr.howThisTypeIsUsed
+                javaToKotlin.mapPlatformClass(fqName, c.module.builtIns).isEmpty() -> attr.howThisTypeIsUsed
 
                 // Read (possibly external) annotations
                 else -> attr.howThisTypeIsUsedAccordingToAnnotations
             }
 
-            val kotlinDescriptor = javaToKotlin.mapJavaToKotlin(fqName) ?: return null
+            val kotlinDescriptor = javaToKotlin.mapJavaToKotlin(fqName, c.module.builtIns) ?: return null
 
             if (javaToKotlin.isReadOnly(kotlinDescriptor)) {
                 if (howThisTypeIsUsedEffectively == MEMBER_SIGNATURE_COVARIANT

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

@@ -22,10 +22,7 @@ import org.jetbrains.kotlin.builtins.CompanionObjectMapping;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor;
 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.name.*;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType;
 import org.jetbrains.kotlin.types.KotlinType;
@@ -34,59 +31,61 @@ import org.jetbrains.kotlin.types.TypeUtils;
 import java.lang.annotation.Annotation;
 import java.util.*;
 
+import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.FQ_NAMES;
+import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt.getBuiltIns;
+import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt.getFqNameUnsafe;
+
 public class JavaToKotlinClassMap implements PlatformToKotlinClassMap {
     public static final JavaToKotlinClassMap INSTANCE = new JavaToKotlinClassMap();
 
-    private final Map<FqName, ClassDescriptor> javaToKotlin = new HashMap<FqName, ClassDescriptor>();
+    private final Map<FqNameUnsafe, FqName> javaToKotlin = new HashMap<FqNameUnsafe, FqName>();
     private final Map<FqNameUnsafe, ClassId> kotlinToJava = new HashMap<FqNameUnsafe, ClassId>();
 
-    private final Map<ClassDescriptor, ClassDescriptor> mutableToReadOnly = new HashMap<ClassDescriptor, ClassDescriptor>();
-    private final Map<ClassDescriptor, ClassDescriptor> readOnlyToMutable = new HashMap<ClassDescriptor, ClassDescriptor>();
+    private final Map<FqNameUnsafe, FqName> mutableToReadOnly = new HashMap<FqNameUnsafe, FqName>();
+    private final Map<FqNameUnsafe, FqName> readOnlyToMutable = new HashMap<FqNameUnsafe, FqName>();
     private final CompanionObjectMapping companionObjectMapping;
 
     private JavaToKotlinClassMap() {
-        KotlinBuiltIns builtIns = JvmBuiltIns.getInstance();
+        add(Object.class, FQ_NAMES.any);
+        add(String.class, FQ_NAMES.string);
+        add(CharSequence.class, FQ_NAMES.charSequence);
+        add(Throwable.class, FQ_NAMES.throwable);
+        add(Cloneable.class, FQ_NAMES.cloneable);
+        add(Number.class, FQ_NAMES.number);
+        add(Comparable.class, FQ_NAMES.comparable);
+        add(Enum.class, FQ_NAMES._enum);
+        add(Annotation.class, FQ_NAMES.annotation);
 
-        add(Object.class, builtIns.getAny());
-        add(String.class, builtIns.getString());
-        add(CharSequence.class, builtIns.getCharSequence());
-        add(Throwable.class, builtIns.getThrowable());
-        add(Cloneable.class, builtIns.getCloneable());
-        add(Number.class, builtIns.getNumber());
-        add(Comparable.class, builtIns.getComparable());
-        add(Enum.class, builtIns.getEnum());
-        add(Annotation.class, builtIns.getAnnotation());
-
-        add(Iterable.class, builtIns.getIterable(), builtIns.getMutableIterable());
-        add(Iterator.class, builtIns.getIterator(), builtIns.getMutableIterator());
-        add(Collection.class, builtIns.getCollection(), builtIns.getMutableCollection());
-        add(List.class, builtIns.getList(), builtIns.getMutableList());
-        add(Set.class, builtIns.getSet(), builtIns.getMutableSet());
-        add(Map.class, builtIns.getMap(), builtIns.getMutableMap());
-        add(Map.Entry.class, builtIns.getMapEntry(), builtIns.getMutableMapEntry());
-        add(ListIterator.class, builtIns.getListIterator(), builtIns.getMutableListIterator());
+        add(Iterable.class, FQ_NAMES.iterable, FQ_NAMES.mutableIterable);
+        add(Iterator.class, FQ_NAMES.iterator, FQ_NAMES.mutableIterator);
+        add(Collection.class, FQ_NAMES.collection, FQ_NAMES.mutableCollection);
+        add(List.class, FQ_NAMES.list, FQ_NAMES.mutableList);
+        add(Set.class, FQ_NAMES.set, FQ_NAMES.mutableSet);
+        add(Map.class, FQ_NAMES.map, FQ_NAMES.mutableMap);
+        add(Map.Entry.class, FQ_NAMES.mapEntry, FQ_NAMES.mutableMapEntry);
+        add(ListIterator.class, FQ_NAMES.listIterator, FQ_NAMES.mutableListIterator);
 
         for (JvmPrimitiveType jvmType : JvmPrimitiveType.values()) {
-            add(ClassId.topLevel(jvmType.getWrapperFqName()), builtIns.getPrimitiveClassDescriptor(jvmType.getPrimitiveType()));
+            add(ClassId.topLevel(jvmType.getWrapperFqName()), KotlinBuiltIns.getPrimitiveFqName(jvmType.getPrimitiveType()));
         }
 
-        companionObjectMapping = new CompanionObjectMapping(builtIns);
-        for (ClassDescriptor descriptor : companionObjectMapping.allClassesWithIntrinsicCompanions()) {
-            ClassDescriptor companion = descriptor.getCompanionObjectDescriptor();
-            assert companion != null : "No companion object found for " + descriptor;
-            add(ClassId.topLevel(new FqName("kotlin.jvm.internal." + descriptor.getName().asString() + "CompanionObject")), companion);
+        companionObjectMapping = new CompanionObjectMapping();
+        for (FqName fqName : companionObjectMapping.allClassesWithIntrinsicCompanions()) {
+            add(ClassId.topLevel(
+                    new FqName("kotlin.jvm.internal." + fqName.shortName().asString() + "CompanionObject")),
+                    fqName.child(SpecialNames.DEFAULT_NAME_FOR_COMPANION_OBJECT));
         }
 
         // TODO: support also functions with >= 23 parameters
         for (int i = 0; i < 23; i++) {
-            add(ClassId.topLevel(new FqName("kotlin.jvm.functions.Function" + i)), builtIns.getFunction(i));
+            add(ClassId.topLevel(new FqName("kotlin.jvm.functions.Function" + i)), KotlinBuiltIns.getFunctionFqName(i));
 
             FunctionClassDescriptor.Kind kFunction = FunctionClassDescriptor.Kind.KFunction;
             String kFun = kFunction.getPackageFqName() + "." + kFunction.getClassNamePrefix();
-            addKotlinToJava(new FqNameUnsafe(kFun + i), ClassId.topLevel(new FqName(kFun)));
+            addKotlinToJava(new FqName(kFun + i), ClassId.topLevel(new FqName(kFun)));
         }
 
-        addKotlinToJava(builtIns.getNothing(), classId(Void.class));
+        addKotlinToJava(FQ_NAMES.nothing.toSafe(), classId(Void.class));
     }
 
     /**
@@ -100,8 +99,9 @@ public class JavaToKotlinClassMap implements PlatformToKotlinClassMap {
      * kotlin.jvm.functions.Function3 -> kotlin.Function3
      */
     @Nullable
-    public ClassDescriptor mapJavaToKotlin(@NotNull FqName fqName) {
-        return javaToKotlin.get(fqName);
+    public ClassDescriptor mapJavaToKotlin(@NotNull FqName fqName, @NotNull KotlinBuiltIns builtIns) {
+        FqName kotlinFqName = javaToKotlin.get(fqName.toUnsafe());
+        return kotlinFqName != null ? builtIns.getBuiltInClassByFqName(kotlinFqName) : null;
     }
 
     /**
@@ -125,37 +125,37 @@ public class JavaToKotlinClassMap implements PlatformToKotlinClassMap {
 
     private void add(
             @NotNull Class<?> javaClass,
-            @NotNull ClassDescriptor kotlinDescriptor,
-            @NotNull ClassDescriptor kotlinMutableDescriptor
+            @NotNull FqName kotlinReadOnlyFqName,
+            @NotNull FqName kotlinMutableFqName
     ) {
         ClassId javaClassId = classId(javaClass);
 
-        add(javaClassId, kotlinDescriptor);
-        addKotlinToJava(kotlinMutableDescriptor, javaClassId);
+        add(javaClassId, kotlinReadOnlyFqName);
+        addKotlinToJava(kotlinMutableFqName, javaClassId);
 
-        mutableToReadOnly.put(kotlinMutableDescriptor, kotlinDescriptor);
-        readOnlyToMutable.put(kotlinDescriptor, kotlinMutableDescriptor);
+        mutableToReadOnly.put(kotlinMutableFqName.toUnsafe(), kotlinReadOnlyFqName);
+        readOnlyToMutable.put(kotlinReadOnlyFqName.toUnsafe(), kotlinMutableFqName);
     }
 
-    private void add(@NotNull ClassId javaClassId, @NotNull ClassDescriptor kotlinDescriptor) {
-        addJavaToKotlin(javaClassId, kotlinDescriptor);
-        addKotlinToJava(kotlinDescriptor, javaClassId);
+    private void add(@NotNull ClassId javaClassId, @NotNull FqName kotlinFqName) {
+        addJavaToKotlin(javaClassId, kotlinFqName);
+        addKotlinToJava(kotlinFqName, javaClassId);
     }
 
-    private void add(@NotNull Class<?> javaClass, @NotNull ClassDescriptor kotlinDescriptor) {
-        add(classId(javaClass), kotlinDescriptor);
+    private void add(@NotNull Class<?> javaClass, @NotNull FqNameUnsafe kotlinFqName) {
+        add(javaClass, kotlinFqName.toSafe());
     }
 
-    private void addJavaToKotlin(@NotNull ClassId javaClassId, @NotNull ClassDescriptor kotlinDescriptor) {
-        javaToKotlin.put(javaClassId.asSingleFqName(), kotlinDescriptor);
+    private void add(@NotNull Class<?> javaClass, @NotNull FqName kotlinFqName) {
+        add(classId(javaClass), kotlinFqName);
     }
 
-    private void addKotlinToJava(@NotNull ClassDescriptor kotlinDescriptor, @NotNull ClassId javaClassId) {
-        addKotlinToJava(DescriptorUtils.getFqName(kotlinDescriptor), javaClassId);
+    private void addJavaToKotlin(@NotNull ClassId javaClassId, @NotNull FqName kotlinFqName) {
+        javaToKotlin.put(javaClassId.asSingleFqName().toUnsafe(), kotlinFqName);
     }
 
-    private void addKotlinToJava(@NotNull FqNameUnsafe kotlinFqName, @NotNull ClassId javaClassId) {
-        kotlinToJava.put(kotlinFqName, javaClassId);
+    private void addKotlinToJava(@NotNull FqName kotlinFqNameUnsafe, @NotNull ClassId javaClassId) {
+        kotlinToJava.put(kotlinFqNameUnsafe.toUnsafe(), javaClassId);
     }
 
     @NotNull
@@ -168,25 +168,27 @@ public class JavaToKotlinClassMap implements PlatformToKotlinClassMap {
     }
 
     @NotNull
-    public Collection<ClassDescriptor> mapPlatformClass(@NotNull FqName fqName) {
-        ClassDescriptor kotlinAnalog = mapJavaToKotlin(fqName);
+    public Collection<ClassDescriptor> mapPlatformClass(@NotNull FqName fqName, @NotNull KotlinBuiltIns builtIns) {
+        ClassDescriptor kotlinAnalog = mapJavaToKotlin(fqName, builtIns);
         if (kotlinAnalog == null) return Collections.emptySet();
 
-        ClassDescriptor kotlinMutableAnalog = readOnlyToMutable.get(kotlinAnalog);
-        if (kotlinMutableAnalog == null) return Collections.singleton(kotlinAnalog);
+        FqName kotlinMutableAnalogFqName = readOnlyToMutable.get(getFqNameUnsafe(kotlinAnalog));
+        if (kotlinMutableAnalogFqName == null) return Collections.singleton(kotlinAnalog);
 
-        return Arrays.asList(kotlinAnalog, kotlinMutableAnalog);
+        return Arrays.asList(kotlinAnalog, builtIns.getBuiltInClassByFqName(kotlinMutableAnalogFqName));
     }
 
     @Override
     @NotNull
     public Collection<ClassDescriptor> mapPlatformClass(@NotNull ClassDescriptor classDescriptor) {
         FqNameUnsafe className = DescriptorUtils.getFqName(classDescriptor);
-        return className.isSafe() ? mapPlatformClass(className.toSafe()) : Collections.<ClassDescriptor>emptySet();
+        return className.isSafe()
+               ? mapPlatformClass(className.toSafe(), getBuiltIns(classDescriptor))
+               : Collections.<ClassDescriptor>emptySet();
     }
 
     public boolean isMutable(@NotNull ClassDescriptor mutable) {
-        return mutableToReadOnly.containsKey(mutable);
+        return mutableToReadOnly.containsKey(DescriptorUtils.getFqName(mutable));
     }
 
     public boolean isMutable(@NotNull KotlinType type) {
@@ -195,7 +197,7 @@ public class JavaToKotlinClassMap implements PlatformToKotlinClassMap {
     }
 
     public boolean isReadOnly(@NotNull ClassDescriptor readOnly) {
-        return readOnlyToMutable.containsKey(readOnly);
+        return readOnlyToMutable.containsKey(DescriptorUtils.getFqName(readOnly));
     }
 
     public boolean isReadOnly(@NotNull KotlinType type) {
@@ -205,19 +207,24 @@ public class JavaToKotlinClassMap implements PlatformToKotlinClassMap {
 
     @NotNull
     public ClassDescriptor convertMutableToReadOnly(@NotNull ClassDescriptor mutable) {
-        ClassDescriptor readOnly = mutableToReadOnly.get(mutable);
-        if (readOnly == null) {
-            throw new IllegalArgumentException("Given class " + mutable + " is not a mutable collection");
+        return convertToOppositeMutability(mutable, mutableToReadOnly, "mutable");
+    }
+
+    @NotNull
+    private static ClassDescriptor convertToOppositeMutability(
+            @NotNull ClassDescriptor descriptor,
+            @NotNull Map<FqNameUnsafe, FqName> map,
+            @NotNull String mutabilityKindName
+    ) {
+        FqName oppositeClassFqName = map.get(DescriptorUtils.getFqName(descriptor));
+        if (oppositeClassFqName == null) {
+            throw new IllegalArgumentException("Given class " + descriptor + " is not a " + mutabilityKindName + " collection");
         }
-        return readOnly;
+        return getBuiltIns(descriptor).getBuiltInClassByFqName(oppositeClassFqName);
     }
 
     @NotNull
     public ClassDescriptor convertReadOnlyToMutable(@NotNull ClassDescriptor readOnly) {
-        ClassDescriptor mutable = readOnlyToMutable.get(readOnly);
-        if (mutable == null) {
-            throw new IllegalArgumentException("Given class " + readOnly + " is not a read-only collection");
-        }
-        return mutable;
+        return convertToOppositeMutability(readOnly, readOnlyToMutable, "read-only");
     }
 }

core/descriptors/src/org/jetbrains/kotlin/builtins/CompanionObjectMapping.kt

@@ -17,25 +17,29 @@
 package org.jetbrains.kotlin.builtins
 
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import java.util.*
 
-class CompanionObjectMapping(private val builtIns: KotlinBuiltIns) {
-    private val classes = linkedSetOf<ClassDescriptor>()
+class CompanionObjectMapping {
+    private val classesFqNames = linkedSetOf<FqName>()
 
     init {
         for (type in PrimitiveType.NUMBER_TYPES) {
-            classes.add(builtIns.getPrimitiveClassDescriptor(type))
+            classesFqNames.add(KotlinBuiltIns.getPrimitiveFqName(type))
         }
-        classes.add(builtIns.string)
-        classes.add(builtIns.enum)
+        classesFqNames.add(KotlinBuiltIns.FQ_NAMES.string.toSafe())
+        classesFqNames.add(KotlinBuiltIns.FQ_NAMES._enum.toSafe())
     }
 
-    fun allClassesWithIntrinsicCompanions(): Set<ClassDescriptor> =
-            Collections.unmodifiableSet(classes)
+    fun allClassesWithIntrinsicCompanions(): Set<FqName> =
+            Collections.unmodifiableSet(classesFqNames)
 
     fun hasMappingToObject(classDescriptor: ClassDescriptor): Boolean {
-        return DescriptorUtils.isCompanionObject(classDescriptor) &&
-               classDescriptor.containingDeclaration in classes
+        if (!DescriptorUtils.isCompanionObject(classDescriptor)) return false
+        val fqName = DescriptorUtils.getFqName(classDescriptor.containingDeclaration)
+        if (!fqName.isSafe) return false
+
+        return fqName.toSafe() in classesFqNames
     }
 }

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

@@ -165,10 +165,12 @@ public abstract class KotlinBuiltIns {
 
 
         public final FqName throwable = fqName("Throwable");
+        public final FqName comparable = fqName("Comparable");
 
         public final FqName deprecated = fqName("Deprecated");
         public final FqName deprecationLevel = fqName("DeprecationLevel");
         public final FqName extensionFunctionType = fqName("ExtensionFunctionType");
+        public final FqName annotation = fqName("Annotation");
         public final FqName target = annotationName("Target");
         public final FqName annotationTarget = annotationName("AnnotationTarget");
         public final FqName annotationRetention = annotationName("AnnotationRetention");
@@ -292,12 +294,28 @@ public abstract class KotlinBuiltIns {
             FqName parent = fqName.parent();
             BuiltInsPackageFragment packageFragment = packageNameToPackageFragment.get(parent);
             if (packageFragment != null) {
-                return getBuiltInClassByNameNullable(fqName.shortName(), packageFragment);
+                ClassDescriptor descriptor = getBuiltInClassByNameNullable(fqName.shortName(), packageFragment);
+                if (descriptor != null) {
+                    return descriptor;
+                }
+            }
+
+            ClassDescriptor possiblyOuterClass = getBuiltInClassByFqNameNullable(parent);
+            if (possiblyOuterClass != null) {
+                return (ClassDescriptor) possiblyOuterClass.getUnsubstitutedInnerClassesScope().getContributedClassifier(
+                        fqName.shortName(), NoLookupLocation.FROM_BUILTINS);
             }
         }
         return null;
     }
 
+    @NotNull
+    public ClassDescriptor getBuiltInClassByFqName(@NotNull FqName fqName) {
+        ClassDescriptor descriptor = getBuiltInClassByFqNameNullable(fqName);
+        assert descriptor != null : "Can't find built-in class " + fqName;
+        return descriptor;
+    }
+
     @Nullable
     private static ClassDescriptor getBuiltInClassByNameNullable(@NotNull Name simpleName, @NotNull PackageFragmentDescriptor packageFragment) {
         ClassifierDescriptor classifier = packageFragment.getMemberScope().getContributedClassifier(
@@ -408,6 +426,11 @@ public abstract class KotlinBuiltIns {
         return "Function" + parameterCount;
     }
 
+    @NotNull
+    public static FqName getFunctionFqName(int parameterCount) {
+        return BUILT_INS_PACKAGE_FQ_NAME.child(Name.identifier(getFunctionName(parameterCount)));
+    }
+
     @NotNull
     public ClassDescriptor getFunction(int parameterCount) {
         return getBuiltInClassByName(getFunctionName(parameterCount));
@@ -915,6 +938,10 @@ public abstract class KotlinBuiltIns {
         return false;
     }
 
+    public static FqName getPrimitiveFqName(@NotNull PrimitiveType primitiveType) {
+        return BUILT_INS_PACKAGE_FQ_NAME.child(primitiveType.getTypeName());
+    }
+
     public static boolean isSuppressAnnotation(@NotNull AnnotationDescriptor annotationDescriptor) {
         return isConstructedFromGivenClass(annotationDescriptor.getType(), FQ_NAMES.suppress);
     }

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

@@ -16,6 +16,7 @@
 
 package kotlin.reflect.jvm.internal
 
+import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
@@ -260,7 +261,7 @@ internal object RuntimeTypeMapper {
 
         val classId = klass.classId
         if (!classId.isLocal) {
-            JavaToKotlinClassMap.INSTANCE.mapJavaToKotlin(classId.asSingleFqName())?.let { return it.classId }
+            JavaToKotlinClassMap.INSTANCE.mapJavaToKotlin(classId.asSingleFqName(), DefaultBuiltIns.Instance)?.let { return it.classId }
         }
 
         return classId

idea/idea-core/src/org/jetbrains/kotlin/idea/core/ImportableFqNameClassifier.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.idea.core
 
+import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.load.java.components.JavaAnnotationMapper
 import org.jetbrains.kotlin.name.FqName
@@ -66,7 +67,7 @@ class ImportableFqNameClassifier(private val file: KtFile) {
         }
 
         return when {
-            JavaToKotlinClassMap.INSTANCE.mapPlatformClass(fqName).isNotEmpty()
+            JavaToKotlinClassMap.INSTANCE.mapPlatformClass(fqName, DefaultBuiltIns.Instance).isNotEmpty()
                     || JavaAnnotationMapper.javaToKotlinNameMap[fqName] != null -> Classification.notToBeUsedInKotlin
 
             fqName.parent() == file.packageFqName -> Classification.fromCurrentPackage

idea/src/org/jetbrains/kotlin/idea/conversion/copy/DataForConversion.kt

@@ -20,6 +20,7 @@ import com.intellij.lang.java.JavaLanguage
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.*
+import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.name.FqNameUnsafe
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.psi.psiUtil.*
@@ -242,7 +243,9 @@ data class DataForConversion private constructor(
                         else {
                             val fqName = FqNameUnsafe(qualifiedName)
                             // skip explicit imports of platform classes mapped into Kotlin classes
-                            if (fqName.isSafe && JavaToKotlinClassMap.INSTANCE.mapPlatformClass(fqName.toSafe()).isNotEmpty()) continue
+                            if (fqName.isSafe
+                                    && JavaToKotlinClassMap.INSTANCE.mapPlatformClass(
+                                    fqName.toSafe(), DefaultBuiltIns.Instance).isNotEmpty()) continue
                             append("import $qualifiedName\n")
                         }
                     }

idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt

@@ -43,6 +43,7 @@ import org.jetbrains.eval4j.jdi.JDIEval
 import org.jetbrains.eval4j.jdi.asJdiValue
 import org.jetbrains.eval4j.jdi.asValue
 import org.jetbrains.eval4j.jdi.makeInitialFrame
+import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding
@@ -546,7 +547,7 @@ fun Type.getClassDescriptor(scope: GlobalSearchScope): ClassDescriptor? {
 
     val jvmName = JvmClassName.byInternalName(internalName).fqNameForClassNameWithoutDollars
 
-    val platformClasses = JavaToKotlinClassMap.INSTANCE.mapPlatformClass(jvmName)
+    val platformClasses = JavaToKotlinClassMap.INSTANCE.mapPlatformClass(jvmName, DefaultBuiltIns.Instance)
     if (platformClasses.isNotEmpty()) return platformClasses.first()
 
     return runReadAction {

j2k/src/org/jetbrains/kotlin/j2k/ast/Imports.kt

@@ -21,6 +21,7 @@ import com.intellij.psi.PsiImportStatementBase
 import com.intellij.psi.PsiJavaCodeReferenceElement
 import org.jetbrains.kotlin.asJava.KtLightClass
 import org.jetbrains.kotlin.asJava.KtLightClassForFacade
+import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.j2k.*
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
@@ -68,7 +69,7 @@ private fun Converter.filterImport(name: String, ref: PsiJavaCodeReferenceElemen
     if (annotationConverter.isImportNotRequired(name)) return null
 
     // If imported class has a kotlin analog, drop the import
-    if (!JavaToKotlinClassMap.INSTANCE.mapPlatformClass(FqName(name)).isEmpty()) return null
+    if (!JavaToKotlinClassMap.INSTANCE.mapPlatformClass(FqName(name), DefaultBuiltIns.Instance).isEmpty()) return null
 
     val target = ref.resolve()
     if (target is KtLightClassForFacade) {

js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/objects/objectsIntrinsics.kt

@@ -38,7 +38,7 @@ class DefaultClassObjectIntrinsic(val fqName: FqName, val moduleName: String): O
 }
 
 class ObjectIntrinsics {
-    private val companionObjectMapping = CompanionObjectMapping(JsPlatform.builtIns)
+    private val companionObjectMapping = CompanionObjectMapping()
 
     fun getIntrinsic(classDescriptor: ClassDescriptor): ObjectIntrinsic {
         if (!companionObjectMapping.hasMappingToObject(classDescriptor)) return NO_OBJECT_INTRINSIC