Skip to content

Commit 21eaa2e

Browse files
nicolasstuckinicolasstucki
committed
Fix Typed abstraction
The typed expression can contain non-Term trees: Wildcard, Alternatives, Bind and Unapply. The solution is to add a TypedTree supertype of Typed that contains a Tree.
1 parent 1c21632 commit 21eaa2e

File tree

11 files changed

+142
-33
lines changed

11 files changed

+142
-33
lines changed

‎compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

Lines changed: 38 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -333,11 +333,19 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
333333

334334
object TermTypeTest extends TypeTest[Tree, Term]:
335335
def unapply(x: Tree): Option[Term & x.type] = x match
336-
case x: tpd.PatternTree => None
336+
case x: (tpd.Ident & x.type) =>
337+
if x.isTerm && x.name != nme.WILDCARD then Some(x)
338+
else None
339+
case x: (tpd.Typed & x.type) =>
340+
// Matches `Typed` but not `TypedTree`
341+
TypedTypeTest.unapply(x)
337342
case x: (tpd.SeqLiteral & x.type) => Some(x)
338343
case x: (tpd.Inlined & x.type) => Some(x)
339344
case x: (tpd.NamedArg & x.type) => Some(x)
340-
case _ => if x.isTerm then Some(x) else None
345+
case x: tpd.PatternTree => None
346+
case _ =>
347+
if x.isTerm then Some(x)
348+
else None
341349
end TermTypeTest
342350

343351
object Term extends TermModule:
@@ -647,7 +655,10 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
647655

648656
object TypedTypeTest extends TypeTest[Tree, Typed]:
649657
def unapply(x: Tree): Option[Typed & x.type] = x match
650-
case x: (tpd.Typed & x.type) => Some(x)
658+
case x: (tpd.Typed & x.type) =>
659+
x.expr match
660+
case TermTypeTest(_) => Some(x)
661+
case _ => None
651662
case _ => None
652663
end TypedTypeTest
653664

@@ -1413,6 +1424,30 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
14131424
def unapply(pattern: Wildcard): true = true
14141425
end Wildcard
14151426

1427+
type TypedTree = tpd.Typed
1428+
1429+
object TypedTreeTypeTest extends TypeTest[Tree, TypedTree]:
1430+
def unapply(x: Tree): Option[TypedTree & x.type] = x match
1431+
case x: (tpd.Typed & x.type) => Some(x)
1432+
case _ => None
1433+
end TypedTreeTypeTest
1434+
1435+
object TypedTree extends TypedTreeModule:
1436+
def apply(expr: Term, tpt: TypeTree): Typed =
1437+
withDefaultPos(tpd.Typed(xCheckMacroValidExpr(expr), tpt))
1438+
def copy(original: Tree)(expr: Term, tpt: TypeTree): Typed =
1439+
tpd.cpy.Typed(original)(xCheckMacroValidExpr(expr), tpt)
1440+
def unapply(x: Typed): (Term, TypeTree) =
1441+
(x.expr, x.tpt)
1442+
end TypedTree
1443+
1444+
given TypedTreeMethods: TypedTreeMethods with
1445+
extension (self: Typed)
1446+
def tree: Tree = self.expr
1447+
def tpt: TypeTree = self.tpt
1448+
end extension
1449+
end TypedTreeMethods
1450+
14161451
type Bind = tpd.Bind
14171452

14181453
object BindTypeTest extends TypeTest[Tree, Bind]:

‎compiler/src/scala/quoted/runtime/impl/printers/Extractors.scala

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -173,6 +173,8 @@ object Extractors {
173173
this += "Unapply(" += fun += ", " ++= implicits += ", " ++= patterns += ")"
174174
case Alternatives(patterns) =>
175175
this += "Alternatives(" ++= patterns += ")"
176+
case TypedTree(tree, tpt) =>
177+
this += "TypedTree(" += tree += ", " += tpt += ")"
176178
}
177179

178180
def visitConstant(x: Constant): this.type = x match {

‎compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala

Lines changed: 16 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -453,6 +453,15 @@ object SourceCode {
453453
printTypeOrAnnots(tpt.tpe)
454454
}
455455
}
456+
case TypedTree(tree1, tpt) =>
457+
printPattern(tree1)
458+
tree1 match
459+
case Wildcard() =>
460+
this += ":"
461+
printType(tpt.tpe)
462+
case _ => // Alternatives, Unapply, Bind
463+
this
464+
456465

457466
case Assign(lhs, rhs) =>
458467
printTree(lhs)
@@ -928,9 +937,13 @@ object SourceCode {
928937
case Alternatives(trees) =>
929938
inParens(printPatterns(trees, " | "))
930939

931-
case Typed(Wildcard(), tpt) =>
932-
this += "_: "
933-
printTypeTree(tpt)
940+
case TypedTree(tree1, tpt) =>
941+
tree1 match
942+
case Wildcard() =>
943+
this += "_: "
944+
printTypeTree(tpt)
945+
case _ =>
946+
printPattern(tree1)
934947

935948
case v: Term =>
936949
printTree(v)

‎library/src/scala/quoted/Quotes.scala

Lines changed: 54 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -123,7 +123,6 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
123123
* | +- Apply
124124
* | +- TypeApply
125125
* | +- Super
126-
* | +- Typed
127126
* | +- Assign
128127
* | +- Block
129128
* | +- Closure
@@ -136,7 +135,16 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
136135
* | +- Inlined
137136
* | +- SelectOuter
138137
* | +- While
138+
* | +---+- Typed
139+
* | /
140+
* +- TypedTree +------------------·
141+
* +- Wildcard
142+
* +- Bind
143+
* +- Unapply
144+
* +- Alternatives
139145
* |
146+
* +- CaseDef
147+
* +- TypeCaseDef
140148
* |
141149
* +- TypeTree ----+- Inferred
142150
* | +- TypeIdent
@@ -154,14 +162,6 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
154162
* |
155163
* +- TypeBoundsTree
156164
* +- WildcardTypeTree
157-
* |
158-
* +- CaseDef
159-
* |
160-
* +- TypeCaseDef
161-
* +- Wildcard
162-
* +- Bind
163-
* +- Unapply
164-
* +- Alternatives
165165
*
166166
* +- ParamClause -+- TypeParamClause
167167
* +- TermParamClause
@@ -1111,8 +1111,12 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
11111111
/** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Typed` */
11121112
given TypedTypeTest: TypeTest[Tree, Typed]
11131113

1114-
/** Tree representing a type ascription `x: T` in the source code */
1115-
type Typed <: Term
1114+
/** Tree representing a type ascription `x: T` in the source code.
1115+
*
1116+
* Also represents a pattern that contains a term `x`.
1117+
* Other `: T` patterns use the more general `TypeTree`.
1118+
*/
1119+
type Typed <: Term & TypeTree
11161120

11171121
/** Module object of `type Typed` */
11181122
val Typed: TypedModule
@@ -2055,6 +2059,41 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
20552059
def unapply(pattern: Wildcard): true
20562060
}
20572061

2062+
/** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `TypedTree` */
2063+
given TypedTreeTypeTest: TypeTest[Tree, TypedTree]
2064+
2065+
/** Tree representing a type ascription or pattern `x: T` in the source code
2066+
*
2067+
* The tree `x` may contain a `Constant`, `Ref`, `Wildcard`, `Bind`, `Unapply` or `Alternatives`.
2068+
*/
2069+
type TypedTree <: Term
2070+
2071+
/** Module object of `type TypedTree` */
2072+
val TypedTree: TypedTreeModule
2073+
2074+
/** Methods of the module object `val TypedTree` */
2075+
trait TypedTreeModule { this: TypedTree.type =>
2076+
2077+
/** Create a type ascription `<x: Tree>: <tpt: TypeTree>` */
2078+
def apply(expr: Tree, tpt: TypeTree): TypedTree
2079+
2080+
def copy(original: Tree)(expr: Tree, tpt: TypeTree): TypedTree
2081+
2082+
/** Matches `<expr: Tree>: <tpt: TypeTree>` */
2083+
def unapply(x: TypedTree): (Tree, TypeTree)
2084+
}
2085+
2086+
/** Makes extension methods on `TypedTree` available without any imports */
2087+
given TypedTreeMethods: TypedTreeMethods
2088+
2089+
/** Extension methods of `TypedTree` */
2090+
trait TypedTreeMethods:
2091+
extension (self: TypedTree)
2092+
def tree: Tree
2093+
def tpt: TypeTree
2094+
end extension
2095+
end TypedTreeMethods
2096+
20582097
/** Pattern representing a `_ @ _` binding. */
20592098
type Bind <: Tree
20602099

@@ -4283,6 +4322,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
42834322
case Bind(_, body) => foldTree(x, body)(owner)
42844323
case Unapply(fun, implicits, patterns) => foldTrees(foldTrees(foldTree(x, fun)(owner), implicits)(owner), patterns)(owner)
42854324
case Alternatives(patterns) => foldTrees(x, patterns)(owner)
4325+
case TypedTree(tree1, tpt) => foldTree(foldTree(x, tree1)(owner), tpt)(owner)
42864326
}
42874327
}
42884328
end TreeAccumulator
@@ -4347,6 +4387,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
43474387
Unapply.copy(pattern)(transformTerm(pattern.fun)(owner), transformSubTrees(pattern.implicits)(owner), transformTrees(pattern.patterns)(owner))
43484388
case pattern: Alternatives =>
43494389
Alternatives.copy(pattern)(transformTrees(pattern.patterns)(owner))
4390+
case TypedTree(expr, tpt) =>
4391+
TypedTree.copy(tree)(transformTree(expr)(owner), transformTypeTree(tpt)(owner))
43504392
}
43514393
}
43524394

@@ -4397,7 +4439,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
43974439
case New(tpt) =>
43984440
New.copy(tree)(transformTypeTree(tpt)(owner))
43994441
case Typed(expr, tpt) =>
4400-
Typed.copy(tree)(/*FIXME #12222: transformTerm(expr)(owner)*/transformTree(expr)(owner).asInstanceOf[Term], transformTypeTree(tpt)(owner))
4442+
Typed.copy(tree)(transformTerm(expr)(owner), transformTypeTree(tpt)(owner))
44014443
case tree: NamedArg =>
44024444
NamedArg.copy(tree)(tree.name, transformTerm(tree.value)(owner))
44034445
case Assign(lhs, rhs) =>

‎tests/pos-macros/i11401/X_1.scala

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@ class SLSelect[S]:
1616

1717
def fold[S](s0:S)(step: (S,SLSelect[S])=> S): S = {
1818
???
19-
}
19+
}
2020

2121
def fold_async[S](s0:S)(step: (S,SLSelect[S])=> Future[S]): Future[S] = {
2222
???
@@ -27,7 +27,7 @@ class SLSelect[S]:
2727
await(s0.onRead(ch)(f).runAsync())
2828

2929
def runAsync(): Future[S] = ???
30-
30+
3131

3232

3333
object X:
@@ -36,30 +36,30 @@ object X:
3636
processImpl[T]('f)
3737
}
3838

39-
def processImpl[T:Type](t:Expr[T])(using Quotes):Expr[Future[T]] =
39+
def processImpl[T:Type](t:Expr[T])(using Quotes):Expr[Future[T]] =
4040
import quotes.reflect._
4141
val r = processTree[T](t.asTerm)
4242
r.asExprOf[Future[T]]
4343

44-
45-
def processTree[T:Type](using Quotes)(t: quotes.reflect.Term):quotes.reflect.Term =
44+
45+
def processTree[T:Type](using Quotes)(t: quotes.reflect.Term):quotes.reflect.Term =
4646
import quotes.reflect._
4747
val r: Term = t match
4848
case Inlined(_,List(),body) => processTree(body)
49-
case Inlined(d,bindings,body) =>
49+
case Inlined(d,bindings,body) =>
5050
Inlined(d,bindings,processTree[T](body))
5151
case Block(stats,expr) => Block(stats,processTree(expr))
5252
case Apply(Apply(TypeApply(Select(x,"fold"),targs),List(state)),List(fun)) =>
53-
val nFun = processLambda[T](fun)
53+
val nFun = processLambda[T](fun)
5454
Apply(Apply(TypeApply(Select.unique(x,"fold_async"),targs),List(state)),List(nFun))
5555
case Apply(TypeApply(Ident("await"),targs),List(body)) => body
5656
case Typed(x,tp) => Typed(processTree(x), Inferred(TypeRepr.of[Future].appliedTo(tp.tpe)) )
5757
case _ => throw new RuntimeException(s"tree not recoginized: $t")
5858
val checker = new TreeMap() {}
5959
checker.transformTerm(r)(Symbol.spliceOwner)
6060
r
61-
62-
def processLambda[T:Type](using Quotes)(fun: quotes.reflect.Term):quotes.reflect.Term =
61+
62+
def processLambda[T:Type](using Quotes)(fun: quotes.reflect.Term):quotes.reflect.Term =
6363
import quotes.reflect._
6464

6565
def changeArgs(oldArgs:List[Tree], newArgs:List[Tree], body:Term, owner: Symbol):Term =

‎tests/pos-macros/i12188b/Macro_1.scala

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -10,4 +10,4 @@ object MatchTest {
1010
// test that the constructors work
1111
Block(Nil, Match(param, List(CaseDef(Literal(IntConstant(1)), None, Block(Nil, Literal(UnitConstant()))), CaseDef(Wildcard(), None, Block(Nil, Literal(UnitConstant())))))).asExprOf[Unit]
1212
}
13-
}
13+
}

‎tests/pos-macros/i12188c/Macro_1.scala

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
import scala.quoted.*
2+
3+
object MatchTest {
4+
inline def test(a: Int): Unit = ${testImpl('a)}
5+
6+
def testImpl(a: Expr[Any])(using Quotes): Expr[Unit] = {
7+
import quotes.reflect.*
8+
val matchTree = Match(a.asTerm, List(
9+
CaseDef(Literal(IntConstant(1)), None, Block(Nil, Literal(UnitConstant()))),
10+
CaseDef(Alternatives(List(Literal(IntConstant(2)), Literal(IntConstant(3)), Literal(IntConstant(4)))), None, Block(Nil, Literal(UnitConstant()))),
11+
CaseDef(TypedTree(Alternatives(List(Literal(IntConstant(4)), Literal(IntConstant(5)))), TypeIdent(defn.IntClass)), None, Block(Nil, Literal(UnitConstant()))),
12+
CaseDef(TypedTree(Wildcard(), TypeIdent(defn.IntClass)), None, Block(Nil, Literal(UnitConstant())))))
13+
matchTree.asExprOf[Unit]
14+
}
15+
}

‎tests/pos-macros/i12188c/Test_2.scala

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,2 @@
1+
2+
def test(a: Int) = MatchTest.test(a)

‎tests/run-macros/tasty-extractors-1.check

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -43,16 +43,16 @@ TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "Unit")
4343
Inlined(None, Nil, Match(Literal(StringConstant("b")), List(CaseDef(Bind("n", Wildcard()), None, Block(Nil, Literal(UnitConstant()))))))
4444
TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "Unit")
4545

46-
Inlined(None, Nil, Match(Literal(StringConstant("c")), List(CaseDef(Bind("n", Typed(Wildcard(), TypeIdent("String"))), None, Block(Nil, Literal(UnitConstant()))))))
46+
Inlined(None, Nil, Match(Literal(StringConstant("c")), List(CaseDef(Bind("n", TypedTree(Wildcard(), TypeIdent("String"))), None, Block(Nil, Literal(UnitConstant()))))))
4747
TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "Unit")
4848

4949
Inlined(None, Nil, Match(Literal(StringConstant("e")), List(CaseDef(Wildcard(), None, Block(Nil, Literal(UnitConstant()))))))
5050
TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "Unit")
5151

52-
Inlined(None, Nil, Match(Literal(StringConstant("f")), List(CaseDef(Typed(Wildcard(), TypeIdent("String")), None, Block(Nil, Literal(UnitConstant()))))))
52+
Inlined(None, Nil, Match(Literal(StringConstant("f")), List(CaseDef(TypedTree(Wildcard(), TypeIdent("String")), None, Block(Nil, Literal(UnitConstant()))))))
5353
TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "Unit")
5454

55-
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()))))))
55+
Inlined(None, Nil, Match(Typed(Literal(StringConstant("g")), TypeIdent("Any")), List(CaseDef(Alternatives(List(TypedTree(Wildcard(), TypeIdent("String")), TypedTree(Wildcard(), TypeIdent("Int")))), None, Block(Nil, Literal(UnitConstant()))))))
5656
TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "Unit")
5757

5858
Inlined(None, Nil, Match(Literal(StringConstant("h")), List(CaseDef(Wildcard(), Some(Literal(BooleanConstant(false))), Block(Nil, Literal(UnitConstant()))))))

0 commit comments

Comments
 (0)