Rename: TypeCheckerTypingConstraints -> TypeCheckerProcedureCallbacks

core/descriptors/src/org/jetbrains/jet/lang/resolve/calls/inference/ConstraintSystemImpl.kt

@@ -28,7 +28,7 @@ import org.jetbrains.jet.lang.types.Variance
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystemImpl.ConstraintKind
 import org.jetbrains.jet.lang.types.checker.TypeCheckingProcedure
-import org.jetbrains.jet.lang.types.checker.TypingConstraints
+import org.jetbrains.jet.lang.types.checker.TypeCheckingProcedureCallbacks
 import org.jetbrains.jet.lang.types.TypeConstructor
 import java.util.LinkedHashMap
 import java.util.HashSet
@@ -214,7 +214,7 @@ public class ConstraintSystemImpl : ConstraintSystem {
     }
 
     private fun addConstraint(constraintKind: ConstraintKind, subType: JetType?, superType: JetType?, constraintPosition: ConstraintPosition) {
-        val typeCheckingProcedure = TypeCheckingProcedure(object : TypingConstraints {
+        val typeCheckingProcedure = TypeCheckingProcedure(object : TypeCheckingProcedureCallbacks {
             private var isTopLevel = true
 
             override fun assertEqualTypes(a: JetType, b: JetType, typeCheckingProcedure: TypeCheckingProcedure): Boolean {

core/descriptors/src/org/jetbrains/jet/lang/types/checker/JetTypeChecker.java

@@ -26,9 +26,9 @@ public class JetTypeChecker {
         boolean equals(@NotNull TypeConstructor a, @NotNull TypeConstructor b);
     }
 
-    public static final JetTypeChecker DEFAULT = new JetTypeChecker(new TypeCheckingProcedure(new TypeCheckerTypingConstraints()));
+    public static final JetTypeChecker DEFAULT = new JetTypeChecker(new TypeCheckingProcedure(new TypeCheckerProcedureCallbacksImpl()));
 
-    public static final JetTypeChecker FLEXIBLE_UNEQUAL_TO_INFLEXIBLE = new JetTypeChecker(new TypeCheckingProcedure(new TypeCheckerTypingConstraints()) {
+    public static final JetTypeChecker FLEXIBLE_UNEQUAL_TO_INFLEXIBLE = new JetTypeChecker(new TypeCheckingProcedure(new TypeCheckerProcedureCallbacksImpl()) {
         @Override
         protected boolean heterogeneousEquivalence(JetType inflexibleType, JetType flexibleType) {
             return false;
@@ -37,7 +37,7 @@ public class JetTypeChecker {
 
     @NotNull
     public static JetTypeChecker withAxioms(@NotNull final TypeConstructorEquality equalityAxioms) {
-        return new JetTypeChecker(new TypeCheckingProcedure(new TypeCheckerTypingConstraints() {
+        return new JetTypeChecker(new TypeCheckingProcedure(new TypeCheckerProcedureCallbacksImpl() {
             @Override
             public boolean assertEqualTypeConstructors(@NotNull TypeConstructor constructor1, @NotNull TypeConstructor constructor2) {
                 return constructor1.equals(constructor2) || equalityAxioms.equals(constructor1, constructor2);

core/descriptors/src/org/jetbrains/jet/lang/types/checker/TypeCheckerProcedureCallbacksImpl.java

@@ -21,7 +21,7 @@ import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeConstructor;
 import org.jetbrains.jet.lang.types.TypeProjection;
 
-class TypeCheckerTypingConstraints implements TypingConstraints {
+class TypeCheckerProcedureCallbacksImpl implements TypeCheckingProcedureCallbacks {
     @Override
     public boolean assertEqualTypes(@NotNull JetType a, @NotNull JetType b, @NotNull TypeCheckingProcedure typeCheckingProcedure) {
         return typeCheckingProcedure.equalTypes(a, b);

core/descriptors/src/org/jetbrains/jet/lang/types/checker/TypeCheckingProcedure.java

@@ -32,19 +32,19 @@ public class TypeCheckingProcedure {
     // as the second parameter, applying the substitution of type arguments to it
     @Nullable
     public static JetType findCorrespondingSupertype(@NotNull JetType subtype, @NotNull JetType supertype) {
-        return findCorrespondingSupertype(subtype, supertype, new TypeCheckerTypingConstraints());
+        return findCorrespondingSupertype(subtype, supertype, new TypeCheckerProcedureCallbacksImpl());
     }
 
     // This method returns the supertype of the first parameter that has the same constructor
     // as the second parameter, applying the substitution of type arguments to it
     @Nullable
-    public static JetType findCorrespondingSupertype(@NotNull JetType subtype, @NotNull JetType supertype, @NotNull TypingConstraints typingConstraints) {
+    public static JetType findCorrespondingSupertype(@NotNull JetType subtype, @NotNull JetType supertype, @NotNull TypeCheckingProcedureCallbacks typeCheckingProcedureCallbacks) {
         TypeConstructor constructor = subtype.getConstructor();
-        if (typingConstraints.assertEqualTypeConstructors(constructor, supertype.getConstructor())) {
+        if (typeCheckingProcedureCallbacks.assertEqualTypeConstructors(constructor, supertype.getConstructor())) {
             return subtype;
         }
         for (JetType immediateSupertype : constructor.getSupertypes()) {
-            JetType correspondingSupertype = findCorrespondingSupertype(immediateSupertype, supertype, typingConstraints);
+            JetType correspondingSupertype = findCorrespondingSupertype(immediateSupertype, supertype, typeCheckingProcedureCallbacks);
             if (correspondingSupertype != null) {
                 return TypeSubstitutor.create(subtype).safeSubstitute(correspondingSupertype, Variance.INVARIANT);
             }
@@ -62,9 +62,9 @@ public class TypeCheckingProcedure {
         return isOutProjected ? KotlinBuiltIns.getInstance().getNothingType() : argument.getType();
     }
 
-    private final TypingConstraints constraints;
+    private final TypeCheckingProcedureCallbacks constraints;
 
-    public TypeCheckingProcedure(TypingConstraints constraints) {
+    public TypeCheckingProcedure(TypeCheckingProcedureCallbacks constraints) {
         this.constraints = constraints;
     }
 

core/descriptors/src/org/jetbrains/jet/lang/types/checker/TypeCheckingProcedureCallbacks.java

@@ -24,7 +24,7 @@ import org.jetbrains.jet.lang.types.TypeProjection;
 /**
  * Methods of this class return true to continue type checking and false to fail
  */
-public interface TypingConstraints {
+public interface TypeCheckingProcedureCallbacks {
     boolean assertEqualTypes(@NotNull JetType a, @NotNull JetType b, @NotNull TypeCheckingProcedure typeCheckingProcedure);
 
     boolean assertEqualTypeConstructors(@NotNull TypeConstructor a, @NotNull TypeConstructor b);