Fix #6588: Dealias inferred quoted types

Author: nicolasstucki

compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala

@@ -202,13 +202,17 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
           val reqType = defn.QuotedTypeType.appliedTo(tp)
           val tag = ctx.typer.inferImplicitArg(reqType, pos.span)
           tag.tpe match {
-            case fail: SearchFailureType =>
+            case _: TermRef =>
+              Some(tag.select(tpnme.splice))
+            case _: SearchFailureType =>
               levelError(i"""
                             |
                             | The access would be accepted with the right type tag, but
                             | ${ctx.typer.missingArgMsg(tag, reqType, "")}""")
             case _ =>
-              Some(tag.select(tpnme.splice))
+              levelError(i"""
+                            |
+                            | The access would be accepted with an implict $reqType""")
           }
         }
       case _ =>

compiler/src/dotty/tools/dotc/transform/Staging.scala

@@ -61,6 +61,15 @@ class Staging extends MacroTransform {
           checker.transform(tree)
         case _ =>
       }
+
+      tree.tpe match {
+        case tpe @ TypeRef(prefix, _) if tpe.typeSymbol eq defn.QuotedType_splice =>
+          // Type splices must have a know term ref, usually to an implicit argument
+          // This is mostly intended to catch `quoted.Type[T]#splice` types which should just be `T`
+          assert(prefix.isInstanceOf[TermRef], prefix)
+        case _ =>
+          // OK
+      }
     }
   }
 

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -674,6 +674,9 @@ trait Implicits { self: Typer =>
         EmptyTree
     }
 
+  /** Synthesize the tree for `'[T]` for an implicit `scala.quoted.Type[T]`.
+   *  `T` is deeply dealiassed to avoid references to local type aliases.
+   */
   lazy val synthesizedTypeTag: SpecialHandler =
     (formal: Type, span: Span) => implicit (ctx: Context) => {
       def quotedType(t: Type) = {
@@ -682,26 +685,11 @@ trait Implicits { self: Typer =>
         ref(defn.InternalQuoted_typeQuote).appliedToType(t)
       }
       formal.argInfos match {
-        case arg :: Nil if !arg.typeSymbol.is(Param) =>
-          object bindFreeVars extends TypeMap {
-            var ok = true
-            def apply(t: Type) = t match {
-              case t @ TypeRef(NoPrefix, _) =>
-                inferImplicit(defn.QuotedTypeType.appliedTo(t), EmptyTree, span) match {
-                  case SearchSuccess(tag, _, _) if tag.tpe.isStable =>
-                    tag.tpe.select(defn.QuotedType_splice)
-                  case _ =>
-                    ok = false
-                    t
-                }
-              case _ => t
-            }
+        case arg :: Nil  =>
+          val deepDealias = new TypeMap {
+            def apply(tp: Type): Type = mapOver(tp.dealias)
           }
-          val tag = bindFreeVars(arg)
-          if (bindFreeVars.ok) quotedType(tag)
-          else EmptyTree
-        case arg :: Nil if ctx.inInlineMethod =>
-          quotedType(arg)
+          quotedType(deepDealias(arg))
         case _ =>
           EmptyTree
       }

tests/neg/quote-0.scala

@@ -14,12 +14,4 @@ class Test {
 
   '{(y: Expr[Int]) => $y }  // error: wrong staging level
 
-  def f[T](t: Type[T], x: Expr[T]) = '{
-    val z2 = $x // error // error: wrong staging level
-  }
-
-  def g[T](implicit t: Type[T], x: Expr[T]) = '{
-    val z2 = $x   // ok
-  }
-
 }

tests/neg/quote-1.scala

@@ -0,0 +1,13 @@
+import scala.quoted._
+
+class Test {
+
+  def f[T](t: Type[T], x: Expr[T]) = '{
+    val z2 = $x // error // error: wrong staging level
+  }
+
+  def g[T](implicit t: Type[T], x: Expr[T]) = '{
+    val z2 = $x   // ok
+  }
+
+}

tests/pos/i6588.scala

@@ -0,0 +1,27 @@
+import scala.quoted._
+
+inline def foo[T:Type]: Int = 10
+
+def main = {
+  type S = Int
+  foo[S]
+  foo[Int]
+
+  type T = Int => Int
+  foo[T]
+  foo[Int => Int]
+
+  type U = List[Int]
+  foo[U]
+  foo[List[Int]]
+
+  type N = List
+  foo[N]
+  foo[List]
+
+  type V = List[S]
+  foo[V]
+
+  type B = V => T
+  foo[B]
+}

tests/run-with-compiler/i4350.check

@@ -1,2 +1,2 @@
 (null: scala.Any).asInstanceOf[java.lang.Object]
-(null: scala.Any).asInstanceOf[scala.Predef.String]
+(null: scala.Any).asInstanceOf[java.lang.String]