Fix Typed abstraction

nicolasstucki · nicolasstucki · commit fffa86da1af2 · 2021-04-26T09:55:35.000+02:00
The typed expression can contain non-Term trees such as Wildcard and Alternatives.

The sulution is to type the expression of Typed as a Tree and not a Term.
This comes with some complications at the user site where we now need to use
`case Typed(expr: Term, _) =&gt;`.
diff --git a/compiler/src/scala/quoted/runtime/impl/Matcher.scala b/compiler/src/scala/quoted/runtime/impl/Matcher.scala
@@ -178,7 +178,7 @@ object Matcher {
 
           /* Term hole */
           // Match a scala.internal.Quoted.patternHole typed as a repeated argument and return the scrutinee tree
-          case (scrutinee @ Typed(s, tpt1), Typed(TypeApply(patternHole, tpt :: Nil), tpt2))
+          case (scrutinee @ Typed(s: Term, tpt1), Typed(TypeApply(patternHole, tpt :: Nil), tpt2))
               if patternHole.symbol == patternHoleSymbol &&
                  s.tpe <:< tpt.tpe &&
                  tpt2.tpe.derivesFrom(defn.RepeatedParamClass) =>
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -188,8 +188,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def unapply(x: Tree): Option[Statement & x.type] = x match
         case _: tpd.PatternTree => None
         case _ =>
-          if x.isTerm then TermTypeTest.unapply(x)
-          else DefinitionTypeTest.unapply(x)
+          TermTypeTest.unapply(x).orElse(DefinitionTypeTest.unapply(x))
     end StatementTypeTest
 
     type Definition = tpd.MemberDef
diff --git a/compiler/src/scala/quoted/runtime/impl/printers/Extractors.scala b/compiler/src/scala/quoted/runtime/impl/printers/Extractors.scala
@@ -172,7 +172,7 @@ object Extractors {
       case Unapply(fun, implicits, patterns) =>
         this += "Unapply(" += fun += ", " ++= implicits += ", " ++= patterns += ")"
       case Alternatives(patterns) =>
-        this += "Alternative(" ++= patterns += ")"
+        this += "Alternatives(" ++= patterns += ")"
     }
 
     def visitConstant(x: Constant): this.type = x match {
diff --git a/compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala b/compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala
@@ -428,7 +428,7 @@ object SourceCode {
           inSquare(this += id)
         this
 
-      case Typed(term, tpt) =>
+      case Typed(term: Term, tpt) =>
         tpt.tpe match {
           case Types.Repeated(_) =>
             printTree(term)
diff --git a/library/src/scala/quoted/ExprMap.scala b/library/src/scala/quoted/ExprMap.scala
@@ -56,7 +56,7 @@ trait ExprMap:
           tree
         case New(tpt) =>
           New.copy(tree)(transformTypeTree(tpt)(owner))
-        case Typed(expr, tpt) =>
+        case Typed(expr: Term, tpt) =>
           val tp = tpt.tpe match
             case AppliedType(TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "<repeated>"), List(tp0: TypeRepr)) =>
               TypeRepr.of[Seq].appliedTo(tp0)
diff --git a/library/src/scala/quoted/FromExpr.scala b/library/src/scala/quoted/FromExpr.scala
@@ -86,7 +86,7 @@ object FromExpr {
       def rec(tree: Term): Option[T] = tree match {
         case Block(stats, e) => if stats.isEmpty then rec(e) else None
         case Inlined(_, bindings, e) => if bindings.isEmpty then rec(e) else None
-        case Typed(e, _) => rec(e)
+        case Typed(e: Term, _) => rec(e)
         case _ =>
           tree.tpe.widenTermRefByName match
             case ConstantType(c) => Some(c.value.asInstanceOf[T])
diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
@@ -1101,13 +1101,13 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     /** Methods of the module object `val Typed` */
     trait TypedModule { this: Typed.type =>
 
-      /** Create a type ascription `<x: Term>: <tpt: TypeTree>` */
-      def apply(expr: Term, tpt: TypeTree): Typed
+      /** Create a type ascription `<x: Tree>: <tpt: TypeTree>` */
+      def apply(expr: Tree, tpt: TypeTree): Typed
 
-      def copy(original: Tree)(expr: Term, tpt: TypeTree): Typed
+      def copy(original: Tree)(expr: Tree, tpt: TypeTree): Typed
 
-      /** Matches `<expr: Term>: <tpt: TypeTree>` */
-      def unapply(x: Typed): (Term, TypeTree)
+      /** Matches `<expr: Tree>: <tpt: TypeTree>` */
+      def unapply(x: Typed): (Tree, TypeTree)
     }
 
     /** Makes extension methods on `Typed` available without any imports */
@@ -1116,7 +1116,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     /** Extension methods of `Typed` */
     trait TypedMethods:
       extension (self: Typed)
-        def expr: Term
+        def expr: Tree
         def tpt: TypeTree
       end extension
     end TypedMethods
@@ -4377,7 +4377,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
           case New(tpt) =>
             New.copy(tree)(transformTypeTree(tpt)(owner))
           case Typed(expr, tpt) =>
-            Typed.copy(tree)(transformTerm(expr)(owner), transformTypeTree(tpt)(owner))
+            Typed.copy(tree)(transformTree(expr)(owner), transformTypeTree(tpt)(owner))
           case tree: NamedArg =>
             NamedArg.copy(tree)(tree.name, transformTerm(tree.value)(owner))
           case Assign(lhs, rhs) =>
diff --git a/library/src/scala/quoted/Varargs.scala b/library/src/scala/quoted/Varargs.scala
@@ -42,7 +42,7 @@ object Varargs {
     import quotes.reflect._
     def rec(tree: Term): Option[Seq[Expr[T]]] = tree match {
       case Repeated(elems, _) => Some(elems.map(x => x.asExpr.asInstanceOf[Expr[T]]))
-      case Typed(e, _) => rec(e)
+      case Typed(e: Term, _) => rec(e)
       case Block(Nil, e) => rec(e)
       case Inlined(_, Nil, e) => rec(e)
       case _  => None
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/BasicSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/BasicSupport.scala
@@ -16,7 +16,7 @@ trait BasicSupport:
     val dri = annotTerm.tpe.typeSymbol.dri
     def inner(t: Term): List[Annotation.AnnotationParameter] = t match {
         case i: Ident => List(Annotation.LinkParameter(None, i.tpe.typeSymbol.dri, i.name))
-        case Typed(term, tpeTree) => inner(term)
+        case Typed(term: Term, tpeTree) => inner(term)
         case SeqLiteral(args, tpeTree) => args.map(_.asInstanceOf[Term]).flatMap(inner)
         case Literal(constant) => List(Annotation.PrimitiveParameter(None, constant.show))
         case NamedArg(name, Literal(constant)) => List(Annotation.PrimitiveParameter(Some(name), constant.show))
diff --git a/tests/neg-macros/i11483/Macro_1.scala b/tests/neg-macros/i11483/Macro_1.scala
@@ -51,7 +51,7 @@ object X {
           )
      case Apply(f,List()) =>
           Apply(TypeApply(Select.unique(m,"pure"),List(Inferred(t.tpe.widen))),List(t))
-     case Typed(x,tp) => Typed(processTree(x,m), Inferred(TypeRepr.of[F].appliedTo(tp.tpe)) )
+     case Typed(x: Term,tp) => Typed(processTree(x,m), Inferred(TypeRepr.of[F].appliedTo(tp.tpe)) )
      case _ => throw new RuntimeException(s"tree not recoginized: $t")
    r
 
diff --git a/tests/pos-macros/i10910/Macro_1.scala b/tests/pos-macros/i10910/Macro_1.scala
@@ -48,7 +48,7 @@ object X:
         case Inlined(x,bindings,body) => transform(body) match
                       case Left(unchanged) => Left(term)
                       case Right(changed) => Right(Inlined(x,bindings,changed))
-        case Typed(arg,tp) => transform(arg)
+        case Typed(arg: Term,tp) => transform(arg)
         case Ident(x) => Left(term)
         case l@Literal(x) => Left(l)
         case other =>
diff --git a/tests/pos-macros/i11401/X_1.scala b/tests/pos-macros/i11401/X_1.scala
@@ -16,7 +16,7 @@ class SLSelect[S]:
 
   def fold[S](s0:S)(step: (S,SLSelect[S])=> S): S = {
      ???
-  }  
+  }
 
   def fold_async[S](s0:S)(step: (S,SLSelect[S])=> Future[S]): Future[S] = {
      ???
@@ -27,7 +27,7 @@ class SLSelect[S]:
       await(s0.onRead(ch)(f).runAsync())
 
   def runAsync(): Future[S] = ???
-      
+
 
 
 object X:
@@ -36,30 +36,30 @@ object X:
    processImpl[T]('f)
  }
 
- def processImpl[T:Type](t:Expr[T])(using Quotes):Expr[Future[T]] = 
+ def processImpl[T:Type](t:Expr[T])(using Quotes):Expr[Future[T]] =
    import quotes.reflect._
    val r = processTree[T](t.asTerm)
    r.asExprOf[Future[T]]
 
- 
- def processTree[T:Type](using Quotes)(t: quotes.reflect.Term):quotes.reflect.Term = 
+
+ def processTree[T:Type](using Quotes)(t: quotes.reflect.Term):quotes.reflect.Term =
    import quotes.reflect._
    val r: Term = t match
      case Inlined(_,List(),body) => processTree(body)
-     case Inlined(d,bindings,body) => 
+     case Inlined(d,bindings,body) =>
        Inlined(d,bindings,processTree[T](body))
      case Block(stats,expr) => Block(stats,processTree(expr))
      case Apply(Apply(TypeApply(Select(x,"fold"),targs),List(state)),List(fun)) =>
-       val nFun = processLambda[T](fun) 
+       val nFun = processLambda[T](fun)
        Apply(Apply(TypeApply(Select.unique(x,"fold_async"),targs),List(state)),List(nFun))
      case Apply(TypeApply(Ident("await"),targs),List(body)) => body
-     case Typed(x,tp) => Typed(processTree(x), Inferred(TypeRepr.of[Future].appliedTo(tp.tpe)) )
+     case Typed(x: Term,tp) => Typed(processTree(x), Inferred(TypeRepr.of[Future].appliedTo(tp.tpe)) )
      case _ => throw new RuntimeException(s"tree not recoginized: $t")
    val checker = new TreeMap() {}
    checker.transformTerm(r)(Symbol.spliceOwner)
    r
-  
- def processLambda[T:Type](using Quotes)(fun: quotes.reflect.Term):quotes.reflect.Term = 
+
+ def processLambda[T:Type](using Quotes)(fun: quotes.reflect.Term):quotes.reflect.Term =
    import quotes.reflect._
 
    def changeArgs(oldArgs:List[Tree], newArgs:List[Tree], body:Term, owner: Symbol):Term =
diff --git a/tests/pos-macros/i11835/X.scala b/tests/pos-macros/i11835/X.scala
@@ -6,7 +6,6 @@ object X:
 
   private def _blah(b: Expr[Boolean])(using Quotes): Expr[Unit] =
     import quotes.reflect.*
-    println("="*120)
-    println(b.asTerm)
-    println(b.valueOrError)
+    b.asTerm
+    b.valueOrError
     '{()}
diff --git a/tests/pos-macros/i12188b/Macro_1.scala b/tests/pos-macros/i12188b/Macro_1.scala
@@ -10,4 +10,4 @@ object MatchTest {
     // test that the constructors work
     Block(Nil, Match(param, List(CaseDef(Literal(IntConstant(1)), None, Block(Nil, Literal(UnitConstant()))), CaseDef(Wildcard(), None, Block(Nil, Literal(UnitConstant())))))).asExprOf[Unit]
   }
-}
+}
diff --git a/tests/pos-macros/i12188c/Macro_1.scala b/tests/pos-macros/i12188c/Macro_1.scala
@@ -0,0 +1,15 @@
+import scala.quoted.*
+
+object MatchTest {
+  inline def test(a: Int): Unit = ${testImpl('a)}
+
+  def testImpl(a: Expr[Any])(using Quotes): Expr[Unit] = {
+    import quotes.reflect.*
+    val matchTree = Match(a.asTerm, List(
+      CaseDef(Literal(IntConstant(1)), None, Block(Nil, Literal(UnitConstant()))),
+      CaseDef(Alternatives(List(Literal(IntConstant(2)), Literal(IntConstant(3)), Literal(IntConstant(4)))), None, Block(Nil, Literal(UnitConstant()))),
+      CaseDef(Typed(Alternatives(List(Literal(IntConstant(4)), Literal(IntConstant(5)))), TypeIdent(defn.IntClass)), None, Block(Nil, Literal(UnitConstant()))),
+      CaseDef(Typed(Wildcard(), TypeIdent(defn.IntClass)), None, Block(Nil, Literal(UnitConstant())))))
+    matchTree.asExprOf[Unit]
+  }
+}
diff --git a/tests/pos-macros/i12188c/Test_2.scala b/tests/pos-macros/i12188c/Test_2.scala
@@ -0,0 +1,2 @@
+
+def test(a: Int) = MatchTest.test(a)
diff --git a/tests/run-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala b/tests/run-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala
@@ -152,7 +152,7 @@ abstract class TreeInterpreter[Q <: Quotes & Singleton](using val q: Q) {
       case While(cond, body)      => log("interpretWhile", tree)(interpretWhile(cond, body))
       case Block(stats, expr)     => log("interpretBlock", tree)(interpretBlock(stats, expr))
       case Literal(const)         => log("interpretLiteral", tree)(interpretLiteral(const))
-      case Typed(expr, _)         => log("<interpretTyped>", tree)(eval(expr))
+      case Typed(expr: Term, _)   => log("<interpretTyped>", tree)(eval(expr))
       case Repeated(elems, _)     => log("<interpretRepeated>", tree)(interpretRepeated(elems.map(elem => eval(elem))))
 
       case _ => throw new MatchError(tree.show(using Printer.TreeStructure))
diff --git a/tests/run-macros/quote-matcher-symantics-3/quoted_1.scala b/tests/run-macros/quote-matcher-symantics-3/quoted_1.scala
@@ -132,7 +132,7 @@ object Const {
           case NullConstant() | UnitConstant() | ClassOfConstant(_) => None
           case _ => Some(c.value.asInstanceOf[T])
       case Block(Nil, e) => rec(e)
-      case Typed(e, _) => rec(e)
+      case Typed(e: Term, _) => rec(e)
       case Inlined(_, Nil, e) => rec(e)
       case _  => None
     }
diff --git a/tests/run-macros/tasty-extractors-1.check b/tests/run-macros/tasty-extractors-1.check
@@ -52,7 +52,7 @@ TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "Unit")
 Inlined(None, Nil, Match(Literal(StringConstant("f")), List(CaseDef(Typed(Wildcard(), TypeIdent("String")), None, Block(Nil, Literal(UnitConstant()))))))
 TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "Unit")
 
-Inlined(None, Nil, Match(Typed(Literal(StringConstant("g")), TypeIdent("Any")), List(CaseDef(Alternative(List(Typed(Wildcard(), TypeIdent("String")), Typed(Wildcard(), TypeIdent("Int")))), None, Block(Nil, Literal(UnitConstant()))))))
+Inlined(None, Nil, Match(Typed(Literal(StringConstant("g")), TypeIdent("Any")), List(CaseDef(Alternatives(List(Typed(Wildcard(), TypeIdent("String")), Typed(Wildcard(), TypeIdent("Int")))), None, Block(Nil, Literal(UnitConstant()))))))
 TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "Unit")
 
 Inlined(None, Nil, Match(Literal(StringConstant("h")), List(CaseDef(Wildcard(), Some(Literal(BooleanConstant(false))), Block(Nil, Literal(UnitConstant()))))))

Original file line number	Diff line number	Diff line change
`@@ -172,7 +172,7 @@ object Extractors {`
`172`	`172`	`case Unapply(fun, implicits, patterns) =>`
`173`	`173`	`this += "Unapply(" += fun += ", " ++= implicits += ", " ++= patterns += ")"`
`174`	`174`	`case Alternatives(patterns) =>`
`175`		`- this += "Alternative(" ++= patterns += ")"`
	`175`	`+ this += "Alternatives(" ++= patterns += ")"`
`176`	`176`	`}`
`177`	`177`
`178`	`178`	`def visitConstant(x: Constant): this.type = x match {`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ object X {`
`51`	`51`	`)`
`52`	`52`	`case Apply(f,List()) =>`
`53`	`53`	`Apply(TypeApply(Select.unique(m,"pure"),List(Inferred(t.tpe.widen))),List(t))`
`54`		`- case Typed(x,tp) => Typed(processTree(x,m), Inferred(TypeRepr.of[F].appliedTo(tp.tpe)) )`
	`54`	`+ case Typed(x: Term,tp) => Typed(processTree(x,m), Inferred(TypeRepr.of[F].appliedTo(tp.tpe)) )`
`55`	`55`	`case _ => throw new RuntimeException(s"tree not recoginized: $t")`
`56`	`56`	`r`
`57`	`57`