diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java index ea3aeb88ee1..0e354116eb1 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java +++ b/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) { diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KtLightClassForExplicitDeclaration.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KtLightClassForExplicitDeclaration.kt index 7b7d705625b..74345689b67 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KtLightClassForExplicitDeclaration.kt +++ b/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 diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt index f89a21f02ac..cf3a2b84512 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt +++ b/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 diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt index 0be888c1043..46c5c930b12 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt +++ b/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 diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.java index a247ceb6d11..c6d6ddf0569 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.java +++ b/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 javaToKotlin = new HashMap(); + private final Map javaToKotlin = new HashMap(); private final Map kotlinToJava = new HashMap(); - private final Map mutableToReadOnly = new HashMap(); - private final Map readOnlyToMutable = new HashMap(); + private final Map mutableToReadOnly = new HashMap(); + private final Map readOnlyToMutable = new HashMap(); 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 mapPlatformClass(@NotNull FqName fqName) { - ClassDescriptor kotlinAnalog = mapJavaToKotlin(fqName); + public Collection 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 mapPlatformClass(@NotNull ClassDescriptor classDescriptor) { FqNameUnsafe className = DescriptorUtils.getFqName(classDescriptor); - return className.isSafe() ? mapPlatformClass(className.toSafe()) : Collections.emptySet(); + return className.isSafe() + ? mapPlatformClass(className.toSafe(), getBuiltIns(classDescriptor)) + : Collections.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 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"); } } diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/CompanionObjectMapping.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/CompanionObjectMapping.kt index 4e8143cdc7b..dd8c1253143 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/CompanionObjectMapping.kt +++ b/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() +class CompanionObjectMapping { + private val classesFqNames = linkedSetOf() 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 = - Collections.unmodifiableSet(classes) + fun allClassesWithIntrinsicCompanions(): Set = + 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 } } diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java index 8c6c53011ba..aeb0c809414 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java +++ b/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); } diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt index 700af7f0444..8a6529ec1c3 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt +++ b/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 diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/ImportableFqNameClassifier.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/ImportableFqNameClassifier.kt index eb31a05162f..37140b793e8 100644 --- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/ImportableFqNameClassifier.kt +++ b/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 diff --git a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/DataForConversion.kt b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/DataForConversion.kt index 3593d77d50b..101cd68896b 100644 --- a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/DataForConversion.kt +++ b/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") } } diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt index 7c00c4d14d3..c8c709c88f3 100644 --- a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt +++ b/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 { diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ast/Imports.kt b/j2k/src/org/jetbrains/kotlin/j2k/ast/Imports.kt index 83b434809dc..19005e6e665 100644 --- a/j2k/src/org/jetbrains/kotlin/j2k/ast/Imports.kt +++ b/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) { diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/objects/objectsIntrinsics.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/objects/objectsIntrinsics.kt index eeb09a110cb..be12e69ba8a 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/objects/objectsIntrinsics.kt +++ b/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