From fbc7f60af1b10a28b0b75e8ffe968d51685fe000 Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Wed, 11 Jan 2012 19:36:55 +0400 Subject: [PATCH] enums for primitive types and fix stdlib.jar reading * PrimitiveType and JvmPrimitiveType enums * roll up for-each-enum copy-paste lines into loop by enum values * finish JetStandardLibrary.getPrimitiveArrayJetTypeByPrimitiveJetType for all primitive types that fixes stdlib.jar loading --- .../jetbrains/jet/codegen/JetTypeMapper.java | 188 ++------- .../org/jetbrains/jet/codegen/StackValue.java | 7 +- .../jet/codegen/intrinsics/ArrayIterator.java | 46 +-- .../codegen/intrinsics/IntrinsicMethods.java | 60 +-- .../resolve/java/JavaTypeTransformer.java | 54 +-- .../java/JetTypeJetSignatureReader.java | 54 +-- .../jet/lang/resolve/java/JvmClassName.java | 10 + .../lang/resolve/java/JvmPrimitiveType.java | 111 ++++++ .../jet/lang/resolve/DescriptorResolver.java | 29 +- .../jet/lang/types/JetStandardLibrary.java | 366 ++++-------------- .../jet/lang/types/PrimitiveType.java | 33 ++ 11 files changed, 334 insertions(+), 624 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmPrimitiveType.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/types/PrimitiveType.java diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index da511707882..205fd3ab061 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -14,6 +14,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaNamespaceDescriptor; import org.jetbrains.jet.lang.resolve.java.JvmAbi; +import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lexer.JetTokens; @@ -35,27 +36,11 @@ public class JetTypeMapper { public static final Type TYPE_TYPEINFOPROJECTION = Type.getType(TypeInfoProjection.class); public static final Type TYPE_JET_OBJECT = Type.getType(JetObject.class); public static final Type TYPE_NOTHING = Type.getObjectType("jet/Nothing"); - public static final Type JL_INTEGER_TYPE = Type.getObjectType("java/lang/Integer"); - public static final Type JL_LONG_TYPE = Type.getObjectType("java/lang/Long"); - public static final Type JL_SHORT_TYPE = Type.getObjectType("java/lang/Short"); - public static final Type JL_BYTE_TYPE = Type.getObjectType("java/lang/Byte"); - public static final Type JL_CHAR_TYPE = Type.getObjectType("java/lang/Character"); - public static final Type JL_FLOAT_TYPE = Type.getObjectType("java/lang/Float"); - public static final Type JL_DOUBLE_TYPE = Type.getObjectType("java/lang/Double"); - public static final Type JL_BOOLEAN_TYPE = Type.getObjectType("java/lang/Boolean"); 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_COMPARABLE_TYPE = Type.getObjectType("java/lang/Comparable"); - public static final Type ARRAY_INT_TYPE = Type.getType(int[].class); - public static final Type ARRAY_LONG_TYPE = Type.getType(long[].class); - public static final Type ARRAY_SHORT_TYPE = Type.getType(short[].class); - public static final Type ARRAY_BYTE_TYPE = Type.getType(byte[].class); - public static final Type ARRAY_CHAR_TYPE = Type.getType(char[].class); - public static final Type ARRAY_FLOAT_TYPE = Type.getType(float[].class); - public static final Type ARRAY_DOUBLE_TYPE = Type.getType(double[].class); - public static final Type ARRAY_BOOL_TYPE = Type.getType(boolean[].class); public static final Type ARRAY_GENERIC_TYPE = Type.getType(Object[].class); private final JetStandardLibrary standardLibrary; @@ -77,14 +62,6 @@ public class JetTypeMapper { public static final Type TYPE_SHARED_CHAR = Type.getObjectType("jet/runtime/SharedVar$Char"); public static final Type TYPE_SHARED_LONG = Type.getObjectType("jet/runtime/SharedVar$Long"); public static final Type TYPE_SHARED_BOOLEAN = Type.getObjectType("jet/runtime/SharedVar$Boolean"); - public static final Type TYPE_BOOLEAN_ITERATOR = Type.getObjectType("jet/BooleanIterator"); - public static final Type TYPE_CHAR_ITERATOR = Type.getObjectType("jet/CharIterator"); - public static final Type TYPE_BYTE_ITERATOR = Type.getObjectType("jet/ByteIterator"); - public static final Type TYPE_SHORT_ITERATOR = Type.getObjectType("jet/ShortIterator"); - public static final Type TYPE_INT_ITERATOR = Type.getObjectType("jet/IntIterator"); - public static final Type TYPE_LONG_ITERATOR = Type.getObjectType("jet/LongIterator"); - public static final Type TYPE_FLOAT_ITERATOR = Type.getObjectType("jet/FloatIterator"); - public static final Type TYPE_DOUBLE_ITERATOR = Type.getObjectType("jet/DoubleIterator"); public static final Type TYPE_FUNCTION0 = Type.getObjectType("jet/Function0"); public static final Type TYPE_FUNCTION1 = Type.getObjectType("jet/Function1"); @@ -107,28 +84,6 @@ public class JetTypeMapper { return type.getSort() != Type.OBJECT && type.getSort() != Type.ARRAY; } - public static Type getBoxedType(final Type type) { - switch (type.getSort()) { - case Type.BYTE: - return JL_BYTE_TYPE; - case Type.BOOLEAN: - return JL_BOOLEAN_TYPE; - case Type.SHORT: - return JL_SHORT_TYPE; - case Type.CHAR: - return JL_CHAR_TYPE; - case Type.INT: - return JL_INTEGER_TYPE; - case Type.FLOAT: - return JL_FLOAT_TYPE; - case Type.LONG: - return JL_LONG_TYPE; - case Type.DOUBLE: - return JL_DOUBLE_TYPE; - } - return type; - } - public static Type correctElementType(Type type) { String internalName = type.getInternalName(); assert internalName.charAt(0) == '['; @@ -378,56 +333,21 @@ public class JetTypeMapper { } public static Type unboxType(final Type type) { - if (type == JL_INTEGER_TYPE) { - return Type.INT_TYPE; + JvmPrimitiveType jvmPrimitiveType = JvmPrimitiveType.getByWrapperAsmType(type); + if (jvmPrimitiveType != null) { + return jvmPrimitiveType.getAsmType(); + } else { + throw new UnsupportedOperationException("Unboxing: " + type); } - else if (type == JL_BOOLEAN_TYPE) { - return Type.BOOLEAN_TYPE; - } - else if (type == JL_CHAR_TYPE) { - return Type.CHAR_TYPE; - } - else if (type == JL_SHORT_TYPE) { - return Type.SHORT_TYPE; - } - else if (type == JL_LONG_TYPE) { - return Type.LONG_TYPE; - } - else if (type == JL_BYTE_TYPE) { - return Type.BYTE_TYPE; - } - else if (type == JL_FLOAT_TYPE) { - return Type.FLOAT_TYPE; - } - else if (type == JL_DOUBLE_TYPE) { - return Type.DOUBLE_TYPE; - } - throw new UnsupportedOperationException("Unboxing: " + type); } public static Type boxType(Type asmType) { - switch (asmType.getSort()) { - case Type.VOID: - return Type.VOID_TYPE; - case Type.BYTE: - return JL_BYTE_TYPE; - case Type.BOOLEAN: - return JL_BOOLEAN_TYPE; - case Type.SHORT: - return JL_SHORT_TYPE; - case Type.CHAR: - return JL_CHAR_TYPE; - case Type.INT: - return JL_INTEGER_TYPE; - case Type.FLOAT: - return JL_FLOAT_TYPE; - case Type.LONG: - return JL_LONG_TYPE; - case Type.DOUBLE: - return JL_DOUBLE_TYPE; + JvmPrimitiveType jvmPrimitiveType = JvmPrimitiveType.getByAsmType(asmType); + if (jvmPrimitiveType != null) { + return jvmPrimitiveType.getWrapper().getAsmType(); + } else { + return asmType; } - - return asmType; } public CallableMethod mapToCallableMethod(FunctionDescriptor functionDescriptor, boolean superCall, OwnerKind kind) { @@ -802,85 +722,39 @@ public class JetTypeMapper { private void initKnownTypeNames() { knowTypeNames.put(JetStandardClasses.getAnyType(), "ANY_TYPE_INFO"); knowTypeNames.put(JetStandardClasses.getNullableAnyType(), "NULLABLE_ANY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getIntType(), "INT_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableIntType(), "NULLABLE_INT_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getLongType(), "LONG_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableLongType(), "NULLABLE_LONG_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getShortType(),"SHORT_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableShortType(),"NULLABLE_SHORT_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getByteType(),"BYTE_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableByteType(),"NULLABLE_BYTE_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getCharType(),"CHAR_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableCharType(),"NULLABLE_CHAR_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getFloatType(),"FLOAT_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableFloatType(),"NULLABLE_FLOAT_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getDoubleType(),"DOUBLE_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableDoubleType(),"NULLABLE_DOUBLE_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getBooleanType(),"BOOLEAN_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableBooleanType(),"NULLABLE_BOOLEAN_TYPE_INFO"); + + for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { + PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); + knowTypeNames.put(standardLibrary.getPrimitiveJetType(primitiveType), jvmPrimitiveType.name() + "_TYPE_INFO"); + knowTypeNames.put(standardLibrary.getNullablePrimitiveJetType(primitiveType), "NULLABLE_" + jvmPrimitiveType.name() + "_TYPE_INFO"); + knowTypeNames.put(standardLibrary.getPrimitiveArrayJetType(primitiveType), jvmPrimitiveType.name() + "_ARRAY_TYPE_INFO"); + knowTypeNames.put(standardLibrary.getNullablePrimitiveArrayJetType(primitiveType), jvmPrimitiveType.name() + "_ARRAY_TYPE_INFO"); + } + knowTypeNames.put(standardLibrary.getStringType(),"STRING_TYPE_INFO"); knowTypeNames.put(standardLibrary.getNullableStringType(),"NULLABLE_STRING_TYPE_INFO"); knowTypeNames.put(standardLibrary.getTuple0Type(),"TUPLE0_TYPE_INFO"); knowTypeNames.put(standardLibrary.getNullableTuple0Type(),"NULLABLE_TUPLE0_TYPE_INFO"); - - knowTypeNames.put(standardLibrary.getIntArrayType(), "INT_ARRAY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getLongArrayType(), "LONG_ARRAY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getShortArrayType(),"SHORT_ARRAY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getByteArrayType(),"BYTE_ARRAY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getCharArrayType(),"CHAR_ARRAY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getFloatArrayType(),"FLOAT_ARRAY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getDoubleArrayType(),"DOUBLE_ARRAY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getBooleanArrayType(),"BOOLEAN_ARRAY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableIntArrayType(), "INT_ARRAY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableLongArrayType(), "LONG_ARRAY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableShortArrayType(),"SHORT_ARRAY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableByteArrayType(),"BYTE_ARRAY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableCharArrayType(),"CHAR_ARRAY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableFloatArrayType(),"FLOAT_ARRAY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableDoubleArrayType(),"DOUBLE_ARRAY_TYPE_INFO"); - knowTypeNames.put(standardLibrary.getNullableBooleanArrayType(),"BOOLEAN_ARRAY_TYPE_INFO"); } private void initKnownTypes() { knowTypes.put(JetStandardClasses.getNothingType(), TYPE_NOTHING); knowTypes.put(JetStandardClasses.getNullableNothingType(), TYPE_NOTHING); - - knowTypes.put(standardLibrary.getIntType(), Type.INT_TYPE); - knowTypes.put(standardLibrary.getNullableIntType(), JL_INTEGER_TYPE); - knowTypes.put(standardLibrary.getLongType(), Type.LONG_TYPE); - knowTypes.put(standardLibrary.getNullableLongType(), JL_LONG_TYPE); - knowTypes.put(standardLibrary.getShortType(),Type.SHORT_TYPE); - knowTypes.put(standardLibrary.getNullableShortType(),JL_SHORT_TYPE); - knowTypes.put(standardLibrary.getByteType(),Type.BYTE_TYPE); - knowTypes.put(standardLibrary.getNullableByteType(),JL_BYTE_TYPE); - knowTypes.put(standardLibrary.getCharType(),Type.CHAR_TYPE); - knowTypes.put(standardLibrary.getNullableCharType(),JL_CHAR_TYPE); - knowTypes.put(standardLibrary.getFloatType(),Type.FLOAT_TYPE); - knowTypes.put(standardLibrary.getNullableFloatType(),JL_FLOAT_TYPE); - knowTypes.put(standardLibrary.getDoubleType(),Type.DOUBLE_TYPE); - knowTypes.put(standardLibrary.getNullableDoubleType(),JL_DOUBLE_TYPE); - knowTypes.put(standardLibrary.getBooleanType(),Type.BOOLEAN_TYPE); - knowTypes.put(standardLibrary.getNullableBooleanType(),JL_BOOLEAN_TYPE); + + for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { + PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); + knowTypes.put(standardLibrary.getPrimitiveJetType(primitiveType), jvmPrimitiveType.getAsmType()); + knowTypes.put(standardLibrary.getNullablePrimitiveJetType(primitiveType), jvmPrimitiveType.getWrapper().getAsmType()); + } knowTypes.put(standardLibrary.getStringType(),JL_STRING_TYPE); knowTypes.put(standardLibrary.getNullableStringType(),JL_STRING_TYPE); - knowTypes.put(standardLibrary.getIntArrayType(), ARRAY_INT_TYPE); - knowTypes.put(standardLibrary.getLongArrayType(), ARRAY_LONG_TYPE); - knowTypes.put(standardLibrary.getShortArrayType(),ARRAY_SHORT_TYPE); - knowTypes.put(standardLibrary.getByteArrayType(),ARRAY_BYTE_TYPE); - knowTypes.put(standardLibrary.getCharArrayType(),ARRAY_CHAR_TYPE); - knowTypes.put(standardLibrary.getFloatArrayType(),ARRAY_FLOAT_TYPE); - knowTypes.put(standardLibrary.getDoubleArrayType(),ARRAY_DOUBLE_TYPE); - knowTypes.put(standardLibrary.getBooleanArrayType(),ARRAY_BOOL_TYPE); - knowTypes.put(standardLibrary.getNullableIntArrayType(), ARRAY_INT_TYPE); - knowTypes.put(standardLibrary.getNullableLongArrayType(), ARRAY_LONG_TYPE); - knowTypes.put(standardLibrary.getNullableShortArrayType(),ARRAY_SHORT_TYPE); - knowTypes.put(standardLibrary.getNullableByteArrayType(),ARRAY_BYTE_TYPE); - knowTypes.put(standardLibrary.getNullableCharArrayType(),ARRAY_CHAR_TYPE); - knowTypes.put(standardLibrary.getNullableFloatArrayType(),ARRAY_FLOAT_TYPE); - knowTypes.put(standardLibrary.getNullableDoubleArrayType(),ARRAY_DOUBLE_TYPE); - knowTypes.put(standardLibrary.getNullableBooleanArrayType(),ARRAY_BOOL_TYPE); + for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { + PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); + knowTypes.put(standardLibrary.getPrimitiveArrayJetType(primitiveType), jvmPrimitiveType.getAsmArrayType()); + knowTypes.put(standardLibrary.getNullablePrimitiveArrayJetType(primitiveType), jvmPrimitiveType.getAsmArrayType()); + } } public String isKnownTypeInfo(JetType jetType) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java b/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java index b29522718c2..0cae7cbf43f 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java @@ -7,6 +7,7 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; import org.jetbrains.jet.lang.resolve.java.JvmAbi; +import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lexer.JetTokens; @@ -36,7 +37,7 @@ public abstract class StackValue { if (type == Type.VOID_TYPE) { instructionAdapter.aconst(null); } else { - Type boxed = JetTypeMapper.getBoxedType(type); + Type boxed = JetTypeMapper.boxType(type); instructionAdapter.invokestatic(boxed.getInternalName(), "valueOf", "(" + type.getDescriptor() + ")" + boxed.getDescriptor()); } } @@ -209,10 +210,10 @@ public abstract class StackValue { else if (this.type.getSort() == Type.OBJECT && type.getSort() <= Type.DOUBLE) { if (this.type.equals(JetTypeMapper.TYPE_OBJECT)) { if (type.getSort() == Type.BOOLEAN) { - v.checkcast(JetTypeMapper.JL_BOOLEAN_TYPE); + v.checkcast(JvmPrimitiveType.BOOLEAN.getWrapper().getAsmType()); } else if (type.getSort() == Type.CHAR) { - v.checkcast(JetTypeMapper.JL_CHAR_TYPE); + v.checkcast(JvmPrimitiveType.CHAR.getWrapper().getAsmType()); } else { v.checkcast(JetTypeMapper.JL_NUMBER_TYPE); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIterator.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIterator.java index 60b7c7ec125..eec17fd486e 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIterator.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIterator.java @@ -10,7 +10,9 @@ import org.jetbrains.jet.lang.psi.JetCallExpression; import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType; import org.jetbrains.jet.lang.types.JetStandardLibrary; +import org.jetbrains.jet.lang.types.PrimitiveType; import org.objectweb.asm.Type; import org.objectweb.asm.commons.InstructionAdapter; @@ -31,40 +33,16 @@ public class ArrayIterator implements IntrinsicMethod { codegen.generateTypeInfo(funDescriptor.getReturnType().getArguments().get(0).getType(), null); v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([Ljava/lang/Object;Ljet/TypeInfo;)Ljet/Iterator;"); return StackValue.onStack(JetTypeMapper.TYPE_ITERATOR); - } - else if(containingDeclaration.equals(standardLibrary.getByteArrayClass())) { - v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([B)Ljet/ByteIterator;"); - return StackValue.onStack(JetTypeMapper.TYPE_BYTE_ITERATOR); - } - else if(containingDeclaration.equals(standardLibrary.getShortArrayClass())) { - v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([S)Ljet/ShortIterator;"); - return StackValue.onStack(JetTypeMapper.TYPE_SHORT_ITERATOR); - } - else if(containingDeclaration.equals(standardLibrary.getIntArrayClass())) { - v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([I)Ljet/IntIterator;"); - return StackValue.onStack(JetTypeMapper.TYPE_INT_ITERATOR); - } - else if(containingDeclaration.equals(standardLibrary.getLongArrayClass())) { - v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([J)Ljet/LongIterator;"); - return StackValue.onStack(JetTypeMapper.TYPE_LONG_ITERATOR); - } - else if(containingDeclaration.equals(standardLibrary.getFloatArrayClass())) { - v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([F)Ljet/FloatIterator;"); - return StackValue.onStack(JetTypeMapper.TYPE_FLOAT_ITERATOR); - } - else if(containingDeclaration.equals(standardLibrary.getDoubleArrayClass())) { - v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([D)Ljet/DoubleIterator;"); - return StackValue.onStack(JetTypeMapper.TYPE_DOUBLE_ITERATOR); - } - else if(containingDeclaration.equals(standardLibrary.getCharArrayClass())) { - v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([C)Ljet/CharIterator;"); - return StackValue.onStack(JetTypeMapper.TYPE_CHAR_ITERATOR); - } - else if(containingDeclaration.equals(standardLibrary.getBooleanArrayClass())) { - v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([Z)Ljet/BooleanIterator;"); - return StackValue.onStack(JetTypeMapper.TYPE_BOOLEAN_ITERATOR); - } - else { + } else { + for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { + PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); + ClassDescriptor arrayClass = standardLibrary.getPrimitiveArrayClassDescriptor(primitiveType); + if (containingDeclaration.equals(arrayClass)) { + String methodSignature = "([" + jvmPrimitiveType.getJvmLetter() + ")" + jvmPrimitiveType.getIterator().getDescriptor(); + v.invokestatic("jet/runtime/ArrayIterator", "iterator", methodSignature); + return StackValue.onStack(jvmPrimitiveType.getIterator().getAsmType()); + } + } throw new UnsupportedOperationException(containingDeclaration.toString()); } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java index b57ecfe31cb..3b2da090884 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java @@ -9,9 +9,11 @@ import com.intellij.psi.PsiMethod; import com.intellij.psi.search.DelegatingGlobalSearchScope; import com.intellij.psi.search.ProjectScope; import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.JetStandardClasses; import org.jetbrains.jet.lang.types.JetStandardLibrary; +import org.jetbrains.jet.lang.types.PrimitiveType; import org.jetbrains.jet.lang.types.TypeProjection; import org.jetbrains.jet.plugin.JetFileType; import org.objectweb.asm.Opcodes; @@ -118,55 +120,25 @@ public class IntrinsicMethods { } private void declareArrayMethods() { + + for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { + declareArrayMethodsForPrimitive(jvmPrimitiveType); + } + declareIntrinsicProperty("Array", "size", ARRAY_SIZE); - declareIntrinsicProperty("ByteArray", "size", ARRAY_SIZE); - declareIntrinsicProperty("ShortArray", "size", ARRAY_SIZE); - declareIntrinsicProperty("IntArray", "size", ARRAY_SIZE); - declareIntrinsicProperty("LongArray", "size", ARRAY_SIZE); - declareIntrinsicProperty("FloatArray", "size", ARRAY_SIZE); - declareIntrinsicProperty("DoubleArray", "size", ARRAY_SIZE); - declareIntrinsicProperty("CharArray", "size", ARRAY_SIZE); - declareIntrinsicProperty("BooleanArray", "size", ARRAY_SIZE); - declareIntrinsicProperty("Array", "indices", ARRAY_INDICES); - declareIntrinsicProperty("ByteArray", "indices", ARRAY_INDICES); - declareIntrinsicProperty("ShortArray", "indices", ARRAY_INDICES); - declareIntrinsicProperty("IntArray", "indices", ARRAY_INDICES); - declareIntrinsicProperty("LongArray", "indices", ARRAY_INDICES); - declareIntrinsicProperty("FloatArray", "indices", ARRAY_INDICES); - declareIntrinsicProperty("DoubleArray", "indices", ARRAY_INDICES); - declareIntrinsicProperty("CharArray", "indices", ARRAY_INDICES); - declareIntrinsicProperty("BooleanArray", "indices", ARRAY_INDICES); - declareIntrinsicFunction("Array", "set", 2, ARRAY_SET); - declareIntrinsicFunction("ByteArray", "set", 2, ARRAY_SET); - declareIntrinsicFunction("ShortArray", "set", 2, ARRAY_SET); - declareIntrinsicFunction("IntArray", "set", 2, ARRAY_SET); - declareIntrinsicFunction("LongArray", "set", 2, ARRAY_SET); - declareIntrinsicFunction("FloatArray", "set", 2, ARRAY_SET); - declareIntrinsicFunction("DoubleArray", "set", 2, ARRAY_SET); - declareIntrinsicFunction("CharArray", "set", 2, ARRAY_SET); - declareIntrinsicFunction("BooleanArray", "set", 2, ARRAY_SET); - declareIntrinsicFunction("Array", "get", 1, ARRAY_GET); - declareIntrinsicFunction("ByteArray", "get", 1, ARRAY_GET); - declareIntrinsicFunction("ShortArray", "get", 1, ARRAY_GET); - declareIntrinsicFunction("IntArray", "get", 1, ARRAY_GET); - declareIntrinsicFunction("LongArray", "get", 1, ARRAY_GET); - declareIntrinsicFunction("FloatArray", "get", 1, ARRAY_GET); - declareIntrinsicFunction("DoubleArray", "get", 1, ARRAY_GET); - declareIntrinsicFunction("CharArray", "get", 1, ARRAY_GET); - declareIntrinsicFunction("BooleanArray", "get", 1, ARRAY_GET); - declareIterator(myStdLib.getArray()); - declareIterator(myStdLib.getByteArrayClass()); - declareIterator(myStdLib.getShortArrayClass()); - declareIterator(myStdLib.getIntArrayClass()); - declareIterator(myStdLib.getLongArrayClass()); - declareIterator(myStdLib.getFloatArrayClass()); - declareIterator(myStdLib.getDoubleArrayClass()); - declareIterator(myStdLib.getCharArrayClass()); - declareIterator(myStdLib.getBooleanArrayClass()); + } + + private void declareArrayMethodsForPrimitive(JvmPrimitiveType jvmPrimitiveType) { + PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); + declareIntrinsicProperty(primitiveType.getArrayTypeName(), "size", ARRAY_SIZE); + declareIntrinsicProperty(primitiveType.getArrayTypeName(), "indices", ARRAY_INDICES); + declareIntrinsicFunction(primitiveType.getArrayTypeName(), "set", 2, ARRAY_SET); + declareIntrinsicFunction(primitiveType.getArrayTypeName(), "get", 1, ARRAY_GET); + declareIterator(myStdLib.getPrimitiveArrayClassDescriptor(primitiveType)); } private void declareIterator(ClassDescriptor classDescriptor) { 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 96e64c6f08c..ea0d6710890 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 @@ -155,31 +155,13 @@ public class JavaTypeTransformer { public Map getPrimitiveTypesMap() { if (primitiveTypesMap == null) { primitiveTypesMap = new HashMap(); - primitiveTypesMap.put("byte", standardLibrary.getByteType()); - primitiveTypesMap.put("short", standardLibrary.getShortType()); - primitiveTypesMap.put("char", standardLibrary.getCharType()); - primitiveTypesMap.put("int", standardLibrary.getIntType()); - primitiveTypesMap.put("long", standardLibrary.getLongType()); - primitiveTypesMap.put("float", standardLibrary.getFloatType()); - primitiveTypesMap.put("double", standardLibrary.getDoubleType()); - primitiveTypesMap.put("boolean", standardLibrary.getBooleanType()); - primitiveTypesMap.put("[byte", standardLibrary.getByteArrayType()); - primitiveTypesMap.put("[short", standardLibrary.getShortArrayType()); - primitiveTypesMap.put("[char", standardLibrary.getCharArrayType()); - primitiveTypesMap.put("[int", standardLibrary.getIntArrayType()); - primitiveTypesMap.put("[long", standardLibrary.getLongArrayType()); - primitiveTypesMap.put("[float", standardLibrary.getFloatArrayType()); - primitiveTypesMap.put("[double", standardLibrary.getDoubleArrayType()); - primitiveTypesMap.put("[boolean", standardLibrary.getBooleanArrayType()); + for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { + PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); + primitiveTypesMap.put(jvmPrimitiveType.getName(), standardLibrary.getPrimitiveJetType(primitiveType)); + primitiveTypesMap.put("[" + jvmPrimitiveType.getName(), standardLibrary.getPrimitiveArrayJetType(primitiveType)); + primitiveTypesMap.put(jvmPrimitiveType.getWrapper().getFqName(), standardLibrary.getNullablePrimitiveJetType(primitiveType)); + } primitiveTypesMap.put("void", JetStandardClasses.getUnitType()); - primitiveTypesMap.put("java.lang.Byte", TypeUtils.makeNullable(standardLibrary.getByteType())); - primitiveTypesMap.put("java.lang.Short", TypeUtils.makeNullable(standardLibrary.getShortType())); - primitiveTypesMap.put("java.lang.Character", TypeUtils.makeNullable(standardLibrary.getCharType())); - primitiveTypesMap.put("java.lang.Integer", TypeUtils.makeNullable(standardLibrary.getIntType())); - primitiveTypesMap.put("java.lang.Long", TypeUtils.makeNullable(standardLibrary.getLongType())); - primitiveTypesMap.put("java.lang.Float", TypeUtils.makeNullable(standardLibrary.getFloatType())); - primitiveTypesMap.put("java.lang.Double", TypeUtils.makeNullable(standardLibrary.getDoubleType())); - primitiveTypesMap.put("java.lang.Boolean", TypeUtils.makeNullable(standardLibrary.getBooleanType())); } return primitiveTypesMap; } @@ -187,14 +169,10 @@ public class JavaTypeTransformer { public Map getClassTypesMap() { if (classTypesMap == null) { classTypesMap = new HashMap(); - classTypesMap.put("java.lang.Byte", TypeUtils.makeNullable(standardLibrary.getByteType())); - classTypesMap.put("java.lang.Short", TypeUtils.makeNullable(standardLibrary.getShortType())); - classTypesMap.put("java.lang.Character", TypeUtils.makeNullable(standardLibrary.getCharType())); - classTypesMap.put("java.lang.Integer", TypeUtils.makeNullable(standardLibrary.getIntType())); - classTypesMap.put("java.lang.Long", TypeUtils.makeNullable(standardLibrary.getLongType())); - classTypesMap.put("java.lang.Float", TypeUtils.makeNullable(standardLibrary.getFloatType())); - classTypesMap.put("java.lang.Double", TypeUtils.makeNullable(standardLibrary.getDoubleType())); - classTypesMap.put("java.lang.Boolean", TypeUtils.makeNullable(standardLibrary.getBooleanType())); + for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { + PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); + classTypesMap.put(jvmPrimitiveType.getWrapper().getFqName(), standardLibrary.getNullablePrimitiveJetType(primitiveType)); + } classTypesMap.put("java.lang.Object", JetStandardClasses.getNullableAnyType()); classTypesMap.put("java.lang.String", standardLibrary.getNullableStringType()); } @@ -204,14 +182,10 @@ public class JavaTypeTransformer { public Map getPrimitiveWrappersClassDescriptorMap() { if (classDescriptorMap == null) { classDescriptorMap = new HashMap(); - classDescriptorMap.put("java.lang.Byte", standardLibrary.getByte()); - classDescriptorMap.put("java.lang.Short", standardLibrary.getShort()); - classDescriptorMap.put("java.lang.Character", standardLibrary.getChar()); - classDescriptorMap.put("java.lang.Integer", standardLibrary.getInt()); - classDescriptorMap.put("java.lang.Long", standardLibrary.getLong()); - classDescriptorMap.put("java.lang.Float", standardLibrary.getFloat()); - classDescriptorMap.put("java.lang.Double", standardLibrary.getDouble()); - classDescriptorMap.put("java.lang.Boolean", standardLibrary.getBoolean()); + for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { + PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); + classDescriptorMap.put(jvmPrimitiveType.getWrapper().getFqName(), standardLibrary.getPrimitiveClassDescriptor(primitiveType)); + } //classDescriptorMap.put("java.lang.Object", standardLibrary.get classDescriptorMap.put("java.lang.String", standardLibrary.getString()); } 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 0f51cf0df1e..dd8e8b6b3c8 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 @@ -38,46 +38,22 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd private JetType getPrimitiveType(char descriptor, boolean nullable) { if (!nullable) { - switch (descriptor) { - case 'Z': - return jetStandardLibrary.getBooleanType(); - case 'C': - return jetStandardLibrary.getCharType(); - case 'B': - return jetStandardLibrary.getByteType(); - case 'S': - return jetStandardLibrary.getShortType(); - case 'I': - return jetStandardLibrary.getIntType(); - case 'F': - return jetStandardLibrary.getFloatType(); - case 'J': - return jetStandardLibrary.getLongType(); - case 'D': - return jetStandardLibrary.getDoubleType(); - case 'V': - return JetStandardClasses.getUnitType(); + for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { + if (jvmPrimitiveType.getJvmLetter() == descriptor) { + return jetStandardLibrary.getPrimitiveJetType(jvmPrimitiveType.getPrimitiveType()); + } + } + if (descriptor == 'V') { + return JetStandardClasses.getUnitType(); } } else { - switch (descriptor) { - case 'Z': - return jetStandardLibrary.getNullableBooleanType(); - case 'C': - return jetStandardLibrary.getNullableCharType(); - case 'B': - return jetStandardLibrary.getNullableByteType(); - case 'S': - return jetStandardLibrary.getNullableShortType(); - case 'I': - return jetStandardLibrary.getNullableIntType(); - case 'F': - return jetStandardLibrary.getNullableFloatType(); - case 'J': - return jetStandardLibrary.getNullableLongType(); - case 'D': - return jetStandardLibrary.getNullableDoubleType(); - case 'V': - throw new IllegalStateException("incorrect signature: nullable void"); + for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { + if (jvmPrimitiveType.getJvmLetter() == descriptor) { + return jetStandardLibrary.getNullablePrimitiveJetType(jvmPrimitiveType.getPrimitiveType()); + } + } + if (descriptor == 'V') { + throw new IllegalStateException("incorrect signature: nullable void"); } } throw new IllegalStateException("incorrect signature"); @@ -138,7 +114,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd JetType primitiveType = getPrimitiveType(descriptor, nullable); JetType arrayType; if (!nullable) { - arrayType = jetStandardLibrary.getPrimitiveArrayType(primitiveType); + arrayType = jetStandardLibrary.getPrimitiveArrayJetTypeByPrimitiveJetType(primitiveType); } else { arrayType = TypeUtils.makeNullableAsSpecified(jetStandardLibrary.getArrayType(primitiveType), nullable); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java index db1bcac52ff..165b0039324 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java @@ -1,6 +1,7 @@ package org.jetbrains.jet.lang.resolve.java; import org.jetbrains.annotations.NotNull; +import org.objectweb.asm.Type; /** * @author Stepan Koltsov @@ -39,4 +40,13 @@ public class JvmClassName { } return descriptor; } + + private Type asmType; + + public Type getAsmType() { + if (asmType == null) { + asmType = Type.getType(getDescriptor()); + } + return asmType; + } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmPrimitiveType.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmPrimitiveType.java new file mode 100644 index 00000000000..73daad8a0b8 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmPrimitiveType.java @@ -0,0 +1,111 @@ +package org.jetbrains.jet.lang.resolve.java; + +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.types.PrimitiveType; +import org.objectweb.asm.Type; + +import java.util.HashMap; +import java.util.Map; + +/** + * @author Stepan Koltsov + */ +public enum JvmPrimitiveType { + BOOLEAN(PrimitiveType.BOOLEAN, "boolean", "java.lang.Boolean", Type.BOOLEAN_TYPE), + CHAR(PrimitiveType.CHAR, "char", "java.lang.Character", Type.CHAR_TYPE), + BYTE(PrimitiveType.BYTE, "byte", "java.lang.Byte", Type.BYTE_TYPE), + SHORT(PrimitiveType.SHORT, "short", "java.lang.Short", Type.SHORT_TYPE), + INT(PrimitiveType.INT, "int", "java.lang.Integer", Type.INT_TYPE), + FLOAT(PrimitiveType.FLOAT, "float", "java.lang.Float", Type.FLOAT_TYPE), + LONG(PrimitiveType.LONG, "long", "java.lang.Long", Type.LONG_TYPE), + DOUBLE(PrimitiveType.DOUBLE, "double", "java.lang.Double", Type.DOUBLE_TYPE), + ; + + private final PrimitiveType primitiveType; + private final String name; + private final JvmClassName wrapper; + private final Type asmType; + private final char jvmLetter; + private final Type asmArrayType; + private final JvmClassName iterator; + + private JvmPrimitiveType(PrimitiveType primitiveType, String name, String wrapperClassName, Type asmType) { + this.primitiveType = primitiveType; + this.name = name; + this.wrapper = new JvmClassName(wrapperClassName); + this.asmType = asmType; + this.jvmLetter = asmType.getDescriptor().charAt(0); + this.asmArrayType = makeArrayType(asmType); + this.iterator = new JvmClassName("jet." + primitiveType.getTypeName() + "Iterator"); + } + + private static Type makeArrayType(Type type) { + StringBuilder sb = new StringBuilder(2); + sb.append('['); + sb.append(type.getDescriptor()); + return Type.getType(sb.toString()); + } + + public PrimitiveType getPrimitiveType() { + return primitiveType; + } + + public String getName() { + return name; + } + + public JvmClassName getWrapper() { + return wrapper; + } + + public Type getAsmType() { + return asmType; + } + + public Type getAsmArrayType() { + return asmArrayType; + } + + public JvmClassName getIterator() { + return iterator; + } + + public char getJvmLetter() { + return jvmLetter; + } + + + + private static class MapByAsmTypeHolder { + private static final Map map; + + static { + map = new HashMap(); + for (JvmPrimitiveType jvmPrimitiveType : values()) { + map.put(jvmPrimitiveType.getAsmType().getSort(), jvmPrimitiveType); + } + } + } + + @Nullable + public static JvmPrimitiveType getByAsmType(Type type) { + return MapByAsmTypeHolder.map.get(type.getSort()); + } + + + private static class MapByWrapperAsmTypeHolder { + private static final Map map; + + static { + map = new HashMap(); + for (JvmPrimitiveType jvmPrimitiveType : values()) { + map.put(jvmPrimitiveType.getWrapper().getAsmType(), jvmPrimitiveType); + } + } + } + + @Nullable + public static JvmPrimitiveType getByWrapperAsmType(Type type) { + return MapByWrapperAsmTypeHolder.map.get(type); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java index dd86b8a9fea..707a8f758dd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java @@ -276,31 +276,12 @@ public class DescriptorResolver { private JetType getVarargParameterType(JetType type) { JetStandardLibrary standardLibrary = semanticServices.getStandardLibrary(); - if (type.equals(standardLibrary.getByteType())) { - return standardLibrary.getByteArrayType(); + JetType arrayType = standardLibrary.getPrimitiveArrayJetTypeByPrimitiveJetType(type); + if (arrayType != null) { + return arrayType; + } else { + return standardLibrary.getArrayType(type); } - if (type.equals(standardLibrary.getCharType())) { - return standardLibrary.getCharArrayType(); - } - if (type.equals(standardLibrary.getShortType())) { - return standardLibrary.getShortArrayType(); - } - if (type.equals(standardLibrary.getIntType())) { - return standardLibrary.getIntArrayType(); - } - if (type.equals(standardLibrary.getLongType())) { - return standardLibrary.getLongArrayType(); - } - if (type.equals(standardLibrary.getFloatType())) { - return standardLibrary.getFloatArrayType(); - } - if (type.equals(standardLibrary.getDoubleType())) { - return standardLibrary.getDoubleArrayType(); - } - if (type.equals(standardLibrary.getBooleanType())) { - return standardLibrary.getBooleanArrayType(); - } - return standardLibrary.getArrayType(type); } public List resolveTypeParameters(DeclarationDescriptor containingDescriptor, WritableScope extensibleScope, List typeParameters) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java index 8ae62f01cee..c79b0c9fc3f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java @@ -4,6 +4,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.io.FileUtil; import com.intellij.psi.PsiFileFactory; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; @@ -50,14 +51,6 @@ public class JetStandardLibrary { private JetScope libraryScope; private ClassDescriptor numberClass; - private ClassDescriptor byteClass; - private ClassDescriptor charClass; - private ClassDescriptor shortClass; - private ClassDescriptor intClass; - private ClassDescriptor longClass; - private ClassDescriptor floatClass; - private ClassDescriptor doubleClass; - private ClassDescriptor booleanClass; private ClassDescriptor stringClass; private ClassDescriptor arrayClass; @@ -65,54 +58,10 @@ public class JetStandardLibrary { private ClassDescriptor typeInfoClass; private ClassDescriptor comparableClass; - private JetType byteType; - private JetType charType; - private JetType shortType; - private JetType intType; - private JetType longType; - private JetType floatType; - private JetType doubleType; - private JetType booleanType; - private JetType stringType; - private JetType nullableByteType; - private JetType nullableCharType; - private JetType nullableShortType; - private JetType nullableIntType; - private JetType nullableLongType; - private JetType nullableFloatType; - private JetType nullableDoubleType; - private JetType nullableBooleanType; private JetType nullableTuple0Type; - private ClassDescriptor byteArrayClass; - private ClassDescriptor charArrayClass; - private ClassDescriptor shortArrayClass; - private ClassDescriptor intArrayClass; - private ClassDescriptor longArrayClass; - private ClassDescriptor floatArrayClass; - private ClassDescriptor doubleArrayClass; - private ClassDescriptor booleanArrayClass; - - private JetType byteArrayType; - private JetType charArrayType; - private JetType shortArrayType; - private JetType intArrayType; - private JetType longArrayType; - private JetType floatArrayType; - private JetType doubleArrayType; - private JetType booleanArrayType; - - private JetType nullableByteArrayType; - private JetType nullableCharArrayType; - private JetType nullableShortArrayType; - private JetType nullableIntArrayType; - private JetType nullableLongArrayType; - private JetType nullableFloatArrayType; - private JetType nullableDoubleArrayType; - private JetType nullableBooleanArrayType; - public JetType getTuple0Type() { return tuple0Type; } @@ -122,6 +71,14 @@ public class JetStandardLibrary { private Set typeInfoFunction; + private EnumMap primitiveTypeToClass; + private EnumMap primitiveTypeToArrayClass; + private EnumMap primitiveTypeToJetType; + private EnumMap primitiveTypeToNullableJetType; + private EnumMap primitiveTypeToArrayJetType; + private EnumMap primitiveTypeToNullableArrayJetType; + private Map primitiveJetTypeToJetArrayType; + private JetStandardLibrary(@NotNull Project project) { // TODO : review List libraryFiles = Arrays.asList( @@ -168,14 +125,6 @@ public class JetStandardLibrary { if(libraryScope == null) { this.libraryScope = JetStandardClasses.STANDARD_CLASSES_NAMESPACE.getMemberScope(); this.numberClass = (ClassDescriptor) libraryScope.getClassifier("Number"); - this.byteClass = (ClassDescriptor) libraryScope.getClassifier("Byte"); - this.charClass = (ClassDescriptor) libraryScope.getClassifier("Char"); - this.shortClass = (ClassDescriptor) libraryScope.getClassifier("Short"); - this.intClass = (ClassDescriptor) libraryScope.getClassifier("Int"); - this.longClass = (ClassDescriptor) libraryScope.getClassifier("Long"); - this.floatClass = (ClassDescriptor) libraryScope.getClassifier("Float"); - this.doubleClass = (ClassDescriptor) libraryScope.getClassifier("Double"); - this.booleanClass = (ClassDescriptor) libraryScope.getClassifier("Boolean"); this.stringClass = (ClassDescriptor) libraryScope.getClassifier("String"); this.arrayClass = (ClassDescriptor) libraryScope.getClassifier("Array"); @@ -185,59 +134,41 @@ public class JetStandardLibrary { this.typeInfoClass = (ClassDescriptor) libraryScope.getClassifier("TypeInfo"); this.typeInfoFunction = libraryScope.getFunctions("typeinfo"); - this.byteType = new JetTypeImpl(getByte()); - this.charType = new JetTypeImpl(getChar()); - this.shortType = new JetTypeImpl(getShort()); - this.intType = new JetTypeImpl(getInt()); - this.longType = new JetTypeImpl(getLong()); - this.floatType = new JetTypeImpl(getFloat()); - this.doubleType = new JetTypeImpl(getDouble()); - this.booleanType = new JetTypeImpl(getBoolean()); - this.stringType = new JetTypeImpl(getString()); this.nullableStringType = TypeUtils.makeNullable(stringType); this.tuple0Type = new JetTypeImpl(JetStandardClasses.getTuple(0)); this.nullableTuple0Type = TypeUtils.makeNullable(tuple0Type); + + primitiveTypeToClass = new EnumMap(PrimitiveType.class); + primitiveTypeToJetType = new EnumMap(PrimitiveType.class); + primitiveTypeToNullableJetType = new EnumMap(PrimitiveType.class); + primitiveTypeToArrayClass = new EnumMap(PrimitiveType.class); + primitiveTypeToArrayJetType = new EnumMap(PrimitiveType.class); + primitiveTypeToNullableArrayJetType = new EnumMap(PrimitiveType.class); + primitiveJetTypeToJetArrayType = new HashMap(); - this.nullableByteType = TypeUtils.makeNullable(byteType); - this.nullableCharType = TypeUtils.makeNullable(charType); - this.nullableShortType = TypeUtils.makeNullable(shortType); - this.nullableIntType = TypeUtils.makeNullable(intType); - this.nullableLongType = TypeUtils.makeNullable(longType); - this.nullableFloatType = TypeUtils.makeNullable(floatType); - this.nullableDoubleType = TypeUtils.makeNullable(doubleType); - this.nullableBooleanType = TypeUtils.makeNullable(booleanType); - - this.byteArrayClass = (ClassDescriptor) libraryScope.getClassifier("ByteArray"); - this.charArrayClass = (ClassDescriptor) libraryScope.getClassifier("CharArray"); - this.shortArrayClass = (ClassDescriptor) libraryScope.getClassifier("ShortArray"); - this.intArrayClass = (ClassDescriptor) libraryScope.getClassifier("IntArray"); - this.longArrayClass = (ClassDescriptor) libraryScope.getClassifier("LongArray"); - this.floatArrayClass = (ClassDescriptor) libraryScope.getClassifier("FloatArray"); - this.doubleArrayClass = (ClassDescriptor) libraryScope.getClassifier("DoubleArray"); - this.booleanArrayClass = (ClassDescriptor) libraryScope.getClassifier("BooleanArray"); - - this.byteArrayType = new JetTypeImpl(byteArrayClass); - this.charArrayType = new JetTypeImpl(charArrayClass); - this.shortArrayType = new JetTypeImpl(shortArrayClass); - this.intArrayType = new JetTypeImpl(intArrayClass); - this.longArrayType = new JetTypeImpl(longArrayClass); - this.floatArrayType = new JetTypeImpl(floatArrayClass); - this.doubleArrayType = new JetTypeImpl(doubleArrayClass); - this.booleanArrayType = new JetTypeImpl(booleanArrayClass); - - this.nullableByteArrayType = TypeUtils.makeNullable(byteArrayType); - this.nullableCharArrayType = TypeUtils.makeNullable(charArrayType); - this.nullableShortArrayType = TypeUtils.makeNullable(shortArrayType); - this.nullableIntArrayType = TypeUtils.makeNullable(intArrayType); - this.nullableLongArrayType = TypeUtils.makeNullable(longArrayType); - this.nullableFloatArrayType = TypeUtils.makeNullable(floatArrayType); - this.nullableDoubleArrayType = TypeUtils.makeNullable(doubleArrayType); - this.nullableBooleanArrayType = TypeUtils.makeNullable(booleanArrayType); + for (PrimitiveType primitive : PrimitiveType.values()) { + makePrimitive(primitive); + } } } + private void makePrimitive(PrimitiveType primitiveType) { + ClassDescriptor clazz = (ClassDescriptor) libraryScope.getClassifier(primitiveType.getTypeName()); + ClassDescriptor arrayClazz = (ClassDescriptor) libraryScope.getClassifier(primitiveType.getTypeName() + "Array"); + JetTypeImpl type = new JetTypeImpl(clazz); + JetTypeImpl arrayType = new JetTypeImpl(arrayClazz); + + primitiveTypeToClass.put(primitiveType, clazz); + primitiveTypeToJetType.put(primitiveType, type); + primitiveTypeToNullableJetType.put(primitiveType, TypeUtils.makeNullable(type)); + primitiveTypeToArrayClass.put(primitiveType, arrayClazz); + primitiveTypeToArrayJetType.put(primitiveType, arrayType); + primitiveTypeToNullableArrayJetType.put(primitiveType, TypeUtils.makeNullable(arrayType)); + primitiveJetTypeToJetArrayType.put(type, arrayType); + } + @NotNull public ClassDescriptor getNumber() { initStdClasses(); @@ -245,51 +176,49 @@ public class JetStandardLibrary { } @NotNull - public ClassDescriptor getByte() { + public ClassDescriptor getPrimitiveClassDescriptor(PrimitiveType primitiveType) { initStdClasses(); - return byteClass; + return primitiveTypeToClass.get(primitiveType); + } + + @NotNull + public ClassDescriptor getByte() { + return getPrimitiveClassDescriptor(PrimitiveType.BYTE); } @NotNull public ClassDescriptor getChar() { - initStdClasses(); - return charClass; + return getPrimitiveClassDescriptor(PrimitiveType.CHAR); } @NotNull public ClassDescriptor getShort() { - initStdClasses(); - return shortClass; + return getPrimitiveClassDescriptor(PrimitiveType.SHORT); } @NotNull public ClassDescriptor getInt() { - initStdClasses(); - return intClass; + return getPrimitiveClassDescriptor(PrimitiveType.INT); } @NotNull public ClassDescriptor getLong() { - initStdClasses(); - return longClass; + return getPrimitiveClassDescriptor(PrimitiveType.LONG); } @NotNull public ClassDescriptor getFloat() { - initStdClasses(); - return floatClass; + return getPrimitiveClassDescriptor(PrimitiveType.FLOAT); } @NotNull public ClassDescriptor getDouble() { - initStdClasses(); - return doubleClass; + return getPrimitiveClassDescriptor(PrimitiveType.DOUBLE); } @NotNull public ClassDescriptor getBoolean() { - initStdClasses(); - return booleanClass; + return getPrimitiveClassDescriptor(PrimitiveType.BOOLEAN); } @NotNull @@ -338,40 +267,39 @@ public class JetStandardLibrary { return new JetTypeImpl(Collections.emptyList(), getTypeInfo().getTypeConstructor(), false, arguments, getTypeInfo().getMemberScope(arguments)); } + @NotNull + public JetType getPrimitiveJetType(PrimitiveType primitiveType) { + return primitiveTypeToJetType.get(primitiveType); + } + @NotNull public JetType getIntType() { - initStdClasses(); - return intType; + return getPrimitiveJetType(PrimitiveType.INT); } @NotNull public JetType getLongType() { - initStdClasses(); - return longType; + return getPrimitiveJetType(PrimitiveType.LONG); } @NotNull public JetType getDoubleType() { - initStdClasses(); - return doubleType; + return getPrimitiveJetType(PrimitiveType.DOUBLE); } @NotNull public JetType getFloatType() { - initStdClasses(); - return floatType; + return getPrimitiveJetType(PrimitiveType.FLOAT); } @NotNull public JetType getCharType() { - initStdClasses(); - return charType; + return getPrimitiveJetType(PrimitiveType.CHAR); } @NotNull public JetType getBooleanType() { - initStdClasses(); - return booleanType; + return getPrimitiveJetType(PrimitiveType.BOOLEAN); } @NotNull @@ -382,14 +310,12 @@ public class JetStandardLibrary { @NotNull public JetType getByteType() { - initStdClasses(); - return byteType; + return getPrimitiveJetType(PrimitiveType.BYTE); } @NotNull public JetType getShortType() { - initStdClasses(); - return shortType; + return getPrimitiveJetType(PrimitiveType.SHORT); } @NotNull @@ -431,168 +357,42 @@ public class JetStandardLibrary { return nullableStringType; } - public JetType getNullableByteType() { + @NotNull + public JetType getNullablePrimitiveJetType(PrimitiveType primitiveType) { initStdClasses(); - return nullableByteType; - } - - public JetType getNullableCharType() { - initStdClasses(); - return nullableCharType; - } - - public JetType getNullableShortType() { - initStdClasses(); - return nullableShortType; - } - - public JetType getNullableIntType() { - initStdClasses(); - return nullableIntType; - } - - public JetType getNullableLongType() { - initStdClasses(); - return nullableLongType; - } - - public JetType getNullableFloatType() { - initStdClasses(); - return nullableFloatType; - } - - public JetType getNullableDoubleType() { - initStdClasses(); - return nullableDoubleType; - } - - public JetType getNullableBooleanType() { - initStdClasses(); - return nullableBooleanType; + return primitiveTypeToNullableJetType.get(primitiveType); } public JetType getNullableTuple0Type() { initStdClasses(); return nullableTuple0Type; } - - public JetType getBooleanArrayType() { - initStdClasses(); - return booleanArrayType; - } - - public JetType getByteArrayType() { - initStdClasses(); - return byteArrayType; - } - - public JetType getCharArrayType() { - initStdClasses(); - return charArrayType; - } - - public JetType getShortArrayType() { - initStdClasses(); - return shortArrayType; - } - - public JetType getIntArrayType() { - initStdClasses(); - return intArrayType; - } - - public JetType getLongArrayType() { - initStdClasses(); - return longArrayType; - } - - public JetType getFloatArrayType() { - initStdClasses(); - return floatArrayType; - } - - public JetType getDoubleArrayType() { - initStdClasses(); - return doubleArrayType; - } - public JetType getPrimitiveArrayType(JetType jetType) { - if (jetType.equals(getIntType())) { - return getIntArrayType(); - } else { - throw new IllegalStateException("not implemented"); - } - } - - public ClassDescriptor getByteArrayClass() { + @NotNull + public JetType getPrimitiveArrayJetType(PrimitiveType primitiveType) { initStdClasses(); - return byteArrayClass; + return primitiveTypeToArrayJetType.get(primitiveType); } - public ClassDescriptor getCharArrayClass() { + /** + * @return null if not primitive + */ + @Nullable + public JetType getPrimitiveArrayJetTypeByPrimitiveJetType(JetType jetType) { + return primitiveJetTypeToJetArrayType.get(jetType); + } + + @NotNull + public ClassDescriptor getPrimitiveArrayClassDescriptor(PrimitiveType primitiveType) { initStdClasses(); - return charArrayClass; + return primitiveTypeToArrayClass.get(primitiveType); } - public ClassDescriptor getShortArrayClass() { + + @NotNull + public JetType getNullablePrimitiveArrayJetType(PrimitiveType primitiveType) { initStdClasses(); - return shortArrayClass; + return primitiveTypeToNullableArrayJetType.get(primitiveType); } - public ClassDescriptor getIntArrayClass() { - initStdClasses(); - return intArrayClass; - } - - public ClassDescriptor getLongArrayClass() { - initStdClasses(); - return longArrayClass; - } - - public ClassDescriptor getFloatArrayClass() { - initStdClasses(); - return floatArrayClass; - } - - public ClassDescriptor getDoubleArrayClass() { - initStdClasses(); - return doubleArrayClass; - } - - public ClassDescriptor getBooleanArrayClass() { - initStdClasses(); - return booleanArrayClass; - } - - public JetType getNullableByteArrayType() { - return nullableByteArrayType; - } - - public JetType getNullableCharArrayType() { - return nullableCharArrayType; - } - - public JetType getNullableShortArrayType() { - return nullableShortArrayType; - } - - public JetType getNullableIntArrayType() { - return nullableIntArrayType; - } - - public JetType getNullableLongArrayType() { - return nullableLongArrayType; - } - - public JetType getNullableFloatArrayType() { - return nullableFloatArrayType; - } - - public JetType getNullableDoubleArrayType() { - return nullableDoubleArrayType; - } - - public JetType getNullableBooleanArrayType() { - return nullableBooleanArrayType; - } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/PrimitiveType.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/PrimitiveType.java new file mode 100644 index 00000000000..1896489d5bc --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/PrimitiveType.java @@ -0,0 +1,33 @@ +package org.jetbrains.jet.lang.types; + +/** + * @author Stepan Koltsov + */ +public enum PrimitiveType { + + BOOLEAN("Boolean"), + CHAR("Char"), + BYTE("Byte"), + SHORT("Short"), + INT("Int"), + FLOAT("Float"), + LONG("Long"), + DOUBLE("Double"), + ; + + private final String typeName; + private final String arrayTypeName; + + private PrimitiveType(String typeName) { + this.typeName = typeName; + this.arrayTypeName = typeName + "Array"; + } + + public String getTypeName() { + return typeName; + } + + public String getArrayTypeName() { + return arrayTypeName; + } +}