diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java
index 5975c2c6e6c..26926f71487 100644
--- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java
+++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java
@@ -114,18 +114,31 @@ public class OverridingUtil {
                 return OverrideCompatibilityInfo.valueParameterTypeMismatch(null, null, OverrideCompatibilityInfo.Result.CONFLICT);
             }
 
-            BiMap<TypeConstructor, TypeConstructor> axioms = HashBiMap.create();
+            final Map<TypeConstructor, TypeConstructor> matchingTypeConstructors = new HashMap<TypeConstructor, TypeConstructor>();
             for (int i = 0, typeParametersSize = superTypeParameters.size(); i < typeParametersSize; i++) {
                 TypeParameterDescriptor superTypeParameter = superTypeParameters.get(i);
                 TypeParameterDescriptor subTypeParameter = subTypeParameters.get(i);
-                axioms.put(superTypeParameter.getTypeConstructor(), subTypeParameter.getTypeConstructor());
+                matchingTypeConstructors.put(superTypeParameter.getTypeConstructor(), subTypeParameter.getTypeConstructor());
             }
 
+            JetTypeChecker.TypeConstructorEquality equalityAxioms = new JetTypeChecker.TypeConstructorEquality() {
+                @Override
+                public boolean equals(@NotNull TypeConstructor a, @NotNull TypeConstructor b) {
+                    TypeConstructor img1 = matchingTypeConstructors.get(a);
+                    TypeConstructor img2 = matchingTypeConstructors.get(b);
+                    if (!(img1 != null && img1.equals(b)) &&
+                        !(img2 != null && img2.equals(a))) {
+                        return false;
+                    }
+                    return true;
+                }
+            };
+
             for (int i = 0, typeParametersSize = superTypeParameters.size(); i < typeParametersSize; i++) {
                 TypeParameterDescriptor superTypeParameter = superTypeParameters.get(i);
                 TypeParameterDescriptor subTypeParameter = subTypeParameters.get(i);
 
-                if (!JetTypeChecker.INSTANCE.equalTypes(superTypeParameter.getUpperBoundsAsType(), subTypeParameter.getUpperBoundsAsType(), axioms)) {
+                if (!JetTypeChecker.INSTANCE.equalTypes(superTypeParameter.getUpperBoundsAsType(), subTypeParameter.getUpperBoundsAsType(), equalityAxioms)) {
                     return OverrideCompatibilityInfo.boundsMismatch(superTypeParameter, subTypeParameter);
                 }
             }
@@ -135,7 +148,7 @@ public class OverridingUtil {
                 JetType subValueParameter = subValueParameters.get(i);
 
                 boolean bothErrors = superValueParameter.isError() && subValueParameter.isError();
-                if (!bothErrors && !JetTypeChecker.INSTANCE.equalTypes(superValueParameter, subValueParameter, axioms)) {
+                if (!bothErrors && !JetTypeChecker.INSTANCE.equalTypes(superValueParameter, subValueParameter, equalityAxioms)) {
                     return OverrideCompatibilityInfo.valueParameterTypeMismatch(superValueParameter, subValueParameter, OverrideCompatibilityInfo.Result.INCOMPATIBLE);
                 }
             }
diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/checker/JetTypeChecker.java b/core/descriptors/src/org/jetbrains/jet/lang/types/checker/JetTypeChecker.java
index 15b8e389ccf..20ff89f3b9a 100644
--- a/core/descriptors/src/org/jetbrains/jet/lang/types/checker/JetTypeChecker.java
+++ b/core/descriptors/src/org/jetbrains/jet/lang/types/checker/JetTypeChecker.java
@@ -16,8 +16,6 @@
 
 package org.jetbrains.jet.lang.types.checker;
 
-import com.google.common.collect.BiMap;
-import com.google.common.collect.HashBiMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeConstructor;
@@ -25,7 +23,9 @@ import org.jetbrains.jet.lang.types.TypeConstructor;
 public class JetTypeChecker {
 
     public static final JetTypeChecker INSTANCE = new JetTypeChecker();
-    public static final HashBiMap<TypeConstructor, TypeConstructor> EMPTY_AXIOMS = HashBiMap.create();
+    public interface TypeConstructorEquality {
+        boolean equals(@NotNull TypeConstructor a, @NotNull TypeConstructor b);
+    }
 
     private JetTypeChecker() {
     }
@@ -39,19 +39,11 @@ public class JetTypeChecker {
         return TYPE_CHECKER.equalTypes(a, b);
     }
 
-    public boolean equalTypes(@NotNull JetType a, @NotNull JetType b, @NotNull final BiMap<TypeConstructor, TypeConstructor> equalityAxioms) {
+    public boolean equalTypes(@NotNull JetType a, @NotNull JetType b, @NotNull final TypeConstructorEquality equalityAxioms) {
         return new TypeCheckingProcedure(new TypeCheckerTypingConstraints() {
             @Override
             public boolean assertEqualTypeConstructors(@NotNull TypeConstructor constructor1, @NotNull TypeConstructor constructor2) {
-                if (!constructor1.equals(constructor2)) {
-                    TypeConstructor img1 = equalityAxioms.get(constructor1);
-                    TypeConstructor img2 = equalityAxioms.get(constructor2);
-                    if (!(img1 != null && img1.equals(constructor2)) &&
-                            !(img2 != null && img2.equals(constructor1))) {
-                        return false;
-                    }
-                }
-                return true;
+                return constructor1.equals(constructor2) || equalityAxioms.equals(constructor1, constructor2);
             }
         }).equalTypes(a, b);
     }