rename JetTypeMapper constants

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

@@ -78,14 +78,14 @@ public class ClosureCodegen extends ObjectOrClosureCodegen {
 
         for (int i = 0; i < paramCount; ++i) {
             signatureWriter.writeParameterType(JvmMethodParameterKind.VALUE);
-            signatureWriter.writeAsmType(JetTypeMapper.TYPE_OBJECT, true);
+            signatureWriter.writeAsmType(JetTypeMapper.OBJECT_TYPE, true);
             signatureWriter.writeParameterTypeEnd();
         }
 
         signatureWriter.writeParametersEnd();
 
         signatureWriter.writeReturnType();
-        signatureWriter.writeAsmType(JetTypeMapper.TYPE_OBJECT, true);
+        signatureWriter.writeAsmType(JetTypeMapper.OBJECT_TYPE, true);
         signatureWriter.writeReturnTypeEnd();
 
         return signatureWriter.makeJvmMethodSignature("invoke");
@@ -242,24 +242,24 @@ public class ClosureCodegen extends ObjectOrClosureCodegen {
             final ReceiverDescriptor receiver = funDescriptor.getReceiverParameter();
             int count = 1;
             if (receiver.exists()) {
-                StackValue.local(count, JetTypeMapper.TYPE_OBJECT).put(JetTypeMapper.TYPE_OBJECT, iv);
+                StackValue.local(count, JetTypeMapper.OBJECT_TYPE).put(JetTypeMapper.OBJECT_TYPE, iv);
-                StackValue.onStack(JetTypeMapper.TYPE_OBJECT)
+                StackValue.onStack(JetTypeMapper.OBJECT_TYPE)
                         .upcast(typeMapper.mapType(receiver.getType(), MapTypeMode.VALUE), iv);
                 count++;
             }
 
             final List<ValueParameterDescriptor> params = funDescriptor.getValueParameters();
             for (ValueParameterDescriptor param : params) {
-                StackValue.local(count, JetTypeMapper.TYPE_OBJECT).put(JetTypeMapper.TYPE_OBJECT, iv);
+                StackValue.local(count, JetTypeMapper.OBJECT_TYPE).put(JetTypeMapper.OBJECT_TYPE, iv);
-                StackValue.onStack(JetTypeMapper.TYPE_OBJECT)
+                StackValue.onStack(JetTypeMapper.OBJECT_TYPE)
                         .upcast(typeMapper.mapType(param.getType(), MapTypeMode.VALUE), iv);
                 count++;
             }
 
             iv.invokevirtual(className, "invoke", delegate.getDescriptor());
-            StackValue.onStack(delegate.getReturnType()).put(JetTypeMapper.TYPE_OBJECT, iv);
+            StackValue.onStack(delegate.getReturnType()).put(JetTypeMapper.OBJECT_TYPE, iv);
 
-            iv.areturn(JetTypeMapper.TYPE_OBJECT);
+            iv.areturn(JetTypeMapper.OBJECT_TYPE);
 
             FunctionCodegen.endVisit(mv, "bridge", fun);
         }
@@ -285,7 +285,7 @@ public class ClosureCodegen extends ObjectOrClosureCodegen {
 
             int k = 1;
             for (int i = 0; i != argTypes.length; ++i) {
-                StackValue.local(0, JetTypeMapper.TYPE_OBJECT).put(JetTypeMapper.TYPE_OBJECT, iv);
+                StackValue.local(0, JetTypeMapper.OBJECT_TYPE).put(JetTypeMapper.OBJECT_TYPE, iv);
                 final Pair<String, Type> nameAndType = args.get(i);
                 final Type type = nameAndType.second;
                 StackValue.local(k, type).put(type, iv);

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

@@ -27,7 +27,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
-import static org.jetbrains.jet.codegen.JetTypeMapper.TYPE_OBJECT;
+import static org.jetbrains.jet.codegen.JetTypeMapper.OBJECT_TYPE;
 
 /*
  * @author max
@@ -169,7 +169,7 @@ public abstract class CodegenContext {
         FrameMap frameMap = new FrameMap();
 
         if (getContextKind() != OwnerKind.NAMESPACE) {
-            frameMap.enterTemp(TYPE_OBJECT);  // 0 slot for this
+            frameMap.enterTemp(OBJECT_TYPE);  // 0 slot for this
         }
 
         CallableDescriptor receiverDescriptor = getReceiverDescriptor();

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

@@ -86,7 +86,7 @@ public class CodegenContexts {
                     return "ROOT";
                 }
             };
-    private static final StackValue local1 = StackValue.local(1, JetTypeMapper.TYPE_OBJECT);
+    private static final StackValue local1 = StackValue.local(1, JetTypeMapper.OBJECT_TYPE);
 
     public abstract static class ReceiverContext extends CodegenContext {
         final CallableDescriptor receiverDescriptor;

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

@@ -33,10 +33,10 @@ public class ConstructorFrameMap extends FrameMap {
     private int myOuterThisIndex = -1;
 
     public ConstructorFrameMap(CallableMethod callableMethod, @Nullable ConstructorDescriptor descriptor, boolean hasThis0) {
-        enterTemp(JetTypeMapper.TYPE_OBJECT); // this
+        enterTemp(JetTypeMapper.OBJECT_TYPE); // this
         if (descriptor != null) {
             if (hasThis0) {
-                myOuterThisIndex = enterTemp(JetTypeMapper.TYPE_OBJECT);   // outer class instance
+                myOuterThisIndex = enterTemp(JetTypeMapper.OBJECT_TYPE);   // outer class instance
             }
         }
 
@@ -45,7 +45,7 @@ public class ConstructorFrameMap extends FrameMap {
         if (descriptor != null &&
             (descriptor.getContainingDeclaration().getKind() == ClassKind.ENUM_CLASS ||
              descriptor.getContainingDeclaration().getKind() == ClassKind.ENUM_ENTRY)) {
-            enterTemp(JetTypeMapper.TYPE_OBJECT); // name
+            enterTemp(JetTypeMapper.OBJECT_TYPE); // name
             enterTemp(Type.INT_TYPE); // ordinal
         }
 

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

@@ -245,8 +245,8 @@ public class FunctionCodegen {
                 else if (kind instanceof OwnerKind.DelegateKind) {
                     OwnerKind.DelegateKind dk = (OwnerKind.DelegateKind) kind;
                     InstructionAdapter iv = new InstructionAdapter(mv);
-                    iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                    iv.load(0, JetTypeMapper.OBJECT_TYPE);
-                    dk.getDelegate().put(JetTypeMapper.TYPE_OBJECT, iv);
+                    dk.getDelegate().put(JetTypeMapper.OBJECT_TYPE, iv);
                     for (int i = 0; i < argTypes.length; i++) {
                         Type argType = argTypes[i];
                         iv.load(i + 1, argType);
@@ -495,7 +495,7 @@ public class FunctionCodegen {
         FrameMap frameMap = owner.prepareFrame(state.getInjector().getJetTypeMapper());
 
         if (kind instanceof OwnerKind.StaticDelegateKind) {
-            frameMap.leaveTemp(JetTypeMapper.TYPE_OBJECT);
+            frameMap.leaveTemp(JetTypeMapper.OBJECT_TYPE);
         }
 
         ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, jvmSignature.getReturnType(), owner, state);
@@ -645,15 +645,15 @@ public class FunctionCodegen {
             Type[] argTypes = overridden.getArgumentTypes();
             Type[] originalArgTypes = jvmSignature.getArgumentTypes();
             InstructionAdapter iv = new InstructionAdapter(mv);
-            iv.load(0, JetTypeMapper.TYPE_OBJECT);
+            iv.load(0, JetTypeMapper.OBJECT_TYPE);
             for (int i = 0, reg = 1; i < argTypes.length; i++) {
                 Type argType = argTypes[i];
                 iv.load(reg, argType);
                 if (argType.getSort() == Type.OBJECT) {
-                    StackValue.onStack(JetTypeMapper.TYPE_OBJECT).put(originalArgTypes[i], iv);
+                    StackValue.onStack(JetTypeMapper.OBJECT_TYPE).put(originalArgTypes[i], iv);
                 }
                 else if (argType.getSort() == Type.ARRAY) {
-                    StackValue.onStack(JetTypeMapper.ARRAY_GENERIC_TYPE).put(originalArgTypes[i], iv);
+                    StackValue.onStack(JetTypeMapper.JAVA_ARRAY_GENERIC_TYPE).put(originalArgTypes[i], iv);
                 }
 
                 //noinspection AssignmentToForLoopParameter
@@ -699,22 +699,22 @@ public class FunctionCodegen {
 
             Type[] argTypes = method.getArgumentTypes();
             InstructionAdapter iv = new InstructionAdapter(mv);
-            iv.load(0, JetTypeMapper.TYPE_OBJECT);
+            iv.load(0, JetTypeMapper.OBJECT_TYPE);
             for (int i = 0, reg = 1; i < argTypes.length; i++) {
                 Type argType = argTypes[i];
                 iv.load(reg, argType);
                 if (argType.getSort() == Type.OBJECT) {
-                    StackValue.onStack(JetTypeMapper.TYPE_OBJECT).put(method.getArgumentTypes()[i], iv);
+                    StackValue.onStack(JetTypeMapper.OBJECT_TYPE).put(method.getArgumentTypes()[i], iv);
                 }
                 else if (argType.getSort() == Type.ARRAY) {
-                    StackValue.onStack(JetTypeMapper.ARRAY_GENERIC_TYPE).put(method.getArgumentTypes()[i], iv);
+                    StackValue.onStack(JetTypeMapper.JAVA_ARRAY_GENERIC_TYPE).put(method.getArgumentTypes()[i], iv);
                 }
 
                 //noinspection AssignmentToForLoopParameter
                 reg += argType.getSize();
             }
 
-            iv.load(0, JetTypeMapper.TYPE_OBJECT);
+            iv.load(0, JetTypeMapper.OBJECT_TYPE);
             field.put(field.type, iv);
             ClassDescriptor classDescriptor = (ClassDescriptor) overriddenDescriptor.getContainingDeclaration();
             String internalName =

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

@@ -47,7 +47,7 @@ import org.jetbrains.jet.utils.BitSetUtils;
 import java.util.*;
 
 import static org.jetbrains.asm4.Opcodes.*;
-import static org.jetbrains.jet.codegen.JetTypeMapper.TYPE_OBJECT;
+import static org.jetbrains.jet.codegen.JetTypeMapper.OBJECT_TYPE;
 
 /**
  * @author max
@@ -400,7 +400,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
                 InstructionAdapter iv = new InstructionAdapter(mv);
 
-                iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                iv.load(0, JetTypeMapper.OBJECT_TYPE);
                 for (int i = 1, reg = 1; i < argTypes.length; i++) {
                     Type argType = argTypes[i];
                     iv.load(reg, argType);
@@ -437,7 +437,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
                     InstructionAdapter iv = new InstructionAdapter(mv);
 
-                    iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                    iv.load(0, JetTypeMapper.OBJECT_TYPE);
                     if (original.getVisibility() == Visibilities.PRIVATE) {
                         iv.getfield(typeMapper.getOwner(original, OwnerKind.IMPLEMENTATION).getInternalName(), original.getName().getName(),
                                     originalMethod.getReturnType().getDescriptor());
@@ -472,7 +472,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
                     InstructionAdapter iv = new InstructionAdapter(mv);
 
-                    iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                    iv.load(0, JetTypeMapper.OBJECT_TYPE);
                     Type[] argTypes = method.getArgumentTypes();
                     for (int i = 1, reg = 1; i < argTypes.length; i++) {
                         Type argType = argTypes[i];
@@ -701,7 +701,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         if (closure != null) {
             int k = hasOuterThis ? 2 : 1;
             if (closure.captureReceiver != null) {
-                iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                iv.load(0, JetTypeMapper.OBJECT_TYPE);
                 final Type asmType = typeMapper.mapType(closure.captureReceiver.getDefaultType(), MapTypeMode.IMPL);
                 iv.load(1, asmType);
                 iv.putfield(typeMapper.mapType(descriptor.getDefaultType(), MapTypeMode.VALUE).getInternalName(), "receiver$0",
@@ -715,7 +715,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                     if (sharedVarType == null) {
                         sharedVarType = typeMapper.mapType(((VariableDescriptor) varDescr).getType(), MapTypeMode.VALUE);
                     }
-                    iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                    iv.load(0, JetTypeMapper.OBJECT_TYPE);
                     iv.load(k, StackValue.refType(sharedVarType));
                     k += StackValue.refType(sharedVarType).getSize();
                     iv.putfield(typeMapper.mapType(descriptor.getDefaultType(), MapTypeMode.VALUE).getInternalName(),
@@ -765,7 +765,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         assert superType != null;
         ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor();
         if (typeMapper.hasThis0(superClassDescriptor)) {
-            iv.load(1, JetTypeMapper.TYPE_OBJECT);
+            iv.load(1, JetTypeMapper.OBJECT_TYPE);
             parameterTypes.add(typeMapper.mapType(
                     typeMapper.getClosureAnnotator().getEclosingClassDescriptor(descriptor).getDefaultType(), MapTypeMode.VALUE));
         }
@@ -778,7 +778,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     private void genSimpleSuperCall(InstructionAdapter iv) {
         iv.load(0, Type.getType("L" + superClass + ";"));
         if (descriptor.getKind() == ClassKind.ENUM_CLASS || descriptor.getKind() == ClassKind.ENUM_ENTRY) {
-            iv.load(1, JetTypeMapper.JL_STRING_TYPE);
+            iv.load(1, JetTypeMapper.JAVA_STRING_TYPE);
             iv.load(2, Type.INT_TYPE);
             iv.invokespecial(superClass, "<init>", "(Ljava/lang/String;I)V");
         }
@@ -1025,7 +1025,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                     Type[] argTypes = function.getArgumentTypes();
                     List<Type> originalArgTypes = jvmSignature.getValueParameterTypes();
                     InstructionAdapter iv = new InstructionAdapter(mv);
-                    iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                    iv.load(0, JetTypeMapper.OBJECT_TYPE);
                     for (int i = 0, reg = 1; i < argTypes.length; i++) {
                         Type argType = argTypes[i];
                         iv.load(reg, argType);
@@ -1065,9 +1065,9 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     ) {
         ClassDescriptor classDecl = constructorDescriptor.getContainingDeclaration();
 
-        iv.load(0, TYPE_OBJECT);
+        iv.load(0, OBJECT_TYPE);
         if (classDecl.getKind() == ClassKind.ENUM_CLASS || classDecl.getKind() == ClassKind.ENUM_ENTRY) {
-            iv.load(1, JetTypeMapper.TYPE_OBJECT);
+            iv.load(1, JetTypeMapper.OBJECT_TYPE);
             iv.load(2, Type.INT_TYPE);
         }
 
@@ -1183,7 +1183,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             }
             iv.dup();
             iv.putstatic(myAsmType.getInternalName(), enumConstant.getName(), "L" + myAsmType.getInternalName() + ";");
-            iv.astore(TYPE_OBJECT);
+            iv.astore(OBJECT_TYPE);
         }
         iv.putstatic(myAsmType.getInternalName(), "$VALUES", arrayAsmType.getDescriptor());
     }
@@ -1206,7 +1206,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                             Type type = typeMapper.mapType(jetType, MapTypeMode.VALUE);
                             if (skipDefaultValue(propertyDescriptor, value, type)) continue;
                         }
-                        iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                        iv.load(0, JetTypeMapper.OBJECT_TYPE);
                         Type type = codegen.expressionType(initializer);
                         if (jetType.isNullable()) {
                             type = JetTypeMapper.boxType(type);

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

@@ -40,10 +40,10 @@ import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibraryNames;
 
-import javax.annotation.PostConstruct;
 import javax.inject.Inject;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Iterator;
 import java.util.List;
 
 import static org.jetbrains.asm4.Opcodes.*;
@@ -53,36 +53,35 @@ import static org.jetbrains.asm4.Opcodes.*;
  * @author alex.tkachman
  */
 public class JetTypeMapper {
-    public static final Type TYPE_OBJECT = Type.getObjectType("java/lang/Object");
+    public static final Type OBJECT_TYPE = Type.getType(Object.class);
-    public static final Type TYPE_THROWABLE = Type.getObjectType("java/lang/Throwable");
+    public static final Type JAVA_NUMBER_TYPE = Type.getType(Number.class);
-    public static final Type TYPE_NOTHING = Type.getObjectType("jet/Nothing");
+    public static final Type JAVA_STRING_BUILDER_TYPE = Type.getType(StringBuilder.class);
-    public static final Type JL_NUMBER_TYPE = Type.getObjectType("java/lang/Number");
+    public static final Type JAVA_STRING_TYPE = Type.getType(String.class);
-    public static final Type JL_STRING_BUILDER = Type.getObjectType("java/lang/StringBuilder");
+    public static final Type JAVA_ENUM_TYPE = Type.getType(Enum.class);
-    public static final Type JL_STRING_TYPE = Type.getObjectType("java/lang/String");
+    public static final Type JAVA_CHAR_SEQUENCE_TYPE = Type.getType(CharSequence.class);
-    public static final Type JL_ENUM_TYPE = Type.getObjectType("java/lang/Enum");
+    public static final Type JAVA_COMPARABLE_TYPE = Type.getType(Comparable.class);
-    public static final Type JL_CHAR_SEQUENCE_TYPE = Type.getObjectType("java/lang/CharSequence");
+    public static final Type JAVA_THROWABLE_TYPE = Type.getType(Throwable.class);
-    public static final Type JL_COMPARABLE_TYPE = Type.getObjectType("java/lang/Comparable");
+    public static final Type JAVA_ITERABLE_TYPE = Type.getType(Iterable.class);
-    public static final Type JL_ITERABLE_TYPE = Type.getObjectType("java/lang/Iterable");
+    public static final Type JAVA_ITERATOR_TYPE = Type.getType(Iterator.class);
-    public static final Type JL_ITERATOR_TYPE = Type.getObjectType("java/util/Iterator");
+    public static final Type JAVA_CLASS_TYPE = Type.getType(Class.class);
-    public static final Type JL_CLASS_TYPE = Type.getObjectType("java/lang/Class");
+    public static final Type JAVA_BOOLEAN_TYPE = Type.getType(Boolean.class);
-    public static final Type JL_BOOLEAN_TYPE = Type.getObjectType("java/lang/Boolean");
+    public static final Type JAVA_ARRAY_GENERIC_TYPE = Type.getType(Object[].class);
 
-    public static final Type ARRAY_GENERIC_TYPE = Type.getType(Object[].class);
+    public static final Type JET_NOTHING_TYPE = Type.getObjectType("jet/Nothing");
-    public static final Type TUPLE0_TYPE = Type.getObjectType("jet/Tuple0");
+    public static final Type JET_TUPLE0_TYPE = Type.getObjectType("jet/Tuple0");
-
+    public static final Type JET_FUNCTION0_TYPE = Type.getObjectType("jet/Function0");
-    public static final Type TYPE_ITERATOR = Type.getObjectType("jet/Iterator");
+    public static final Type JET_FUNCTION1_TYPE = Type.getObjectType("jet/Function1");
-    public static final Type TYPE_INT_RANGE = Type.getObjectType("jet/IntRange");
+    public static final Type JET_ITERATOR_TYPE = Type.getObjectType("jet/Iterator");
-    public static final Type TYPE_SHARED_VAR = Type.getObjectType("jet/runtime/SharedVar$Object");
+    public static final Type JET_INT_RANGE_TYPE = Type.getObjectType("jet/IntRange");
-    public static final Type TYPE_SHARED_INT = Type.getObjectType("jet/runtime/SharedVar$Int");
+    public static final Type JET_SHARED_VAR_TYPE = Type.getObjectType("jet/runtime/SharedVar$Object");
-    public static final Type TYPE_SHARED_DOUBLE = Type.getObjectType("jet/runtime/SharedVar$Double");
+    public static final Type JET_SHARED_INT_TYPE = Type.getObjectType("jet/runtime/SharedVar$Int");
-    public static final Type TYPE_SHARED_FLOAT = Type.getObjectType("jet/runtime/SharedVar$Float");
+    public static final Type JET_SHARED_DOUBLE_TYPE = Type.getObjectType("jet/runtime/SharedVar$Double");
-    public static final Type TYPE_SHARED_BYTE = Type.getObjectType("jet/runtime/SharedVar$Byte");
+    public static final Type JET_SHARED_FLOAT_TYPE = Type.getObjectType("jet/runtime/SharedVar$Float");
-    public static final Type TYPE_SHARED_SHORT = Type.getObjectType("jet/runtime/SharedVar$Short");
+    public static final Type JET_SHARED_BYTE_TYPE = Type.getObjectType("jet/runtime/SharedVar$Byte");
-    public static final Type TYPE_SHARED_CHAR = Type.getObjectType("jet/runtime/SharedVar$Char");
+    public static final Type JET_SHARED_SHORT_TYPE = Type.getObjectType("jet/runtime/SharedVar$Short");
-    public static final Type TYPE_SHARED_LONG = Type.getObjectType("jet/runtime/SharedVar$Long");
+    public static final Type JET_SHARED_CHAR_TYPE = Type.getObjectType("jet/runtime/SharedVar$Char");
-    public static final Type TYPE_SHARED_BOOLEAN = Type.getObjectType("jet/runtime/SharedVar$Boolean");
+    public static final Type JET_SHARED_LONG_TYPE = Type.getObjectType("jet/runtime/SharedVar$Long");
-    public static final Type TYPE_FUNCTION0 = Type.getObjectType("jet/Function0");
+    public static final Type JET_SHARED_BOOLEAN_TYPE = Type.getObjectType("jet/runtime/SharedVar$Boolean");
-    public static final Type TYPE_FUNCTION1 = Type.getObjectType("jet/Function1");
 
     public BindingContext bindingContext;
     private ClosureAnnotator closureAnnotator;
@@ -254,7 +253,7 @@ public class JetTypeMapper {
             if (signatureVisitor != null) {
                 signatureVisitor.writeNothing(true);
             }
-            return TYPE_OBJECT;
+            return OBJECT_TYPE;
         }
         return mapType(jetType, signatureVisitor, MapTypeMode.VALUE);
     }
@@ -413,7 +412,7 @@ public class JetTypeMapper {
                 r = Type.getType("[" + boxType(mapType(memberType, kind)).getDescriptor());
             }
             else {
-                r = ARRAY_GENERIC_TYPE;
+                r = JAVA_ARRAY_GENERIC_TYPE;
             }
             checkValidType(r);
             return r;

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

@@ -25,7 +25,6 @@ import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
-import org.jetbrains.jet.lang.resolve.name.FqNameBase;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.lang.PrimitiveType;
@@ -83,7 +82,7 @@ public class KotlinToJavaTypesMap {
     }
 
     public void init() {
-        register(NOTHING, TYPE_NOTHING);
+        register(NOTHING, JET_NOTHING_TYPE);
 
         for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
             ClassName className = jvmPrimitiveType.getPrimitiveType().getClassName();
@@ -92,17 +91,17 @@ public class KotlinToJavaTypesMap {
             registerNullable(className, jvmPrimitiveType.getWrapper().getAsmType());
         }
 
-        register(ANY, TYPE_OBJECT);
+        register(ANY, OBJECT_TYPE);
-        register(NUMBER, JL_NUMBER_TYPE);
+        register(NUMBER, JAVA_NUMBER_TYPE);
-        register(STRING, JL_STRING_TYPE);
+        register(STRING, JAVA_STRING_TYPE);
-        register(CHAR_SEQUENCE, JL_CHAR_SEQUENCE_TYPE);
+        register(CHAR_SEQUENCE, JAVA_CHAR_SEQUENCE_TYPE);
-        register(THROWABLE, TYPE_THROWABLE);
+        register(THROWABLE, JAVA_THROWABLE_TYPE);
-        register(COMPARABLE, JL_COMPARABLE_TYPE);
+        register(COMPARABLE, JAVA_COMPARABLE_TYPE);
-        register(ENUM, JL_ENUM_TYPE);
+        register(ENUM, JAVA_ENUM_TYPE);
-        register(ITERABLE, JL_ITERABLE_TYPE);
+        register(ITERABLE, JAVA_ITERABLE_TYPE);
-        register(ITERATOR, JL_ITERATOR_TYPE);
+        register(ITERATOR, JAVA_ITERATOR_TYPE);
-        register(MUTABLE_ITERABLE, JL_ITERABLE_TYPE);
+        register(MUTABLE_ITERABLE, JAVA_ITERABLE_TYPE);
-        register(MUTABLE_ITERATOR, JL_ITERATOR_TYPE);
+        register(MUTABLE_ITERATOR, JAVA_ITERATOR_TYPE);
 
         for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
             PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType();

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

@@ -215,7 +215,7 @@ public class PropertyCodegen {
                 else {
                     InstructionAdapter iv = new InstructionAdapter(mv);
                     if (kind != OwnerKind.NAMESPACE) {
-                        iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                        iv.load(0, JetTypeMapper.OBJECT_TYPE);
                     }
                     final Type type = state.getInjector().getJetTypeMapper().mapType(propertyDescriptor.getType(), MapTypeMode.VALUE);
 
@@ -225,7 +225,7 @@ public class PropertyCodegen {
 
                     if (kind instanceof OwnerKind.DelegateKind) {
                         OwnerKind.DelegateKind dk = (OwnerKind.DelegateKind) kind;
-                        dk.getDelegate().put(JetTypeMapper.TYPE_OBJECT, iv);
+                        dk.getDelegate().put(JetTypeMapper.OBJECT_TYPE, iv);
                         iv.invokeinterface(dk.getOwnerClass(), getterName, descriptor);
                     }
                     else {
@@ -320,7 +320,7 @@ public class PropertyCodegen {
                     final Type type = state.getInjector().getJetTypeMapper().mapType(propertyDescriptor.getType(), MapTypeMode.VALUE);
                     int paramCode = 0;
                     if (kind != OwnerKind.NAMESPACE) {
-                        iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                        iv.load(0, JetTypeMapper.OBJECT_TYPE);
                         paramCode = 1;
                     }
 
@@ -330,8 +330,8 @@ public class PropertyCodegen {
 
                     if (kind instanceof OwnerKind.DelegateKind) {
                         OwnerKind.DelegateKind dk = (OwnerKind.DelegateKind) kind;
-                        iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                        iv.load(0, JetTypeMapper.OBJECT_TYPE);
-                        dk.getDelegate().put(JetTypeMapper.TYPE_OBJECT, iv);
+                        dk.getDelegate().put(JetTypeMapper.OBJECT_TYPE, iv);
 
                         iv.load(paramCode, type);
                         iv.invokeinterface(dk.getOwnerClass(), setterName(propertyDescriptor.getName()), descriptor);

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

@@ -38,7 +38,7 @@ import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import javax.inject.Inject;
 import java.util.List;
 
-import static org.jetbrains.jet.codegen.JetTypeMapper.TYPE_OBJECT;
+import static org.jetbrains.jet.codegen.JetTypeMapper.OBJECT_TYPE;
 
 /**
  * @author Stepan Koltsov
@@ -159,7 +159,7 @@ public class ScriptCodegen {
         FrameMap frameMap = context.prepareFrame(jetTypeMapper);
 
         for (ScriptDescriptor importedScript : importedScripts) {
-            frameMap.enter(importedScript, TYPE_OBJECT);
+            frameMap.enter(importedScript, OBJECT_TYPE);
         }
 
         Type[] argTypes = jvmSignature.getAsmMethod().getArgumentTypes();

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

@@ -35,7 +35,7 @@ import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.List;
 
-import static org.jetbrains.jet.codegen.JetTypeMapper.TYPE_OBJECT;
+import static org.jetbrains.jet.codegen.JetTypeMapper.OBJECT_TYPE;
 
 /**
  * @author yole
@@ -267,15 +267,15 @@ public abstract class StackValue {
                 v.iconst(0);
             }
         }
-        else if (toType.equals(JetTypeMapper.TUPLE0_TYPE) && !fromType.equals(JetTypeMapper.TUPLE0_TYPE)) {
+        else if (toType.equals(JetTypeMapper.JET_TUPLE0_TYPE) && !fromType.equals(JetTypeMapper.JET_TUPLE0_TYPE)) {
             pop(fromType, v);
             putTuple0Instance(v);
         }
-        else if (toType.getSort() == Type.OBJECT && fromType.equals(TYPE_OBJECT) || toType.getSort() == Type.ARRAY) {
+        else if (toType.getSort() == Type.OBJECT && fromType.equals(OBJECT_TYPE) || toType.getSort() == Type.ARRAY) {
             v.checkcast(toType);
         }
         else if (toType.getSort() == Type.OBJECT) {
-            if (fromType.getSort() == Type.OBJECT && !toType.equals(TYPE_OBJECT)) {
+            if (fromType.getSort() == Type.OBJECT && !toType.equals(OBJECT_TYPE)) {
                 v.checkcast(toType);
             }
             else {
@@ -283,7 +283,7 @@ public abstract class StackValue {
             }
         }
         else if (fromType.getSort() == Type.OBJECT && toType.getSort() <= Type.DOUBLE) {
-            if (fromType.equals(TYPE_OBJECT)) {
+            if (fromType.equals(OBJECT_TYPE)) {
                 if (toType.getSort() == Type.BOOLEAN) {
                     v.checkcast(JvmPrimitiveType.BOOLEAN.getWrapper().getAsmType());
                 }
@@ -291,7 +291,7 @@ public abstract class StackValue {
                     v.checkcast(JvmPrimitiveType.CHAR.getWrapper().getAsmType());
                 }
                 else {
-                    v.checkcast(JetTypeMapper.JL_NUMBER_TYPE);
+                    v.checkcast(JetTypeMapper.JAVA_NUMBER_TYPE);
                 }
             }
             unbox(toType, v);
@@ -477,11 +477,11 @@ public abstract class StackValue {
             if (type == Type.VOID_TYPE) {
                 return;
             }
-            if (type.equals(JetTypeMapper.TUPLE0_TYPE)) {
+            if (type.equals(JetTypeMapper.JET_TUPLE0_TYPE)) {
                 putTuple0Instance(v);
                 return;
             }
-            if (type != Type.BOOLEAN_TYPE && !type.equals(TYPE_OBJECT) && !type.equals(JetTypeMapper.JL_BOOLEAN_TYPE)) {
+            if (type != Type.BOOLEAN_TYPE && !type.equals(OBJECT_TYPE) && !type.equals(JetTypeMapper.JAVA_BOOLEAN_TYPE)) {
                 throw new UnsupportedOperationException("don't know how to put a compare as a non-boolean type " + type);
             }
             putAsBoolean(v);
@@ -570,7 +570,7 @@ public abstract class StackValue {
                 myOperand.put(type, v);    // the operand will remove itself from the stack if needed
                 return;
             }
-            if (type != Type.BOOLEAN_TYPE && !type.equals(TYPE_OBJECT) && !type.equals(JetTypeMapper.JL_BOOLEAN_TYPE)) {
+            if (type != Type.BOOLEAN_TYPE && !type.equals(OBJECT_TYPE) && !type.equals(JetTypeMapper.JAVA_BOOLEAN_TYPE)) {
                 throw new UnsupportedOperationException("don't know how to put a compare as a non-boolean type");
             }
             putAsBoolean(v);
@@ -718,10 +718,10 @@ public abstract class StackValue {
                 int firstTypeParamIndex = -1;
                 for (int i = typeParameters.size() - 1; i >= 0; --i) {
                     if (typeParameters.get(i).isReified()) {
-                        frame.enterTemp(TYPE_OBJECT);
+                        frame.enterTemp(OBJECT_TYPE);
                         lastIndex++;
                         size++;
-                        v.store(firstTypeParamIndex = lastIndex - 1, TYPE_OBJECT);
+                        v.store(firstTypeParamIndex = lastIndex - 1, OBJECT_TYPE);
                     }
                 }
 
@@ -739,10 +739,10 @@ public abstract class StackValue {
                 ReceiverDescriptor thisObject = resolvedGetCall.getThisObject();
                 int thisIndex = -1;
                 if (thisObject.exists()) {
-                    frame.enterTemp(TYPE_OBJECT);
+                    frame.enterTemp(OBJECT_TYPE);
                     lastIndex++;
                     size++;
-                    v.store((thisIndex = lastIndex) - 1, TYPE_OBJECT);
+                    v.store((thisIndex = lastIndex) - 1, OBJECT_TYPE);
                 }
 
                 // for setter
@@ -756,7 +756,7 @@ public abstract class StackValue {
                     }
                     else {
                         realReceiverIndex = thisIndex;
-                        realReceiverType = TYPE_OBJECT;
+                        realReceiverType = OBJECT_TYPE;
                     }
                 }
                 else {
@@ -771,7 +771,7 @@ public abstract class StackValue {
 
                 if (resolvedSetCall.getThisObject().exists()) {
                     if (resolvedSetCall.getReceiverArgument().exists()) {
-                        codegen.generateFromResolvedCall(resolvedSetCall.getThisObject(), TYPE_OBJECT);
+                        codegen.generateFromResolvedCall(resolvedSetCall.getThisObject(), OBJECT_TYPE);
                     }
                     v.load(realReceiverIndex - realReceiverType.getSize(), realReceiverType);
                 }
@@ -794,7 +794,7 @@ public abstract class StackValue {
 
                 // restoring original
                 if (thisIndex != -1) {
-                    v.load(thisIndex - 1, TYPE_OBJECT);
+                    v.load(thisIndex - 1, OBJECT_TYPE);
                 }
 
                 if (receiverIndex != -1) {
@@ -806,7 +806,7 @@ public abstract class StackValue {
                     index = firstTypeParamIndex;
                     for (int i = 0; i != typeParameters.size(); ++i) {
                         if (typeParameters.get(i).isReified()) {
-                            v.load(index - 1, TYPE_OBJECT);
+                            v.load(index - 1, OBJECT_TYPE);
                             index--;
                         }
                     }
@@ -821,7 +821,7 @@ public abstract class StackValue {
                 }
 
                 for (int i = 0; i < size; i++) {
-                    frame.leaveTemp(TYPE_OBJECT);
+                    frame.leaveTemp(OBJECT_TYPE);
                 }
             }
         }
@@ -1022,7 +1022,7 @@ public abstract class StackValue {
 
         @Override
         public void put(Type type, InstructionAdapter v) {
-            v.load(index, TYPE_OBJECT);
+            v.load(index, OBJECT_TYPE);
             Type refType = refType(this.type);
             Type sharedType = sharedTypeForType(this.type);
             v.visitFieldInsn(Opcodes.GETFIELD, sharedType.getInternalName(), "ref", refType.getDescriptor());
@@ -1030,13 +1030,13 @@ public abstract class StackValue {
             coerce(this.type, type, v);
             if (isReleaseOnPut) {
                 v.aconst(null);
-                v.store(index, TYPE_OBJECT);
+                v.store(index, OBJECT_TYPE);
             }
         }
 
         @Override
         public void store(Type topOfStackType, InstructionAdapter v) {
-            v.load(index, TYPE_OBJECT);
+            v.load(index, OBJECT_TYPE);
             v.swap();
             Type refType = refType(this.type);
             Type sharedType = sharedTypeForType(this.type);
@@ -1048,31 +1048,31 @@ public abstract class StackValue {
         switch (type.getSort()) {
             case Type.OBJECT:
             case Type.ARRAY:
-                return JetTypeMapper.TYPE_SHARED_VAR;
+                return JetTypeMapper.JET_SHARED_VAR_TYPE;
 
             case Type.BYTE:
-                return JetTypeMapper.TYPE_SHARED_BYTE;
+                return JetTypeMapper.JET_SHARED_BYTE_TYPE;
 
             case Type.SHORT:
-                return JetTypeMapper.TYPE_SHARED_SHORT;
+                return JetTypeMapper.JET_SHARED_SHORT_TYPE;
 
             case Type.CHAR:
-                return JetTypeMapper.TYPE_SHARED_CHAR;
+                return JetTypeMapper.JET_SHARED_CHAR_TYPE;
 
             case Type.INT:
-                return JetTypeMapper.TYPE_SHARED_INT;
+                return JetTypeMapper.JET_SHARED_INT_TYPE;
 
             case Type.LONG:
-                return JetTypeMapper.TYPE_SHARED_LONG;
+                return JetTypeMapper.JET_SHARED_LONG_TYPE;
 
             case Type.BOOLEAN:
-                return JetTypeMapper.TYPE_SHARED_BOOLEAN;
+                return JetTypeMapper.JET_SHARED_BOOLEAN_TYPE;
 
             case Type.FLOAT:
-                return JetTypeMapper.TYPE_SHARED_FLOAT;
+                return JetTypeMapper.JET_SHARED_FLOAT_TYPE;
 
             case Type.DOUBLE:
-                return JetTypeMapper.TYPE_SHARED_DOUBLE;
+                return JetTypeMapper.JET_SHARED_DOUBLE_TYPE;
 
             default:
                 throw new UnsupportedOperationException();
@@ -1081,7 +1081,7 @@ public abstract class StackValue {
 
     public static Type refType(Type type) {
         if (type.getSort() == Type.OBJECT || type.getSort() == Type.ARRAY) {
-            return TYPE_OBJECT;
+            return OBJECT_TYPE;
         }
 
         return type;
@@ -1141,7 +1141,7 @@ public abstract class StackValue {
 
         @Override
         public void store(Type topOfStackType, InstructionAdapter v) {
-            prefix.put(TYPE_OBJECT, v);
+            prefix.put(OBJECT_TYPE, v);
             suffix.store(topOfStackType, v);
         }
     }
@@ -1151,7 +1151,7 @@ public abstract class StackValue {
         private final ClassDescriptor descriptor;
 
         public ThisOuter(ExpressionCodegen codegen, ClassDescriptor descriptor) {
-            super(TYPE_OBJECT);
+            super(OBJECT_TYPE);
             this.codegen = codegen;
             this.descriptor = descriptor;
         }

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

@@ -42,7 +42,7 @@ public class ArrayGet implements IntrinsicMethod {
             StackValue receiver,
             @NotNull GenerationState state
     ) {
-        receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+        receiver.put(JetTypeMapper.OBJECT_TYPE, v);
         Type type = JetTypeMapper.correctElementType(receiver.type);
 
         codegen.gen(arguments.get(0), Type.INT_TYPE);

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

@@ -39,9 +39,9 @@ public class ArrayIndices implements IntrinsicMethod {
             StackValue receiver,
             @NotNull GenerationState state
     ) {
-        receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+        receiver.put(JetTypeMapper.OBJECT_TYPE, v);
         v.arraylength();
         v.invokestatic("jet/IntRange", "count", "(I)Ljet/IntRange;");
-        return StackValue.onStack(JetTypeMapper.TYPE_INT_RANGE);
+        return StackValue.onStack(JetTypeMapper.JET_INT_RANGE_TYPE);
     }
 }

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

@@ -50,7 +50,7 @@ public class ArrayIterator implements IntrinsicMethod {
             StackValue receiver,
             @NotNull GenerationState state
     ) {
-        receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+        receiver.put(JetTypeMapper.OBJECT_TYPE, v);
         JetCallExpression call = (JetCallExpression) element;
         FunctionDescriptor funDescriptor = (FunctionDescriptor) codegen.getBindingContext()
                 .get(BindingContext.REFERENCE_TARGET, (JetSimpleNameExpression) call.getCalleeExpression());
@@ -58,7 +58,7 @@ public class ArrayIterator implements IntrinsicMethod {
         ClassDescriptor containingDeclaration = (ClassDescriptor) funDescriptor.getContainingDeclaration().getOriginal();
         if (JetStandardLibraryNames.ARRAY.is(containingDeclaration)) {
             v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([Ljava/lang/Object;)Ljava/util/Iterator;");
-            return StackValue.onStack(JetTypeMapper.TYPE_ITERATOR);
+            return StackValue.onStack(JetTypeMapper.JET_ITERATOR_TYPE);
         }
         else {
             for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {

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

@@ -42,7 +42,7 @@ public class ArraySet implements IntrinsicMethod {
             StackValue receiver,
             @NotNull GenerationState state
     ) {
-        receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+        receiver.put(JetTypeMapper.OBJECT_TYPE, v);
         Type type = JetTypeMapper.correctElementType(receiver.type);
 
         codegen.gen(arguments.get(0), Type.INT_TYPE);

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

@@ -42,7 +42,7 @@ public class ArraySize implements IntrinsicMethod {
             StackValue receiver,
             @NotNull GenerationState state
     ) {
-        receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+        receiver.put(JetTypeMapper.OBJECT_TYPE, v);
         v.arraylength();
 
         return StackValue.onStack(Type.INT_TYPE);

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

@@ -48,7 +48,7 @@ public class Concat implements IntrinsicMethod {
             codegen.invokeAppend(arguments.get(1));
         }
         else {                                    // LHS.plus(RHS)
-            receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+            receiver.put(JetTypeMapper.OBJECT_TYPE, v);
             codegen.generateStringBuilderConstructor();
             v.swap();                                                              // StringBuilder LHS
             codegen.invokeAppendMethod(expectedType);  // StringBuilder(LHS)
@@ -56,7 +56,7 @@ public class Concat implements IntrinsicMethod {
         }
 
         v.invokevirtual("java/lang/StringBuilder", "toString", "()Ljava/lang/String;");
-        StackValue.onStack(JetTypeMapper.JL_STRING_TYPE).put(expectedType, v);
+        StackValue.onStack(JetTypeMapper.JAVA_STRING_TYPE).put(expectedType, v);
         return StackValue.onStack(expectedType);
     }
 }

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

@@ -40,9 +40,9 @@ public class EnumName implements IntrinsicMethod {
             StackValue receiver,
             @NotNull GenerationState state
     ) {
-        receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+        receiver.put(JetTypeMapper.OBJECT_TYPE, v);
         v.invokevirtual("java/lang/Enum", "name", "()Ljava/lang/String;");
-        StackValue.onStack(JetTypeMapper.JL_STRING_TYPE).put(expectedType, v);
+        StackValue.onStack(JetTypeMapper.JAVA_STRING_TYPE).put(expectedType, v);
         return StackValue.onStack(expectedType);
     }
 }

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

@@ -40,7 +40,7 @@ public class EnumOrdinal implements IntrinsicMethod {
             StackValue receiver,
             @NotNull GenerationState state
     ) {
-        receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+        receiver.put(JetTypeMapper.OBJECT_TYPE, v);
         v.invokevirtual("java/lang/Enum", "ordinal", "()I");
         StackValue.onStack(Type.INT_TYPE).put(expectedType, v);
         return StackValue.onStack(expectedType);

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

@@ -50,7 +50,7 @@ public class EnumValueOf implements IntrinsicMethod {
         Type type = state.getInjector().getJetTypeMapper().mapType(
                 returnType, MapTypeMode.VALUE);
         assert arguments != null;
-        codegen.gen(arguments.get(0), JetTypeMapper.JL_STRING_TYPE);
+        codegen.gen(arguments.get(0), JetTypeMapper.JAVA_STRING_TYPE);
         v.invokestatic(type.getInternalName(), "valueOf", "(Ljava/lang/String;)" + type.getDescriptor());
         StackValue.onStack(type).put(expectedType, v);
         return StackValue.onStack(expectedType);

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

@@ -50,7 +50,7 @@ public class Equals implements IntrinsicMethod {
         boolean leftNullable = true;
         JetExpression rightExpr;
         if (element instanceof JetCallExpression) {
-            receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+            receiver.put(JetTypeMapper.OBJECT_TYPE, v);
             JetCallExpression jetCallExpression = (JetCallExpression) element;
             JetExpression calleeExpression = jetCallExpression.getCalleeExpression();
             if (calleeExpression != null) {
@@ -66,16 +66,16 @@ public class Equals implements IntrinsicMethod {
             JetType leftType = codegen.getBindingContext().get(BindingContext.EXPRESSION_TYPE, leftExpr);
             assert leftType != null;
             leftNullable = leftType.isNullable();
-            codegen.gen(leftExpr).put(JetTypeMapper.TYPE_OBJECT, v);
+            codegen.gen(leftExpr).put(JetTypeMapper.OBJECT_TYPE, v);
             rightExpr = arguments.get(1);
         }
 
         JetType rightType = codegen.getBindingContext().get(BindingContext.EXPRESSION_TYPE, rightExpr);
-        codegen.gen(rightExpr).put(JetTypeMapper.TYPE_OBJECT, v);
+        codegen.gen(rightExpr).put(JetTypeMapper.OBJECT_TYPE, v);
 
         assert rightType != null;
         return codegen
-                .generateEqualsForExpressionsOnStack(JetTokens.EQEQ, JetTypeMapper.TYPE_OBJECT, JetTypeMapper.TYPE_OBJECT, leftNullable,
+                .generateEqualsForExpressionsOnStack(JetTokens.EQEQ, JetTypeMapper.OBJECT_TYPE, JetTypeMapper.OBJECT_TYPE, leftNullable,
                                                      rightType.isNullable());
     }
 }

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

@@ -44,7 +44,7 @@ public class HashCode implements IntrinsicMethod {
             StackValue receiver,
             @NotNull GenerationState state
     ) {
-        receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+        receiver.put(JetTypeMapper.OBJECT_TYPE, v);
         v.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Object", "hashCode", "()I");
         return StackValue.onStack(Type.INT_TYPE);
     }

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

@@ -46,15 +46,15 @@ public class IdentityEquals implements IntrinsicMethod {
             @NotNull GenerationState state
     ) {
         if (element instanceof JetCallExpression) {
-            receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+            receiver.put(JetTypeMapper.OBJECT_TYPE, v);
-            codegen.gen(arguments.get(0)).put(JetTypeMapper.TYPE_OBJECT, v);
+            codegen.gen(arguments.get(0)).put(JetTypeMapper.OBJECT_TYPE, v);
         }
         else {
             assert element instanceof JetBinaryExpression;
             JetBinaryExpression e = (JetBinaryExpression) element;
-            codegen.gen(e.getLeft()).put(JetTypeMapper.TYPE_OBJECT, v);
+            codegen.gen(e.getLeft()).put(JetTypeMapper.OBJECT_TYPE, v);
-            codegen.gen(e.getRight()).put(JetTypeMapper.TYPE_OBJECT, v);
+            codegen.gen(e.getRight()).put(JetTypeMapper.OBJECT_TYPE, v);
         }
-        return StackValue.cmp(JetTokens.EQEQEQ, JetTypeMapper.TYPE_OBJECT);
+        return StackValue.cmp(JetTokens.EQEQEQ, JetTypeMapper.OBJECT_TYPE);
     }
 }

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

@@ -70,7 +70,7 @@ public class IteratorNext implements IntrinsicMethod {
         else {
             throw new UnsupportedOperationException();
         }
-        receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+        receiver.put(JetTypeMapper.OBJECT_TYPE, v);
         v.invokevirtual("jet/" + name + "Iterator", "next" + name, "()" + expectedType.getDescriptor());
         return StackValue.onStack(expectedType);
     }

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

@@ -57,6 +57,6 @@ public class JavaClassFunction implements IntrinsicMethod {
         else {
             v.aconst(type);
         }
-        return StackValue.onStack(JetTypeMapper.JL_CLASS_TYPE);
+        return StackValue.onStack(JetTypeMapper.JAVA_CLASS_TYPE);
     }
 }

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

@@ -53,6 +53,6 @@ public class JavaClassProperty implements IntrinsicMethod {
         else {
             v.invokevirtual("java/lang/Object", "getClass", "()Ljava/lang/Class;");
         }
-        return StackValue.onStack(JetTypeMapper.JL_CLASS_TYPE);
+        return StackValue.onStack(JetTypeMapper.JAVA_CLASS_TYPE);
     }
 }

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

@@ -43,7 +43,7 @@ public class StringGetChar implements IntrinsicMethod {
             @NotNull GenerationState state
     ) {
         if (receiver != null) {
-            receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+            receiver.put(JetTypeMapper.OBJECT_TYPE, v);
         }
         if (arguments != null) {
             codegen.gen(arguments.get(0)).put(Type.INT_TYPE, v);

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

@@ -42,7 +42,7 @@ public class StringLength implements IntrinsicMethod {
             StackValue receiver,
             @NotNull GenerationState state
     ) {
-        receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+        receiver.put(JetTypeMapper.OBJECT_TYPE, v);
         v.invokeinterface("java/lang/CharSequence", "length", "()I");
         return StackValue.onStack(Type.INT_TYPE);
     }

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

@@ -43,14 +43,14 @@ public class StringPlus implements IntrinsicMethod {
             @NotNull GenerationState state
     ) {
         if (receiver == null || receiver == StackValue.none()) {
-            codegen.gen(arguments.get(0)).put(JetTypeMapper.JL_STRING_TYPE, v);
+            codegen.gen(arguments.get(0)).put(JetTypeMapper.JAVA_STRING_TYPE, v);
-            codegen.gen(arguments.get(1)).put(JetTypeMapper.TYPE_OBJECT, v);
+            codegen.gen(arguments.get(1)).put(JetTypeMapper.OBJECT_TYPE, v);
         }
         else {
-            receiver.put(JetTypeMapper.JL_STRING_TYPE, v);
+            receiver.put(JetTypeMapper.JAVA_STRING_TYPE, v);
-            codegen.gen(arguments.get(0)).put(JetTypeMapper.TYPE_OBJECT, v);
+            codegen.gen(arguments.get(0)).put(JetTypeMapper.OBJECT_TYPE, v);
         }
         v.invokestatic("jet/runtime/Intrinsics", "stringPlus", "(Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/String;");
-        return StackValue.onStack(JetTypeMapper.JL_STRING_TYPE);
+        return StackValue.onStack(JetTypeMapper.JAVA_STRING_TYPE);
     }
 }

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

@@ -42,9 +42,9 @@ public class StupidSync implements IntrinsicMethod {
             StackValue receiver,
             @NotNull GenerationState state
     ) {
-        codegen.pushMethodArguments((JetCallExpression) element, Arrays.asList(JetTypeMapper.TYPE_OBJECT, JetTypeMapper.TYPE_FUNCTION0));
+        codegen.pushMethodArguments((JetCallExpression) element, Arrays.asList(JetTypeMapper.OBJECT_TYPE, JetTypeMapper.JET_FUNCTION0_TYPE));
         v.invokestatic("jet/runtime/Intrinsics", "stupidSync", "(Ljava/lang/Object;Ljet/Function0;)Ljava/lang/Object;");
-        StackValue.onStack(JetTypeMapper.TYPE_OBJECT).put(expectedType, v);
+        StackValue.onStack(JetTypeMapper.OBJECT_TYPE).put(expectedType, v);
         return StackValue.onStack(expectedType);
     }
 }

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

@@ -42,8 +42,8 @@ public class ToString implements IntrinsicMethod {
             StackValue receiver,
             @NotNull GenerationState state
     ) {
-        receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+        receiver.put(JetTypeMapper.OBJECT_TYPE, v);
         v.invokestatic("java/lang/String", "valueOf", "(Ljava/lang/Object;)Ljava/lang/String;");
-        return StackValue.onStack(JetTypeMapper.JL_STRING_TYPE);
+        return StackValue.onStack(JetTypeMapper.JAVA_STRING_TYPE);
     }
 }

compiler/backend/src/org/jetbrains/jet/codegen/signature/BothSignatureWriter.java

@@ -196,7 +196,7 @@ public class BothSignatureWriter {
         jetSignatureWriter.visitClassType("jet/Nothing", nullable, false);
         jetSignatureWriter.visitEnd();
         if (nullable) {
-            writeAsmType0(JetTypeMapper.TYPE_OBJECT);
+            writeAsmType0(JetTypeMapper.OBJECT_TYPE);
         }
         else {
             writeAsmType0(Type.VOID_TYPE);