missing cases for less eager dealiasing after following type alias

Author: pweisenburger

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

@@ -289,6 +289,23 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       }
     }
 
+    def realiasConstraint(param: Type, alias: NamedType, dealiased: Type) =
+      if alias.symbol.isStatic then
+        param.stripTypeVar match
+          case param: TypeParamRef =>
+            constraint.entry(param) match
+              case TypeBounds(lo, hi) =>
+                val aliasLo = (alias ne lo) && (dealiased eq lo)
+                val aliasHi = (alias ne hi) && (dealiased eq hi)
+                if aliasLo || aliasHi then
+                  constraint = constraint.updateEntry(param, TypeBounds(
+                    if aliasLo then alias else lo,
+                    if aliasHi then alias else hi))
+              case tp =>
+                if (alias ne tp) && (dealiased eq tp) then
+                  constraint = constraint.updateEntry(param, alias)
+          case _ =>
+
     def firstTry: Boolean = tp2 match {
       case tp2: NamedType =>
         def compareNamed(tp1: Type, tp2: NamedType): Boolean =
@@ -297,14 +314,18 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
           val info2 = tp2.info
           info2 match
             case info2: TypeAlias =>
-              if recur(tp1, info2.alias) then return true
+              val res = recur(tp1, info2.alias)
+              realiasConstraint(tp1, tp2, info2.alias)
+              if res then return true
               if tp2.asInstanceOf[TypeRef].canDropAlias then return false
             case _ =>
           tp1 match
             case tp1: NamedType =>
               tp1.info match {
                 case info1: TypeAlias =>
-                  if recur(info1.alias, tp2) then return true
+                  val res = recur(info1.alias, tp2)
+                  realiasConstraint(tp2, tp1, info1.alias)
+                  if res then return true
                   if tp1.asInstanceOf[TypeRef].canDropAlias then return false
                 case _ =>
               }
@@ -413,26 +434,10 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       case tp1: NamedType =>
         tp1.info match {
           case info1: TypeAlias =>
-            def realiasConstraint() = tp2 match {
-              case tp2: TypeParamRef =>
-                constraint.entry(tp2) match {
-                  case TypeBounds(lo, hi) =>
-                    val aliasLo = (tp1 ne lo) && (info1.alias eq lo)
-                    val aliasHi = (tp1 ne hi) && (info1.alias eq hi)
-                    if aliasLo || aliasHi then
-                      constraint = constraint.updateEntry(tp2, TypeBounds(
-                        if aliasLo then tp1 else lo,
-                        if aliasHi then tp1 else hi))
-                  case tp =>
-                    if (tp1 ne tp) && (info1.alias eq tp) then
-                      constraint = constraint.updateEntry(tp2, tp1)
-                }
-              case _ =>
-            }
             val res = recur(info1.alias, tp2)
-            if (tp1.symbol.isStatic) realiasConstraint()
-            if (res) return true
-            if (tp1.prefix.isStable) return tryLiftedToThis1
+            realiasConstraint(tp2, tp1, info1.alias)
+            if res then return true
+            if tp1.prefix.isStable then return tryLiftedToThis1
           case _ =>
             if (tp1 eq NothingType) || isBottom(tp1) then return true
         }

tests/run-macros/i15304.check

@@ -0,0 +1,5 @@
+Test.MyString
+Test.MyString
+Test.MyString
+scala.Seq[Test.MyString]
+scala.Tuple2[Test.MyString, scala.Int]

tests/run-macros/i15304/Macro_1.scala

@@ -0,0 +1,9 @@
+import scala.quoted._
+
+def typeNameOf[A: Type](using Quotes): Expr[String] =
+  val name = Type.show[A]
+  Expr(name)
+
+inline def typeNameOf[A]: String = ${ typeNameOf[A] }
+
+inline def typeNameOfF1[A](f: A => Unit): String = ${ typeNameOf[A] }

tests/run-macros/i15304/Test_2.scala

@@ -0,0 +1,9 @@
+object Test:
+  type MyString = String
+
+  def main(args: Array[String]): Unit =
+    println(typeNameOf[MyString])
+    println(typeNameOfF1 { (x: MyString) =>  })
+    println(typeNameOfF1[MyString] { (x: MyString) =>  })
+    println(typeNameOfF1 { (x: Seq[MyString]) => })
+    println(typeNameOfF1 { (x: (MyString, Int)) => })

tests/run-macros/quote-matcher-runtime.check

@@ -245,7 +245,7 @@ Pattern: scala.StringContext.apply("abc", "xyz")
 Result: Some(List())
 
 Scrutinee: scala.StringContext.apply("abc", "xyz")
-Pattern: scala.StringContext.apply(scala.quoted.runtime.Patterns.patternHole[java.lang.String], scala.quoted.runtime.Patterns.patternHole[java.lang.String])
+Pattern: scala.StringContext.apply(scala.quoted.runtime.Patterns.patternHole[scala.Predef.String], scala.quoted.runtime.Patterns.patternHole[scala.Predef.String])
 Result: Some(List(Expr("abc"), Expr("xyz")))
 
 Scrutinee: scala.StringContext.apply("abc", "xyz")