@@ -9,7 +9,6 @@ import dotty.tools.dotc.ast.untpd
9
9
import dotty .tools .dotc .core .Annotations
10
10
import dotty .tools .dotc .core .Contexts ._
11
11
import dotty .tools .dotc .core .Types
12
- import dotty .tools .dotc .core .Flags ._
13
12
import dotty .tools .dotc .core .NameKinds
14
13
import dotty .tools .dotc .core .StdNames ._
15
14
import dotty .tools .dotc .quoted .reflect ._
@@ -267,12 +266,13 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
267
266
268
267
object DefDef extends DefDefModule :
269
268
def apply (symbol : Symbol , rhsFn : List [List [Tree ]] => Option [Term ]): DefDef =
270
- assert(symbol.isTerm, s " expected a term symbol but received $symbol" )
269
+ xCheckMacroAssert(symbol.isTerm, s " expected a term symbol but received $symbol" )
270
+ xCheckMacroAssert(symbol.flags.is(Flags .Method ), " expected a symbol with `Method` flag set" )
271
271
withDefaultPos(tpd.DefDef (symbol.asTerm, prefss =>
272
- xCheckMacroedOwners (xCheckMacroValidExpr(rhsFn(prefss)), symbol).getOrElse(tpd.EmptyTree )
272
+ xCheckedMacroOwners (xCheckMacroValidExpr(rhsFn(prefss)), symbol).getOrElse(tpd.EmptyTree )
273
273
))
274
274
def copy (original : Tree )(name : String , paramss : List [ParamClause ], tpt : TypeTree , rhs : Option [Term ]): DefDef =
275
- tpd.cpy.DefDef (original)(name.toTermName, paramss, tpt, xCheckMacroedOwners (rhs, original.symbol).getOrElse(tpd.EmptyTree ))
275
+ tpd.cpy.DefDef (original)(name.toTermName, paramss, tpt, xCheckedMacroOwners (rhs, original.symbol).getOrElse(tpd.EmptyTree ))
276
276
def unapply (ddef : DefDef ): (String , List [ParamClause ], TypeTree , Option [Term ]) =
277
277
(ddef.name.toString, ddef.paramss, ddef.tpt, optional(ddef.rhs))
278
278
end DefDef
@@ -298,9 +298,10 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
298
298
299
299
object ValDef extends ValDefModule :
300
300
def apply (symbol : Symbol , rhs : Option [Term ]): ValDef =
301
- tpd.ValDef (symbol.asTerm, xCheckMacroedOwners(xCheckMacroValidExpr(rhs), symbol).getOrElse(tpd.EmptyTree ))
301
+ xCheckMacroAssert(! symbol.flags.is(Flags .Method ), " expected a symbol without `Method` flag set" )
302
+ tpd.ValDef (symbol.asTerm, xCheckedMacroOwners(xCheckMacroValidExpr(rhs), symbol).getOrElse(tpd.EmptyTree ))
302
303
def copy (original : Tree )(name : String , tpt : TypeTree , rhs : Option [Term ]): ValDef =
303
- tpd.cpy.ValDef (original)(name.toTermName, tpt, xCheckMacroedOwners (xCheckMacroValidExpr(rhs), original.symbol).getOrElse(tpd.EmptyTree ))
304
+ tpd.cpy.ValDef (original)(name.toTermName, tpt, xCheckedMacroOwners (xCheckMacroValidExpr(rhs), original.symbol).getOrElse(tpd.EmptyTree ))
304
305
def unapply (vdef : ValDef ): (String , TypeTree , Option [Term ]) =
305
306
(vdef.name.toString, vdef.tpt, optional(vdef.rhs))
306
307
@@ -390,7 +391,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
390
391
def etaExpand (owner : Symbol ): Term = self.tpe.widen match {
391
392
case mtpe : Types .MethodType if ! mtpe.isParamDependent =>
392
393
val closureResType = mtpe.resType match {
393
- case t : Types .MethodType => t.toFunctionType(isJava = self.symbol.is(JavaDefined ))
394
+ case t : Types .MethodType => t.toFunctionType(isJava = self.symbol.is(dotc.core. Flags . JavaDefined ))
394
395
case t => t
395
396
}
396
397
val closureTpe = Types .MethodType (mtpe.paramNames, mtpe.paramInfos, closureResType)
@@ -803,7 +804,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
803
804
object Lambda extends LambdaModule :
804
805
def apply (owner : Symbol , tpe : MethodType , rhsFn : (Symbol , List [Tree ]) => Tree ): Block =
805
806
val meth = dotc.core.Symbols .newAnonFun(owner, tpe)
806
- withDefaultPos(tpd.Closure (meth, tss => xCheckMacroedOwners (xCheckMacroValidExpr(rhsFn(meth, tss.head.map(withDefaultPos))), meth)))
807
+ withDefaultPos(tpd.Closure (meth, tss => xCheckedMacroOwners (xCheckMacroValidExpr(rhsFn(meth, tss.head.map(withDefaultPos))), meth)))
807
808
808
809
def unapply (tree : Block ): Option [(List [ValDef ], Term )] = tree match {
809
810
case Block ((ddef @ DefDef (_, tpd.ValDefs (params) :: Nil , _, Some (body))) :: Nil , Closure (meth, _))
@@ -1474,6 +1475,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
1474
1475
1475
1476
object Bind extends BindModule :
1476
1477
def apply (sym : Symbol , pattern : Tree ): Bind =
1478
+ xCheckMacroAssert(sym.flags.is(Flags .Case ), " expected a symbol with `Case` flag set" )
1477
1479
tpd.Bind (sym, pattern)
1478
1480
def copy (original : Tree )(name : String , pattern : Tree ): Bind =
1479
1481
withDefaultPos(tpd.cpy.Bind (original)(name.toTermName, pattern))
@@ -2484,13 +2486,28 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
2484
2486
def newMethod (owner : Symbol , name : String , tpe : TypeRepr ): Symbol =
2485
2487
newMethod(owner, name, tpe, Flags .EmptyFlags , noSymbol)
2486
2488
def newMethod (owner : Symbol , name : String , tpe : TypeRepr , flags : Flags , privateWithin : Symbol ): Symbol =
2489
+ import Flags .*
2490
+ // TODO: missing AbsOverride
2491
+ checkValidFlags(flags.toTermFlags, Private | Protected | Override | Deferred | Final | Method | Implicit | Given | Local | JavaStatic ) // Synthetic | ExtensionMethod | Exported | Erased | Infix | Invisible
2487
2492
dotc.core.Symbols .newSymbol(owner, name.toTermName, flags | dotc.core.Flags .Method , tpe, privateWithin)
2488
2493
def newVal (owner : Symbol , name : String , tpe : TypeRepr , flags : Flags , privateWithin : Symbol ): Symbol =
2494
+ import Flags .*
2495
+ // TODO: missing AbsOverride
2496
+ checkValidFlags(flags.toTermFlags, Private | Protected | Override | Deferred | Final | Param | Implicit | Lazy | Mutable | Local | ParamAccessor | Module | Package | Case | CaseAccessor | Given | Enum | JavaStatic ) // Synthetic | Erased | Invisible
2489
2497
dotc.core.Symbols .newSymbol(owner, name.toTermName, flags, tpe, privateWithin)
2490
2498
def newBind (owner : Symbol , name : String , flags : Flags , tpe : TypeRepr ): Symbol =
2491
- dotc.core.Symbols .newSymbol(owner, name.toTermName, flags | Case , tpe)
2499
+ import Flags .*
2500
+ checkValidFlags(flags.toTermFlags, Case ) // | Implicit | Given | Erased
2501
+ dotc.core.Symbols .newSymbol(owner, name.toTermName, flags | dotc.core.Flags .Case , tpe)
2492
2502
def noSymbol : Symbol = dotc.core.Symbols .NoSymbol
2493
2503
2504
+ private inline def checkValidFlags (inline flags : Flags , inline valid : Flags ): Unit =
2505
+ xCheckMacroAssert(
2506
+ flags <= valid,
2507
+ s " Received invalid flags. Expected flags ${flags.show} to only contain a subset of ${valid.show}. "
2508
+ )
2509
+
2510
+
2494
2511
def freshName (prefix : String ): String =
2495
2512
NameKinds .MacroNames .fresh(prefix.toTermName).toString
2496
2513
end Symbol
@@ -2563,7 +2580,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
2563
2580
self.isTerm && ! self.is(dotc.core.Flags .Method ) && ! self.is(dotc.core.Flags .Case /* , FIXME add this check and fix sourcecode butNot = Enum | Module*/ )
2564
2581
def isDefDef : Boolean = self.is(dotc.core.Flags .Method )
2565
2582
def isBind : Boolean =
2566
- self.is(dotc.core.Flags .Case , butNot = Enum | Module ) && ! self.isClass
2583
+ self.is(dotc.core.Flags .Case , butNot = dotc.core. Flags . Enum | dotc.core. Flags . Module ) && ! self.isClass
2567
2584
def isNoSymbol : Boolean = self == Symbol .noSymbol
2568
2585
def exists : Boolean = self != Symbol .noSymbol
2569
2586
@@ -2919,7 +2936,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
2919
2936
/** Checks that all definitions in this tree have the expected owner.
2920
2937
* Nested definitions are ignored and assumed to be correct by construction.
2921
2938
*/
2922
- private def xCheckMacroedOwners (tree : Option [Tree ], owner : Symbol ): tree.type =
2939
+ private def xCheckedMacroOwners (tree : Option [Tree ], owner : Symbol ): tree.type =
2923
2940
if xCheckMacro then
2924
2941
tree match
2925
2942
case Some (tree) =>
@@ -2930,7 +2947,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
2930
2947
/** Checks that all definitions in this tree have the expected owner.
2931
2948
* Nested definitions are ignored and assumed to be correct by construction.
2932
2949
*/
2933
- private def xCheckMacroedOwners (tree : Tree , owner : Symbol ): tree.type =
2950
+ private def xCheckedMacroOwners (tree : Tree , owner : Symbol ): tree.type =
2934
2951
if xCheckMacro then
2935
2952
xCheckMacroOwners(tree, owner)
2936
2953
tree
@@ -3001,6 +3018,9 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
3001
3018
" Reference to a method must be eta-expanded before it is used as an expression: " + term.show)
3002
3019
term
3003
3020
3021
+ private inline def xCheckMacroAssert (inline cond : Boolean , inline msg : String ): Unit =
3022
+ assert(! xCheckMacro || cond, msg)
3023
+
3004
3024
object Printer extends PrinterModule :
3005
3025
3006
3026
lazy val TreeCode : Printer [Tree ] = new Printer [Tree ]:
0 commit comments