Fix Typed abstraction

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, _) =>`.

Author: nicolasstucki

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) =>

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)

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)

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])

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) =>

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

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))

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
 

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 =>

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 =