From a386a5eb1ef2a022d530b4f625055a2cf3941fd5 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Fri, 24 Aug 2012 17:12:31 +0400 Subject: [PATCH] KotlinToJavaTypesMap, JavaToKotlinTypesMap added --- .../jetbrains/jet/codegen/JetTypeMapper.java | 108 +------------- .../jet/codegen/KotlinToJavaTypesMap.java | 140 ++++++++++++++++++ .../jet/di/InjectorForJetTypeMapper.java | 2 - .../jet/di/InjectorForJvmCodegen.java | 2 - .../resolve/java/JavaToKotlinTypesMap.java | 117 +++++++++++++++ .../resolve/java/JavaTypeTransformer.java | 72 +-------- .../java/JetTypeJetSignatureReader.java | 2 +- 7 files changed, 269 insertions(+), 174 deletions(-) create mode 100644 compiler/backend/src/org/jetbrains/jet/codegen/KotlinToJavaTypesMap.java create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinTypesMap.java diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index b5ad7be0287..3f8fb1a3bee 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -16,7 +16,6 @@ package org.jetbrains.jet.codegen; -import com.google.common.collect.Maps; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -34,22 +33,18 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.*; -import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lang.types.lang.JetStandardLibraryNames; -import org.jetbrains.jet.lang.types.lang.PrimitiveType; -import org.jetbrains.jet.lang.types.ref.ClassName; import javax.annotation.PostConstruct; import javax.inject.Inject; import java.util.ArrayList; import java.util.Collections; import java.util.List; -import java.util.Map; import static org.jetbrains.asm4.Opcodes.*; @@ -64,11 +59,11 @@ public class JetTypeMapper { public static final Type JL_NUMBER_TYPE = Type.getObjectType("java/lang/Number"); public static final Type JL_STRING_BUILDER = Type.getObjectType("java/lang/StringBuilder"); public static final Type JL_STRING_TYPE = Type.getObjectType("java/lang/String"); - private static final Type JL_ENUM_TYPE = Type.getObjectType("java/lang/Enum"); - private static final Type JL_CHAR_SEQUENCE_TYPE = Type.getObjectType("java/lang/CharSequence"); - private static final Type JL_COMPARABLE_TYPE = Type.getObjectType("java/lang/Comparable"); - private static final Type JL_ITERABLE_TYPE = Type.getObjectType("java/lang/Iterable"); - private static final Type JL_ITERATOR_TYPE = Type.getObjectType("java/util/Iterator"); + public static final Type JL_ENUM_TYPE = Type.getObjectType("java/lang/Enum"); + public static final Type JL_CHAR_SEQUENCE_TYPE = Type.getObjectType("java/lang/CharSequence"); + public static final Type JL_COMPARABLE_TYPE = Type.getObjectType("java/lang/Comparable"); + public static final Type JL_ITERABLE_TYPE = Type.getObjectType("java/lang/Iterable"); + public static final Type JL_ITERATOR_TYPE = Type.getObjectType("java/util/Iterator"); public static final Type JL_CLASS_TYPE = Type.getObjectType("java/lang/Class"); public static final Type JL_BOOLEAN_TYPE = Type.getObjectType("java/lang/Boolean"); @@ -89,84 +84,10 @@ public class JetTypeMapper { public static final Type TYPE_FUNCTION0 = Type.getObjectType("jet/Function0"); public static final Type TYPE_FUNCTION1 = Type.getObjectType("jet/Function1"); - public static class SpecialTypes { - private static final class SpecialTypeKey { - @NotNull - private final FqNameUnsafe className; - private final boolean nullable; - - private SpecialTypeKey(@NotNull FqNameUnsafe className, boolean nullable) { - this.className = className; - this.nullable = nullable; - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - - SpecialTypeKey that = (SpecialTypeKey) o; - - if (nullable != that.nullable) return false; - if (!className.equals(that.className)) return false; - - return true; - } - - @Override - public int hashCode() { - int result = className.hashCode(); - result = 31 * result + (nullable ? 1 : 0); - return result; - } - } - - private final Map asmTypes = Maps.newHashMap(); - - @Nullable - public Type get(@NotNull JetType type) { - ClassifierDescriptor classifier = type.getConstructor().getDeclarationDescriptor(); - assert classifier != null; - return asmTypes.get(new SpecialTypeKey(DescriptorUtils.getFQName(classifier), type.isNullable())); - } - - private void register(@NotNull ClassName className, @NotNull Type nonNullType, @NotNull Type nullableType) { - asmTypes.put(new SpecialTypeKey(className.getFqName().toUnsafe(), true), nullableType); - asmTypes.put(new SpecialTypeKey(className.getFqName().toUnsafe(), false), nonNullType); - } - - public void init() { - register(JetStandardLibraryNames.NOTHING, TYPE_NOTHING, TYPE_NOTHING); - - for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { - PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); - register(primitiveType.getClassName(), jvmPrimitiveType.getAsmType(), jvmPrimitiveType.getWrapper().getAsmType()); - } - - register(JetStandardLibraryNames.NUMBER, JL_NUMBER_TYPE, JL_NUMBER_TYPE); - register(JetStandardLibraryNames.STRING, JL_STRING_TYPE, JL_STRING_TYPE); - register(JetStandardLibraryNames.CHAR_SEQUENCE, JL_CHAR_SEQUENCE_TYPE, JL_CHAR_SEQUENCE_TYPE); - register(JetStandardLibraryNames.THROWABLE, TYPE_THROWABLE, TYPE_THROWABLE); - register(JetStandardLibraryNames.COMPARABLE, JL_COMPARABLE_TYPE, JL_COMPARABLE_TYPE); - register(JetStandardLibraryNames.ENUM, JL_ENUM_TYPE, JL_ENUM_TYPE); - register(JetStandardLibraryNames.ITERABLE, JL_ITERABLE_TYPE, JL_ITERABLE_TYPE); - register(JetStandardLibraryNames.ITERATOR, JL_ITERATOR_TYPE, JL_ITERATOR_TYPE); - register(JetStandardLibraryNames.MUTABLE_ITERABLE, JL_ITERABLE_TYPE, JL_ITERABLE_TYPE); - register(JetStandardLibraryNames.MUTABLE_ITERATOR, JL_ITERATOR_TYPE, JL_ITERATOR_TYPE); - - for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { - PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); - register(primitiveType.getArrayClassName(), jvmPrimitiveType.getAsmArrayType(), jvmPrimitiveType.getAsmArrayType()); - } - } - } - - public BindingContext bindingContext; private ClosureAnnotator closureAnnotator; private boolean mapBuiltinsToJava; private ClassBuilderMode classBuilderMode; - private final SpecialTypes specialTypes = new SpecialTypes(); @Inject public void setBindingContext(BindingContext bindingContext) { @@ -188,11 +109,6 @@ public class JetTypeMapper { this.classBuilderMode = classBuilderMode; } - @PostConstruct - public void init() { - specialTypes.init(); - } - public boolean hasThis0(ClassDescriptor classDescriptor) { return closureAnnotator.hasThis0(classDescriptor); } @@ -429,7 +345,7 @@ public class JetTypeMapper { if (mapBuiltinsToJava) { if (classifier instanceof ClassDescriptor) { - known = specialTypes.get(jetType); + known = KotlinToJavaTypesMap.getInstance().getJavaAnalog(jetType); } } @@ -514,7 +430,7 @@ public class JetTypeMapper { if (descriptor instanceof ClassDescriptor) { JvmClassName name = getJvmClassName((ClassDescriptor) descriptor); Type asmType = Type.getObjectType(name.getInternalName() + (kind == MapTypeMode.TRAIT_IMPL ? JvmAbi.TRAIT_IMPL_SUFFIX : "")); - boolean forceReal = isForceReal(name); + boolean forceReal = KotlinToJavaTypesMap.isForceReal(name); writeGenericType(jetType, signatureVisitor, asmType, forceReal); @@ -1067,16 +983,6 @@ public class JetTypeMapper { } } - private static boolean isForceReal(JvmClassName className) { - return JvmPrimitiveType.getByWrapperClass(className) != null - || className.getFqName().getFqName().equals("java.lang.String") - || className.getFqName().getFqName().equals("java.lang.CharSequence") - || className.getFqName().getFqName().equals("java.lang.Object") - || className.getFqName().getFqName().equals("java.lang.Number") - || className.getFqName().getFqName().equals("java.lang.Enum") - || className.getFqName().getFqName().equals("java.lang.Comparable"); - } - private static boolean isGenericsArray(JetType type) { return JetStandardLibraryNames.ARRAY.is(type) && type.getArguments().get(0).getType().getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/KotlinToJavaTypesMap.java b/compiler/backend/src/org/jetbrains/jet/codegen/KotlinToJavaTypesMap.java new file mode 100644 index 00000000000..a45d2b2fa66 --- /dev/null +++ b/compiler/backend/src/org/jetbrains/jet/codegen/KotlinToJavaTypesMap.java @@ -0,0 +1,140 @@ +/* + * Copyright 2010-2012 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.jet.codegen; + +import com.google.common.collect.Maps; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.asm4.Type; +import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; +import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.java.JvmClassName; +import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType; +import org.jetbrains.jet.lang.resolve.name.FqNameBase; +import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.lang.PrimitiveType; +import org.jetbrains.jet.lang.types.ref.ClassName; + +import java.util.Map; + +import static org.jetbrains.jet.codegen.JetTypeMapper.*; +import static org.jetbrains.jet.lang.types.lang.JetStandardLibraryNames.*; + +/** +* @author svtk +*/ +public class KotlinToJavaTypesMap { + private static KotlinToJavaTypesMap instance = null; + + @NotNull + public static KotlinToJavaTypesMap getInstance() { + if (instance == null) { + instance = new KotlinToJavaTypesMap(); + } + return instance; + } + + private final Map asmTypes = Maps.newHashMap(); + + private KotlinToJavaTypesMap() { + init(); + } + + @Nullable + public Type getJavaAnalog(@NotNull JetType jetType) { + ClassifierDescriptor classifier = jetType.getConstructor().getDeclarationDescriptor(); + assert classifier != null; + return asmTypes.get(new SpecialTypeKey(DescriptorUtils.getFQName(classifier), jetType.isNullable())); + } + + private void register(@NotNull ClassName className, @NotNull Type type) { + register(className, type, type); + } + + private void register(@NotNull ClassName className, @NotNull Type nonNullType, @NotNull Type nullableType) { + asmTypes.put(new SpecialTypeKey(className.getFqName().toUnsafe(), true), nullableType); + asmTypes.put(new SpecialTypeKey(className.getFqName().toUnsafe(), false), nonNullType); + } + + public void init() { + register(NOTHING, TYPE_NOTHING); + + for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { + PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); + register(primitiveType.getClassName(), jvmPrimitiveType.getAsmType(), jvmPrimitiveType.getWrapper().getAsmType()); + } + + register(NUMBER, JL_NUMBER_TYPE); + register(STRING, JL_STRING_TYPE); + register(CHAR_SEQUENCE, JL_CHAR_SEQUENCE_TYPE); + register(THROWABLE, TYPE_THROWABLE); + register(COMPARABLE, JL_COMPARABLE_TYPE); + register(ENUM, JL_ENUM_TYPE); + register(ITERABLE, JL_ITERABLE_TYPE); + register(ITERATOR, JL_ITERATOR_TYPE); + register(MUTABLE_ITERABLE, JL_ITERABLE_TYPE); + register(MUTABLE_ITERATOR, JL_ITERATOR_TYPE); + + for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { + PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); + register(primitiveType.getArrayClassName(), jvmPrimitiveType.getAsmArrayType()); + } + } + + public static boolean isForceReal(JvmClassName className) { + return JvmPrimitiveType.getByWrapperClass(className) != null + || className.getFqName().getFqName().equals("java.lang.String") + || className.getFqName().getFqName().equals("java.lang.CharSequence") + || className.getFqName().getFqName().equals("java.lang.Object") + || className.getFqName().getFqName().equals("java.lang.Number") + || className.getFqName().getFqName().equals("java.lang.Enum") + || className.getFqName().getFqName().equals("java.lang.Comparable"); + } + + + private static final class SpecialTypeKey { + @NotNull + private final FqNameUnsafe className; + private final boolean nullable; + + private SpecialTypeKey(@NotNull FqNameUnsafe className, boolean nullable) { + this.className = className; + this.nullable = nullable; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + SpecialTypeKey that = (SpecialTypeKey) o; + + if (nullable != that.nullable) return false; + if (!className.equals(that.className)) return false; + + return true; + } + + @Override + public int hashCode() { + int result = className.hashCode(); + result = 31 * result + (nullable ? 1 : 0); + return result; + } + } +} diff --git a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java index 122bfa6e444..67eb799cee9 100644 --- a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java @@ -56,8 +56,6 @@ public class InjectorForJetTypeMapper { closureAnnotator.setBindingContext(bindingContext); closureAnnotator.setFiles(listOfJetFile); - jetTypeMapper.init(); - } @PreDestroy diff --git a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java index 6398a054a7e..4359135f053 100644 --- a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java @@ -100,8 +100,6 @@ public class InjectorForJvmCodegen { this.closureAnnotator.setBindingContext(bindingContext); this.closureAnnotator.setFiles(listOfJetFile); - jetTypeMapper.init(); - intrinsics.init(); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinTypesMap.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinTypesMap.java new file mode 100644 index 00000000000..dc6faaa1331 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinTypesMap.java @@ -0,0 +1,117 @@ +/* + * Copyright 2010-2012 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.jet.lang.resolve.java; + +import com.google.common.collect.Maps; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; +import org.jetbrains.jet.lang.types.lang.PrimitiveType; + +import java.util.Map; + +/** + * @author svtk + */ +public class JavaToKotlinTypesMap { + private static JavaToKotlinTypesMap instance = null; + + @NotNull + public static JavaToKotlinTypesMap getInstance() { + if (instance == null) { + instance = new JavaToKotlinTypesMap(); + } + return instance; + } + + private final Map classDescriptorMap = Maps.newHashMap(); + private final Map classDescriptorMapForCovariantPositions = Maps.newHashMap(); + private final Map primitiveTypesMap = Maps.newHashMap(); + + private JavaToKotlinTypesMap() { + init(); + initPrimitive(); + } + + @Nullable + public JetType getPrimitiveKotlinAnalog(@NotNull String name) { + return primitiveTypesMap.get(name); + } + + @Nullable + public ClassDescriptor getKotlinAnalog(@NotNull FqName fqName, @NotNull JavaTypeTransformer.TypeUsage typeUsage) { + if (typeUsage == JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_COVARIANT) { + ClassDescriptor descriptor = classDescriptorMapForCovariantPositions.get(fqName); + if (descriptor != null) { + return descriptor; + } + } + return classDescriptorMap.get(fqName); + } + + private void init() { + JetStandardLibrary standardLibrary = JetStandardLibrary.getInstance(); + + for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { + PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); + register(jvmPrimitiveType.getWrapper().getFqName(), standardLibrary.getPrimitiveClassDescriptor(primitiveType)); + } + register("java.lang.Object", JetStandardClasses.getAny()); + register("java.lang.String", standardLibrary.getString()); + register("java.lang.CharSequence", standardLibrary.getCharSequence()); + register("java.lang.Throwable", standardLibrary.getThrowable()); + register("java.lang.Number", standardLibrary.getNumber()); + register("java.lang.Comparable", standardLibrary.getComparable()); + register("java.lang.Enum", standardLibrary.getEnum()); + register("java.lang.Iterable", standardLibrary.getIterable()); + register("java.util.Iterator", standardLibrary.getIterator()); + + registerCovariant("java.lang.Iterable", standardLibrary.getMutableIterable()); + registerCovariant("java.util.Iterator", standardLibrary.getMutableIterator()); + } + + private void register(String className, ClassDescriptor classDescriptor) { + register(new FqName(className), classDescriptor); + } + + private void register(FqName fqName, ClassDescriptor classDescriptor) { + classDescriptorMap.put(fqName, classDescriptor); + } + + private void registerCovariant(String className, ClassDescriptor classDescriptor) { + registerCovariant(new FqName(className), classDescriptor); + } + + private void registerCovariant(FqName fqName, ClassDescriptor classDescriptor) { + classDescriptorMapForCovariantPositions.put(fqName, classDescriptor); + } + + private void initPrimitive() { + for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { + PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); + primitiveTypesMap.put(jvmPrimitiveType.getName(), JetStandardLibrary.getInstance().getPrimitiveJetType(primitiveType)); + primitiveTypesMap.put("[" + jvmPrimitiveType.getName(), JetStandardLibrary.getInstance().getPrimitiveArrayJetType(primitiveType)); + primitiveTypesMap.put(jvmPrimitiveType.getWrapper().getFqName().getFqName(), JetStandardLibrary.getInstance().getNullablePrimitiveJetType( + primitiveType)); + } + primitiveTypesMap.put("void", JetStandardClasses.getUnitType()); + } +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java index ca684690294..c4b6725a790 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java @@ -17,11 +17,9 @@ package org.jetbrains.jet.lang.resolve.java; import com.google.common.collect.Lists; -import com.google.common.collect.Maps; import com.google.common.collect.Sets; import com.intellij.psi.*; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; @@ -45,7 +43,6 @@ public class JavaTypeTransformer { private JavaSemanticServices javaSemanticServices; private JavaDescriptorResolver resolver; - @Inject public void setJavaSemanticServices(JavaSemanticServices javaSemanticServices) { this.javaSemanticServices = javaSemanticServices; @@ -56,13 +53,6 @@ public class JavaTypeTransformer { this.resolver = resolver; } - - - private Map primitiveTypesMap; - private Map classDescriptorMap; - private Map classDescriptorMapForCovariantPositions; - - @NotNull private TypeProjection transformToTypeProjection(@NotNull final PsiType javaType, @NotNull final TypeParameterDescriptor typeParameterDescriptor, @@ -159,7 +149,8 @@ public class JavaTypeTransformer { // 'L extends List' in Java is a List in Kotlin, not a List boolean nullable = !EnumSet.of(SUPERTYPE_ARGUMENT, SUPERTYPE).contains(howThisTypeIsUsed); - ClassDescriptor classData = getKotlinAnalog(new FqName(psiClass.getQualifiedName()), howThisTypeIsUsed); + ClassDescriptor classData = JavaToKotlinTypesMap.getInstance().getKotlinAnalog(new FqName(psiClass.getQualifiedName()), + howThisTypeIsUsed); if (classData == null) { classData = resolver.resolveClass(new FqName(psiClass.getQualifiedName()), DescriptorSearchRule.INCLUDE_KOTLIN); @@ -206,7 +197,7 @@ public class JavaTypeTransformer { @Override public JetType visitPrimitiveType(PsiPrimitiveType primitiveType) { String canonicalText = primitiveType.getCanonicalText(); - JetType type = getPrimitiveTypesMap().get(canonicalText); + JetType type = JavaToKotlinTypesMap.getInstance().getPrimitiveKotlinAnalog(canonicalText); assert type != null : canonicalText; return type; } @@ -215,7 +206,7 @@ public class JavaTypeTransformer { public JetType visitArrayType(PsiArrayType arrayType) { PsiType componentType = arrayType.getComponentType(); if (componentType instanceof PsiPrimitiveType) { - JetType jetType = getPrimitiveTypesMap().get("[" + componentType.getCanonicalText()); + JetType jetType = JavaToKotlinTypesMap.getInstance().getPrimitiveKotlinAnalog("[" + componentType.getCanonicalText()); if (jetType != null) return TypeUtils.makeNullable(jetType); } @@ -240,61 +231,6 @@ public class JavaTypeTransformer { return result; } - public Map getPrimitiveTypesMap() { - if (primitiveTypesMap == null) { - primitiveTypesMap = new HashMap(); - for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { - PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); - primitiveTypesMap.put(jvmPrimitiveType.getName(), JetStandardLibrary.getInstance().getPrimitiveJetType(primitiveType)); - primitiveTypesMap.put("[" + jvmPrimitiveType.getName(), JetStandardLibrary.getInstance().getPrimitiveArrayJetType(primitiveType)); - primitiveTypesMap.put(jvmPrimitiveType.getWrapper().getFqName().getFqName(), JetStandardLibrary.getInstance().getNullablePrimitiveJetType( - primitiveType)); - } - primitiveTypesMap.put("void", JetStandardClasses.getUnitType()); - } - return primitiveTypesMap; - } - - public Map getClassDescriptorMap() { - if (classDescriptorMap == null) { - classDescriptorMap = Maps.newHashMap(); - for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { - PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); - classDescriptorMap.put(jvmPrimitiveType.getWrapper().getFqName(), JetStandardLibrary.getInstance().getPrimitiveClassDescriptor(primitiveType)); - } - classDescriptorMap.put(new FqName("java.lang.Object"), JetStandardClasses.getAny()); - classDescriptorMap.put(new FqName("java.lang.String"), JetStandardLibrary.getInstance().getString()); - classDescriptorMap.put(new FqName("java.lang.CharSequence"), JetStandardLibrary.getInstance().getCharSequence()); - classDescriptorMap.put(new FqName("java.lang.Throwable"), JetStandardLibrary.getInstance().getThrowable()); - classDescriptorMap.put(new FqName("java.lang.Number"), JetStandardLibrary.getInstance().getNumber()); - classDescriptorMap.put(new FqName("java.lang.Comparable"), JetStandardLibrary.getInstance().getComparable()); - classDescriptorMap.put(new FqName("java.lang.Enum"), JetStandardLibrary.getInstance().getEnum()); - classDescriptorMap.put(new FqName("java.lang.Iterable"), JetStandardLibrary.getInstance().getIterable()); - classDescriptorMap.put(new FqName("java.util.Iterator"), JetStandardLibrary.getInstance().getIterator()); - } - return classDescriptorMap; - } - - public Map getClassDescriptorMapForCovariantPositions() { - if (classDescriptorMapForCovariantPositions == null) { - classDescriptorMapForCovariantPositions = Maps.newHashMap(); - classDescriptorMapForCovariantPositions.put(new FqName("java.lang.Iterable"), JetStandardLibrary.getInstance().getMutableIterable()); - classDescriptorMapForCovariantPositions.put(new FqName("java.util.Iterator"), JetStandardLibrary.getInstance().getMutableIterator()); - } - return classDescriptorMapForCovariantPositions; - } - - @Nullable - public ClassDescriptor getKotlinAnalog(@NotNull FqName fqName, @NotNull TypeUsage typeUsage) { - if (typeUsage == MEMBER_SIGNATURE_COVARIANT) { - ClassDescriptor descriptor = getClassDescriptorMapForCovariantPositions().get(fqName); - if (descriptor != null) { - return descriptor; - } - } - return getClassDescriptorMap().get(fqName); - } - /** * We convert Java types differently, depending on where they occur in the Java code * This enum encodes the kinds of occurrences diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java index 3d993f32329..a2eff386569 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java @@ -95,7 +95,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd this.classDescriptor = null; if (!forceReal) { - classDescriptor = javaSemanticServices.getTypeTransformer().getKotlinAnalog(ourName, JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_INVARIANT); + classDescriptor = JavaToKotlinTypesMap.getInstance().getKotlinAnalog(ourName, JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_INVARIANT); } if (classDescriptor == null) {