Dealias less in OrderingConstraint.replace and AvoidMap

Basically if the transformation doesn't apply to the dealias type,
then return the original type instead of the dealiased one.

In general it's reduce dealiasing to a minimum when typing,
because it can affect type unification as shown in the tests.

Unfortunately this doesn't handle the case of a singleton type alias,
because `widenSingletons` also dealiases and the same fix doesn't work.

Author: joroKr21

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

@@ -454,7 +454,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
    *  of the parameter elsewhere in the constraint by type `tp`.
    */
   def replace(param: TypeParamRef, tp: Type)(using Context): OrderingConstraint =
-    val replacement = tp.dealiasKeepAnnots.stripTypeVar
+    val replacement = tp.withDealiased(_.stripTypeVar)
     if param == replacement then this.checkNonCyclic()
     else
       assert(replacement.isValueTypeOrLambda)

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

@@ -451,8 +451,8 @@ object TypeOps:
       try
         tp match
           case tp: TermRef if toAvoid(tp) =>
-            tp.info.widenExpr.dealias match {
-              case info: SingletonType => apply(info)
+            tp.info.widenExpr.withDealiased {
+              case singleton: SingletonType => apply(singleton)
               case info => range(defn.NothingType, apply(info))
             }
           case tp: TypeRef if toAvoid(tp) =>

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

@@ -1430,6 +1430,14 @@ object Types {
      */
     final def dealiasKeepOpaques(using Context): Type = dealias1(keepNever, keepOpaques = true)
 
+    /** Apply `f` to this type dealiased. If the type changes, keep the change,
+     *  otherwise return the original (not dealiased) type.
+     */
+    final def withDealiased(f: Type => Type)(using Context): Type =
+      val tpd = dealias
+      val result = f(tpd)
+      if result eq tpd then this else result
+
     /** Approximate this type with a type that does not contain skolem types. */
     final def deskolemized(using Context): Type =
       val deskolemizer = new ApproximatingTypeMap {
@@ -1478,10 +1486,9 @@ object Types {
     }
 
     /** Dealias, and if result is a dependent function type, drop the `apply` refinement. */
-    final def dropDependentRefinement(using Context): Type = dealias match {
+    final def dropDependentRefinement(using Context): Type = dealias match
       case RefinedType(parent, nme.apply, _) => parent
-      case tp => tp
-    }
+      case _ => this
 
     /** The type constructor of an applied type, otherwise the type itself */
     final def typeConstructor(using Context): Type = this match {

tests/neg/i14171.scala

@@ -0,0 +1,13 @@
+object Test:
+  trait MyTypeclass[F[_]]
+  def f[F[_]: MyTypeclass, U](t: F[U]) = ()
+
+  // using a non-singleton type makes it compile because `widenSingletons` dealiases
+  type MyType[T] = Nil.type
+  given MyTypeclass[MyType] = null
+
+  val stream: Option[MyType[Int]] = null
+  for
+    keyStream <- stream
+    x = 17 // commenting this line makes it compile
+  yield f(keyStream) // error

tests/pos/i14171.scala

@@ -0,0 +1,12 @@
+object Test:
+  trait MyTypeclass[F[_]]
+  def f[F[_]: MyTypeclass, U](t: F[U]) = ()
+
+  type MyType[T] = String
+  given MyTypeclass[MyType] = null
+
+  val stream: Option[MyType[Int]] = null
+  for
+    keyStream <- stream
+    x = 17
+  yield f(keyStream)