diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/KotlinToJavaTypesMap.java b/compiler/backend/src/org/jetbrains/jet/codegen/KotlinToJavaTypesMap.java
index 25196abc14e..85aebacb26e 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/KotlinToJavaTypesMap.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/KotlinToJavaTypesMap.java
@@ -37,8 +37,6 @@ import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 
-import static org.jetbrains.jet.codegen.JetTypeMapper.*;
-
 /**
 * @author svtk
 */
@@ -55,46 +53,13 @@ public class KotlinToJavaTypesMap {
 
     private final Map<FqNameUnsafe, Type> asmTypes = Maps.newHashMap();
     private final Map<FqNameUnsafe, Type> asmNullableTypes = Maps.newHashMap();
-    private final Set<String> asmTypeNames = Sets.newHashSet();
+    private final Set<String> mappedTypeNames = Sets.newHashSet();
 
     private KotlinToJavaTypesMap() {
         init();
         initPrimitives();
     }
 
-    @Nullable
-    public Type getJavaAnalog(@NotNull JetType jetType) {
-        ClassifierDescriptor classifier = jetType.getConstructor().getDeclarationDescriptor();
-        assert classifier != null;
-        FqNameUnsafe className = DescriptorUtils.getFQName(classifier);
-        if (jetType.isNullable()) {
-            Type nullableType = asmNullableTypes.get(className);
-            if (nullableType != null) {
-                return nullableType;
-            }
-        }
-        return asmTypes.get(className);
-    }
-
-    private void register(@NotNull ClassDescriptor kotlinDescriptor, @NotNull Class<?> javaClass) {
-        register(kotlinDescriptor, Type.getType(javaClass));
-    }
-
-    private void register(@NotNull ClassDescriptor kotlinDescriptor, @NotNull Type javaType) {
-        FqNameUnsafe fqName = DescriptorUtils.getFQName(kotlinDescriptor);
-        ClassName className = new ClassName(fqName.toSafe(), kotlinDescriptor.getDefaultType().getArguments().size());
-        register(className, javaType);
-    }
-
-    private void register(@NotNull ClassName className, @NotNull Type type) {
-        asmTypeNames.add(type.getClassName());
-        asmTypes.put(className.getFqName().toUnsafe(), type);
-    }
-
-    private void registerNullable(@NotNull ClassName className, @NotNull Type nullableType) {
-        asmNullableTypes.put(className.getFqName().toUnsafe(), nullableType);
-    }
-
     private void init() {
         JetStandardLibrary standardLibrary = JetStandardLibrary.getInstance();
 
@@ -124,8 +89,41 @@ public class KotlinToJavaTypesMap {
         }
     }
 
+    @Nullable
+    public Type getJavaAnalog(@NotNull JetType jetType) {
+        ClassifierDescriptor classifier = jetType.getConstructor().getDeclarationDescriptor();
+        assert classifier != null;
+        FqNameUnsafe className = DescriptorUtils.getFQName(classifier);
+        if (jetType.isNullable()) {
+            Type nullableType = asmNullableTypes.get(className);
+            if (nullableType != null) {
+                return nullableType;
+            }
+        }
+        return asmTypes.get(className);
+    }
+
+    private void register(@NotNull ClassDescriptor kotlinDescriptor, @NotNull Class<?> javaClass) {
+        register(kotlinDescriptor, Type.getType(javaClass));
+    }
+
+    private void register(@NotNull ClassDescriptor kotlinDescriptor, @NotNull Type javaType) {
+        FqNameUnsafe fqName = DescriptorUtils.getFQName(kotlinDescriptor);
+        ClassName className = new ClassName(fqName.toSafe(), kotlinDescriptor.getDefaultType().getArguments().size());
+        register(className, javaType);
+    }
+
+    private void register(@NotNull ClassName className, @NotNull Type type) {
+        mappedTypeNames.add(type.getClassName());
+        asmTypes.put(className.getFqName().toUnsafe(), type);
+    }
+
+    private void registerNullable(@NotNull ClassName className, @NotNull Type nullableType) {
+        asmNullableTypes.put(className.getFqName().toUnsafe(), nullableType);
+    }
+
     public boolean isForceReal(@NotNull JvmClassName className) {
         return JvmPrimitiveType.getByWrapperClass(className) != null
-               || asmTypeNames.contains(className.getFqName().getFqName());
+               || mappedTypeNames.contains(className.getFqName().getFqName());
     }
 }
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinTypesMap.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinTypesMap.java
index c0e136755d9..55ce2ed344d 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinTypesMap.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinTypesMap.java
@@ -17,6 +17,7 @@
 package org.jetbrains.jet.lang.resolve.java;
 
 import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
@@ -28,6 +29,7 @@ import org.jetbrains.jet.lang.types.lang.PrimitiveType;
 
 import java.util.Iterator;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * @author svtk
@@ -46,28 +48,13 @@ public class JavaToKotlinTypesMap {
     private final Map<FqName, ClassDescriptor> classDescriptorMap = Maps.newHashMap();
     private final Map<FqName, ClassDescriptor> classDescriptorMapForCovariantPositions = Maps.newHashMap();
     private final Map<String, JetType> primitiveTypesMap = Maps.newHashMap();
+    private final Set<String> mappedTypeNames = Sets.newHashSet();
 
     private JavaToKotlinTypesMap() {
         init();
         initPrimitives();
     }
 
-    @Nullable
-    public JetType getPrimitiveKotlinAnalog(@NotNull String name) {
-        return primitiveTypesMap.get(name);
-    }
-
-    @Nullable
-    public ClassDescriptor getKotlinAnalog(@NotNull FqName fqName, @NotNull JavaTypeTransformer.TypeUsage typeUsage) {
-        if (typeUsage == JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_COVARIANT) {
-            ClassDescriptor descriptor = classDescriptorMapForCovariantPositions.get(fqName);
-            if (descriptor != null) {
-                return descriptor;
-            }
-        }
-        return classDescriptorMap.get(fqName);
-    }
-
     private void init() {
         JetStandardLibrary standardLibrary = JetStandardLibrary.getInstance();
 
@@ -85,22 +72,6 @@ public class JavaToKotlinTypesMap {
         registerCovariant(Iterator.class, standardLibrary.getMutableIterator());
     }
 
-    private void register(@NotNull Class<?> javaClass, @NotNull ClassDescriptor kotlinDescriptor) {
-        register(new FqName(javaClass.getName()), kotlinDescriptor);
-    }
-
-    private void register(@NotNull FqName javaClassName, @NotNull ClassDescriptor kotlinDescriptor) {
-        classDescriptorMap.put(javaClassName, kotlinDescriptor);
-    }
-
-    private void registerCovariant(@NotNull Class<?> javaClass, @NotNull ClassDescriptor kotlinDescriptor) {
-        registerCovariant(new FqName(javaClass.getName()), kotlinDescriptor);
-    }
-
-    private void registerCovariant(@NotNull FqName javaClassName, @NotNull ClassDescriptor kotlinDescriptor) {
-        classDescriptorMapForCovariantPositions.put(javaClassName, kotlinDescriptor);
-    }
-
     private void initPrimitives() {
         JetStandardLibrary standardLibrary = JetStandardLibrary.getInstance();
         for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
@@ -117,4 +88,38 @@ public class JavaToKotlinTypesMap {
         }
         primitiveTypesMap.put("void", JetStandardClasses.getUnitType());
     }
+
+    @Nullable
+    public JetType getPrimitiveKotlinAnalog(@NotNull String name) {
+        return primitiveTypesMap.get(name);
+    }
+
+    @Nullable
+    public ClassDescriptor getKotlinAnalog(@NotNull FqName fqName, @NotNull JavaTypeTransformer.TypeUsage typeUsage) {
+        if (typeUsage == JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_COVARIANT) {
+            ClassDescriptor descriptor = classDescriptorMapForCovariantPositions.get(fqName);
+            if (descriptor != null) {
+                return descriptor;
+            }
+        }
+        return classDescriptorMap.get(fqName);
+    }
+
+    private void register(@NotNull Class<?> javaClass, @NotNull ClassDescriptor kotlinDescriptor) {
+        register(new FqName(javaClass.getName()), kotlinDescriptor);
+    }
+
+    private void register(@NotNull FqName javaClassName, @NotNull ClassDescriptor kotlinDescriptor) {
+        mappedTypeNames.add(javaClassName.getFqName());
+        classDescriptorMap.put(javaClassName, kotlinDescriptor);
+    }
+
+    private void registerCovariant(@NotNull Class<?> javaClass, @NotNull ClassDescriptor kotlinDescriptor) {
+        registerCovariant(new FqName(javaClass.getName()), kotlinDescriptor);
+    }
+
+    private void registerCovariant(@NotNull FqName javaClassName, @NotNull ClassDescriptor kotlinDescriptor) {
+        mappedTypeNames.add(javaClassName.getFqName());
+        classDescriptorMapForCovariantPositions.put(javaClassName, kotlinDescriptor);
+    }
 }