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
This commit is contained in:
Stepan Koltsov
@@ -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) {
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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) {
|
||||
|
||||
+14
-40
@@ -155,31 +155,13 @@ public class JavaTypeTransformer {
|
||||
public Map<String, JetType> getPrimitiveTypesMap() {
|
||||
if (primitiveTypesMap == null) {
|
||||
primitiveTypesMap = new HashMap<String, JetType>();
|
||||
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<String, JetType> getClassTypesMap() {
|
||||
if (classTypesMap == null) {
|
||||
classTypesMap = new HashMap<String, JetType>();
|
||||
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<String, ClassDescriptor> getPrimitiveWrappersClassDescriptorMap() {
|
||||
if (classDescriptorMap == null) {
|
||||
classDescriptorMap = new HashMap<String, ClassDescriptor>();
|
||||
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());
|
||||
}
|
||||
|
||||
+15
-39
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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<Integer, JvmPrimitiveType> map;
|
||||
|
||||
static {
|
||||
map = new HashMap<Integer, JvmPrimitiveType>();
|
||||
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<Type, JvmPrimitiveType> map;
|
||||
|
||||
static {
|
||||
map = new HashMap<Type, JvmPrimitiveType>();
|
||||
for (JvmPrimitiveType jvmPrimitiveType : values()) {
|
||||
map.put(jvmPrimitiveType.getWrapper().getAsmType(), jvmPrimitiveType);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Nullable
|
||||
public static JvmPrimitiveType getByWrapperAsmType(Type type) {
|
||||
return MapByWrapperAsmTypeHolder.map.get(type);
|
||||
}
|
||||
}
|
||||
@@ -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<TypeParameterDescriptor> resolveTypeParameters(DeclarationDescriptor containingDescriptor, WritableScope extensibleScope, List<JetTypeParameter> typeParameters) {
|
||||
|
||||
@@ -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<FunctionDescriptor> typeInfoFunction;
|
||||
|
||||
private EnumMap<PrimitiveType, ClassDescriptor> primitiveTypeToClass;
|
||||
private EnumMap<PrimitiveType, ClassDescriptor> primitiveTypeToArrayClass;
|
||||
private EnumMap<PrimitiveType, JetType> primitiveTypeToJetType;
|
||||
private EnumMap<PrimitiveType, JetType> primitiveTypeToNullableJetType;
|
||||
private EnumMap<PrimitiveType, JetType> primitiveTypeToArrayJetType;
|
||||
private EnumMap<PrimitiveType, JetType> primitiveTypeToNullableArrayJetType;
|
||||
private Map<JetType, JetType> primitiveJetTypeToJetArrayType;
|
||||
|
||||
private JetStandardLibrary(@NotNull Project project) {
|
||||
// TODO : review
|
||||
List<String> 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, ClassDescriptor>(PrimitiveType.class);
|
||||
primitiveTypeToJetType = new EnumMap<PrimitiveType, JetType>(PrimitiveType.class);
|
||||
primitiveTypeToNullableJetType = new EnumMap<PrimitiveType, JetType>(PrimitiveType.class);
|
||||
primitiveTypeToArrayClass = new EnumMap<PrimitiveType, ClassDescriptor>(PrimitiveType.class);
|
||||
primitiveTypeToArrayJetType = new EnumMap<PrimitiveType, JetType>(PrimitiveType.class);
|
||||
primitiveTypeToNullableArrayJetType = new EnumMap<PrimitiveType, JetType>(PrimitiveType.class);
|
||||
primitiveJetTypeToJetArrayType = new HashMap<JetType, JetType>();
|
||||
|
||||
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.<AnnotationDescriptor>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 <code>null</code> 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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user