Simplify JvmPrimitiveType, PrimitiveType

Delete utility methods from interfaces, move once-used methods to where they're
used

compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java

@@ -82,16 +82,37 @@ public class AsmUtil {
     private static final String STUB_EXCEPTION = "java/lang/RuntimeException";
     private static final String STUB_EXCEPTION_MESSAGE = "Stubs are for compiler only, do not add them to runtime classpath";
 
+    private static final ImmutableMap<Integer, JvmPrimitiveType> primitiveTypeByAsmSort;
+    private static final ImmutableMap<Type, JvmPrimitiveType> primitiveTypeByBoxedType;
+
+    static {
+        ImmutableMap.Builder<Integer, JvmPrimitiveType> typeBySortBuilder = ImmutableMap.builder();
+        ImmutableMap.Builder<Type, JvmPrimitiveType> typeByWrapperBuilder = ImmutableMap.builder();
+        for (JvmPrimitiveType type : JvmPrimitiveType.values()) {
+            typeBySortBuilder.put(type.getAsmType().getSort(), type);
+            typeByWrapperBuilder.put(type.getWrapper().getAsmType(), type);
+        }
+        primitiveTypeByAsmSort = typeBySortBuilder.build();
+        primitiveTypeByBoxedType = typeByWrapperBuilder.build();
+    }
+
     private AsmUtil() {
     }
 
-    public static Type boxType(Type asmType) {
+    @NotNull
-        JvmPrimitiveType jvmPrimitiveType = JvmPrimitiveType.getByAsmType(asmType);
+    public static Type boxType(@NotNull Type type) {
+        JvmPrimitiveType jvmPrimitiveType = primitiveTypeByAsmSort.get(type.getSort());
+        return jvmPrimitiveType != null ? jvmPrimitiveType.getWrapper().getAsmType() : type;
+    }
+
+    @NotNull
+    public static Type unboxType(@NotNull Type type) {
+        JvmPrimitiveType jvmPrimitiveType = primitiveTypeByBoxedType.get(type);
         if (jvmPrimitiveType != null) {
-            return jvmPrimitiveType.getWrapper().getAsmType();
+            return jvmPrimitiveType.getAsmType();
         }
         else {
-            return asmType;
+            throw new UnsupportedOperationException("Unboxing: " + type);
         }
     }
 
@@ -120,16 +141,6 @@ public class AsmUtil {
         return Type.getType(internalName.substring(1));
     }
 
-    public static Type unboxType(Type type) {
-        JvmPrimitiveType jvmPrimitiveType = JvmPrimitiveType.getByWrapperAsmType(type);
-        if (jvmPrimitiveType != null) {
-            return jvmPrimitiveType.getAsmType();
-        }
-        else {
-            throw new UnsupportedOperationException("Unboxing: " + type);
-        }
-    }
-
     public static boolean isAbstractMethod(FunctionDescriptor functionDescriptor, OwnerKind kind) {
         return (functionDescriptor.getModality() == Modality.ABSTRACT
                 || isInterface(functionDescriptor.getContainingDeclaration()))

compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java

@@ -54,7 +54,6 @@ import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
-import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
 import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -673,12 +672,9 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         // This method consumes range/progression from stack
         // The result is stored to local variable
         protected void generateRangeOrProgressionProperty(Type loopRangeType, String getterName, Type elementType, int varToStore) {
-            JvmPrimitiveType primitiveType = JvmPrimitiveType.getByAsmType(elementType);
+            Type boxedType = boxType(elementType);
-            assert primitiveType != null : elementType;
+            v.invokevirtual(loopRangeType.getInternalName(), getterName, "()" + boxedType.getDescriptor());
-            Type asmWrapperType = primitiveType.getWrapper().getAsmType();
+            StackValue.coerce(boxedType, elementType, v);
-
-            v.invokevirtual(loopRangeType.getInternalName(), getterName, "()" + asmWrapperType.getDescriptor());
-            StackValue.coerce(asmWrapperType, elementType, v);
             v.store(varToStore, elementType);
         }
     }

compiler/backend/src/org/jetbrains/jet/codegen/RangeCodegenUtil.java

@@ -24,6 +24,7 @@ import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lang.types.lang.PrimitiveType;
@@ -40,8 +41,8 @@ public class RangeCodegenUtil {
         ImmutableMap.Builder<FqName, PrimitiveType> rangeBuilder = ImmutableMap.builder();
         ImmutableMap.Builder<FqName, PrimitiveType> progressionBuilder = ImmutableMap.builder();
         for (PrimitiveType primitiveType : PrimitiveType.values()) {
-            rangeBuilder.put(primitiveType.getRangeClassName(), primitiveType);
+            rangeBuilder.put(getRangeClassFqName(primitiveType), primitiveType);
-            progressionBuilder.put(primitiveType.getProgressionClassName(), primitiveType);
+            progressionBuilder.put(getProgressionClassFqName(primitiveType), primitiveType);
         }
         RANGE_TO_ELEMENT_TYPE = rangeBuilder.build();
         PROGRESSION_TO_ELEMENT_TYPE = progressionBuilder.build();
@@ -120,6 +121,16 @@ public class RangeCodegenUtil {
         return false;
     }
 
+    @NotNull
+    public static FqName getRangeClassFqName(@NotNull PrimitiveType type) {
+        return KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.child(Name.identifier(type.getTypeName() + "Range"));
+    }
+
+    @NotNull
+    public static FqName getProgressionClassFqName(@NotNull PrimitiveType type) {
+        return KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.child(Name.identifier(type.getTypeName() + "Progression"));
+    }
+
     public static class BinaryCall {
         public final JetExpression left;
         public final JetExpression op;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIterator.java

@@ -20,7 +20,6 @@ import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
-import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.codegen.state.GenerationState;
@@ -30,6 +29,8 @@ 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.AsmTypeConstants;
+import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lang.types.lang.PrimitiveType;
@@ -62,9 +63,10 @@ public class ArrayIterator implements IntrinsicMethod {
                 PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType();
                 ClassDescriptor arrayClass = KotlinBuiltIns.getInstance().getPrimitiveArrayClassDescriptor(primitiveType);
                 if (containingDeclaration.equals(arrayClass)) {
-                    String methodSignature = "([" + jvmPrimitiveType.getJvmLetter() + ")" + jvmPrimitiveType.getIterator().getDescriptor();
+                    JvmClassName iterator = JvmClassName.byFqNameWithoutInnerClasses("jet." + primitiveType.getTypeName() + "Iterator");
+                    String methodSignature = "([" + jvmPrimitiveType.getAsmType() + ")" + iterator.getDescriptor();
                     v.invokestatic("jet/runtime/ArrayIterator", "iterator", methodSignature);
-                    return StackValue.onStack(jvmPrimitiveType.getIterator().getAsmType());
+                    return StackValue.onStack(iterator.getAsmType());
                 }
             }
             throw new UnsupportedOperationException(containingDeclaration.toString());

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java

@@ -19,6 +19,7 @@ package org.jetbrains.jet.codegen.intrinsics;
 import com.google.common.collect.ImmutableList;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.codegen.RangeCodegenUtil;
 import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
@@ -152,16 +153,17 @@ public class IntrinsicMethods {
         registerStaticField(getFQName(KotlinBuiltIns.getInstance().getUnit()).toSafe(), Name.identifier("VALUE"));
 
         for (PrimitiveType type : PrimitiveType.NUMBER_TYPES) {
-            registerStaticField(type.getRangeClassName(), Name.identifier("EMPTY"));
+            FqName rangeClassFqName = RangeCodegenUtil.getRangeClassFqName(type);
-        }
+            FqName progressionClassFqName = RangeCodegenUtil.getProgressionClassFqName(type);
 
-        for (PrimitiveType type : PrimitiveType.NUMBER_TYPES) {
+            registerStaticField(rangeClassFqName, Name.identifier("EMPTY"));
-            registerRangeOrProgressionProperty(type.getRangeClassName(), Name.identifier("start"));
-            registerRangeOrProgressionProperty(type.getRangeClassName(), Name.identifier("end"));
 
-            registerRangeOrProgressionProperty(type.getProgressionClassName(), Name.identifier("start"));
+            registerRangeOrProgressionProperty(rangeClassFqName, Name.identifier("start"));
-            registerRangeOrProgressionProperty(type.getProgressionClassName(), Name.identifier("end"));
+            registerRangeOrProgressionProperty(rangeClassFqName, Name.identifier("end"));
-            registerRangeOrProgressionProperty(type.getProgressionClassName(), Name.identifier("increment"));
+
+            registerRangeOrProgressionProperty(progressionClassFqName, Name.identifier("start"));
+            registerRangeOrProgressionProperty(progressionClassFqName, Name.identifier("end"));
+            registerRangeOrProgressionProperty(progressionClassFqName, Name.identifier("increment"));
         }
 
         declareArrayMethods();

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassFunction.java

@@ -21,7 +21,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
-import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.codegen.state.GenerationState;
@@ -30,11 +29,14 @@ import org.jetbrains.jet.lang.psi.JetCallExpression;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
-import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
+import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants;
 import org.jetbrains.jet.lang.types.JetType;
 
 import java.util.List;
 
+import static org.jetbrains.jet.codegen.AsmUtil.boxType;
+import static org.jetbrains.jet.codegen.AsmUtil.isPrimitive;
+
 public class JavaClassFunction implements IntrinsicMethod {
     @Override
     public StackValue generate(
@@ -49,9 +51,8 @@ public class JavaClassFunction implements IntrinsicMethod {
         JetType returnType = resultingDescriptor.getReturnType();
         assert returnType != null;
         Type type = state.getTypeMapper().mapType(returnType.getArguments().get(0).getType());
-        JvmPrimitiveType primitiveType = JvmPrimitiveType.getByAsmType(type);
+        if (isPrimitive(type)) {
-        if (primitiveType != null) {
+            v.getstatic(boxType(type).getInternalName(), "TYPE", "Ljava/lang/Class;");
-            v.getstatic(primitiveType.getWrapper().getAsmType().getInternalName(), "TYPE", "Ljava/lang/Class;");
         }
         else {
             v.aconst(type);

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassProperty.java

@@ -21,15 +21,17 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
-import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
-import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
+import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants;
 
 import java.util.List;
 
+import static org.jetbrains.jet.codegen.AsmUtil.boxType;
+import static org.jetbrains.jet.codegen.AsmUtil.isPrimitive;
+
 public class JavaClassProperty implements IntrinsicMethod {
     @Override
     public StackValue generate(
@@ -41,12 +43,12 @@ public class JavaClassProperty implements IntrinsicMethod {
             StackValue receiver,
             @NotNull GenerationState state
     ) {
-        JvmPrimitiveType primitiveType = JvmPrimitiveType.getByAsmType(receiver.type);
+        Type type = receiver.type;
-        if (primitiveType != null) {
+        if (isPrimitive(type)) {
-            v.getstatic(primitiveType.getWrapper().getAsmType().getInternalName(), "TYPE", "Ljava/lang/Class;");
+            v.getstatic(boxType(type).getInternalName(), "TYPE", "Ljava/lang/Class;");
         }
         else {
-            receiver.put(receiver.type, v);
+            receiver.put(type, v);
             v.invokevirtual("java/lang/Object", "getClass", "()Ljava/lang/Class;");
         }
         return StackValue.onStack(AsmTypeConstants.getType(Class.class));

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/PropertyOfProgressionOrRange.java

@@ -25,14 +25,14 @@ import org.jetbrains.jet.codegen.PropertyCodegen;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
-import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
-import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
 import java.util.List;
 
+import static org.jetbrains.jet.codegen.AsmUtil.boxType;
+
 public class PropertyOfProgressionOrRange implements IntrinsicMethod {
     private final FqName ownerClass;
     private final Name propertyName;
@@ -53,12 +53,12 @@ public class PropertyOfProgressionOrRange implements IntrinsicMethod {
             @NotNull GenerationState state
     ) {
         String ownerInternalName = JvmClassName.byFqNameWithoutInnerClasses(this.ownerClass).getInternalName();
-        JvmClassName wrapperClass = JvmPrimitiveType.getByAsmType(expectedType).getWrapper();
+        Type boxedType = boxType(expectedType);
         String getterName = PropertyCodegen.getterName(propertyName);
 
         receiver.put(receiver.type, v);
-        v.invokevirtual(ownerInternalName, getterName, "()" + wrapperClass.getDescriptor());
+        v.invokevirtual(ownerInternalName, getterName, "()" + boxedType.getDescriptor());
-        StackValue.coerce(wrapperClass.getAsmType(), expectedType, v);
+        StackValue.coerce(boxedType, expectedType, v);
         return StackValue.onStack(expectedType);
     }
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JvmPrimitiveType.java

@@ -16,13 +16,9 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.lang.types.lang.PrimitiveType;
 
-import java.util.HashMap;
-import java.util.Map;
-
 public enum JvmPrimitiveType {
     BOOLEAN(PrimitiveType.BOOLEAN, "boolean", "java.lang.Boolean", Type.BOOLEAN_TYPE),
     CHAR(PrimitiveType.CHAR, "char", "java.lang.Character", Type.CHAR_TYPE),
@@ -38,25 +34,12 @@ public enum JvmPrimitiveType {
     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 = JvmClassName.byFqNameWithoutInnerClasses(wrapperClassName);
         this.asmType = asmType;
-        this.jvmLetter = asmType.getDescriptor().charAt(0);
-        this.asmArrayType = makeArrayType(asmType);
-        this.iterator = JvmClassName.byFqNameWithoutInnerClasses("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() {
@@ -74,51 +57,4 @@ public enum JvmPrimitiveType {
     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);
-    }
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/mapping/JavaToKotlinClassMap.java

@@ -66,14 +66,11 @@ public class JavaToKotlinClassMap extends JavaToKotlinClassMapBuilder implements
         KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance();
         for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
             PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType();
+            String name = jvmPrimitiveType.getName();
             register(jvmPrimitiveType.getWrapper().getFqName(), builtIns.getPrimitiveClassDescriptor(primitiveType));
-        }
+            primitiveTypesMap.put(name, builtIns.getPrimitiveJetType(primitiveType));
-
+            primitiveTypesMap.put("[" + name, builtIns.getPrimitiveArrayJetType(primitiveType));
-        for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
+            primitiveTypesMap.put(jvmPrimitiveType.getWrapper().getFqName().asString(), builtIns.getNullablePrimitiveJetType(
-            PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType();
-            primitiveTypesMap.put(jvmPrimitiveType.getName(), KotlinBuiltIns.getInstance().getPrimitiveJetType(primitiveType));
-            primitiveTypesMap.put("[" + jvmPrimitiveType.getName(), KotlinBuiltIns.getInstance().getPrimitiveArrayJetType(primitiveType));
-            primitiveTypesMap.put(jvmPrimitiveType.getWrapper().getFqName().asString(), KotlinBuiltIns.getInstance().getNullablePrimitiveJetType(
                     primitiveType));
         }
         primitiveTypesMap.put("void", KotlinBuiltIns.getInstance().getUnitType());

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/mapping/KotlinToJavaTypesMap.java

@@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lang.types.lang.PrimitiveType;
 
 import java.util.HashMap;
@@ -52,15 +53,16 @@ public class KotlinToJavaTypesMap extends JavaToKotlinClassMapBuilder {
     }
 
     private void initPrimitives() {
-        for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
+        FqName builtInsFqName = KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME;
-            FqName className = jvmPrimitiveType.getPrimitiveType().getClassName();
-
-            register(className, jvmPrimitiveType.getAsmType());
-            registerNullable(className, jvmPrimitiveType.getWrapper().getAsmType());
-        }
         for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
             PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType();
-            register(primitiveType.getArrayClassName(), jvmPrimitiveType.getAsmArrayType());
+            Type asmType = jvmPrimitiveType.getAsmType();
+            FqName fqName = builtInsFqName.child(primitiveType.getTypeName());
+
+            register(fqName, asmType);
+            registerNullable(fqName, jvmPrimitiveType.getWrapper().getAsmType());
+
+            register(builtInsFqName.child(primitiveType.getArrayTypeName()), Type.getType("[" + asmType.getDescriptor()));
         }
     }
 

core/descriptors/src/org/jetbrains/jet/lang/types/lang/PrimitiveType.java

@@ -18,11 +18,9 @@ package org.jetbrains.jet.lang.types.lang;
 
 import com.google.common.collect.ImmutableSet;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
 public enum PrimitiveType {
-
     BOOLEAN("Boolean"),
     CHAR("Char"),
     BYTE("Byte"),
@@ -37,21 +35,10 @@ public enum PrimitiveType {
 
     private final Name typeName;
     private final Name arrayTypeName;
-    private final Name rangeTypeName;
-    private final FqName className;
-    private final FqName arrayClassName;
-    private final FqName rangeClassName;
-    private final FqName progressionClassName;
 
     private PrimitiveType(String typeName) {
         this.typeName = Name.identifier(typeName);
         this.arrayTypeName = Name.identifier(typeName + "Array");
-        this.rangeTypeName = Name.identifier(typeName + "Range");
-        FqName builtInsPackageFqName = KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME;
-        this.className = builtInsPackageFqName.child(this.typeName);
-        this.arrayClassName = builtInsPackageFqName.child(this.arrayTypeName);
-        this.rangeClassName = builtInsPackageFqName.child(this.rangeTypeName);
-        this.progressionClassName = builtInsPackageFqName.child(Name.identifier(typeName + "Progression"));
     }
 
     @NotNull
@@ -63,29 +50,4 @@ public enum PrimitiveType {
     public Name getArrayTypeName() {
         return arrayTypeName;
     }
-
-    @NotNull
-    public Name getRangeTypeName() {
-        return rangeTypeName;
-    }
-
-    @NotNull
-    public FqName getClassName() {
-        return className;
-    }
-
-    @NotNull
-    public FqName getArrayClassName() {
-        return arrayClassName;
-    }
-
-    @NotNull
-    public FqName getRangeClassName() {
-        return rangeClassName;
-    }
-
-    @NotNull
-    public FqName getProgressionClassName() {
-        return progressionClassName;
-    }
 }