From 5ff718b94c09d7058546f62d483019052dd09cba Mon Sep 17 00:00:00 2001
From: Evgeny Gerashchenko <Evgeny.Gerashchenko@jetbrains.com>
Date: Tue, 13 Nov 2012 19:10:42 +0400
Subject: [PATCH] Minor. Renamed variables where 'projection kind' term should
 be used instead of 'variance'.

---
 .../SignaturesPropagation.java                | 28 +++++++++----------
 .../TypeTransformingVisitor.java              | 18 ++++++------
 2 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagation.java
index 253e18dd487..15acc75a2fb 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagation.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagation.java
@@ -116,36 +116,36 @@ public class SignaturesPropagation {
             boolean covariantPosition = effectiveProjectionKind == TypeCheckingProcedure.EnrichedProjectionKind.OUT;
 
             JetType type = modifyReturnTypeAccordingToSuperMethods(argumentType, argTypesFromSuper, covariantPosition);
-            Variance variance = calculateArgumentVarianceFromSuper(argument, projectionsFromSuper);
+            Variance projectionKind = calculateArgumentProjectionKindFromSuper(argument, projectionsFromSuper);
 
-            resultArguments.add(new TypeProjection(variance, type));
+            resultArguments.add(new TypeProjection(projectionKind, type));
         }
         return resultArguments;
     }
 
-    private static Variance calculateArgumentVarianceFromSuper(TypeProjection argument, List<TypeProjection> projectionsFromSuper) {
-        Set<Variance> variancesInSuper = Sets.newHashSet();
+    private static Variance calculateArgumentProjectionKindFromSuper(TypeProjection argument, List<TypeProjection> projectionsFromSuper) {
+        Set<Variance> projectionKindsInSuper = Sets.newHashSet();
         for (TypeProjection projection : projectionsFromSuper) {
-            variancesInSuper.add(projection.getProjectionKind());
+            projectionKindsInSuper.add(projection.getProjectionKind());
         }
 
-        Variance defaultVariance = argument.getProjectionKind();
-        if (variancesInSuper.size() == 0) {
-            return defaultVariance;
+        Variance defaultProjectionKind = argument.getProjectionKind();
+        if (projectionKindsInSuper.size() == 0) {
+            return defaultProjectionKind;
         }
-        else if (variancesInSuper.size() == 1) {
-            Variance varianceInSuper = variancesInSuper.iterator().next();
-            if (defaultVariance == Variance.INVARIANT || defaultVariance == varianceInSuper) {
-                return varianceInSuper;
+        else if (projectionKindsInSuper.size() == 1) {
+            Variance projectionKindInSuper = projectionKindsInSuper.iterator().next();
+            if (defaultProjectionKind == Variance.INVARIANT || defaultProjectionKind == projectionKindInSuper) {
+                return projectionKindInSuper;
             }
             else {
                 // TODO report error
-                return defaultVariance;
+                return defaultProjectionKind;
             }
         }
         else {
             // TODO report error
-            return defaultVariance;
+            return defaultProjectionKind;
         }
     }
 
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java
index 6f79c65a2d0..5a782edbf2b 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java
@@ -123,30 +123,30 @@ class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
 
             TypeProjection argument = arguments.get(i);
             JetType alternativeType = computeType(argumentAlternativeTypeElement, argument.getType(), originalToAltTypeParameters);
-            Variance variance = argument.getProjectionKind();
-            Variance altVariance;
+            Variance projectionKind = argument.getProjectionKind();
+            Variance altProjectionKind;
             if (type instanceof JetUserType) {
                 JetTypeProjection typeProjection = ((JetUserType) type).getTypeArguments().get(i);
                 switch (typeProjection.getProjectionKind()) {
                     case IN:
-                        altVariance = Variance.IN_VARIANCE;
+                        altProjectionKind = Variance.IN_VARIANCE;
                         break;
                     case OUT:
-                        altVariance = Variance.OUT_VARIANCE;
+                        altProjectionKind = Variance.OUT_VARIANCE;
                         break;
                     case STAR:
                         throw new AlternativeSignatureMismatchException("Star projection is not available in alternative signatures");
                     default:
-                        altVariance = Variance.INVARIANT;
+                        altProjectionKind = Variance.INVARIANT;
                 }
-                if (altVariance != variance && variance != Variance.INVARIANT) {
-                    throw new AlternativeSignatureMismatchException("Variance mismatch, actual: %s, in alternative signature: %s", variance, altVariance);
+                if (altProjectionKind != projectionKind && projectionKind != Variance.INVARIANT) {
+                    throw new AlternativeSignatureMismatchException("Variance mismatch, actual: %s, in alternative signature: %s", projectionKind, altProjectionKind);
                 }
             }
             else {
-                altVariance = variance;
+                altProjectionKind = projectionKind;
             }
-            altArguments.add(new TypeProjection(altVariance, alternativeType));
+            altArguments.add(new TypeProjection(altProjectionKind, alternativeType));
         }
 
         TypeConstructor typeConstructor;