Drop adaptHkVariance

Author: odersky

compiler/src/dotty/tools/dotc/core/GadtConstraint.scala

@@ -155,26 +155,8 @@ final class ProperGadtConstraint private(
           else if (isUpper) addLess(symTvar.origin, boundTvar.origin)
           else addLess(boundTvar.origin, symTvar.origin)
         case bound =>
-          val oldUpperBound = bounds(symTvar.origin)
-          // If we have bounds:
-          //     F >: [t] => List[t] <: [t] => Any
-          // and we want to record that:
-          //     F <: [+A] => List[A]
-          // we need to adapt the variance and instead record that:
-          //     F <: [A] => List[A]
-          // We cannot record the original bound, since it is false that:
-          //     [t] => List[t]  <:  [+A] => List[A]
-          //
-          // Note that the following code is accepted:
-          //     class Foo[F[t] >: List[t]]
-          //     type T = Foo[List]
-          // precisely because Foo[List] is desugared to Foo[[A] => List[A]].
-          //
-          // Ideally we'd adapt the bound in ConstraintHandling#addOneBound,
-          // but doing it there actually interferes with type inference.
-          val bound1 = bound.adaptHkVariances(oldUpperBound)
-          if (isUpper) addUpperBound(symTvar.origin, bound1)
-          else addLowerBound(symTvar.origin, bound1)
+          if (isUpper) addUpperBound(symTvar.origin, bound)
+          else addLowerBound(symTvar.origin, bound)
       }
     ).reporting({
       val descr = if (isUpper) "upper" else "lower"

compiler/src/dotty/tools/dotc/core/TypeApplications.scala

@@ -271,62 +271,6 @@ class TypeApplications(val self: Type) extends AnyVal {
     }
   }
 
-  /** If argument A and type parameter P are higher-kinded, adapt the variances
-   *  of A to those of P, ensuring that the variances of the type lambda A
-   *  agree with the variances of corresponding higher-kinded type parameters of P. Example:
-   *
-   *     class GenericCompanion[+CC[X]]
-   *     GenericCompanion[List]
-   *
-   *  with adaptHkVariances, the argument `List` will expand to
-   *
-   *     [X] => List[X]
-   *
-   *  instead of
-   *
-   *     [+X] => List[X]
-   *
-   *  even though `List` is covariant. This adaptation is necessary to ignore conflicting
-   *  variances in overriding members that have types of hk-type parameters such as
-   *  `GenericCompanion[GenTraversable]` or `GenericCompanion[ListBuffer]`.
-   *  When checking overriding, we need to validate the subtype relationship
-   *
-   *      GenericCompanion[[X] -> ListBuffer[X]] <: GenericCompanion[[+X] -> GenTraversable[X]]
-   *
-   *   Without adaptation, this would be false, and hence an overriding error would
-   *   result. But with adaptation, the rhs argument will be adapted to
-   *
-   *     [X] -> GenTraversable[X]
-   *
-   *   which makes the subtype test succeed. The crucial point here is that, since
-   *   GenericCompanion only expects a non-variant CC, the fact that GenTraversable
-   *   is covariant is irrelevant, so can be ignored.
-   */
-  def adaptHkVariances(bound: Type)(implicit ctx: Context): Type = self/*{
-    val hkParams = bound.hkTypeParams
-    if (hkParams.isEmpty) self
-    else {
-      def adaptArg(arg: Type): Type = arg match {
-        case arg @ HKTypeLambda(tparams, body) if
-             !tparams.corresponds(hkParams)(_.paramVarianceSign == _.paramVarianceSign) &&
-             tparams.corresponds(hkParams)(varianceConforms) =>
-          HKTypeLambda(
-            tparams.lazyZip(hkParams).map((tparam, hkparam) =>
-              tparam.paramName.withVariance(hkparam.paramVarianceSign)))(
-            tl => arg.paramInfos.map(_.subst(arg, tl).bounds),
-            tl => arg.resultType.subst(arg, tl)
-          )
-        case arg: AliasingBounds =>
-          arg.derivedAlias(adaptArg(arg.alias))
-        case arg @ TypeBounds(lo, hi) =>
-          arg.derivedTypeBounds(adaptArg(lo), adaptArg(hi))
-        case _ =>
-          arg
-      }
-      adaptArg(self)
-    }
-  }*/
-
   /** The type representing
    *
    *     T[U1, ..., Un]

compiler/src/dotty/tools/dotc/core/TypeComparer.scala

@@ -1279,14 +1279,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
             }
         }
 
-        val arg1 = args1.head
-        val arg2 = args2.head
-        isSubArg(arg1, arg2) || {
-          // last effort: try to adapt variances of higher-kinded types if this is sound.
-          // TODO: Move this to eta-expansion?
-          val adapted2 = arg2.adaptHkVariances(tparam.paramInfo)
-          adapted2.ne(arg2) && isSubArg(arg1, adapted2)
-        }
+        isSubArg(args1.head, args2.head)
       } && recurArgs(args1.tail, args2.tail, tparams2.tail)
 
     recurArgs(args1, args2, tparams2)
@@ -1553,19 +1546,12 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
    *       Further, no refinement refers back to the refined type via a refined this.
    *  The precondition is established by `skipMatching`.
    */
-  private def isSubRefinements(tp1: RefinedType, tp2: RefinedType, limit: Type): Boolean = {
-    def hasSubRefinement(tp1: RefinedType, refine2: Type): Boolean =
-      isSubType(tp1.refinedInfo, refine2) || {
-        // last effort: try to adapt variances of higher-kinded types if this is sound.
-        // TODO: Move this to eta-expansion?
-        val adapted2 = refine2.adaptHkVariances(tp1.parent.member(tp1.refinedName).symbol.info)
-        adapted2.ne(refine2) && hasSubRefinement(tp1, adapted2)
-      }
-    hasSubRefinement(tp1, tp2.refinedInfo) && (
-      (tp2.parent eq limit) ||
-      isSubRefinements(
-        tp1.parent.asInstanceOf[RefinedType], tp2.parent.asInstanceOf[RefinedType], limit))
-  }
+  private def isSubRefinements(tp1: RefinedType, tp2: RefinedType, limit: Type): Boolean =
+    isSubType(tp1.refinedInfo, tp2.refinedInfo)
+    && ((tp2.parent eq limit)
+       || isSubRefinements(
+            tp1.parent.asInstanceOf[RefinedType],
+            tp2.parent.asInstanceOf[RefinedType], limit))
 
   /** A type has been covered previously in subtype checking if it
    *  is some combination of TypeRefs that point to classes, where the