Don't let wildcards enter constraints when adding type lambdas

Author: odersky

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

@@ -91,17 +91,11 @@ trait ConstraintHandling {
       // so we shouldn't allow them as constraints either.
       false
     else
-      val dropWildcards = new ApproximatingTypeMap:
+      val dropWildcards = new AvoidWildcardsMap:
         if !isUpper then variance = -1
-        def apply(t: Type): Type = t match
-          case t: WildcardType =>
-            if approximateWildcards then
-              val bounds = t.effectiveBounds
-              range(bounds.lo, bounds.hi)
-            else
-              newTypeVar(apply(t.effectiveBounds).toBounds)
-          case _ =>
-            mapOver(t)
+        override def mapWild(t: WildcardType) =
+          if approximateWildcards then super.mapWild(t)
+          else newTypeVar(apply(t.effectiveBounds).toBounds)
       val bound = dropWildcards(rawBound)
       val oldBounds @ TypeBounds(lo, hi) = constraint.nonParamBounds(param)
       val equalBounds = (if isUpper then lo else hi) eq bound

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

@@ -280,9 +280,11 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     var current = this
     val todos = new mutable.ListBuffer[(OrderingConstraint, TypeParamRef) => OrderingConstraint]
     var i = 0
+    val dropWildcards = AvoidWildcardsMap()
     while (i < poly.paramNames.length) {
       val param = poly.paramRefs(i)
-      val stripped = stripParams(nonParamBounds(param), todos, isUpper = true)
+      val bounds = dropWildcards(nonParamBounds(param))
+      val stripped = stripParams(bounds, todos, isUpper = true)
       current = updateEntry(current, param, stripped)
       while todos.nonEmpty do
         current = todos.head(current, param)

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

@@ -5701,6 +5701,15 @@ object Types {
       lo.toText(printer) ~ ".." ~ hi.toText(printer)
   }
 
+  /** Approximate wildcards by their bounds */
+  class AvoidWildcardsMap(using Context) extends ApproximatingTypeMap:
+    protected def mapWild(t: WildcardType) =
+      val bounds = t.effectiveBounds
+      range(atVariance(-variance)(apply(bounds.lo)), apply(bounds.hi))
+    def apply(t: Type): Type = t match
+      case t: WildcardType => mapWild(t)
+      case _ => mapOver(t)
+
   // ----- TypeAccumulators ----------------------------------------------------
 
   abstract class TypeAccumulator[T](implicit protected val accCtx: Context)