From 40561dabed3b2723bc5c4c1a4a1ba1bab4f3007f Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Wed, 3 May 2017 17:58:01 +0300 Subject: [PATCH] J2K JavaToKotlinClassMap --- .../codegen/CollectionStubMethodGenerator.kt | 2 +- ...JvmOverridesBackwardCompatibilityHelper.kt | 2 +- .../jvm/platform/JvmPlatformConfigurator.kt | 2 +- .../KtLightClassForSourceDeclaration.kt | 2 +- .../LazyJavaAnnotationDescriptor.kt | 2 +- .../load/java/lazy/types/JavaTypeResolver.kt | 4 +- .../java/typeEnhancement/typeEnhancement.kt | 2 +- .../java/typeEnhancement/typeQualifiers.kt | 2 +- .../kotlin/load/kotlin/JvmBuiltInsSettings.kt | 4 +- .../load/kotlin/methodSignatureMapping.kt | 4 +- .../load/kotlin/typeSignatureMapping.kt | 2 +- .../kotlin/platform/JavaToKotlinClassMap.java | 239 ------------------ .../kotlin/platform/JavaToKotlinClassMap.kt | 211 ++++++++++++++++ .../serialization/jvm/ClassMapperLite.kt | 2 +- .../reflect/jvm/internal/RuntimeTypeMapper.kt | 2 +- .../src/kotlin/reflect/jvm/internal/util.kt | 2 +- .../jetbrains/kotlin/idea/util/TypeUtils.kt | 2 +- .../navigation/SourceNavigationHelper.kt | 2 +- .../smart/TypeInstantiationItems.kt | 2 +- .../idea/core/ImportableFqNameClassifier.kt | 2 +- .../idea/conversion/copy/DataForConversion.kt | 2 +- .../copy/PlainTextPasteImportResolver.kt | 2 +- .../evaluate/KotlinEvaluationBuilder.kt | 2 +- .../jetbrains/kotlin/j2k/importConversion.kt | 2 +- 24 files changed, 236 insertions(+), 264 deletions(-) delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.java create mode 100644 core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt index f807cc739de..b30b09cf5e9 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt @@ -351,7 +351,7 @@ private val READ_ONLY_ARE_EQUAL_TO_MUTABLE_TYPE_CHECKER = KotlinTypeCheckerImpl. val firstClass = x.declarationDescriptor as? ClassDescriptor ?: return@withAxioms x == y val secondClass = y.declarationDescriptor as? ClassDescriptor ?: return@withAxioms x == y - val j2k = JavaToKotlinClassMap.INSTANCE + val j2k = JavaToKotlinClassMap val firstReadOnly = if (j2k.isMutable(firstClass)) j2k.convertMutableToReadOnly(firstClass) else firstClass val secondReadOnly = if (j2k.isMutable(secondClass)) j2k.convertMutableToReadOnly(secondClass) else secondClass firstReadOnly.typeConstructor == secondReadOnly.typeConstructor diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmOverridesBackwardCompatibilityHelper.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmOverridesBackwardCompatibilityHelper.kt index f4f1838772f..c1b628bd54f 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmOverridesBackwardCompatibilityHelper.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmOverridesBackwardCompatibilityHelper.kt @@ -55,7 +55,7 @@ object JvmOverridesBackwardCompatibilityHelper : OverridesBackwardCompatibilityH val containingClass = DescriptorUtils.getContainingClass(overriddenDescriptor) ?: return false - if (JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(containingClass.fqNameUnsafe) != null) return true + if (JavaToKotlinClassMap.mapKotlinToJava(containingClass.fqNameUnsafe) != null) return true if (overriddenDescriptor.overriddenDescriptors.isEmpty()) return false return isOverridingOnlyDescriptorsThatCanBeImplicitlyOverridden(overriddenDescriptor, visitedDescriptors) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt index 74bc03b6cc0..245046d0d00 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt @@ -74,7 +74,7 @@ object JvmPlatformConfigurator : PlatformConfigurator( overloadFilter = JvmOverloadFilter, - platformToKotlinClassMap = JavaToKotlinClassMap.INSTANCE, + platformToKotlinClassMap = JavaToKotlinClassMap, delegationFilter = JvmDelegationFilter, diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt index 5ff406709c5..50c7a35332a 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt @@ -390,7 +390,7 @@ abstract class KtLightClassForSourceDeclaration(protected val classOrObject: KtC val fqName = FqNameUnsafe(qualifiedName) val mappedQName = if (fqName.isSafe) - JavaToKotlinClassMap.INSTANCE.mapJavaToKotlin(fqName.toSafe())?.asSingleFqName()?.asString() + JavaToKotlinClassMap.mapJavaToKotlin(fqName.toSafe())?.asSingleFqName()?.asString() else null 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 2f4220604a7..ef21904cef7 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 @@ -51,7 +51,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, c.module.builtIns) + val annotationClass = JavaToKotlinClassMap.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/JavaTypeResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt index df6b533883f..3b7067bf5a0 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt @@ -148,7 +148,7 @@ class JavaTypeResolver( return c.components.reflectionTypes.kClass } - val javaToKotlin = JavaToKotlinClassMap.INSTANCE + val javaToKotlin = JavaToKotlinClassMap val howThisTypeIsUsedEffectively = when { attr.flexibility == FLEXIBLE_LOWER_BOUND -> MEMBER_SIGNATURE_COVARIANT @@ -185,7 +185,7 @@ class JavaTypeResolver( fun JavaType?.isSuperWildcard(): Boolean = (this as? JavaWildcardType)?.let { it.bound != null && !it.isExtends } ?: false if (!typeArguments.lastOrNull().isSuperWildcard()) return false - val mutableLastParameterVariance = JavaToKotlinClassMap.INSTANCE.convertReadOnlyToMutable(readOnlyContainer) + val mutableLastParameterVariance = JavaToKotlinClassMap.convertReadOnlyToMutable(readOnlyContainer) .typeConstructor.parameters.lastOrNull()?.variance ?: return false return mutableLastParameterVariance != OUT_VARIANCE diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt index cdafd57590a..56a2e160970 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt @@ -155,7 +155,7 @@ private fun ClassifierDescriptor.enhanceMutability(qualifiers: JavaTypeQualifier if (!position.shouldEnhance()) return this.noChange() if (this !is ClassDescriptor) return this.noChange() // mutability is not applicable for type parameters - val mapping = JavaToKotlinClassMap.INSTANCE + val mapping = JavaToKotlinClassMap when (qualifiers.mutability) { READ_ONLY -> { diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeQualifiers.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeQualifiers.kt index 3b53390b81e..a9cf6ca190f 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeQualifiers.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeQualifiers.kt @@ -55,7 +55,7 @@ private fun KotlinType.extractQualifiers(): JavaTypeQualifiers { asFlexibleType().let { Pair(it.lowerBound, it.upperBound) } else Pair(this, this) - val mapping = JavaToKotlinClassMap.INSTANCE + val mapping = JavaToKotlinClassMap return JavaTypeQualifiers( if (lower.isMarkedNullable) NULLABLE else if (!upper.isMarkedNullable) NOT_NULL else null, if (mapping.isReadOnly(lower)) READ_ONLY else if (mapping.isMutable(upper)) MUTABLE else null, diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/JvmBuiltInsSettings.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/JvmBuiltInsSettings.kt index 9ded7dd1f0f..59f5849df00 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/JvmBuiltInsSettings.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/JvmBuiltInsSettings.kt @@ -56,7 +56,7 @@ open class JvmBuiltInsSettings( deferredOwnerModuleDescriptor: () -> ModuleDescriptor, isAdditionalBuiltInsFeatureSupported: () -> Boolean ) : AdditionalClassPartsProvider, PlatformDependentDeclarationFilter { - private val j2kClassMap = JavaToKotlinClassMap.INSTANCE + private val j2kClassMap = JavaToKotlinClassMap private val ownerModuleDescriptor: ModuleDescriptor by lazy(deferredOwnerModuleDescriptor) private val isAdditionalBuiltInsFeatureSupported: Boolean by lazy(isAdditionalBuiltInsFeatureSupported) @@ -326,7 +326,7 @@ open class JvmBuiltInsSettings( if (isArrayOrPrimitiveArray(fqName)) { return true } - val javaClassId = JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(fqName) ?: return false + val javaClassId = JavaToKotlinClassMap.mapKotlinToJava(fqName) ?: return false val classViaReflection = try { Class.forName(javaClassId.asSingleFqName().asString()) } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/methodSignatureMapping.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/methodSignatureMapping.kt index 71d16d99aee..123671206ae 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/methodSignatureMapping.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/methodSignatureMapping.kt @@ -80,7 +80,7 @@ internal fun CallableDescriptor.computeJvmSignature(): String? = signatures { internal val ClassDescriptor.internalName: String get() { - JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(fqNameSafe.toUnsafe())?.let { + JavaToKotlinClassMap.mapKotlinToJava(fqNameSafe.toUnsafe())?.let { return JvmClassName.byClassId(it).internalName } @@ -89,7 +89,7 @@ internal val ClassDescriptor.internalName: String internal val ClassId.internalName: String get() { - return JvmClassName.byClassId(JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(asSingleFqName().toUnsafe()) ?: this).internalName + return JvmClassName.byClassId(JavaToKotlinClassMap.mapKotlinToJava(asSingleFqName().toUnsafe()) ?: this).internalName } private fun StringBuilder.appendErasedType(type: KotlinType) { diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/typeSignatureMapping.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/typeSignatureMapping.kt index ffeb9d5c123..0b838464db2 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/typeSignatureMapping.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/typeSignatureMapping.kt @@ -209,7 +209,7 @@ private fun mapBuiltInType( return typeFactory.createFromString("[" + JvmPrimitiveType.get(arrayElementType).desc) } - val classId = JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(fqName) + val classId = JavaToKotlinClassMap.mapKotlinToJava(fqName) if (classId != null) { return typeFactory.createObjectType(JvmClassName.byClassId(classId, typeMappingConfiguration).internalName) } 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 deleted file mode 100644 index 76085da49eb..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.java +++ /dev/null @@ -1,239 +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.platform; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -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.*; -import org.jetbrains.kotlin.resolve.DescriptorUtils; -import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType; -import org.jetbrains.kotlin.types.KotlinType; -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 kotlinToJava = new HashMap(); - - private final Map mutableToReadOnly = new HashMap(); - private final Map readOnlyToMutable = new HashMap(); - - private JavaToKotlinClassMap() { - addTopLevel(Object.class, FQ_NAMES.any); - addTopLevel(String.class, FQ_NAMES.string); - addTopLevel(CharSequence.class, FQ_NAMES.charSequence); - addTopLevel(Throwable.class, FQ_NAMES.throwable); - addTopLevel(Cloneable.class, FQ_NAMES.cloneable); - addTopLevel(Number.class, FQ_NAMES.number); - addTopLevel(Comparable.class, FQ_NAMES.comparable); - addTopLevel(Enum.class, FQ_NAMES._enum); - addTopLevel(Annotation.class, FQ_NAMES.annotation); - - addMutableReadOnlyPair(Iterable.class, ClassId.topLevel(FQ_NAMES.iterable), FQ_NAMES.mutableIterable); - addMutableReadOnlyPair(Iterator.class, ClassId.topLevel(FQ_NAMES.iterator), FQ_NAMES.mutableIterator); - addMutableReadOnlyPair(Collection.class, ClassId.topLevel(FQ_NAMES.collection), FQ_NAMES.mutableCollection); - addMutableReadOnlyPair(List.class, ClassId.topLevel(FQ_NAMES.list), FQ_NAMES.mutableList); - addMutableReadOnlyPair(Set.class, ClassId.topLevel(FQ_NAMES.set), FQ_NAMES.mutableSet); - addMutableReadOnlyPair(ListIterator.class, ClassId.topLevel(FQ_NAMES.listIterator), FQ_NAMES.mutableListIterator); - - ClassId mapClassId = ClassId.topLevel(FQ_NAMES.map); - addMutableReadOnlyPair(Map.class, mapClassId, FQ_NAMES.mutableMap); - addMutableReadOnlyPair(Map.Entry.class, mapClassId.createNestedClassId(FQ_NAMES.mapEntry.shortName()), FQ_NAMES.mutableMapEntry); - - for (JvmPrimitiveType jvmType : JvmPrimitiveType.values()) { - add( - ClassId.topLevel(jvmType.getWrapperFqName()), - ClassId.topLevel(KotlinBuiltIns.getPrimitiveFqName(jvmType.getPrimitiveType())) - ); - } - - for (ClassId classId : CompanionObjectMapping.INSTANCE.allClassesWithIntrinsicCompanions()) { - add(ClassId.topLevel( - new FqName("kotlin.jvm.internal." + classId.getShortClassName().asString() + "CompanionObject")), - classId.createNestedClassId(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)), KotlinBuiltIns.getFunctionClassId(i)); - - FunctionClassDescriptor.Kind kFunction = FunctionClassDescriptor.Kind.KFunction; - String kFun = kFunction.getPackageFqName() + "." + kFunction.getClassNamePrefix(); - addKotlinToJava(new FqName(kFun + i), ClassId.topLevel(new FqName(kFun))); - } - - addKotlinToJava(FQ_NAMES.nothing.toSafe(), classId(Void.class)); - } - - /** - * E.g. - * java.lang.String -> kotlin.String - * java.lang.Integer -> kotlin.Int - * kotlin.jvm.internal.IntCompanionObject -> kotlin.Int.Companion - * java.util.List -> kotlin.List - * java.util.Map.Entry -> kotlin.Map.Entry - * java.lang.Void -> null - * kotlin.jvm.functions.Function3 -> kotlin.Function3 - */ - @Nullable - public ClassId mapJavaToKotlin(@NotNull FqName fqName) { - return javaToKotlin.get(fqName.toUnsafe()); - } - - @Nullable - public ClassDescriptor mapJavaToKotlin(@NotNull FqName fqName, @NotNull KotlinBuiltIns builtIns) { - ClassId kotlinClassId = mapJavaToKotlin(fqName); - return kotlinClassId != null ? builtIns.getBuiltInClassByFqName(kotlinClassId.asSingleFqName()) : null; - } - - /** - * E.g. - * kotlin.Throwable -> java.lang.Throwable - * kotlin.Int -> java.lang.Integer - * kotlin.Int.Companion -> kotlin.jvm.internal.IntCompanionObject - * kotlin.Nothing -> java.lang.Void - * kotlin.IntArray -> null - * kotlin.Function3 -> kotlin.jvm.functions.Function3 - * kotlin.reflect.KFunction3 -> kotlin.reflect.KFunction - */ - @Nullable - public ClassId mapKotlinToJava(@NotNull FqNameUnsafe kotlinFqName) { - return kotlinToJava.get(kotlinFqName); - } - - private void addMutableReadOnlyPair( - @NotNull Class javaClass, - @NotNull ClassId kotlinReadOnlyClassId, - @NotNull FqName kotlinMutableFqName - ) { - ClassId javaClassId = classId(javaClass); - - add(javaClassId, kotlinReadOnlyClassId); - addKotlinToJava(kotlinMutableFqName, javaClassId); - - FqName kotlinReadOnlyFqName = kotlinReadOnlyClassId.asSingleFqName(); - mutableToReadOnly.put(kotlinMutableFqName.toUnsafe(), kotlinReadOnlyFqName); - readOnlyToMutable.put(kotlinReadOnlyFqName.toUnsafe(), kotlinMutableFqName); - } - - private void add(@NotNull ClassId javaClassId, @NotNull ClassId kotlinClassId) { - addJavaToKotlin(javaClassId, kotlinClassId); - addKotlinToJava(kotlinClassId.asSingleFqName(), javaClassId); - } - - private void addTopLevel(@NotNull Class javaClass, @NotNull FqNameUnsafe kotlinFqName) { - addTopLevel(javaClass, kotlinFqName.toSafe()); - } - - private void addTopLevel(@NotNull Class javaClass, @NotNull FqName kotlinFqName) { - add(classId(javaClass), ClassId.topLevel(kotlinFqName)); - } - - private void addJavaToKotlin(@NotNull ClassId javaClassId, @NotNull ClassId kotlinClassId) { - javaToKotlin.put(javaClassId.asSingleFqName().toUnsafe(), kotlinClassId); - } - - private void addKotlinToJava(@NotNull FqName kotlinFqNameUnsafe, @NotNull ClassId javaClassId) { - kotlinToJava.put(kotlinFqNameUnsafe.toUnsafe(), javaClassId); - } - - @NotNull - private static ClassId classId(@NotNull Class clazz) { - assert !clazz.isPrimitive() && !clazz.isArray() : "Invalid class: " + clazz; - Class outer = clazz.getDeclaringClass(); - return outer == null - ? ClassId.topLevel(new FqName(clazz.getCanonicalName())) - : classId(outer).createNestedClassId(Name.identifier(clazz.getSimpleName())); - } - - public boolean isJavaPlatformClass(@NotNull FqName fqName) { - return mapJavaToKotlin(fqName) != null; - } - - @NotNull - public Collection mapPlatformClass(@NotNull FqName fqName, @NotNull KotlinBuiltIns builtIns) { - ClassDescriptor kotlinAnalog = mapJavaToKotlin(fqName, builtIns); - if (kotlinAnalog == null) return Collections.emptySet(); - - FqName kotlinMutableAnalogFqName = readOnlyToMutable.get(getFqNameUnsafe(kotlinAnalog)); - if (kotlinMutableAnalogFqName == null) return Collections.singleton(kotlinAnalog); - - 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(), getBuiltIns(classDescriptor)) - : Collections.emptySet(); - } - - public boolean isMutable(@NotNull ClassDescriptor mutable) { - return mutableToReadOnly.containsKey(DescriptorUtils.getFqName(mutable)); - } - - public boolean isMutable(@NotNull KotlinType type) { - ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(type); - return classDescriptor != null && isMutable(classDescriptor); - } - - public boolean isReadOnly(@NotNull ClassDescriptor readOnly) { - return readOnlyToMutable.containsKey(DescriptorUtils.getFqName(readOnly)); - } - - public boolean isReadOnly(@NotNull KotlinType type) { - ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(type); - return classDescriptor != null && isReadOnly(classDescriptor); - } - - @NotNull - public ClassDescriptor convertMutableToReadOnly(@NotNull ClassDescriptor mutable) { - 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 getBuiltIns(descriptor).getBuiltInClassByFqName(oppositeClassFqName); - } - - @NotNull - public ClassDescriptor convertReadOnlyToMutable(@NotNull ClassDescriptor readOnly) { - return convertToOppositeMutability(readOnly, readOnlyToMutable, "read-only"); - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.kt new file mode 100644 index 00000000000..7d9c831cf18 --- /dev/null +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.kt @@ -0,0 +1,211 @@ +/* + * 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.platform + +import org.jetbrains.kotlin.builtins.CompanionObjectMapping +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.builtins.KotlinBuiltIns.FQ_NAMES +import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.name.* +import org.jetbrains.kotlin.resolve.DescriptorUtils +import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns +import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe +import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType +import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.types.TypeUtils +import java.util.* + +object JavaToKotlinClassMap : PlatformToKotlinClassMap { + + private val javaToKotlin = HashMap() + private val kotlinToJava = HashMap() + + private val mutableToReadOnly = HashMap() + private val readOnlyToMutable = HashMap() + + init { + addTopLevel(Any::class.java, FQ_NAMES.any) + addTopLevel(String::class.java, FQ_NAMES.string) + addTopLevel(CharSequence::class.java, FQ_NAMES.charSequence) + addTopLevel(Throwable::class.java, FQ_NAMES.throwable) + addTopLevel(Cloneable::class.java, FQ_NAMES.cloneable) + addTopLevel(Number::class.java, FQ_NAMES.number) + addTopLevel(Comparable::class.java, FQ_NAMES.comparable) + addTopLevel(Enum::class.java, FQ_NAMES._enum) + addTopLevel(Annotation::class.java, FQ_NAMES.annotation) + + addMutableReadOnlyPair(Iterable::class.java, ClassId.topLevel(FQ_NAMES.iterable), FQ_NAMES.mutableIterable) + addMutableReadOnlyPair(Iterator::class.java, ClassId.topLevel(FQ_NAMES.iterator), FQ_NAMES.mutableIterator) + addMutableReadOnlyPair(Collection::class.java, ClassId.topLevel(FQ_NAMES.collection), FQ_NAMES.mutableCollection) + addMutableReadOnlyPair(List::class.java, ClassId.topLevel(FQ_NAMES.list), FQ_NAMES.mutableList) + addMutableReadOnlyPair(Set::class.java, ClassId.topLevel(FQ_NAMES.set), FQ_NAMES.mutableSet) + addMutableReadOnlyPair(ListIterator::class.java, ClassId.topLevel(FQ_NAMES.listIterator), FQ_NAMES.mutableListIterator) + + val mapClassId = ClassId.topLevel(FQ_NAMES.map) + addMutableReadOnlyPair(Map::class.java, mapClassId, FQ_NAMES.mutableMap) + addMutableReadOnlyPair(Map.Entry::class.java, mapClassId.createNestedClassId(FQ_NAMES.mapEntry.shortName()), FQ_NAMES.mutableMapEntry) + + for (jvmType in JvmPrimitiveType.values()) { + add(ClassId.topLevel(jvmType.wrapperFqName), + ClassId.topLevel(KotlinBuiltIns.getPrimitiveFqName(jvmType.primitiveType))) + } + + for (classId in CompanionObjectMapping.allClassesWithIntrinsicCompanions()) { + add(ClassId.topLevel(FqName("kotlin.jvm.internal." + classId.shortClassName.asString() + "CompanionObject")), + classId.createNestedClassId(SpecialNames.DEFAULT_NAME_FOR_COMPANION_OBJECT)) + } + + // TODO: support also functions with >= 23 parameters + for (i in 0..22) { + add(ClassId.topLevel(FqName("kotlin.jvm.functions.Function" + i)), KotlinBuiltIns.getFunctionClassId(i)) + + val kFunction = FunctionClassDescriptor.Kind.KFunction + val kFun = kFunction.packageFqName.toString() + "." + kFunction.classNamePrefix + addKotlinToJava(FqName(kFun + i), ClassId.topLevel(FqName(kFun))) + } + + addKotlinToJava(FQ_NAMES.nothing.toSafe(), classId(Void::class.java)) + } + + /** + * E.g. + * java.lang.String -> kotlin.String + * java.lang.Integer -> kotlin.Int + * kotlin.jvm.internal.IntCompanionObject -> kotlin.Int.Companion + * java.util.List -> kotlin.List + * java.util.Map.Entry -> kotlin.Map.Entry + * java.lang.Void -> null + * kotlin.jvm.functions.Function3 -> kotlin.Function3 + */ + fun mapJavaToKotlin(fqName: FqName): ClassId? { + return javaToKotlin[fqName.toUnsafe()] + } + + fun mapJavaToKotlin(fqName: FqName, builtIns: KotlinBuiltIns): ClassDescriptor? { + val kotlinClassId = mapJavaToKotlin(fqName) + return if (kotlinClassId != null) builtIns.getBuiltInClassByFqName(kotlinClassId.asSingleFqName()) else null + } + + /** + * E.g. + * kotlin.Throwable -> java.lang.Throwable + * kotlin.Int -> java.lang.Integer + * kotlin.Int.Companion -> kotlin.jvm.internal.IntCompanionObject + * kotlin.Nothing -> java.lang.Void + * kotlin.IntArray -> null + * kotlin.Function3 -> kotlin.jvm.functions.Function3 + * kotlin.reflect.KFunction3 -> kotlin.reflect.KFunction + */ + fun mapKotlinToJava(kotlinFqName: FqNameUnsafe): ClassId? { + return kotlinToJava[kotlinFqName] + } + + private fun addMutableReadOnlyPair( + javaClass: Class<*>, + kotlinReadOnlyClassId: ClassId, + kotlinMutableFqName: FqName + ) { + val javaClassId = classId(javaClass) + + add(javaClassId, kotlinReadOnlyClassId) + addKotlinToJava(kotlinMutableFqName, javaClassId) + + val kotlinReadOnlyFqName = kotlinReadOnlyClassId.asSingleFqName() + mutableToReadOnly.put(kotlinMutableFqName.toUnsafe(), kotlinReadOnlyFqName) + readOnlyToMutable.put(kotlinReadOnlyFqName.toUnsafe(), kotlinMutableFqName) + } + + private fun add(javaClassId: ClassId, kotlinClassId: ClassId) { + addJavaToKotlin(javaClassId, kotlinClassId) + addKotlinToJava(kotlinClassId.asSingleFqName(), javaClassId) + } + + private fun addTopLevel(javaClass: Class<*>, kotlinFqName: FqNameUnsafe) { + addTopLevel(javaClass, kotlinFqName.toSafe()) + } + + private fun addTopLevel(javaClass: Class<*>, kotlinFqName: FqName) { + add(classId(javaClass), ClassId.topLevel(kotlinFqName)) + } + + private fun addJavaToKotlin(javaClassId: ClassId, kotlinClassId: ClassId) { + javaToKotlin.put(javaClassId.asSingleFqName().toUnsafe(), kotlinClassId) + } + + private fun addKotlinToJava(kotlinFqNameUnsafe: FqName, javaClassId: ClassId) { + kotlinToJava.put(kotlinFqNameUnsafe.toUnsafe(), javaClassId) + } + + fun isJavaPlatformClass(fqName: FqName): Boolean = mapJavaToKotlin(fqName) != null + + fun mapPlatformClass(fqName: FqName, builtIns: KotlinBuiltIns): Collection { + val kotlinAnalog = mapJavaToKotlin(fqName, builtIns) ?: return emptySet() + + val kotlinMutableAnalogFqName = readOnlyToMutable[kotlinAnalog.fqNameUnsafe] ?: return setOf(kotlinAnalog) + + return Arrays.asList(kotlinAnalog, builtIns.getBuiltInClassByFqName(kotlinMutableAnalogFqName)) + } + + override fun mapPlatformClass(classDescriptor: ClassDescriptor): Collection { + val className = DescriptorUtils.getFqName(classDescriptor) + return if (className.isSafe) + mapPlatformClass(className.toSafe(), classDescriptor.builtIns) + else + emptySet() + } + + fun isMutable(mutable: ClassDescriptor): Boolean = mutableToReadOnly.containsKey(DescriptorUtils.getFqName(mutable)) + + fun isMutable(type: KotlinType): Boolean { + val classDescriptor = TypeUtils.getClassDescriptor(type) + return classDescriptor != null && isMutable(classDescriptor) + } + + fun isReadOnly(readOnly: ClassDescriptor): Boolean = readOnlyToMutable.containsKey(DescriptorUtils.getFqName(readOnly)) + + fun isReadOnly(type: KotlinType): Boolean { + val classDescriptor = TypeUtils.getClassDescriptor(type) + return classDescriptor != null && isReadOnly(classDescriptor) + } + + fun convertMutableToReadOnly(mutable: ClassDescriptor): ClassDescriptor { + return convertToOppositeMutability(mutable, mutableToReadOnly, "mutable") + } + + fun convertReadOnlyToMutable(readOnly: ClassDescriptor): ClassDescriptor { + return convertToOppositeMutability(readOnly, readOnlyToMutable, "read-only") + } + + private fun classId(clazz: Class<*>): ClassId { + assert(!clazz.isPrimitive && !clazz.isArray) { "Invalid class: " + clazz } + val outer = clazz.declaringClass + return if (outer == null) + ClassId.topLevel(FqName(clazz.canonicalName)) + else + classId(outer).createNestedClassId(Name.identifier(clazz.simpleName)) + } + + private fun convertToOppositeMutability( + descriptor: ClassDescriptor, + map: Map, + mutabilityKindName: String + ): ClassDescriptor { + val oppositeClassFqName = map[DescriptorUtils.getFqName(descriptor)] ?: throw IllegalArgumentException("Given class $descriptor is not a $mutabilityKindName collection") + return descriptor.builtIns.getBuiltInClassByFqName(oppositeClassFqName) + } +} diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/serialization/jvm/ClassMapperLite.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/serialization/jvm/ClassMapperLite.kt index 38f41eec15a..d18d9654da7 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/serialization/jvm/ClassMapperLite.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/serialization/jvm/ClassMapperLite.kt @@ -42,7 +42,7 @@ object ClassMapperLite { if (simpleName == KotlinBuiltIns.FQ_NAMES.unit.shortName().asString()) return "V" } - val javaClassId = JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(classId.asSingleFqName().toUnsafe()) + val javaClassId = JavaToKotlinClassMap.mapKotlinToJava(classId.asSingleFqName().toUnsafe()) if (javaClassId != null) { return "L" + javaClassId.asString().replace('.', '$') + ";" } 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 72c2adc1359..661aa0e4628 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt @@ -269,7 +269,7 @@ internal object RuntimeTypeMapper { val classId = klass.classId if (!classId.isLocal) { - JavaToKotlinClassMap.INSTANCE.mapJavaToKotlin(classId.asSingleFqName())?.let { return it } + JavaToKotlinClassMap.mapJavaToKotlin(classId.asSingleFqName())?.let { return it } } return classId diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/util.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/util.kt index 55808677492..bf3d5ab0d32 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/util.kt +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/util.kt @@ -55,7 +55,7 @@ internal fun ClassDescriptor.toJavaClass(): Class<*>? { else -> { // If this is neither a Kotlin class nor a Java class, it is either a built-in or some fake class descriptor like the one // that's created for java.io.Serializable in JvmBuiltInsSettings - val classId = JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(DescriptorUtils.getFqName(this)) ?: classId!! + val classId = JavaToKotlinClassMap.mapKotlinToJava(DescriptorUtils.getFqName(this)) ?: classId!! val packageName = classId.packageFqName.asString() val className = classId.relativeClassName.asString() // All pseudo-classes like kotlin.String.Companion must be accessible from the current class loader diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt index 6847aebad4f..706c7bed6c2 100644 --- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt +++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt @@ -49,7 +49,7 @@ private fun KotlinType.approximateNonDynamicFlexibleTypes( if (isFlexible()) { val flexible = asFlexibleType() val lowerClass = flexible.lowerBound.constructor.declarationDescriptor as? ClassDescriptor? - val isCollection = lowerClass != null && JavaToKotlinClassMap.INSTANCE.isMutable(lowerClass) + val isCollection = lowerClass != null && JavaToKotlinClassMap.isMutable(lowerClass) // (Mutable)Collection! -> MutableCollection? // Foo<(Mutable)Collection!>! -> Foo>? // Foo! -> Foo? diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/SourceNavigationHelper.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/SourceNavigationHelper.kt index da640a67245..b679647f689 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/SourceNavigationHelper.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/SourceNavigationHelper.kt @@ -215,7 +215,7 @@ object SourceNavigationHelper { fun getOriginalPsiClassOrCreateLightClass(classOrObject: KtClassOrObject): PsiClass? { val fqName = classOrObject.fqName if (fqName != null) { - val javaClassId = JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(fqName.toUnsafe()) + val javaClassId = JavaToKotlinClassMap.mapKotlinToJava(fqName.toUnsafe()) if (javaClassId != null) { return JavaPsiFacade.getInstance(classOrObject.project).findClass( javaClassId.asSingleFqName().asString(), diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt index 05b9bde6733..49b9a9b096e 100644 --- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt +++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt @@ -112,7 +112,7 @@ class TypeInstantiationItems( val typeArgs = fuzzyType.type.arguments inheritanceSearchers.addInheritorSearcher(classDescriptor, classDescriptor, typeArgs, fuzzyType.freeParameters, tail) - val javaClassId = JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(DescriptorUtils.getFqName(classifier)) + val javaClassId = JavaToKotlinClassMap.mapKotlinToJava(DescriptorUtils.getFqName(classifier)) if (javaClassId != null) { val javaAnalog = resolutionFacade.moduleDescriptor.resolveTopLevelClass(javaClassId.asSingleFqName(), NoLookupLocation.FROM_IDE) if (javaAnalog != null) { 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 ada925eea18..2e7ec69aecc 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 @@ -93,4 +93,4 @@ class ImportableFqNameClassifier(private val file: KtFile) { } fun isJavaClassNotToBeUsedInKotlin(fqName: FqName): Boolean - = JavaToKotlinClassMap.INSTANCE.isJavaPlatformClass(fqName) || JavaAnnotationMapper.javaToKotlinNameMap[fqName] != null + = JavaToKotlinClassMap.isJavaPlatformClass(fqName) || JavaAnnotationMapper.javaToKotlinNameMap[fqName] != null 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 44aa947ac2f..683bb89fa52 100644 --- a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/DataForConversion.kt +++ b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/DataForConversion.kt @@ -249,7 +249,7 @@ 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.isJavaPlatformClass(fqName.toSafe())) continue + if (fqName.isSafe && JavaToKotlinClassMap.isJavaPlatformClass(fqName.toSafe())) continue append("import $qualifiedName\n") } } diff --git a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/PlainTextPasteImportResolver.kt b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/PlainTextPasteImportResolver.kt index a0edce8e6f2..e5247b434be 100644 --- a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/PlainTextPasteImportResolver.kt +++ b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/PlainTextPasteImportResolver.kt @@ -122,7 +122,7 @@ class PlainTextPasteImportResolver(val dataForConversion: DataForConversion, val .map { it to it.resolveToDescriptor(resolutionFacade) } .filter { canBeImported(it.second) } - classes.find { (_, descriptor) -> JavaToKotlinClassMap.INSTANCE.mapPlatformClass(descriptor!!).isNotEmpty() } + classes.find { (_, descriptor) -> JavaToKotlinClassMap.mapPlatformClass(descriptor!!).isNotEmpty() } ?.let { (psiClass, _) -> addImport(psiElementFactory.createImportStatement(psiClass)) } if (reference.resolve() != null) return true 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 128de0bb998..07eac486079 100644 --- a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt +++ b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt @@ -552,7 +552,7 @@ fun Type.getClassDescriptor(scope: GlobalSearchScope): ClassDescriptor? { val jvmName = JvmClassName.byInternalName(internalName).fqNameForClassNameWithoutDollars // TODO: use the correct built-ins from the module instead of DefaultBuiltIns here - JavaToKotlinClassMap.INSTANCE.mapJavaToKotlin(jvmName)?.let( + JavaToKotlinClassMap.mapJavaToKotlin(jvmName)?.let( DefaultBuiltIns.Instance.builtInsModule::findClassAcrossModuleDependencies )?.let { return it } diff --git a/j2k/src/org/jetbrains/kotlin/j2k/importConversion.kt b/j2k/src/org/jetbrains/kotlin/j2k/importConversion.kt index 3b677cca621..a4e9bab739d 100644 --- a/j2k/src/org/jetbrains/kotlin/j2k/importConversion.kt +++ b/j2k/src/org/jetbrains/kotlin/j2k/importConversion.kt @@ -60,7 +60,7 @@ private fun Converter.convertImport(fqName: FqName, ref: PsiJavaCodeReferenceEle if (annotationConverter.isImportNotRequired(fqName)) return emptyList() - val mapped = JavaToKotlinClassMap.INSTANCE.mapJavaToKotlin(fqName) + val mapped = JavaToKotlinClassMap.mapJavaToKotlin(fqName) mapped?.let { // If imported class has a kotlin analog, drop the import if it is not nested if (!it.isNestedClass) return emptyList()