From 0c5d7f8ac4fe7dce20781ee4d31d159a72c517b4 Mon Sep 17 00:00:00 2001 From: Nicolas Stucki Date: Sat, 9 Mar 2019 20:47:49 +0100 Subject: [PATCH 01/10] Fix IsTerm not matching Repeated --- .../src/dotty/tools/dotc/tastyreflect/KernelImpl.scala | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala index 2dfa27bde725..4eb0359f89ab 100644 --- a/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala +++ b/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala @@ -199,8 +199,11 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. type Term = tpd.Tree - def matchTerm(tree: Tree)(implicit ctx: Context): Option[Term] = - if (tree.isTerm) Some(tree) else None + def matchTerm(tree: Tree)(implicit ctx: Context): Option[Term] = tree match { + case x: tpd.SeqLiteral => Some(tree) + case _ if tree.isTerm => Some(tree) + case _ => None + } // TODO move to Kernel and use isTerm directly with a cast def matchTermNotTypeTree(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context): Option[Term] = From e8074c7f97afd758785b95421bc35c8bfedf81c8 Mon Sep 17 00:00:00 2001 From: Nicolas Stucki Date: Sat, 9 Mar 2019 20:49:41 +0100 Subject: [PATCH 02/10] Fix printing Super extractor --- library/src/scala/tasty/reflect/Printers.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/src/scala/tasty/reflect/Printers.scala b/library/src/scala/tasty/reflect/Printers.scala index 1049dfc2a247..1796e8133122 100644 --- a/library/src/scala/tasty/reflect/Printers.scala +++ b/library/src/scala/tasty/reflect/Printers.scala @@ -181,7 +181,7 @@ trait Printers case Term.This(qual) => this += "Term.This(" += qual += ")" case Term.Super(qual, mix) => - this += "Term.TypeApply(" += qual += ", " += mix += ")" + this += "Term.Super(" += qual += ", " += mix += ")" case Term.Apply(fun, args) => this += "Term.Apply(" += fun += ", " ++= args += ")" case Term.TypeApply(fun, args) => From dd1945252cfba61c8df50bf20d79d00585fc4309 Mon Sep 17 00:00:00 2001 From: Nicolas Stucki Date: Sat, 9 Mar 2019 21:17:04 +0100 Subject: [PATCH 03/10] Make TASTy reflect TypeOrBoundsTree <:< Tree --- .../tools/dotc/tastyreflect/KernelImpl.scala | 252 +++++++------- .../other-new-features/tasty-reflect.md | 85 +++-- library/src/scala/tasty/reflect/Core.scala | 206 ++++++------ library/src/scala/tasty/reflect/Kernel.scala | 310 +++++++++--------- .../src/scala/tasty/reflect/Printers.scala | 57 +--- .../tasty/reflect/TypeOrBoundsTreeOps.scala | 124 +++---- 6 files changed, 500 insertions(+), 534 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala index 4eb0359f89ab..0ca921dbccad 100644 --- a/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala +++ b/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala @@ -600,134 +600,6 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. def While_copy(original: Tree)(cond: Term, body: Term)(implicit ctx: Context): While = tpd.cpy.WhileDo(original)(cond, body) - // - // CASES - // - - type CaseDef = tpd.CaseDef - - def CaseDef_pattern(self: CaseDef)(implicit ctx: Context): Pattern = self.pat - def CaseDef_guard(self: CaseDef)(implicit ctx: Context): Option[Term] = optional(self.guard) - def CaseDef_rhs(self: CaseDef)(implicit ctx: Context): Term = self.body - - def CaseDef_module_apply(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef = - tpd.CaseDef(pattern, guard.getOrElse(tpd.EmptyTree), body) - - def CaseDef_module_copy(original: CaseDef)(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef = - tpd.cpy.CaseDef(original)(pattern, guard.getOrElse(tpd.EmptyTree), body) - - type TypeCaseDef = tpd.CaseDef - - def TypeCaseDef_pattern(self: TypeCaseDef)(implicit ctx: Context): TypeTree = self.pat - def TypeCaseDef_rhs(self: TypeCaseDef)(implicit ctx: Context): TypeTree = self.body - - def TypeCaseDef_module_apply(pattern: TypeTree, body: TypeTree)(implicit ctx: Context): TypeCaseDef = - tpd.CaseDef(pattern, tpd.EmptyTree, body) - - def TypeCaseDef_module_copy(original: TypeCaseDef)(pattern: TypeTree, body: TypeTree)(implicit ctx: Context): TypeCaseDef = - tpd.cpy.CaseDef(original)(pattern, tpd.EmptyTree, body) - - // - // PATTERNS - // - - type Pattern = tpd.Tree - - def Pattern_pos(self: Pattern)(implicit ctx: Context): Position = self.sourcePos - def Pattern_tpe(self: Pattern)(implicit ctx: Context): Type = self.tpe.stripTypeVar - def Pattern_symbol(self: Pattern)(implicit ctx: Context): Symbol = self.symbol - - type Value = tpd.Tree - - def matchPattern_Value(pattern: Pattern): Option[Value] = pattern match { - case lit: tpd.Literal => Some(lit) - case ref: tpd.RefTree if ref.isTerm => Some(ref) - case ths: tpd.This => Some(ths) - case _ => None - } - - def Pattern_Value_value(self: Value)(implicit ctx: Context): Term = self - - def Pattern_Value_module_apply(term: Term)(implicit ctx: Context): Value = term match { - case lit: tpd.Literal => lit - case ref: tpd.RefTree if ref.isTerm => ref - case ths: tpd.This => ths - } - def Pattern_Value_module_copy(original: Value)(term: Term)(implicit ctx: Context): Value = term match { - case lit: tpd.Literal => tpd.cpy.Literal(original)(lit.const) - case ref: tpd.RefTree if ref.isTerm => tpd.cpy.Ref(original.asInstanceOf[tpd.RefTree])(ref.name) - case ths: tpd.This => tpd.cpy.This(original)(ths.qual) - } - - type Bind = tpd.Bind - - def matchPattern_Bind(x: Pattern)(implicit ctx: Context): Option[Bind] = x match { - case x: tpd.Bind if x.name.isTermName => Some(x) - case _ => None - } - - def Pattern_Bind_name(self: Bind)(implicit ctx: Context): String = self.name.toString - - def Pattern_Bind_pattern(self: Bind)(implicit ctx: Context): Pattern = self.body - - def Pattern_Bind_module_copy(original: Bind)(name: String, pattern: Pattern)(implicit ctx: Context): Bind = - withDefaultPos(ctx => tpd.cpy.Bind(original)(name.toTermName, pattern)(ctx)) - - type Unapply = tpd.UnApply - - def matchPattern_Unapply(pattern: Pattern)(implicit ctx: Context): Option[Unapply] = pattern match { - case pattern @ Trees.UnApply(_, _, _) => Some(pattern) - case Trees.Typed(pattern @ Trees.UnApply(_, _, _), _) => Some(pattern) - case _ => None - } - - def Pattern_Unapply_fun(self: Unapply)(implicit ctx: Context): Term = self.fun - def Pattern_Unapply_implicits(self: Unapply)(implicit ctx: Context): List[Term] = self.implicits - def Pattern_Unapply_patterns(self: Unapply)(implicit ctx: Context): List[Pattern] = effectivePatterns(self.patterns) - - def Pattern_Unapply_module_copy(original: Unapply)(fun: Term, implicits: List[Term], patterns: List[Pattern])(implicit ctx: Context): Unapply = - withDefaultPos(ctx => tpd.cpy.UnApply(original)(fun, implicits, patterns)(ctx)) - - private def effectivePatterns(patterns: List[Pattern]): List[Pattern] = patterns match { - case patterns0 :+ Trees.SeqLiteral(elems, _) => patterns0 ::: elems - case _ => patterns - } - - type Alternatives = tpd.Alternative - - def matchPattern_Alternatives(pattern: Pattern)(implicit ctx: Context): Option[Alternatives] = pattern match { - case pattern: tpd.Alternative => Some(pattern) - case _ => None - } - - def Pattern_Alternatives_patterns(self: Alternatives)(implicit ctx: Context): List[Pattern] = self.trees - - def Pattern_Alternatives_module_apply(patterns: List[Pattern])(implicit ctx: Context): Alternatives = - withDefaultPos(ctx => tpd.Alternative(patterns)(ctx)) - - def Pattern_Alternatives_module_copy(original: Alternatives)(patterns: List[Pattern])(implicit ctx: Context): Alternatives = - tpd.cpy.Alternative(original)(patterns) - - type TypeTest = tpd.Typed - - def matchPattern_TypeTest(pattern: Pattern)(implicit ctx: Context): Option[TypeTest] = pattern match { - case Trees.Typed(_: tpd.UnApply, _) => None - case pattern: tpd.Typed => Some(pattern) - case _ => None - } - - def Pattern_TypeTest_tpt(self: TypeTest)(implicit ctx: Context): TypeTree = self.tpt - - def Pattern_TypeTest_module_apply(tpt: TypeTree)(implicit ctx: Context): TypeTest = - withDefaultPos(ctx => tpd.Typed(untpd.Ident(nme.WILDCARD)(ctx.source).withType(tpt.tpe)(ctx), tpt)(ctx)) - - def Pattern_TypeTest_module_copy(original: TypeTest)(tpt: TypeTree)(implicit ctx: Context): TypeTest = - tpd.cpy.Typed(original)(untpd.Ident(nme.WILDCARD).withSpan(original.span).withType(tpt.tpe), tpt) - - // - // TYPE TREES - // - type TypeOrBoundsTree = tpd.Tree def TypeOrBoundsTree_tpe(self: TypeOrBoundsTree)(implicit ctx: Context): Type = self.tpe.stripTypeVar @@ -962,6 +834,130 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. case _ => None } + // + // CASES + // + + type CaseDef = tpd.CaseDef + + def CaseDef_pattern(self: CaseDef)(implicit ctx: Context): Pattern = self.pat + def CaseDef_guard(self: CaseDef)(implicit ctx: Context): Option[Term] = optional(self.guard) + def CaseDef_rhs(self: CaseDef)(implicit ctx: Context): Term = self.body + + def CaseDef_module_apply(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef = + tpd.CaseDef(pattern, guard.getOrElse(tpd.EmptyTree), body) + + def CaseDef_module_copy(original: CaseDef)(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef = + tpd.cpy.CaseDef(original)(pattern, guard.getOrElse(tpd.EmptyTree), body) + + type TypeCaseDef = tpd.CaseDef + + def TypeCaseDef_pattern(self: TypeCaseDef)(implicit ctx: Context): TypeTree = self.pat + def TypeCaseDef_rhs(self: TypeCaseDef)(implicit ctx: Context): TypeTree = self.body + + def TypeCaseDef_module_apply(pattern: TypeTree, body: TypeTree)(implicit ctx: Context): TypeCaseDef = + tpd.CaseDef(pattern, tpd.EmptyTree, body) + + def TypeCaseDef_module_copy(original: TypeCaseDef)(pattern: TypeTree, body: TypeTree)(implicit ctx: Context): TypeCaseDef = + tpd.cpy.CaseDef(original)(pattern, tpd.EmptyTree, body) + + // + // PATTERNS + // + + type Pattern = tpd.Tree + + def Pattern_pos(self: Pattern)(implicit ctx: Context): Position = self.sourcePos + def Pattern_tpe(self: Pattern)(implicit ctx: Context): Type = self.tpe.stripTypeVar + def Pattern_symbol(self: Pattern)(implicit ctx: Context): Symbol = self.symbol + + type Value = tpd.Tree + + def matchPattern_Value(pattern: Pattern): Option[Value] = pattern match { + case lit: tpd.Literal => Some(lit) + case ref: tpd.RefTree if ref.isTerm => Some(ref) + case ths: tpd.This => Some(ths) + case _ => None + } + + def Pattern_Value_value(self: Value)(implicit ctx: Context): Term = self + + def Pattern_Value_module_apply(term: Term)(implicit ctx: Context): Value = term match { + case lit: tpd.Literal => lit + case ref: tpd.RefTree if ref.isTerm => ref + case ths: tpd.This => ths + } + def Pattern_Value_module_copy(original: Value)(term: Term)(implicit ctx: Context): Value = term match { + case lit: tpd.Literal => tpd.cpy.Literal(original)(lit.const) + case ref: tpd.RefTree if ref.isTerm => tpd.cpy.Ref(original.asInstanceOf[tpd.RefTree])(ref.name) + case ths: tpd.This => tpd.cpy.This(original)(ths.qual) + } + + type Bind = tpd.Bind + + def matchPattern_Bind(x: Pattern)(implicit ctx: Context): Option[Bind] = x match { + case x: tpd.Bind if x.name.isTermName => Some(x) + case _ => None + } + + def Pattern_Bind_name(self: Bind)(implicit ctx: Context): String = self.name.toString + + def Pattern_Bind_pattern(self: Bind)(implicit ctx: Context): Pattern = self.body + + def Pattern_Bind_module_copy(original: Bind)(name: String, pattern: Pattern)(implicit ctx: Context): Bind = + withDefaultPos(ctx => tpd.cpy.Bind(original)(name.toTermName, pattern)(ctx)) + + type Unapply = tpd.UnApply + + def matchPattern_Unapply(pattern: Pattern)(implicit ctx: Context): Option[Unapply] = pattern match { + case pattern @ Trees.UnApply(_, _, _) => Some(pattern) + case Trees.Typed(pattern @ Trees.UnApply(_, _, _), _) => Some(pattern) + case _ => None + } + + def Pattern_Unapply_fun(self: Unapply)(implicit ctx: Context): Term = self.fun + def Pattern_Unapply_implicits(self: Unapply)(implicit ctx: Context): List[Term] = self.implicits + def Pattern_Unapply_patterns(self: Unapply)(implicit ctx: Context): List[Pattern] = effectivePatterns(self.patterns) + + def Pattern_Unapply_module_copy(original: Unapply)(fun: Term, implicits: List[Term], patterns: List[Pattern])(implicit ctx: Context): Unapply = + withDefaultPos(ctx => tpd.cpy.UnApply(original)(fun, implicits, patterns)(ctx)) + + private def effectivePatterns(patterns: List[Pattern]): List[Pattern] = patterns match { + case patterns0 :+ Trees.SeqLiteral(elems, _) => patterns0 ::: elems + case _ => patterns + } + + type Alternatives = tpd.Alternative + + def matchPattern_Alternatives(pattern: Pattern)(implicit ctx: Context): Option[Alternatives] = pattern match { + case pattern: tpd.Alternative => Some(pattern) + case _ => None + } + + def Pattern_Alternatives_patterns(self: Alternatives)(implicit ctx: Context): List[Pattern] = self.trees + + def Pattern_Alternatives_module_apply(patterns: List[Pattern])(implicit ctx: Context): Alternatives = + withDefaultPos(ctx => tpd.Alternative(patterns)(ctx)) + + def Pattern_Alternatives_module_copy(original: Alternatives)(patterns: List[Pattern])(implicit ctx: Context): Alternatives = + tpd.cpy.Alternative(original)(patterns) + + type TypeTest = tpd.Typed + + def matchPattern_TypeTest(pattern: Pattern)(implicit ctx: Context): Option[TypeTest] = pattern match { + case Trees.Typed(_: tpd.UnApply, _) => None + case pattern: tpd.Typed => Some(pattern) + case _ => None + } + + def Pattern_TypeTest_tpt(self: TypeTest)(implicit ctx: Context): TypeTree = self.tpt + + def Pattern_TypeTest_module_apply(tpt: TypeTree)(implicit ctx: Context): TypeTest = + withDefaultPos(ctx => tpd.Typed(untpd.Ident(nme.WILDCARD)(ctx.source).withType(tpt.tpe)(ctx), tpt)(ctx)) + + def Pattern_TypeTest_module_copy(original: TypeTest)(tpt: TypeTree)(implicit ctx: Context): TypeTest = + tpd.cpy.Typed(original)(untpd.Ident(nme.WILDCARD).withSpan(original.span).withType(tpt.tpe), tpt) + // // TYPES // diff --git a/docs/docs/reference/other-new-features/tasty-reflect.md b/docs/docs/reference/other-new-features/tasty-reflect.md index 8114a530e0a7..ac939d81688e 100644 --- a/docs/docs/reference/other-new-features/tasty-reflect.md +++ b/docs/docs/reference/other-new-features/tasty-reflect.md @@ -88,49 +88,48 @@ TASTy Reflect provides the following types: +- Tree -+- PackageClause +- Import +- Statement -+- Definition --+- PackageDef - | +- ClassDef - | +- TypeDef - | +- DefDef - | +- ValDef - | - +- Term --------+- Ident - +- Select - +- Literal - +- This - +- New - +- NamedArg - +- Apply - +- TypeApply - +- Super - +- Typed - +- Assign - +- Block - +- Lambda - +- If - +- Match - +- Try - +- Return - +- Repeated - +- Inlined - +- SelectOuter - +- While - - - +- TypeTree ----+- Synthetic - | +- Ident - | +- Select - | +- Project - | +- Singleton -+- TypeOrBoundsTree ---+ +- Refined - | +- Applied - | +- Annotated - | +- MatchType - | +- ByName - | +- LambdaTypeTree - | +- Bind - | - +- TypeBoundsTree - +- SyntheticBounds + | | +- ClassDef + | | +- TypeDef + | | +- DefDef + | | +- ValDef + | | + | +- Term --------+- Ident + | +- Select + | +- Literal + | +- This + | +- New + | +- NamedArg + | +- Apply + | +- TypeApply + | +- Super + | +- Typed + | +- Assign + | +- Block + | +- Lambda + | +- If + | +- Match + | +- Try + | +- Return + | +- Repeated + | +- Inlined + | +- SelectOuter + | +- While + | + | +- TypeTree ----+- Synthetic + | | +- Ident + | | +- Select + | | +- Project + | | +- Singleton + +- TypeOrBoundsTree ---+ +- Refined + | +- Applied + | +- Annotated + | +- MatchType + | +- ByName + | +- LambdaTypeTree + | +- Bind + | + +- TypeBoundsTree + +- SyntheticBounds +- CaseDef +- TypeCaseDef diff --git a/library/src/scala/tasty/reflect/Core.scala b/library/src/scala/tasty/reflect/Core.scala index bd5f00c5654a..66d6442be7dc 100644 --- a/library/src/scala/tasty/reflect/Core.scala +++ b/library/src/scala/tasty/reflect/Core.scala @@ -8,51 +8,51 @@ package scala.tasty.reflect * +- Tree -+- PackageClause * +- Import * +- Statement -+- Definition --+- PackageDef - * | +- ClassDef - * | +- TypeDef - * | +- DefDef - * | +- ValDef - * | - * +- Term --------+- Ref -+- Ident - * | +- Select - * | - * +- Literal - * +- This - * +- New - * +- NamedArg - * +- Apply - * +- TypeApply - * +- Super - * +- Typed - * +- Assign - * +- Block - * +- Lambda - * +- If - * +- Match - * +- Try - * +- Return - * +- Repeated - * +- Inlined - * +- SelectOuter - * +- While - * - * - * +- TypeTree ----+- Inferred - * | +- Ident - * | +- Select - * | +- Project - * | +- Singleton - * +- TypeOrBoundsTree ---+ +- Refined - * | +- Applied - * | +- Annotated - * | +- MatchType - * | +- ByName - * | +- LambdaTypeTree - * | +- TypeBind - * | +- TypeBlock - * | - * +- TypeBoundsTree - * +- WildcardTypeTree + * | | +- ClassDef + * | | +- TypeDef + * | | +- DefDef + * | | +- ValDef + * | | + * | +- Term --------+- Ref -+- Ident + * | | +- Select + * | | + * | +- Literal + * | +- This + * | +- New + * | +- NamedArg + * | +- Apply + * | +- TypeApply + * | +- Super + * | +- Typed + * | +- Assign + * | +- Block + * | +- Lambda + * | +- If + * | +- Match + * | +- Try + * | +- Return + * | +- Repeated + * | +- Inlined + * | +- SelectOuter + * | +- While + * | + * | + * | +- TypeTree ----+- TypeTree_Inferred + * | | +- TypeTree_Ident + * | | +- TypeTree_Select + * | | +- TypeTree_Project + * | | +- TypeTree_Singleton + * +- TypeOrBoundsTree -+ +- TypeTree_Refined + * | +- TypeTree_Applied + * | +- TypeTree_Annotated + * | +- TypeTree_MatchType + * | +- TypeTree_ByName + * | +- TypeTree_LambdaTypeTree + * | +- TypeTree_TypeBind + * | +- TypeTree_TypeBlock + * | + * +- TypeBoundsTree + * +- WildcardTypeTree * * +- CaseDef * +- TypeCaseDef @@ -237,91 +237,91 @@ trait Core { } - /** Branch of a pattern match or catch clause */ - type CaseDef = kernel.CaseDef + /** Type tree representing a type or a bounds written in the source */ + type TypeOrBoundsTree = kernel.TypeOrBoundsTree - /** Branch of a type pattern match */ - type TypeCaseDef = kernel.TypeCaseDef + /** Type tree representing a type written in the source */ + type TypeTree = kernel.TypeTree - /** Pattern tree of the pattern part of a CaseDef */ - type Pattern = kernel.Pattern + /** Type trees representing a type written in the source */ + val TypeTree: TypeTreeCoreModule - /** Pattern representing a value. This includes `1`, ```x``` and `_` */ - type Value = kernel.Value + /** Type trees representing a type written in the source */ + trait TypeTreeCoreModule { - /** Pattern representing a `_ @ _` binding. */ - type Bind = kernel.Bind + /** Type tree representing an inferred type */ + type Inferred = kernel.TypeTree_Inferred - /** Pattern representing a `Xyz(...)` unapply. */ - type Unapply = kernel.Unapply + /** Type tree representing a reference to definition with a given name */ + type Ident = kernel.TypeTree_Ident - /** Pattern representing `X | Y | ...` alternatives. */ - type Alternatives = kernel.Alternatives + /** Type tree representing a selection of definition with a given name on a given term prefix */ + type Select = kernel.TypeTree_Select - /** Pattern representing a `x: Y` type test. */ - type TypeTest = kernel.TypeTest + /** Type tree representing a selection of definition with a given name on a given type prefix */ + type Projection = kernel.TypeTree_Projection - /** Type tree representing a type or a bounds written in the source */ - type TypeOrBoundsTree = kernel.TypeOrBoundsTree + /** Type tree representing a singleton type */ + type Singleton = kernel.TypeTree_Singleton - /** Type tree representing a type written in the source */ - type TypeTree = kernel.TypeTree + /** Type tree representing a type refinement */ + type Refined = kernel.TypeTree_Refined - /** Type trees representing a type written in the source */ - val TypeTree: TypeTreeCoreModule + /** Type tree representing a type application */ + type Applied = kernel.TypeTree_Applied - /** Type trees representing a type written in the source */ - trait TypeTreeCoreModule { + /** Type tree representing an annotated type */ + type Annotated = kernel.TypeTree_Annotated - /** Type tree representing an inferred type */ - type Inferred = kernel.TypeTree_Inferred + /** Type tree representing a type match */ + type MatchType = kernel.TypeTree_MatchType - /** Type tree representing a reference to definition with a given name */ - type Ident = kernel.TypeTree_Ident + /** Type tree representing a by name parameter */ + type ByName = kernel.TypeTree_ByName - /** Type tree representing a selection of definition with a given name on a given term prefix */ - type Select = kernel.TypeTree_Select + /** Type tree representing a lambda abstraction type */ + type LambdaTypeTree = kernel.TypeTree_LambdaTypeTree - /** Type tree representing a selection of definition with a given name on a given type prefix */ - type Projection = kernel.TypeTree_Projection + /** Type tree representing a type binding */ + type TypeBind = kernel.TypeTree_TypeBind - /** Type tree representing a singleton type */ - type Singleton = kernel.TypeTree_Singleton + /** Type tree within a block with aliases `{ type U1 = ... ; T[U1, U2] }` */ + type TypeBlock = kernel.TypeTree_TypeBlock - /** Type tree representing a type refinement */ - type Refined = kernel.TypeTree_Refined + } - /** Type tree representing a type application */ - type Applied = kernel.TypeTree_Applied + /** Type tree representing a type bound written in the source */ + type TypeBoundsTree = kernel.TypeBoundsTree - /** Type tree representing an annotated type */ - type Annotated = kernel.TypeTree_Annotated + /** Type tree representing wildcard type bounds written in the source. + * The wildcard type `_` (for example in in `List[_]`) will be a type tree that + * represents a type but has `TypeBound`a inside. + */ + type WildcardTypeTree = kernel.WildcardTypeTree - /** Type tree representing a type match */ - type MatchType = kernel.TypeTree_MatchType + /** Branch of a pattern match or catch clause */ + type CaseDef = kernel.CaseDef - /** Type tree representing a by name parameter */ - type ByName = kernel.TypeTree_ByName + /** Branch of a type pattern match */ + type TypeCaseDef = kernel.TypeCaseDef - /** Type tree representing a lambda abstraction type */ - type LambdaTypeTree = kernel.TypeTree_LambdaTypeTree + /** Pattern tree of the pattern part of a CaseDef */ + type Pattern = kernel.Pattern - /** Type tree representing a type binding */ - type TypeBind = kernel.TypeTree_TypeBind + /** Pattern representing a value. This includes `1`, ```x``` and `_` */ + type Value = kernel.Value - /** Type tree within a block with aliases `{ type U1 = ... ; T[U1, U2] }` */ - type TypeBlock = kernel.TypeTree_TypeBlock + /** Pattern representing a `_ @ _` binding. */ + type Bind = kernel.Bind - } + /** Pattern representing a `Xyz(...)` unapply. */ + type Unapply = kernel.Unapply - /** Type tree representing a type bound written in the source */ - type TypeBoundsTree = kernel.TypeBoundsTree + /** Pattern representing `X | Y | ...` alternatives. */ + type Alternatives = kernel.Alternatives - /** Type tree representing wildcard type bounds written in the source. - * The wildcard type `_` (for example in in `List[_]`) will be a type tree that - * represents a type but has `TypeBound`a inside. - */ - type WildcardTypeTree = kernel.WildcardTypeTree + /** Pattern representing a `x: Y` type test. */ + type TypeTest = kernel.TypeTest /** Type or bounds */ type TypeOrBounds = kernel.TypeOrBounds diff --git a/library/src/scala/tasty/reflect/Kernel.scala b/library/src/scala/tasty/reflect/Kernel.scala index 237b507bdc47..e116f424bdf4 100644 --- a/library/src/scala/tasty/reflect/Kernel.scala +++ b/library/src/scala/tasty/reflect/Kernel.scala @@ -7,51 +7,51 @@ package scala.tasty.reflect * +- Tree -+- PackageClause * +- Import * +- Statement -+- Definition --+- PackageDef - * | +- ClassDef - * | +- TypeDef - * | +- DefDef - * | +- ValDef - * | - * +- Term --------+- Ref -+- Ident - * | +- Select - * | - * +- Literal - * +- This - * +- New - * +- NamedArg - * +- Apply - * +- TypeApply - * +- Super - * +- Typed - * +- Assign - * +- Block - * +- Lambda - * +- If - * +- Match - * +- Try - * +- Return - * +- Repeated - * +- Inlined - * +- SelectOuter - * +- While - * - * - * +- TypeTree ----+- TypeTree_Inferred - * | +- TypeTree_Ident - * | +- TypeTree_Select - * | +- TypeTree_Project - * | +- TypeTree_Singleton - * +- TypeOrBoundsTree ---+ +- TypeTree_Refined - * | +- TypeTree_Applied - * | +- TypeTree_Annotated - * | +- TypeTree_MatchType - * | +- TypeTree_ByName - * | +- TypeTree_LambdaTypeTree - * | +- TypeTree_TypeBind - * | +- TypeTree_TypeBlock - * | - * +- TypeBoundsTree - * +- WildcardTypeTree + * | | +- ClassDef + * | | +- TypeDef + * | | +- DefDef + * | | +- ValDef + * | | + * | +- Term --------+- Ref -+- Ident + * | | +- Select + * | | + * | +- Literal + * | +- This + * | +- New + * | +- NamedArg + * | +- Apply + * | +- TypeApply + * | +- Super + * | +- Typed + * | +- Assign + * | +- Block + * | +- Lambda + * | +- If + * | +- Match + * | +- Try + * | +- Return + * | +- Repeated + * | +- Inlined + * | +- SelectOuter + * | +- While + * | + * | + * | +- TypeTree ----+- TypeTree_Inferred + * | | +- TypeTree_Ident + * | | +- TypeTree_Select + * | | +- TypeTree_Project + * | | +- TypeTree_Singleton + * +- TypeOrBoundsTree -+ +- TypeTree_Refined + * | +- TypeTree_Applied + * | +- TypeTree_Annotated + * | +- TypeTree_MatchType + * | +- TypeTree_ByName + * | +- TypeTree_LambdaTypeTree + * | +- TypeTree_TypeBind + * | +- TypeTree_TypeBlock + * | + * +- TypeBoundsTree + * +- WildcardTypeTree * * +- CaseDef * +- TypeCaseDef @@ -518,107 +518,15 @@ trait Kernel { def While_apply(cond: Term, body: Term)(implicit ctx: Context): While def While_copy(original: Tree)(cond: Term, body: Term)(implicit ctx: Context): While - // - // CASES - // - - /** Branch of a pattern match or catch clause */ - type CaseDef <: AnyRef - - def CaseDef_pattern(self: CaseDef)(implicit ctx: Context): Pattern - def CaseDef_guard(self: CaseDef)(implicit ctx: Context): Option[Term] - def CaseDef_rhs(self: CaseDef)(implicit ctx: Context): Term - - def CaseDef_module_apply(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef - def CaseDef_module_copy(original: CaseDef)(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef - - /** Branch of a type pattern match */ - type TypeCaseDef <: AnyRef - - def TypeCaseDef_pattern(self: TypeCaseDef)(implicit ctx: Context): TypeTree - def TypeCaseDef_rhs(self: TypeCaseDef)(implicit ctx: Context): TypeTree - - def TypeCaseDef_module_apply(pattern: TypeTree, body: TypeTree)(implicit ctx: Context): TypeCaseDef - def TypeCaseDef_module_copy(original: TypeCaseDef)(pattern: TypeTree, body: TypeTree)(implicit ctx: Context): TypeCaseDef - - // - // PATTERNS - // - - /** Pattern tree of the pattern part of a CaseDef */ - type Pattern <: AnyRef - - def Pattern_pos(self: Pattern)(implicit ctx: Context): Position - def Pattern_tpe(self: Pattern)(implicit ctx: Context): Type - def Pattern_symbol(self: Pattern)(implicit ctx: Context): Symbol - - /** Pattern representing a value. This includes `1`, ```x``` and `_` */ - type Value <: Pattern - - def matchPattern_Value(pattern: Pattern): Option[Value] - - def Pattern_Value_value(self: Value)(implicit ctx: Context): Term - - def Pattern_Value_module_apply(term: Term)(implicit ctx: Context): Value - def Pattern_Value_module_copy(original: Value)(term: Term)(implicit ctx: Context): Value - - /** Pattern representing a `_ @ _` binding. */ - type Bind <: Pattern - - def matchPattern_Bind(x: Pattern)(implicit ctx: Context): Option[Bind] - - def Pattern_Bind_name(self: Bind)(implicit ctx: Context): String - - def Pattern_Bind_pattern(self: Bind)(implicit ctx: Context): Pattern - - def Pattern_Bind_module_copy(original: Bind)(name: String, pattern: Pattern)(implicit ctx: Context): Bind - - /** Pattern representing a `Xyz(...)` unapply. */ - type Unapply <: Pattern - - def matchPattern_Unapply(pattern: Pattern)(implicit ctx: Context): Option[Unapply] - - def Pattern_Unapply_fun(self: Unapply)(implicit ctx: Context): Term - - def Pattern_Unapply_implicits(self: Unapply)(implicit ctx: Context): List[Term] - - def Pattern_Unapply_patterns(self: Unapply)(implicit ctx: Context): List[Pattern] - - def Pattern_Unapply_module_copy(original: Unapply)(fun: Term, implicits: List[Term], patterns: List[Pattern])(implicit ctx: Context): Unapply - - /** Pattern representing `X | Y | ...` alternatives. */ - type Alternatives <: Pattern - - def matchPattern_Alternatives(pattern: Pattern)(implicit ctx: Context): Option[Alternatives] - - def Pattern_Alternatives_patterns(self: Alternatives)(implicit ctx: Context): List[Pattern] - - def Pattern_Alternatives_module_apply(patterns: List[Pattern])(implicit ctx: Context): Alternatives - def Pattern_Alternatives_module_copy(original: Alternatives)(patterns: List[Pattern])(implicit ctx: Context): Alternatives - - /** Pattern representing a `x: Y` type test. */ - type TypeTest <: Pattern - - def matchPattern_TypeTest(pattern: Pattern)(implicit ctx: Context): Option[TypeTest] - - def Pattern_TypeTest_tpt(self: TypeTest)(implicit ctx: Context): TypeTree - - def Pattern_TypeTest_module_apply(tpt: TypeTree)(implicit ctx: Context): TypeTest - def Pattern_TypeTest_module_copy(original: TypeTest)(tpt: TypeTree)(implicit ctx: Context): TypeTest - - // - // TYPE TREES - // - /** Type tree representing a type or a bounds written in the source */ - type TypeOrBoundsTree <: AnyRef + type TypeOrBoundsTree <: Tree def TypeOrBoundsTree_tpe(self: TypeOrBoundsTree)(implicit ctx: Context): Type /** Type tree representing a type written in the source */ type TypeTree <: TypeOrBoundsTree - def matchTypeTree(x: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree] + def matchTypeTree(tree: Tree)(implicit ctx: Context): Option[TypeTree] def matchTypeTreeNotTerm(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context): Option[TypeTree] def TypeTree_pos(self: TypeTree)(implicit ctx: Context): Position @@ -628,14 +536,14 @@ trait Kernel { /** Type tree representing an inferred type */ type TypeTree_Inferred <: TypeTree - def matchTypeTree_Inferred(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Inferred] + def matchTypeTree_Inferred(tree: Tree)(implicit ctx: Context): Option[TypeTree_Inferred] def TypeTree_Inferred_apply(tpe: Type)(implicit ctx: Context): TypeTree_Inferred /** Type tree representing a reference to definition with a given name */ type TypeTree_Ident <: TypeTree - def matchTypeTree_Ident(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Ident] + def matchTypeTree_Ident(tree: Tree)(implicit ctx: Context): Option[TypeTree_Ident] def TypeTree_Ident_name(self: TypeTree_Ident)(implicit ctx: Context): String @@ -644,7 +552,7 @@ trait Kernel { /** Type tree representing a selection of definition with a given name on a given term prefix */ type TypeTree_Select <: TypeTree - def matchTypeTree_Select(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Select] + def matchTypeTree_Select(tree: Tree)(implicit ctx: Context): Option[TypeTree_Select] def TypeTree_Select_qualifier(self: TypeTree_Select)(implicit ctx: Context): Term def TypeTree_Select_name(self: TypeTree_Select)(implicit ctx: Context): String @@ -655,7 +563,7 @@ trait Kernel { /** Type tree representing a selection of definition with a given name on a given type prefix */ type TypeTree_Projection <: TypeTree - def matchTypeTree_Projection(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Projection] + def matchTypeTree_Projection(tree: Tree)(implicit ctx: Context): Option[TypeTree_Projection] def TypeTree_Projection_qualifier(self: TypeTree_Projection)(implicit ctx: Context): TypeTree def TypeTree_Projection_name(self: TypeTree_Projection)(implicit ctx: Context): String @@ -665,7 +573,7 @@ trait Kernel { /** Type tree representing a singleton type */ type TypeTree_Singleton <: TypeTree - def matchTypeTree_Singleton(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Singleton] + def matchTypeTree_Singleton(tree: Tree)(implicit ctx: Context): Option[TypeTree_Singleton] def TypeTree_Singleton_ref(self: TypeTree_Singleton)(implicit ctx: Context): Term @@ -675,7 +583,7 @@ trait Kernel { /** Type tree representing a type refinement */ type TypeTree_Refined <: TypeTree - def matchTypeTree_Refined(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Refined] + def matchTypeTree_Refined(tree: Tree)(implicit ctx: Context): Option[TypeTree_Refined] def TypeTree_Refined_tpt(self: TypeTree_Refined)(implicit ctx: Context): TypeTree def TypeTree_Refined_refinements(self: TypeTree_Refined)(implicit ctx: Context): List[Definition] @@ -685,7 +593,7 @@ trait Kernel { /** Type tree representing a type application */ type TypeTree_Applied <: TypeTree - def matchTypeTree_Applied(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Applied] + def matchTypeTree_Applied(tree: Tree)(implicit ctx: Context): Option[TypeTree_Applied] def TypeTree_Applied_tpt(self: TypeTree_Applied)(implicit ctx: Context): TypeTree def TypeTree_Applied_args(self: TypeTree_Applied)(implicit ctx: Context): List[TypeOrBoundsTree] @@ -696,7 +604,7 @@ trait Kernel { /** Type tree representing an annotated type */ type TypeTree_Annotated <: TypeTree - def matchTypeTree_Annotated(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Annotated] + def matchTypeTree_Annotated(tree: Tree)(implicit ctx: Context): Option[TypeTree_Annotated] def TypeTree_Annotated_arg(self: TypeTree_Annotated)(implicit ctx: Context): TypeTree def TypeTree_Annotated_annotation(self: TypeTree_Annotated)(implicit ctx: Context): Term @@ -707,7 +615,7 @@ trait Kernel { /** Type tree representing a type match */ type TypeTree_MatchType <: TypeTree - def matchTypeTree_MatchType(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_MatchType] + def matchTypeTree_MatchType(tree: Tree)(implicit ctx: Context): Option[TypeTree_MatchType] def TypeTree_MatchType_bound(self: TypeTree_MatchType)(implicit ctx: Context): Option[TypeTree] def TypeTree_MatchType_selector(self: TypeTree_MatchType)(implicit ctx: Context): TypeTree @@ -721,7 +629,7 @@ trait Kernel { def TypeTree_ByName_result(self: TypeTree_ByName)(implicit ctx: Context): TypeTree - def matchTypeTree_ByName(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_ByName] + def matchTypeTree_ByName(tree: Tree)(implicit ctx: Context): Option[TypeTree_ByName] def TypeTree_ByName_apply(result: TypeTree)(implicit ctx: Context): TypeTree_ByName def TypeTree_ByName_copy(original: TypeTree_ByName)(result: TypeTree)(implicit ctx: Context): TypeTree_ByName @@ -729,7 +637,7 @@ trait Kernel { /** Type tree representing a lambda abstraction type */ type TypeTree_LambdaTypeTree <: TypeTree - def matchTypeTree_LambdaTypeTree(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_LambdaTypeTree] + def matchTypeTree_LambdaTypeTree(tree: Tree)(implicit ctx: Context): Option[TypeTree_LambdaTypeTree] def TypeTree_LambdaTypeTree_tparams(self: TypeTree_LambdaTypeTree)(implicit ctx: Context): List[TypeDef] def TypeTree_LambdaTypeTree_body(self: TypeTree_LambdaTypeTree)(implicit ctx: Context): TypeOrBoundsTree @@ -740,7 +648,7 @@ trait Kernel { /** Type tree representing a type binding */ type TypeTree_TypeBind <: TypeTree - def matchTypeTree_TypeBind(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_TypeBind] + def matchTypeTree_TypeBind(tree: Tree)(implicit ctx: Context): Option[TypeTree_TypeBind] def TypeTree_TypeBind_name(self: TypeTree_TypeBind)(implicit ctx: Context): String def TypeTree_TypeBind_body(self: TypeTree_TypeBind)(implicit ctx: Context): TypeOrBoundsTree @@ -750,7 +658,7 @@ trait Kernel { /** Type tree within a block with aliases `{ type U1 = ... ; T[U1, U2] }` */ type TypeTree_TypeBlock <: TypeTree - def matchTypeTree_TypeBlock(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_TypeBlock] + def matchTypeTree_TypeBlock(tree: Tree)(implicit ctx: Context): Option[TypeTree_TypeBlock] def TypeTree_TypeBlock_aliases(self: TypeTree_TypeBlock)(implicit ctx: Context): List[TypeDef] def TypeTree_TypeBlock_tpt(self: TypeTree_TypeBlock)(implicit ctx: Context): TypeTree @@ -761,19 +669,107 @@ trait Kernel { /** Type tree representing a type bound written in the source */ type TypeBoundsTree <: TypeOrBoundsTree - def matchTypeBoundsTree(x: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeBoundsTree] + def matchTypeBoundsTree(tree: Tree)(implicit ctx: Context): Option[TypeBoundsTree] def TypeBoundsTree_tpe(self: TypeBoundsTree)(implicit ctx: Context): TypeBounds def TypeBoundsTree_low(self: TypeBoundsTree)(implicit ctx: Context): TypeTree def TypeBoundsTree_hi(self: TypeBoundsTree)(implicit ctx: Context): TypeTree /** Type tree representing wildcard type bounds written in the source. - * The wildcard type `_` (for example in in `List[_]`) will be a type tree that - * represents a type but has `TypeBound`a inside. - */ + * The wildcard type `_` (for example in in `List[_]`) will be a type tree that + * represents a type but has `TypeBound`a inside. + */ type WildcardTypeTree <: TypeOrBoundsTree - def matchWildcardTypeTree(x: TypeOrBoundsTree)(implicit ctx: Context): Option[WildcardTypeTree] + def matchWildcardTypeTree(tree: Tree)(implicit ctx: Context): Option[WildcardTypeTree] + + // + // CASES + // + + /** Branch of a pattern match or catch clause */ + type CaseDef <: AnyRef + + def CaseDef_pattern(self: CaseDef)(implicit ctx: Context): Pattern + def CaseDef_guard(self: CaseDef)(implicit ctx: Context): Option[Term] + def CaseDef_rhs(self: CaseDef)(implicit ctx: Context): Term + + def CaseDef_module_apply(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef + def CaseDef_module_copy(original: CaseDef)(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef + + /** Branch of a type pattern match */ + type TypeCaseDef <: AnyRef + + def TypeCaseDef_pattern(self: TypeCaseDef)(implicit ctx: Context): TypeTree + def TypeCaseDef_rhs(self: TypeCaseDef)(implicit ctx: Context): TypeTree + + def TypeCaseDef_module_apply(pattern: TypeTree, body: TypeTree)(implicit ctx: Context): TypeCaseDef + def TypeCaseDef_module_copy(original: TypeCaseDef)(pattern: TypeTree, body: TypeTree)(implicit ctx: Context): TypeCaseDef + + // + // PATTERNS + // + + /** Pattern tree of the pattern part of a CaseDef */ + type Pattern <: AnyRef + + def Pattern_pos(self: Pattern)(implicit ctx: Context): Position + def Pattern_tpe(self: Pattern)(implicit ctx: Context): Type + def Pattern_symbol(self: Pattern)(implicit ctx: Context): Symbol + + /** Pattern representing a value. This includes `1`, ```x``` and `_` */ + type Value <: Pattern + + def matchPattern_Value(pattern: Pattern): Option[Value] + + def Pattern_Value_value(self: Value)(implicit ctx: Context): Term + + def Pattern_Value_module_apply(term: Term)(implicit ctx: Context): Value + def Pattern_Value_module_copy(original: Value)(term: Term)(implicit ctx: Context): Value + + /** Pattern representing a `_ @ _` binding. */ + type Bind <: Pattern + + def matchPattern_Bind(x: Pattern)(implicit ctx: Context): Option[Bind] + + def Pattern_Bind_name(self: Bind)(implicit ctx: Context): String + + def Pattern_Bind_pattern(self: Bind)(implicit ctx: Context): Pattern + + def Pattern_Bind_module_copy(original: Bind)(name: String, pattern: Pattern)(implicit ctx: Context): Bind + + /** Pattern representing a `Xyz(...)` unapply. */ + type Unapply <: Pattern + + def matchPattern_Unapply(pattern: Pattern)(implicit ctx: Context): Option[Unapply] + + def Pattern_Unapply_fun(self: Unapply)(implicit ctx: Context): Term + + def Pattern_Unapply_implicits(self: Unapply)(implicit ctx: Context): List[Term] + + def Pattern_Unapply_patterns(self: Unapply)(implicit ctx: Context): List[Pattern] + + def Pattern_Unapply_module_copy(original: Unapply)(fun: Term, implicits: List[Term], patterns: List[Pattern])(implicit ctx: Context): Unapply + + /** Pattern representing `X | Y | ...` alternatives. */ + type Alternatives <: Pattern + + def matchPattern_Alternatives(pattern: Pattern)(implicit ctx: Context): Option[Alternatives] + + def Pattern_Alternatives_patterns(self: Alternatives)(implicit ctx: Context): List[Pattern] + + def Pattern_Alternatives_module_apply(patterns: List[Pattern])(implicit ctx: Context): Alternatives + def Pattern_Alternatives_module_copy(original: Alternatives)(patterns: List[Pattern])(implicit ctx: Context): Alternatives + + /** Pattern representing a `x: Y` type test. */ + type TypeTest <: Pattern + + def matchPattern_TypeTest(pattern: Pattern)(implicit ctx: Context): Option[TypeTest] + + def Pattern_TypeTest_tpt(self: TypeTest)(implicit ctx: Context): TypeTree + + def Pattern_TypeTest_module_apply(tpt: TypeTree)(implicit ctx: Context): TypeTest + def Pattern_TypeTest_module_copy(original: TypeTest)(tpt: TypeTree)(implicit ctx: Context): TypeTest // // TYPES diff --git a/library/src/scala/tasty/reflect/Printers.scala b/library/src/scala/tasty/reflect/Printers.scala index 1796e8133122..45475aaa8045 100644 --- a/library/src/scala/tasty/reflect/Printers.scala +++ b/library/src/scala/tasty/reflect/Printers.scala @@ -31,14 +31,6 @@ trait Printers def showCode(implicit ctx: Context): String = new SourceCodePrinter().showTree(tree) } - /** Adds `show` as an extension method of a `TypeOrBoundsTree` */ - implicit class TypeOrBoundsTreeShowDeco(tpt: TypeOrBoundsTree) { - /** Shows the tree as extractors */ - def show(implicit ctx: Context): String = new ExtractorsPrinter().showTypeOrBoundsTree(tpt) - /** Shows the tree as source code */ - def showCode(implicit ctx: Context): String = new SourceCodePrinter().showTypeOrBoundsTree(tpt) - } - /** Adds `show` as an extension method of a `TypeOrBounds` */ implicit class TypeOrBoundsShowDeco(tpe: TypeOrBounds) { /** Shows the tree as extractors */ @@ -95,8 +87,6 @@ trait Printers def showPattern(pattern: Pattern)(implicit ctx: Context): String - def showTypeOrBoundsTree(tpt: TypeOrBoundsTree)(implicit ctx: Context): String - def showTypeOrBounds(tpe: TypeOrBounds)(implicit ctx: Context): String def showConstant(const: Constant)(implicit ctx: Context): String @@ -111,15 +101,13 @@ trait Printers def showTree(tree: Tree)(implicit ctx: Context): String = new Buffer().visitTree(tree).result() + def showCaseDef(caseDef: CaseDef)(implicit ctx: Context): String = new Buffer().visitCaseDef(caseDef).result() def showPattern(pattern: Pattern)(implicit ctx: Context): String = new Buffer().visitPattern(pattern).result() - def showTypeOrBoundsTree(tpt: TypeOrBoundsTree)(implicit ctx: Context): String = - new Buffer().visitTypeTree(tpt).result() - def showTypeOrBounds(tpe: TypeOrBounds)(implicit ctx: Context): String = new Buffer().visitType(tpe).result() @@ -226,7 +214,7 @@ trait Printers this += "ClassDef(\"" += name += "\", " += constr += ", " visitList[TermOrTypeTree](parents, visitTermOrTypeTree) this += ", " - visitList[TypeTree](derived, visitTypeTree) + visitList[TypeTree](derived, visitTree) this += ", " += self += ", " ++= body += ")" case PackageDef(name, owner) => this += "PackageDef(\"" += name += "\", " += owner += ")" @@ -234,9 +222,6 @@ trait Printers this += "Import(" += impliedOnly += ", " += expr += ", " ++= selectors += ")" case PackageClause(pid, stats) => this += "PackageClause(" += pid += ", " ++= stats += ")" - } - - def visitTypeTree(x: TypeOrBoundsTree): Buffer = x match { case TypeTree.Inferred() => this += "TypeTree.Inferred()" case TypeTree.Ident(name) => @@ -422,12 +407,6 @@ trait Printers def +=(x: Constant): Buffer = { visitConstant(x); buff } } - private implicit class TypeTreeOps(buff: Buffer) { - def +=(x: TypeOrBoundsTree): Buffer = { visitTypeTree(x); buff } - def +=(x: Option[TypeOrBoundsTree]): Buffer = { visitOption(x, visitTypeTree); buff } - def ++=(x: List[TypeOrBoundsTree]): Buffer = { visitList(x, visitTypeTree); buff } - } - private implicit class TypeOps(buff: Buffer) { def +=(x: TypeOrBounds): Buffer = { visitType(x); buff } def ++=(x: List[TypeOrBounds]): Buffer = { visitList(x, visitType); buff } @@ -492,9 +471,6 @@ trait Printers def showPattern(pattern: Pattern)(implicit ctx: Context): String = (new Buffer).printPattern(pattern).result() - def showTypeOrBoundsTree(tpt: TypeOrBoundsTree)(implicit ctx: Context): String = - (new Buffer).printTypeOrBoundsTree(tpt).result() - def showTypeOrBounds(tpe: TypeOrBounds)(implicit ctx: Context): String = (new Buffer).printTypeOrBound(tpe).result() @@ -866,7 +842,7 @@ trait Printers // type bounds already printed in `fn` this case _ => - inSquare(printTypeOrBoundsTrees(args, ", ")) + inSquare(printTrees(args, ", ")) } case Term.Super(qual, idOpt) => @@ -961,6 +937,18 @@ trait Printers case Term.Repeated(elems, _) => printTrees(elems, ", ") + case TypeBoundsTree(lo, hi) => + this += "_ >: " + printTypeTree(lo) + this += " <: " + printTypeTree(hi) + + case IsWildcardTypeTree(tpt) => + printTypeOrBound(tpt.tpe) + + case IsTypeTree(tpt) => + printTypeTree(tpt) + case _ => throw new MatchError(tree.show) @@ -1142,19 +1130,6 @@ trait Printers this } - def printTypeOrBoundsTrees(typesTrees: List[TypeOrBoundsTree], sep: String): Buffer = { - def printSeparated(list: List[TypeOrBoundsTree]): Unit = list match { - case Nil => - case x :: Nil => printTypeOrBoundsTree(x) - case x :: xs => - printTypeOrBoundsTree(x) - this += sep - printSeparated(xs) - } - printSeparated(typesTrees) - this - } - def printTypesOrBounds(types: List[TypeOrBounds], sep: String): Buffer = { def printSeparated(list: List[TypeOrBounds]): Unit = list match { case Nil => @@ -1430,7 +1405,7 @@ trait Printers case TypeTree.Applied(tpt, args) => printTypeTree(tpt) - inSquare(printTypeOrBoundsTrees(args, ", ")) + inSquare(printTrees(args, ", ")) case TypeTree.Annotated(tpt, annot) => val Annotation(ref, args) = annot diff --git a/library/src/scala/tasty/reflect/TypeOrBoundsTreeOps.scala b/library/src/scala/tasty/reflect/TypeOrBoundsTreeOps.scala index 7a57529e8728..f3024cac2d93 100644 --- a/library/src/scala/tasty/reflect/TypeOrBoundsTreeOps.scala +++ b/library/src/scala/tasty/reflect/TypeOrBoundsTreeOps.scala @@ -23,7 +23,7 @@ trait TypeOrBoundsTreeOps extends Core { } object IsTypeTree { - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree] = + def unapply(tpt: Tree)(implicit ctx: Context): Option[TypeTree] = kernel.matchTypeTree(tpt) def unapply(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context, dummy: DummyImplicit): Option[TypeTree] = kernel.matchTypeTreeNotTerm(termOrTypeTree) @@ -33,8 +33,8 @@ trait TypeOrBoundsTreeOps extends Core { object IsInferred { /** Matches any Inferred and returns it */ - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[Inferred] = - kernel.matchTypeTree_Inferred(tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[Inferred] = + kernel.matchTypeTree_Inferred(tree) } /** TypeTree containing an inferred type */ @@ -42,28 +42,28 @@ trait TypeOrBoundsTreeOps extends Core { def apply(tpe: Type)(implicit ctx: Context): Inferred = kernel.TypeTree_Inferred_apply(tpe) /** Matches a TypeTree containing an inferred type */ - def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Boolean = - kernel.matchTypeTree_Inferred(typeOrBoundsTree).isDefined + def unapply(tree: Tree)(implicit ctx: Context): Boolean = + kernel.matchTypeTree_Inferred(tree).isDefined } object IsIdent { /** Matches any Ident and returns it */ - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[Ident] = - kernel.matchTypeTree_Ident(tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[Ident] = + kernel.matchTypeTree_Ident(tree) } object Ident { // TODO def apply(name: String)(implicit ctx: Context): Ident def copy(original: Ident)(name: String)(implicit ctx: Context): Ident = kernel.TypeTree_Ident_copy(original)(name) - def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[String] = - kernel.matchTypeTree_Ident(typeOrBoundsTree).map(_.name) + def unapply(tree: Tree)(implicit ctx: Context): Option[String] = + kernel.matchTypeTree_Ident(tree).map(_.name) } object IsSelect { /** Matches any Select and returns it */ - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[Select] = - kernel.matchTypeTree_Select(tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[Select] = + kernel.matchTypeTree_Select(tree) } object Select { @@ -71,28 +71,28 @@ trait TypeOrBoundsTreeOps extends Core { kernel.TypeTree_Select_apply(qualifier, name) def copy(original: Select)(qualifier: Term, name: String)(implicit ctx: Context): Select = kernel.TypeTree_Select_copy(original)(qualifier, name) - def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[(Term, String)] = - kernel.matchTypeTree_Select(typeOrBoundsTree).map(x => (x.qualifier, x.name)) + def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, String)] = + kernel.matchTypeTree_Select(tree).map(x => (x.qualifier, x.name)) } object IsProjection { /** Matches any Projection and returns it */ - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[Projection] = - kernel.matchTypeTree_Projection(tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[Projection] = + kernel.matchTypeTree_Projection(tree) } object Projection { // TODO def apply(qualifier: TypeTree, name: String)(implicit ctx: Context): Project def copy(original: Projection)(qualifier: TypeTree, name: String)(implicit ctx: Context): Projection = kernel.TypeTree_Projection_copy(original)(qualifier, name) - def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[(TypeTree, String)] = - kernel.matchTypeTree_Projection(typeOrBoundsTree).map(x => (x.qualifier, x.name)) + def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, String)] = + kernel.matchTypeTree_Projection(tree).map(x => (x.qualifier, x.name)) } object IsSingleton { /** Matches any Singleton and returns it */ - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[Singleton] = - kernel.matchTypeTree_Singleton(tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[Singleton] = + kernel.matchTypeTree_Singleton(tree) } object Singleton { @@ -100,28 +100,28 @@ trait TypeOrBoundsTreeOps extends Core { kernel.TypeTree_Singleton_apply(ref) def copy(original: Singleton)(ref: Term)(implicit ctx: Context): Singleton = kernel.TypeTree_Singleton_copy(original)(ref) - def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[Term] = - kernel.matchTypeTree_Singleton(typeOrBoundsTree).map(_.ref) + def unapply(tree: Tree)(implicit ctx: Context): Option[Term] = + kernel.matchTypeTree_Singleton(tree).map(_.ref) } object IsRefined { /** Matches any Refined and returns it */ - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[Refined] = - kernel.matchTypeTree_Refined(tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[Refined] = + kernel.matchTypeTree_Refined(tree) } object Refined { // TODO def apply(tpt: TypeTree, refinements: List[Definition])(implicit ctx: Context): Refined def copy(original: Refined)(tpt: TypeTree, refinements: List[Definition])(implicit ctx: Context): Refined = kernel.TypeTree_Refined_copy(original)(tpt, refinements) - def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[(TypeTree, List[Definition])] = - kernel.matchTypeTree_Refined(typeOrBoundsTree).map(x => (x.tpt, x.refinements)) + def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, List[Definition])] = + kernel.matchTypeTree_Refined(tree).map(x => (x.tpt, x.refinements)) } object IsApplied { /** Matches any Applied and returns it */ - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[Applied] = - kernel.matchTypeTree_Applied(tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[Applied] = + kernel.matchTypeTree_Applied(tree) } object Applied { @@ -129,14 +129,14 @@ trait TypeOrBoundsTreeOps extends Core { kernel.TypeTree_Applied_apply(tpt, args) def copy(original: Applied)(tpt: TypeTree, args: List[TypeOrBoundsTree])(implicit ctx: Context): Applied = kernel.TypeTree_Applied_copy(original)(tpt, args) - def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[(TypeTree, List[TypeOrBoundsTree])] = - kernel.matchTypeTree_Applied(typeOrBoundsTree).map(x => (x.tpt, x.args)) + def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, List[TypeOrBoundsTree])] = + kernel.matchTypeTree_Applied(tree).map(x => (x.tpt, x.args)) } object IsAnnotated { /** Matches any Annotated and returns it */ - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[Annotated] = - kernel.matchTypeTree_Annotated(tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[Annotated] = + kernel.matchTypeTree_Annotated(tree) } object Annotated { @@ -144,14 +144,14 @@ trait TypeOrBoundsTreeOps extends Core { kernel.TypeTree_Annotated_apply(arg, annotation) def copy(original: Annotated)(arg: TypeTree, annotation: Term)(implicit ctx: Context): Annotated = kernel.TypeTree_Annotated_copy(original)(arg, annotation) - def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[(TypeTree, Term)] = - kernel.matchTypeTree_Annotated(typeOrBoundsTree).map(x => (x.arg, x.annotation)) + def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, Term)] = + kernel.matchTypeTree_Annotated(tree).map(x => (x.arg, x.annotation)) } object IsMatchType { /** Matches any MatchType and returns it */ - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[MatchType] = - kernel.matchTypeTree_MatchType(tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[MatchType] = + kernel.matchTypeTree_MatchType(tree) } object MatchType { @@ -159,14 +159,14 @@ trait TypeOrBoundsTreeOps extends Core { kernel.TypeTree_MatchType_apply(bound, selector, cases) def copy(original: MatchType)(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef])(implicit ctx: Context): MatchType = kernel.TypeTree_MatchType_copy(original)(bound, selector, cases) - def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[(Option[TypeTree], TypeTree, List[TypeCaseDef])] = - kernel.matchTypeTree_MatchType(typeOrBoundsTree).map(x => (x.bound, x.selector, x.cases)) + def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[TypeTree], TypeTree, List[TypeCaseDef])] = + kernel.matchTypeTree_MatchType(tree).map(x => (x.bound, x.selector, x.cases)) } object IsByName { /** Matches any ByName and returns it */ - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[ByName] = - kernel.matchTypeTree_ByName(tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[ByName] = + kernel.matchTypeTree_ByName(tree) } object ByName { @@ -174,14 +174,14 @@ trait TypeOrBoundsTreeOps extends Core { kernel.TypeTree_ByName_apply(result) def copy(original: ByName)(result: TypeTree)(implicit ctx: Context): ByName = kernel.TypeTree_ByName_copy(original)(result) - def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree] = - kernel.matchTypeTree_ByName(typeOrBoundsTree).map(_.result) + def unapply(tree: Tree)(implicit ctx: Context): Option[TypeTree] = + kernel.matchTypeTree_ByName(tree).map(_.result) } object IsLambdaTypeTree { /** Matches any LambdaTypeTree and returns it */ - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[LambdaTypeTree] = - kernel.matchTypeTree_LambdaTypeTree(tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[LambdaTypeTree] = + kernel.matchTypeTree_LambdaTypeTree(tree) } object LambdaTypeTree { @@ -189,28 +189,28 @@ trait TypeOrBoundsTreeOps extends Core { kernel.TypeTree_LambdaTypeTree_apply(tparams, body) def copy(original: LambdaTypeTree)(tparams: List[TypeDef], body: TypeOrBoundsTree)(implicit ctx: Context): LambdaTypeTree = kernel.TypeTree_LambdaTypeTree_copy(original)(tparams, body) - def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[(List[TypeDef], TypeOrBoundsTree)] = - kernel.matchTypeTree_LambdaTypeTree(typeOrBoundsTree).map(x => (x.tparams, x.body)) + def unapply(tree: Tree)(implicit ctx: Context): Option[(List[TypeDef], TypeOrBoundsTree)] = + kernel.matchTypeTree_LambdaTypeTree(tree).map(x => (x.tparams, x.body)) } object IsTypeBind { /** Matches any TypeBind and returns it */ - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeBind] = - kernel.matchTypeTree_TypeBind(tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBind] = + kernel.matchTypeTree_TypeBind(tree) } object TypeBind { - // TODO def apply(name: String, tpt: TypeOrBoundsTree)(implicit ctx: Context): TypeBind + // TODO def apply(name: String, tree: Tree)(implicit ctx: Context): TypeBind def copy(original: TypeBind)(name: String, tpt: TypeOrBoundsTree)(implicit ctx: Context): TypeBind = kernel.TypeTree_TypeBind_copy(original)(name, tpt) - def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[(String, TypeOrBoundsTree)] = - kernel.matchTypeTree_TypeBind(typeOrBoundsTree).map(x => (x.name, x.body)) + def unapply(tree: Tree)(implicit ctx: Context): Option[(String, TypeOrBoundsTree)] = + kernel.matchTypeTree_TypeBind(tree).map(x => (x.name, x.body)) } object IsTypeBlock { /** Matches any TypeBlock and returns it */ - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeBlock] = - kernel.matchTypeTree_TypeBlock(tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBlock] = + kernel.matchTypeTree_TypeBlock(tree) } object TypeBlock { @@ -218,8 +218,8 @@ trait TypeOrBoundsTreeOps extends Core { kernel.TypeTree_TypeBlock_apply(aliases, tpt) def copy(original: TypeBlock)(aliases: List[TypeDef], tpt: TypeTree)(implicit ctx: Context): TypeBlock = kernel.TypeTree_TypeBlock_copy(original)(aliases, tpt) - def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[(List[TypeDef], TypeTree)] = - kernel.matchTypeTree_TypeBlock(typeOrBoundsTree).map(x => (x.aliases, x.tpt)) + def unapply(tree: Tree)(implicit ctx: Context): Option[(List[TypeDef], TypeTree)] = + kernel.matchTypeTree_TypeBlock(tree).map(x => (x.aliases, x.tpt)) } } @@ -290,25 +290,25 @@ trait TypeOrBoundsTreeOps extends Core { } object IsTypeBoundsTree { - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeBoundsTree] = - kernel.matchTypeBoundsTree(tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBoundsTree] = + kernel.matchTypeBoundsTree(tree) } object TypeBoundsTree { - def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[(TypeTree, TypeTree)] = - kernel.matchTypeBoundsTree(typeOrBoundsTree).map(x => (x.low, x.hi)) + def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, TypeTree)] = + kernel.matchTypeBoundsTree(tree).map(x => (x.low, x.hi)) } object IsWildcardTypeTree { - def unapply(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[WildcardTypeTree] = - kernel.matchWildcardTypeTree(tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[WildcardTypeTree] = + kernel.matchWildcardTypeTree(tree) } /** TypeBoundsTree containing wildcard type bounds */ object WildcardTypeTree { /** Matches a TypeBoundsTree containing wildcard type bounds */ - def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Boolean = - kernel.matchWildcardTypeTree(typeOrBoundsTree).isDefined + def unapply(tree: Tree)(implicit ctx: Context): Boolean = + kernel.matchWildcardTypeTree(tree).isDefined } } From f5bf7fc9c1530eaf0dd622a4157c636800af6e1e Mon Sep 17 00:00:00 2001 From: Nicolas Stucki Date: Sat, 9 Mar 2019 21:21:16 +0100 Subject: [PATCH 04/10] Move TypeOrBoundsTreeOps into TreeOps --- library/src/scala/tasty/Reflection.scala | 1 - .../src/scala/tasty/reflect/Printers.scala | 1 - library/src/scala/tasty/reflect/TreeOps.scala | 309 +++++++++++++++++ .../src/scala/tasty/reflect/TreeUtils.scala | 3 +- .../tasty/reflect/TypeOrBoundsTreeOps.scala | 314 ------------------ tests/run/tasty-custom-show/quoted_1.scala | 1 - 6 files changed, 310 insertions(+), 319 deletions(-) delete mode 100644 library/src/scala/tasty/reflect/TypeOrBoundsTreeOps.scala diff --git a/library/src/scala/tasty/Reflection.scala b/library/src/scala/tasty/Reflection.scala index 6ba6fe08f636..e9cdfc0599de 100644 --- a/library/src/scala/tasty/Reflection.scala +++ b/library/src/scala/tasty/Reflection.scala @@ -23,7 +23,6 @@ abstract class Reflection with SymbolOps with TreeOps with TreeUtils - with TypeOrBoundsTreeOps with TypeOrBoundsOps { self => def typeOf[T: scala.quoted.Type]: Type = diff --git a/library/src/scala/tasty/reflect/Printers.scala b/library/src/scala/tasty/reflect/Printers.scala index 45475aaa8045..2f06e8e368b5 100644 --- a/library/src/scala/tasty/reflect/Printers.scala +++ b/library/src/scala/tasty/reflect/Printers.scala @@ -20,7 +20,6 @@ trait Printers with StandardDefinitions with SymbolOps with TreeOps - with TypeOrBoundsTreeOps with TypeOrBoundsOps { /** Adds `show` as an extension method of a `Tree` */ diff --git a/library/src/scala/tasty/reflect/TreeOps.scala b/library/src/scala/tasty/reflect/TreeOps.scala index d0436d84961a..a6d976497791 100644 --- a/library/src/scala/tasty/reflect/TreeOps.scala +++ b/library/src/scala/tasty/reflect/TreeOps.scala @@ -6,6 +6,7 @@ trait TreeOps extends Core { // Decorators implicit def termAsTermOrTypeTree(term: Term): TermOrTypeTree = term.asInstanceOf[TermOrTypeTree] + implicit def typeTreeAsTermOrTypeTree(term: TypeTree): TermOrTypeTree = term.asInstanceOf[TermOrTypeTree] // ----- Tree ----------------------------------------------------- @@ -741,4 +742,312 @@ trait TreeOps extends Core { def body(implicit ctx: Context): Term = kernel.While_body(self) } + // ----- TypeOrBoundsTree ------------------------------------------------ + + implicit class TypeOrBoundsTreeAPI(self: TypeOrBoundsTree) { + def tpe(implicit ctx: Context): TypeOrBounds = kernel.TypeOrBoundsTree_tpe(self) + } + + // ----- TypeTrees ------------------------------------------------ + + implicit class TypeTreeAPI(self: TypeTree) { + /** Position in the source code */ + def pos(implicit ctx: Context): Position = kernel.TypeTree_pos(self) + + /** Type of this type tree */ + def tpe(implicit ctx: Context): Type = kernel.TypeTree_tpe(self) + + /** Symbol of this type tree */ + def symbol(implicit ctx: Context): Symbol = kernel.TypeTree_symbol(self) + } + + object IsTypeTree { + def unapply(tpt: Tree)(implicit ctx: Context): Option[TypeTree] = + kernel.matchTypeTree(tpt) + def unapply(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context, dummy: DummyImplicit): Option[TypeTree] = + kernel.matchTypeTreeNotTerm(termOrTypeTree) + } + + object TypeTree extends TypeTreeCoreModule { + + object IsInferred { + /** Matches any Inferred and returns it */ + def unapply(tree: Tree)(implicit ctx: Context): Option[Inferred] = + kernel.matchTypeTree_Inferred(tree) + } + + /** TypeTree containing an inferred type */ + object Inferred { + def apply(tpe: Type)(implicit ctx: Context): Inferred = + kernel.TypeTree_Inferred_apply(tpe) + /** Matches a TypeTree containing an inferred type */ + def unapply(tree: Tree)(implicit ctx: Context): Boolean = + kernel.matchTypeTree_Inferred(tree).isDefined + } + + object IsIdent { + /** Matches any Ident and returns it */ + def unapply(tree: Tree)(implicit ctx: Context): Option[Ident] = + kernel.matchTypeTree_Ident(tree) + } + + object Ident { + // TODO def apply(name: String)(implicit ctx: Context): Ident + def copy(original: Ident)(name: String)(implicit ctx: Context): Ident = + kernel.TypeTree_Ident_copy(original)(name) + def unapply(tree: Tree)(implicit ctx: Context): Option[String] = + kernel.matchTypeTree_Ident(tree).map(_.name) + } + + object IsSelect { + /** Matches any Select and returns it */ + def unapply(tree: Tree)(implicit ctx: Context): Option[Select] = + kernel.matchTypeTree_Select(tree) + } + + object Select { + def apply(qualifier: Term, name: String)(implicit ctx: Context): Select = + kernel.TypeTree_Select_apply(qualifier, name) + def copy(original: Select)(qualifier: Term, name: String)(implicit ctx: Context): Select = + kernel.TypeTree_Select_copy(original)(qualifier, name) + def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, String)] = + kernel.matchTypeTree_Select(tree).map(x => (x.qualifier, x.name)) + } + + object IsProjection { + /** Matches any Projection and returns it */ + def unapply(tree: Tree)(implicit ctx: Context): Option[Projection] = + kernel.matchTypeTree_Projection(tree) + } + + object Projection { + // TODO def apply(qualifier: TypeTree, name: String)(implicit ctx: Context): Project + def copy(original: Projection)(qualifier: TypeTree, name: String)(implicit ctx: Context): Projection = + kernel.TypeTree_Projection_copy(original)(qualifier, name) + def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, String)] = + kernel.matchTypeTree_Projection(tree).map(x => (x.qualifier, x.name)) + } + + object IsSingleton { + /** Matches any Singleton and returns it */ + def unapply(tree: Tree)(implicit ctx: Context): Option[Singleton] = + kernel.matchTypeTree_Singleton(tree) + } + + object Singleton { + def apply(ref: Term)(implicit ctx: Context): Singleton = + kernel.TypeTree_Singleton_apply(ref) + def copy(original: Singleton)(ref: Term)(implicit ctx: Context): Singleton = + kernel.TypeTree_Singleton_copy(original)(ref) + def unapply(tree: Tree)(implicit ctx: Context): Option[Term] = + kernel.matchTypeTree_Singleton(tree).map(_.ref) + } + + object IsRefined { + /** Matches any Refined and returns it */ + def unapply(tree: Tree)(implicit ctx: Context): Option[Refined] = + kernel.matchTypeTree_Refined(tree) + } + + object Refined { + // TODO def apply(tpt: TypeTree, refinements: List[Definition])(implicit ctx: Context): Refined + def copy(original: Refined)(tpt: TypeTree, refinements: List[Definition])(implicit ctx: Context): Refined = + kernel.TypeTree_Refined_copy(original)(tpt, refinements) + def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, List[Definition])] = + kernel.matchTypeTree_Refined(tree).map(x => (x.tpt, x.refinements)) + } + + object IsApplied { + /** Matches any Applied and returns it */ + def unapply(tree: Tree)(implicit ctx: Context): Option[Applied] = + kernel.matchTypeTree_Applied(tree) + } + + object Applied { + def apply(tpt: TypeTree, args: List[TypeOrBoundsTree])(implicit ctx: Context): Applied = + kernel.TypeTree_Applied_apply(tpt, args) + def copy(original: Applied)(tpt: TypeTree, args: List[TypeOrBoundsTree])(implicit ctx: Context): Applied = + kernel.TypeTree_Applied_copy(original)(tpt, args) + def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, List[TypeOrBoundsTree])] = + kernel.matchTypeTree_Applied(tree).map(x => (x.tpt, x.args)) + } + + object IsAnnotated { + /** Matches any Annotated and returns it */ + def unapply(tree: Tree)(implicit ctx: Context): Option[Annotated] = + kernel.matchTypeTree_Annotated(tree) + } + + object Annotated { + def apply(arg: TypeTree, annotation: Term)(implicit ctx: Context): Annotated = + kernel.TypeTree_Annotated_apply(arg, annotation) + def copy(original: Annotated)(arg: TypeTree, annotation: Term)(implicit ctx: Context): Annotated = + kernel.TypeTree_Annotated_copy(original)(arg, annotation) + def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, Term)] = + kernel.matchTypeTree_Annotated(tree).map(x => (x.arg, x.annotation)) + } + + object IsMatchType { + /** Matches any MatchType and returns it */ + def unapply(tree: Tree)(implicit ctx: Context): Option[MatchType] = + kernel.matchTypeTree_MatchType(tree) + } + + object MatchType { + def apply(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef])(implicit ctx: Context): MatchType = + kernel.TypeTree_MatchType_apply(bound, selector, cases) + def copy(original: MatchType)(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef])(implicit ctx: Context): MatchType = + kernel.TypeTree_MatchType_copy(original)(bound, selector, cases) + def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[TypeTree], TypeTree, List[TypeCaseDef])] = + kernel.matchTypeTree_MatchType(tree).map(x => (x.bound, x.selector, x.cases)) + } + + object IsByName { + /** Matches any ByName and returns it */ + def unapply(tree: Tree)(implicit ctx: Context): Option[ByName] = + kernel.matchTypeTree_ByName(tree) + } + + object ByName { + def apply(result: TypeTree)(implicit ctx: Context): ByName = + kernel.TypeTree_ByName_apply(result) + def copy(original: ByName)(result: TypeTree)(implicit ctx: Context): ByName = + kernel.TypeTree_ByName_copy(original)(result) + def unapply(tree: Tree)(implicit ctx: Context): Option[TypeTree] = + kernel.matchTypeTree_ByName(tree).map(_.result) + } + + object IsLambdaTypeTree { + /** Matches any LambdaTypeTree and returns it */ + def unapply(tree: Tree)(implicit ctx: Context): Option[LambdaTypeTree] = + kernel.matchTypeTree_LambdaTypeTree(tree) + } + + object LambdaTypeTree { + def apply(tparams: List[TypeDef], body: TypeOrBoundsTree)(implicit ctx: Context): LambdaTypeTree = + kernel.TypeTree_LambdaTypeTree_apply(tparams, body) + def copy(original: LambdaTypeTree)(tparams: List[TypeDef], body: TypeOrBoundsTree)(implicit ctx: Context): LambdaTypeTree = + kernel.TypeTree_LambdaTypeTree_copy(original)(tparams, body) + def unapply(tree: Tree)(implicit ctx: Context): Option[(List[TypeDef], TypeOrBoundsTree)] = + kernel.matchTypeTree_LambdaTypeTree(tree).map(x => (x.tparams, x.body)) + } + + object IsTypeBind { + /** Matches any TypeBind and returns it */ + def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBind] = + kernel.matchTypeTree_TypeBind(tree) + } + + object TypeBind { + // TODO def apply(name: String, tree: Tree)(implicit ctx: Context): TypeBind + def copy(original: TypeBind)(name: String, tpt: TypeOrBoundsTree)(implicit ctx: Context): TypeBind = + kernel.TypeTree_TypeBind_copy(original)(name, tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[(String, TypeOrBoundsTree)] = + kernel.matchTypeTree_TypeBind(tree).map(x => (x.name, x.body)) + } + + object IsTypeBlock { + /** Matches any TypeBlock and returns it */ + def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBlock] = + kernel.matchTypeTree_TypeBlock(tree) + } + + object TypeBlock { + def apply(aliases: List[TypeDef], tpt: TypeTree)(implicit ctx: Context): TypeBlock = + kernel.TypeTree_TypeBlock_apply(aliases, tpt) + def copy(original: TypeBlock)(aliases: List[TypeDef], tpt: TypeTree)(implicit ctx: Context): TypeBlock = + kernel.TypeTree_TypeBlock_copy(original)(aliases, tpt) + def unapply(tree: Tree)(implicit ctx: Context): Option[(List[TypeDef], TypeTree)] = + kernel.matchTypeTree_TypeBlock(tree).map(x => (x.aliases, x.tpt)) + } + } + + implicit class TypeTree_IdentAPI(self: TypeTree.Ident) { + def name(implicit ctx: Context): String = kernel.TypeTree_Ident_name(self) + } + + implicit class TypeTree_SelectAPI(self: TypeTree.Select) { + def qualifier(implicit ctx: Context): Term = kernel.TypeTree_Select_qualifier(self) + def name(implicit ctx: Context): String = kernel.TypeTree_Select_name(self) + } + + implicit class TypeTree_ProjectionAPI(self: TypeTree.Projection) { + def qualifier(implicit ctx: Context): TypeTree = kernel.TypeTree_Projection_qualifier(self) + def name(implicit ctx: Context): String = kernel.TypeTree_Projection_name(self) + } + + implicit class TypeTree_SingletonAPI(self: TypeTree.Singleton) { + def ref(implicit ctx: Context): Term = kernel.TypeTree_Singleton_ref(self) + } + + implicit class TypeTree_RefinedAPI(self: TypeTree.Refined) { + def tpt(implicit ctx: Context): TypeTree = kernel.TypeTree_Refined_tpt(self) + def refinements(implicit ctx: Context): List[Definition] = kernel.TypeTree_Refined_refinements(self) + } + + implicit class TypeTree_AppliedAPI(self: TypeTree.Applied) { + def tpt(implicit ctx: Context): TypeTree = kernel.TypeTree_Applied_tpt(self) + def args(implicit ctx: Context): List[TypeOrBoundsTree] = kernel.TypeTree_Applied_args(self) + } + + implicit class TypeTree_AnnotatedAPI(self: TypeTree.Annotated) { + def arg(implicit ctx: Context): TypeTree = kernel.TypeTree_Annotated_arg(self) + def annotation(implicit ctx: Context): Term = kernel.TypeTree_Annotated_annotation(self) + } + + implicit class TypeTree_MatchTypeAPI(self: TypeTree.MatchType) { + def bound(implicit ctx: Context): Option[TypeTree] = kernel.TypeTree_MatchType_bound(self) + def selector(implicit ctx: Context): TypeTree = kernel.TypeTree_MatchType_selector(self) + def cases(implicit ctx: Context): List[TypeCaseDef] = kernel.TypeTree_MatchType_cases(self) + } + + implicit class TypeTree_ByNameAPI(self: TypeTree.ByName) { + def result(implicit ctx: Context): TypeTree = kernel.TypeTree_ByName_result(self) + } + + implicit class TypeTree_LambdaTypeTreeAPI(self: TypeTree.LambdaTypeTree) { + def tparams(implicit ctx: Context): List[TypeDef] = kernel.TypeTree_LambdaTypeTree_tparams(self) + def body(implicit ctx: Context): TypeOrBoundsTree = kernel.TypeTree_LambdaTypeTree_body(self) + } + + implicit class TypeTree_TypeBindAPI(self: TypeTree.TypeBind) { + def name(implicit ctx: Context): String = kernel.TypeTree_TypeBind_name(self) + def body(implicit ctx: Context): TypeOrBoundsTree = kernel.TypeTree_TypeBind_body(self) + } + + implicit class TypeTree_TypeBlockAPI(self: TypeTree.TypeBlock) { + def aliases(implicit ctx: Context): List[TypeDef] = kernel.TypeTree_TypeBlock_aliases(self) + def tpt(implicit ctx: Context): TypeTree = kernel.TypeTree_TypeBlock_tpt(self) + } + + // ----- TypeBoundsTrees ------------------------------------------------ + + implicit class TypeBoundsTreeAPI(self: TypeBoundsTree) { + def tpe(implicit ctx: Context): TypeBounds = kernel.TypeBoundsTree_tpe(self) + def low(implicit ctx: Context): TypeTree = kernel.TypeBoundsTree_low(self) + def hi(implicit ctx: Context): TypeTree = kernel.TypeBoundsTree_hi(self) + } + + object IsTypeBoundsTree { + def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBoundsTree] = + kernel.matchTypeBoundsTree(tree) + } + + object TypeBoundsTree { + def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, TypeTree)] = + kernel.matchTypeBoundsTree(tree).map(x => (x.low, x.hi)) + } + + object IsWildcardTypeTree { + def unapply(tree: Tree)(implicit ctx: Context): Option[WildcardTypeTree] = + kernel.matchWildcardTypeTree(tree) + } + + /** TypeBoundsTree containing wildcard type bounds */ + object WildcardTypeTree { + /** Matches a TypeBoundsTree containing wildcard type bounds */ + def unapply(tree: Tree)(implicit ctx: Context): Boolean = + kernel.matchWildcardTypeTree(tree).isDefined + } + } diff --git a/library/src/scala/tasty/reflect/TreeUtils.scala b/library/src/scala/tasty/reflect/TreeUtils.scala index 3463c8da8d51..fc0e2444657b 100644 --- a/library/src/scala/tasty/reflect/TreeUtils.scala +++ b/library/src/scala/tasty/reflect/TreeUtils.scala @@ -7,8 +7,7 @@ trait TreeUtils with CaseDefOps with PatternOps with SymbolOps - with TreeOps - with TypeOrBoundsTreeOps { + with TreeOps { abstract class TreeAccumulator[X] { diff --git a/library/src/scala/tasty/reflect/TypeOrBoundsTreeOps.scala b/library/src/scala/tasty/reflect/TypeOrBoundsTreeOps.scala deleted file mode 100644 index f3024cac2d93..000000000000 --- a/library/src/scala/tasty/reflect/TypeOrBoundsTreeOps.scala +++ /dev/null @@ -1,314 +0,0 @@ -package scala.tasty -package reflect - -trait TypeOrBoundsTreeOps extends Core { - - implicit def typeTreeAsParent(term: TypeTree): TermOrTypeTree = term.asInstanceOf[TermOrTypeTree] - - implicit class TypeOrBoundsTreeAPI(self: TypeOrBoundsTree) { - def tpe(implicit ctx: Context): TypeOrBounds = kernel.TypeOrBoundsTree_tpe(self) - } - - // ----- TypeTrees ------------------------------------------------ - - implicit class TypeTreeAPI(self: TypeTree) { - /** Position in the source code */ - def pos(implicit ctx: Context): Position = kernel.TypeTree_pos(self) - - /** Type of this type tree */ - def tpe(implicit ctx: Context): Type = kernel.TypeTree_tpe(self) - - /** Symbol of this type tree */ - def symbol(implicit ctx: Context): Symbol = kernel.TypeTree_symbol(self) - } - - object IsTypeTree { - def unapply(tpt: Tree)(implicit ctx: Context): Option[TypeTree] = - kernel.matchTypeTree(tpt) - def unapply(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context, dummy: DummyImplicit): Option[TypeTree] = - kernel.matchTypeTreeNotTerm(termOrTypeTree) - } - - object TypeTree extends TypeTreeCoreModule { - - object IsInferred { - /** Matches any Inferred and returns it */ - def unapply(tree: Tree)(implicit ctx: Context): Option[Inferred] = - kernel.matchTypeTree_Inferred(tree) - } - - /** TypeTree containing an inferred type */ - object Inferred { - def apply(tpe: Type)(implicit ctx: Context): Inferred = - kernel.TypeTree_Inferred_apply(tpe) - /** Matches a TypeTree containing an inferred type */ - def unapply(tree: Tree)(implicit ctx: Context): Boolean = - kernel.matchTypeTree_Inferred(tree).isDefined - } - - object IsIdent { - /** Matches any Ident and returns it */ - def unapply(tree: Tree)(implicit ctx: Context): Option[Ident] = - kernel.matchTypeTree_Ident(tree) - } - - object Ident { - // TODO def apply(name: String)(implicit ctx: Context): Ident - def copy(original: Ident)(name: String)(implicit ctx: Context): Ident = - kernel.TypeTree_Ident_copy(original)(name) - def unapply(tree: Tree)(implicit ctx: Context): Option[String] = - kernel.matchTypeTree_Ident(tree).map(_.name) - } - - object IsSelect { - /** Matches any Select and returns it */ - def unapply(tree: Tree)(implicit ctx: Context): Option[Select] = - kernel.matchTypeTree_Select(tree) - } - - object Select { - def apply(qualifier: Term, name: String)(implicit ctx: Context): Select = - kernel.TypeTree_Select_apply(qualifier, name) - def copy(original: Select)(qualifier: Term, name: String)(implicit ctx: Context): Select = - kernel.TypeTree_Select_copy(original)(qualifier, name) - def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, String)] = - kernel.matchTypeTree_Select(tree).map(x => (x.qualifier, x.name)) - } - - object IsProjection { - /** Matches any Projection and returns it */ - def unapply(tree: Tree)(implicit ctx: Context): Option[Projection] = - kernel.matchTypeTree_Projection(tree) - } - - object Projection { - // TODO def apply(qualifier: TypeTree, name: String)(implicit ctx: Context): Project - def copy(original: Projection)(qualifier: TypeTree, name: String)(implicit ctx: Context): Projection = - kernel.TypeTree_Projection_copy(original)(qualifier, name) - def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, String)] = - kernel.matchTypeTree_Projection(tree).map(x => (x.qualifier, x.name)) - } - - object IsSingleton { - /** Matches any Singleton and returns it */ - def unapply(tree: Tree)(implicit ctx: Context): Option[Singleton] = - kernel.matchTypeTree_Singleton(tree) - } - - object Singleton { - def apply(ref: Term)(implicit ctx: Context): Singleton = - kernel.TypeTree_Singleton_apply(ref) - def copy(original: Singleton)(ref: Term)(implicit ctx: Context): Singleton = - kernel.TypeTree_Singleton_copy(original)(ref) - def unapply(tree: Tree)(implicit ctx: Context): Option[Term] = - kernel.matchTypeTree_Singleton(tree).map(_.ref) - } - - object IsRefined { - /** Matches any Refined and returns it */ - def unapply(tree: Tree)(implicit ctx: Context): Option[Refined] = - kernel.matchTypeTree_Refined(tree) - } - - object Refined { - // TODO def apply(tpt: TypeTree, refinements: List[Definition])(implicit ctx: Context): Refined - def copy(original: Refined)(tpt: TypeTree, refinements: List[Definition])(implicit ctx: Context): Refined = - kernel.TypeTree_Refined_copy(original)(tpt, refinements) - def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, List[Definition])] = - kernel.matchTypeTree_Refined(tree).map(x => (x.tpt, x.refinements)) - } - - object IsApplied { - /** Matches any Applied and returns it */ - def unapply(tree: Tree)(implicit ctx: Context): Option[Applied] = - kernel.matchTypeTree_Applied(tree) - } - - object Applied { - def apply(tpt: TypeTree, args: List[TypeOrBoundsTree])(implicit ctx: Context): Applied = - kernel.TypeTree_Applied_apply(tpt, args) - def copy(original: Applied)(tpt: TypeTree, args: List[TypeOrBoundsTree])(implicit ctx: Context): Applied = - kernel.TypeTree_Applied_copy(original)(tpt, args) - def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, List[TypeOrBoundsTree])] = - kernel.matchTypeTree_Applied(tree).map(x => (x.tpt, x.args)) - } - - object IsAnnotated { - /** Matches any Annotated and returns it */ - def unapply(tree: Tree)(implicit ctx: Context): Option[Annotated] = - kernel.matchTypeTree_Annotated(tree) - } - - object Annotated { - def apply(arg: TypeTree, annotation: Term)(implicit ctx: Context): Annotated = - kernel.TypeTree_Annotated_apply(arg, annotation) - def copy(original: Annotated)(arg: TypeTree, annotation: Term)(implicit ctx: Context): Annotated = - kernel.TypeTree_Annotated_copy(original)(arg, annotation) - def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, Term)] = - kernel.matchTypeTree_Annotated(tree).map(x => (x.arg, x.annotation)) - } - - object IsMatchType { - /** Matches any MatchType and returns it */ - def unapply(tree: Tree)(implicit ctx: Context): Option[MatchType] = - kernel.matchTypeTree_MatchType(tree) - } - - object MatchType { - def apply(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef])(implicit ctx: Context): MatchType = - kernel.TypeTree_MatchType_apply(bound, selector, cases) - def copy(original: MatchType)(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef])(implicit ctx: Context): MatchType = - kernel.TypeTree_MatchType_copy(original)(bound, selector, cases) - def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[TypeTree], TypeTree, List[TypeCaseDef])] = - kernel.matchTypeTree_MatchType(tree).map(x => (x.bound, x.selector, x.cases)) - } - - object IsByName { - /** Matches any ByName and returns it */ - def unapply(tree: Tree)(implicit ctx: Context): Option[ByName] = - kernel.matchTypeTree_ByName(tree) - } - - object ByName { - def apply(result: TypeTree)(implicit ctx: Context): ByName = - kernel.TypeTree_ByName_apply(result) - def copy(original: ByName)(result: TypeTree)(implicit ctx: Context): ByName = - kernel.TypeTree_ByName_copy(original)(result) - def unapply(tree: Tree)(implicit ctx: Context): Option[TypeTree] = - kernel.matchTypeTree_ByName(tree).map(_.result) - } - - object IsLambdaTypeTree { - /** Matches any LambdaTypeTree and returns it */ - def unapply(tree: Tree)(implicit ctx: Context): Option[LambdaTypeTree] = - kernel.matchTypeTree_LambdaTypeTree(tree) - } - - object LambdaTypeTree { - def apply(tparams: List[TypeDef], body: TypeOrBoundsTree)(implicit ctx: Context): LambdaTypeTree = - kernel.TypeTree_LambdaTypeTree_apply(tparams, body) - def copy(original: LambdaTypeTree)(tparams: List[TypeDef], body: TypeOrBoundsTree)(implicit ctx: Context): LambdaTypeTree = - kernel.TypeTree_LambdaTypeTree_copy(original)(tparams, body) - def unapply(tree: Tree)(implicit ctx: Context): Option[(List[TypeDef], TypeOrBoundsTree)] = - kernel.matchTypeTree_LambdaTypeTree(tree).map(x => (x.tparams, x.body)) - } - - object IsTypeBind { - /** Matches any TypeBind and returns it */ - def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBind] = - kernel.matchTypeTree_TypeBind(tree) - } - - object TypeBind { - // TODO def apply(name: String, tree: Tree)(implicit ctx: Context): TypeBind - def copy(original: TypeBind)(name: String, tpt: TypeOrBoundsTree)(implicit ctx: Context): TypeBind = - kernel.TypeTree_TypeBind_copy(original)(name, tpt) - def unapply(tree: Tree)(implicit ctx: Context): Option[(String, TypeOrBoundsTree)] = - kernel.matchTypeTree_TypeBind(tree).map(x => (x.name, x.body)) - } - - object IsTypeBlock { - /** Matches any TypeBlock and returns it */ - def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBlock] = - kernel.matchTypeTree_TypeBlock(tree) - } - - object TypeBlock { - def apply(aliases: List[TypeDef], tpt: TypeTree)(implicit ctx: Context): TypeBlock = - kernel.TypeTree_TypeBlock_apply(aliases, tpt) - def copy(original: TypeBlock)(aliases: List[TypeDef], tpt: TypeTree)(implicit ctx: Context): TypeBlock = - kernel.TypeTree_TypeBlock_copy(original)(aliases, tpt) - def unapply(tree: Tree)(implicit ctx: Context): Option[(List[TypeDef], TypeTree)] = - kernel.matchTypeTree_TypeBlock(tree).map(x => (x.aliases, x.tpt)) - } - } - - implicit class TypeTree_IdentAPI(self: TypeTree.Ident) { - def name(implicit ctx: Context): String = kernel.TypeTree_Ident_name(self) - } - - implicit class TypeTree_SelectAPI(self: TypeTree.Select) { - def qualifier(implicit ctx: Context): Term = kernel.TypeTree_Select_qualifier(self) - def name(implicit ctx: Context): String = kernel.TypeTree_Select_name(self) - } - - implicit class TypeTree_ProjectionAPI(self: TypeTree.Projection) { - def qualifier(implicit ctx: Context): TypeTree = kernel.TypeTree_Projection_qualifier(self) - def name(implicit ctx: Context): String = kernel.TypeTree_Projection_name(self) - } - - implicit class TypeTree_SingletonAPI(self: TypeTree.Singleton) { - def ref(implicit ctx: Context): Term = kernel.TypeTree_Singleton_ref(self) - } - - implicit class TypeTree_RefinedAPI(self: TypeTree.Refined) { - def tpt(implicit ctx: Context): TypeTree = kernel.TypeTree_Refined_tpt(self) - def refinements(implicit ctx: Context): List[Definition] = kernel.TypeTree_Refined_refinements(self) - } - - implicit class TypeTree_AppliedAPI(self: TypeTree.Applied) { - def tpt(implicit ctx: Context): TypeTree = kernel.TypeTree_Applied_tpt(self) - def args(implicit ctx: Context): List[TypeOrBoundsTree] = kernel.TypeTree_Applied_args(self) - } - - implicit class TypeTree_AnnotatedAPI(self: TypeTree.Annotated) { - def arg(implicit ctx: Context): TypeTree = kernel.TypeTree_Annotated_arg(self) - def annotation(implicit ctx: Context): Term = kernel.TypeTree_Annotated_annotation(self) - } - - implicit class TypeTree_MatchTypeAPI(self: TypeTree.MatchType) { - def bound(implicit ctx: Context): Option[TypeTree] = kernel.TypeTree_MatchType_bound(self) - def selector(implicit ctx: Context): TypeTree = kernel.TypeTree_MatchType_selector(self) - def cases(implicit ctx: Context): List[TypeCaseDef] = kernel.TypeTree_MatchType_cases(self) - } - - implicit class TypeTree_ByNameAPI(self: TypeTree.ByName) { - def result(implicit ctx: Context): TypeTree = kernel.TypeTree_ByName_result(self) - } - - implicit class TypeTree_LambdaTypeTreeAPI(self: TypeTree.LambdaTypeTree) { - def tparams(implicit ctx: Context): List[TypeDef] = kernel.TypeTree_LambdaTypeTree_tparams(self) - def body(implicit ctx: Context): TypeOrBoundsTree = kernel.TypeTree_LambdaTypeTree_body(self) - } - - implicit class TypeTree_TypeBindAPI(self: TypeTree.TypeBind) { - def name(implicit ctx: Context): String = kernel.TypeTree_TypeBind_name(self) - def body(implicit ctx: Context): TypeOrBoundsTree = kernel.TypeTree_TypeBind_body(self) - } - - implicit class TypeTree_TypeBlockAPI(self: TypeTree.TypeBlock) { - def aliases(implicit ctx: Context): List[TypeDef] = kernel.TypeTree_TypeBlock_aliases(self) - def tpt(implicit ctx: Context): TypeTree = kernel.TypeTree_TypeBlock_tpt(self) - } - - // ----- TypeBoundsTrees ------------------------------------------------ - - implicit class TypeBoundsTreeAPI(self: TypeBoundsTree) { - def tpe(implicit ctx: Context): TypeBounds = kernel.TypeBoundsTree_tpe(self) - def low(implicit ctx: Context): TypeTree = kernel.TypeBoundsTree_low(self) - def hi(implicit ctx: Context): TypeTree = kernel.TypeBoundsTree_hi(self) - } - - object IsTypeBoundsTree { - def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBoundsTree] = - kernel.matchTypeBoundsTree(tree) - } - - object TypeBoundsTree { - def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, TypeTree)] = - kernel.matchTypeBoundsTree(tree).map(x => (x.low, x.hi)) - } - - object IsWildcardTypeTree { - def unapply(tree: Tree)(implicit ctx: Context): Option[WildcardTypeTree] = - kernel.matchWildcardTypeTree(tree) - } - - /** TypeBoundsTree containing wildcard type bounds */ - object WildcardTypeTree { - /** Matches a TypeBoundsTree containing wildcard type bounds */ - def unapply(tree: Tree)(implicit ctx: Context): Boolean = - kernel.matchWildcardTypeTree(tree).isDefined - } - -} diff --git a/tests/run/tasty-custom-show/quoted_1.scala b/tests/run/tasty-custom-show/quoted_1.scala index 0011dbc9f5bd..2b9fb7d08156 100644 --- a/tests/run/tasty-custom-show/quoted_1.scala +++ b/tests/run/tasty-custom-show/quoted_1.scala @@ -44,7 +44,6 @@ object Macros { def showTree(tree: Tree)(implicit ctx: Context): String = "Tree" def showCaseDef(caseDef: CaseDef)(implicit ctx: Context): String = "CaseDef" def showPattern(pattern: Pattern)(implicit ctx: Context): String = "Pattern" - def showTypeOrBoundsTree(tpt: TypeOrBoundsTree)(implicit ctx: Context): String = "TypeOrBoundsTree" def showTypeOrBounds(tpe: TypeOrBounds)(implicit ctx: Context): String = "TypeOrBounds" def showConstant(const: Constant)(implicit ctx: Context): String = "Constant" def showSymbol(symbol: Symbol)(implicit ctx: Context): String = "Symbol" From fb5f46eb03c5a97cd5a9d21f44386eaa18bd55a8 Mon Sep 17 00:00:00 2001 From: Nicolas Stucki Date: Sat, 9 Mar 2019 21:46:45 +0100 Subject: [PATCH 05/10] Simplify TreeUtils --- .../src/scala/tasty/reflect/TreeUtils.scala | 68 +++++++++---------- .../dotty/semanticdb/SemanticdbConsumer.scala | 23 ++++--- tests/run/tasty-extractors-3/quoted_1.scala | 15 ++-- 3 files changed, 57 insertions(+), 49 deletions(-) diff --git a/library/src/scala/tasty/reflect/TreeUtils.scala b/library/src/scala/tasty/reflect/TreeUtils.scala index fc0e2444657b..4430d0784a69 100644 --- a/library/src/scala/tasty/reflect/TreeUtils.scala +++ b/library/src/scala/tasty/reflect/TreeUtils.scala @@ -13,13 +13,11 @@ trait TreeUtils // Ties the knot of the traversal: call `foldOver(x, tree))` to dive in the `tree` node. def foldTree(x: X, tree: Tree)(implicit ctx: Context): X - def foldTypeTree(x: X, tree: TypeOrBoundsTree)(implicit ctx: Context): X def foldCaseDef(x: X, tree: CaseDef)(implicit ctx: Context): X def foldTypeCaseDef(x: X, tree: TypeCaseDef)(implicit ctx: Context): X def foldPattern(x: X, tree: Pattern)(implicit ctx: Context): X def foldTrees(x: X, trees: Iterable[Tree])(implicit ctx: Context): X = (x /: trees)(foldTree) - def foldTypeTrees(x: X, trees: Iterable[TypeOrBoundsTree])(implicit ctx: Context): X = (x /: trees)(foldTypeTree) def foldCaseDefs(x: X, trees: Iterable[CaseDef])(implicit ctx: Context): X = (x /: trees)(foldCaseDef) def foldTypeCaseDefs(x: X, trees: Iterable[TypeCaseDef])(implicit ctx: Context): X = (x /: trees)(foldTypeCaseDef) def foldPatterns(x: X, trees: Iterable[Pattern])(implicit ctx: Context): X = (x /: trees)(foldPattern) @@ -39,13 +37,13 @@ trait TreeUtils case Term.Apply(fun, args) => foldTrees(foldTree(x, fun), args) case Term.TypeApply(fun, args) => - foldTypeTrees(foldTree(x, fun), args) + foldTrees(foldTree(x, fun), args) case Term.Literal(const) => x case Term.New(tpt) => - foldTypeTree(x, tpt) + foldTree(x, tpt) case Term.Typed(expr, tpt) => - foldTypeTree(foldTree(x, expr), tpt) + foldTree(foldTree(x, expr), tpt) case Term.NamedArg(_, arg) => foldTree(x, arg) case Term.Assign(lhs, rhs) => @@ -56,7 +54,7 @@ trait TreeUtils foldTree(foldTree(foldTree(x, cond), thenp), elsep) case Term.Lambda(meth, tpt) => val a = foldTree(x, meth) - tpt.fold(a)(b => foldTypeTree(a, b)) + tpt.fold(a)(b => foldTree(a, b)) case Term.Match(selector, cases) => foldCaseDefs(foldTree(x, selector), cases) case Term.Return(expr) => @@ -64,53 +62,50 @@ trait TreeUtils case Term.Try(block, handler, finalizer) => foldTrees(foldCaseDefs(foldTree(x, block), handler), finalizer) case Term.Repeated(elems, elemtpt) => - foldTrees(foldTypeTree(x, elemtpt), elems) + foldTrees(foldTree(x, elemtpt), elems) case Term.Inlined(call, bindings, expansion) => foldTree(foldTrees(x, bindings), expansion) case IsDefinition(vdef @ ValDef(_, tpt, rhs)) => implicit val ctx = localCtx(vdef) - foldTrees(foldTypeTree(x, tpt), rhs) + foldTrees(foldTree(x, tpt), rhs) case IsDefinition(ddef @ DefDef(_, tparams, vparamss, tpt, rhs)) => implicit val ctx = localCtx(ddef) - foldTrees(foldTypeTree((foldTrees(x, tparams) /: vparamss)(foldTrees), tpt), rhs) + foldTrees(foldTree((foldTrees(x, tparams) /: vparamss)(foldTrees), tpt), rhs) case IsDefinition(tdef @ TypeDef(_, rhs)) => implicit val ctx = localCtx(tdef) - foldTypeTree(x, rhs) + foldTree(x, rhs) case IsDefinition(cdef @ ClassDef(_, constr, parents, derived, self, body)) => implicit val ctx = localCtx(cdef) - foldTrees(foldTrees(foldTypeTrees(foldParents(foldTree(x, constr), parents), derived), self), body) + foldTrees(foldTrees(foldTrees(foldParents(foldTree(x, constr), parents), derived), self), body) case Import(_, expr, _) => foldTree(x, expr) case IsPackageClause(clause @ PackageClause(pid, stats)) => foldTrees(foldTree(x, pid), stats)(clause.symbol.localContext) + case TypeTree.Inferred() => x + case TypeTree.Ident(_) => x + case TypeTree.Select(qualifier, _) => foldTree(x, qualifier) + case TypeTree.Projection(qualifier, _) => foldTree(x, qualifier) + case TypeTree.Singleton(ref) => foldTree(x, ref) + case TypeTree.Refined(tpt, refinements) => foldTrees(foldTree(x, tpt), refinements) + case TypeTree.Applied(tpt, args) => foldTrees(foldTree(x, tpt), args) + case TypeTree.ByName(result) => foldTree(x, result) + case TypeTree.Annotated(arg, annot) => foldTree(foldTree(x, arg), annot) + case TypeTree.LambdaTypeTree(typedefs, arg) => foldTree(foldTrees(x, typedefs), arg) + case TypeTree.TypeBind(_, tbt) => foldTree(x, tbt) + case TypeTree.TypeBlock(typedefs, tpt) => foldTree(foldTrees(x, typedefs), tpt) + case TypeTree.MatchType(boundopt, selector, cases) => + foldTypeCaseDefs(foldTree(boundopt.fold(x)(foldTree(x, _)), selector), cases) + case WildcardTypeTree() => x + case TypeBoundsTree(lo, hi) => foldTree(foldTree(x, lo), hi) } } - def foldOverTypeTree(x: X, tree: TypeOrBoundsTree)(implicit ctx: Context): X = tree match { - case TypeTree.Inferred() => x - case TypeTree.Ident(_) => x - case TypeTree.Select(qualifier, _) => foldTree(x, qualifier) - case TypeTree.Projection(qualifier, _) => foldTypeTree(x, qualifier) - case TypeTree.Singleton(ref) => foldTree(x, ref) - case TypeTree.Refined(tpt, refinements) => foldTrees(foldTypeTree(x, tpt), refinements) - case TypeTree.Applied(tpt, args) => foldTypeTrees(foldTypeTree(x, tpt), args) - case TypeTree.ByName(result) => foldTypeTree(x, result) - case TypeTree.Annotated(arg, annot) => foldTree(foldTypeTree(x, arg), annot) - case TypeTree.LambdaTypeTree(typedefs, arg) => foldTypeTree(foldTrees(x, typedefs), arg) - case TypeTree.TypeBind(_, tbt) => foldTypeTree(x, tbt) - case TypeTree.TypeBlock(typedefs, tpt) => foldTypeTree(foldTrees(x, typedefs), tpt) - case TypeTree.MatchType(boundopt, selector, cases) => - foldTypeCaseDefs(foldTypeTree(boundopt.fold(x)(foldTypeTree(x, _)), selector), cases) - case WildcardTypeTree() => x - case TypeBoundsTree(lo, hi) => foldTypeTree(foldTypeTree(x, lo), hi) - } - def foldOverCaseDef(x: X, tree: CaseDef)(implicit ctx: Context): X = tree match { case CaseDef(pat, guard, body) => foldTree(foldTrees(foldPattern(x, pat), guard), body) } def foldOverTypeCaseDef(x: X, tree: TypeCaseDef)(implicit ctx: Context): X = tree match { - case TypeCaseDef(pat, body) => foldTypeTree(foldTypeTree(x, pat), body) + case TypeCaseDef(pat, body) => foldTree(foldTree(x, pat), body) } def foldOverPattern(x: X, tree: Pattern)(implicit ctx: Context): X = tree match { @@ -118,12 +113,12 @@ trait TreeUtils case Pattern.Bind(_, body) => foldPattern(x, body) case Pattern.Unapply(fun, implicits, patterns) => foldPatterns(foldTrees(foldTree(x, fun), implicits), patterns) case Pattern.Alternatives(patterns) => foldPatterns(x, patterns) - case Pattern.TypeTest(tpt) => foldTypeTree(x, tpt) + case Pattern.TypeTest(tpt) => foldTree(x, tpt) } private def foldTermOrTypeTree(x: X, tree: TermOrTypeTree)(implicit ctx: Context): X = tree match { case IsTerm(termOrTypeTree) => foldTree(x, termOrTypeTree) - case IsTypeTree(termOrTypeTree) => foldTypeTree(x, termOrTypeTree) + case IsTypeTree(termOrTypeTree) => foldTree(x, termOrTypeTree) } } @@ -131,19 +126,16 @@ trait TreeUtils abstract class TreeTraverser extends TreeAccumulator[Unit] { def traverseTree(tree: Tree)(implicit ctx: Context): Unit = traverseTreeChildren(tree) - def traverseTypeTree(tree: TypeOrBoundsTree)(implicit ctx: Context): Unit = traverseTypeTreeChildren(tree) def traverseCaseDef(tree: CaseDef)(implicit ctx: Context): Unit = traverseCaseDefChildren(tree) def traverseTypeCaseDef(tree: TypeCaseDef)(implicit ctx: Context): Unit = traverseTypeCaseDefChildren(tree) def traversePattern(tree: Pattern)(implicit ctx: Context): Unit = traversePatternChildren(tree) def foldTree(x: Unit, tree: Tree)(implicit ctx: Context): Unit = traverseTree(tree) - def foldTypeTree(x: Unit, tree: TypeOrBoundsTree)(implicit ctx: Context) = traverseTypeTree(tree) def foldCaseDef(x: Unit, tree: CaseDef)(implicit ctx: Context) = traverseCaseDef(tree) def foldTypeCaseDef(x: Unit, tree: TypeCaseDef)(implicit ctx: Context) = traverseTypeCaseDef(tree) def foldPattern(x: Unit, tree: Pattern)(implicit ctx: Context) = traversePattern(tree) protected def traverseTreeChildren(tree: Tree)(implicit ctx: Context): Unit = foldOverTree((), tree) - protected def traverseTypeTreeChildren(tree: TypeOrBoundsTree)(implicit ctx: Context): Unit = foldOverTypeTree((), tree) protected def traverseCaseDefChildren(tree: CaseDef)(implicit ctx: Context): Unit = foldOverCaseDef((), tree) protected def traverseTypeCaseDefChildren(tree: TypeCaseDef)(implicit ctx: Context): Unit = foldOverTypeCaseDef((), tree) protected def traversePatternChildren(tree: Pattern)(implicit ctx: Context): Unit = foldOverPattern((), tree) @@ -160,6 +152,9 @@ trait TreeUtils Import.copy(tree)(tree.impliedOnly, transformTerm(tree.expr), tree.selectors) case IsStatement(tree) => transformStatement(tree) + case IsTypeTree(tree) => transformTypeTree(tree) + case IsTypeBoundsTree(tree) => tree // TODO traverse tree + case IsWildcardTypeTree(tree) => tree // TODO traverse tree } } @@ -234,6 +229,7 @@ trait TreeUtils def transformTypeOrBoundsTree(tree: TypeOrBoundsTree)(implicit ctx: Context): TypeOrBoundsTree = tree match { case IsTypeTree(tree) => transformTypeTree(tree) case IsTypeBoundsTree(tree) => tree // TODO traverse tree + case IsWildcardTypeTree(tree) => tree // TODO traverse tree } def transformTypeTree(tree: TypeTree)(implicit ctx: Context): TypeTree = tree match { diff --git a/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala b/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala index 63de499a730d..0e0298358f6a 100644 --- a/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala +++ b/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala @@ -41,11 +41,16 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum object ChildTraverser extends TreeTraverser { var children: List[Tree] = Nil var childrenType: List[TypeOrBoundsTree] = Nil - override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = - children = tree :: children + override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = tree match { + case IsTypeTree(tree) => + traverseTypeTree(tree) + case IsTypeBoundsTree(tree) => + traverseTypeTree(tree) + case _ => children = tree :: children + } override def traversePattern(pattern: Pattern)( implicit ctx: Context): Unit = () - override def traverseTypeTree(tree: TypeOrBoundsTree)( + def traverseTypeTree(tree: TypeOrBoundsTree)( implicit ctx: Context): Unit = childrenType = tree :: childrenType override def traverseCaseDef(tree: CaseDef)(implicit ctx: Context): Unit = @@ -61,7 +66,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum } def getChildrenType(tree: TypeOrBoundsTree)(implicit ctx: Context): List[TypeOrBoundsTree] = { childrenType = Nil - traverseTypeTreeChildren(tree)(ctx) + traverseTreeChildren(tree)(ctx) return childrenType } } @@ -643,7 +648,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum }) } - override def traverseTypeTree(tree: TypeOrBoundsTree)( + def traverseTypeTree(tree: TypeOrBoundsTree)( implicit ctx: Context): Unit = { tree match { case TypeTree.Ident(_) => { @@ -658,7 +663,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum addOccurenceTypeTree(typetree, s.SymbolOccurrence.Role.REFERENCE, range) - super.traverseTypeTree(typetree) + super.traverseTree(typetree) } case TypeTree.Projection(qualifier, x) => { @@ -667,7 +672,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum addOccurenceTypeTree(typetree, s.SymbolOccurrence.Role.REFERENCE, range) - super.traverseTypeTree(typetree) + super.traverseTree(typetree) } case TypeTree.Inferred() => { @@ -703,7 +708,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum } case _ => { - super.traverseTypeTree(tree) + super.traverseTree(tree) } } } @@ -805,7 +810,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum // we add the parents to the symbol list parents.foreach(_ match { - case IsTypeTree(t) => traverseTypeTree(t) + case IsTypeTree(t) => traverseTree(t) case IsTerm(t) => traverseTree(t) }) diff --git a/tests/run/tasty-extractors-3/quoted_1.scala b/tests/run/tasty-extractors-3/quoted_1.scala index 4762d885627d..5eb6169f6b45 100644 --- a/tests/run/tasty-extractors-3/quoted_1.scala +++ b/tests/run/tasty-extractors-3/quoted_1.scala @@ -12,10 +12,17 @@ object Macros { val buff = new StringBuilder val traverser = new TreeTraverser { - override def traverseTypeTree(tree: TypeOrBoundsTree)(implicit ctx: Context): Unit = { - buff.append(tree.tpe.show) - buff.append("\n\n") - traverseTypeTreeChildren(tree) + override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = tree match { + case IsTypeBoundsTree(tree) => + buff.append(tree.tpe.show) + buff.append("\n\n") + traverseTreeChildren(tree) + case IsTypeTree(tree) => + buff.append(tree.tpe.show) + buff.append("\n\n") + traverseTreeChildren(tree) + case _ => + super.traverseTree(tree) } } From 160bad28abe82eed2fc37a4cc9f14502d285a8ce Mon Sep 17 00:00:00 2001 From: Nicolas Stucki Date: Sat, 9 Mar 2019 21:58:54 +0100 Subject: [PATCH 06/10] Remove TermOrTypeTree and use Tree --- .../tools/dotc/tastyreflect/KernelImpl.scala | 22 ++++------------ .../other-new-features/tasty-reflect.md | 2 -- library/src/scala/tasty/reflect/Core.scala | 7 ------ library/src/scala/tasty/reflect/Kernel.scala | 20 ++++----------- .../src/scala/tasty/reflect/Printers.scala | 13 +++------- library/src/scala/tasty/reflect/TreeOps.scala | 25 ++++++------------- .../src/scala/tasty/reflect/TreeUtils.scala | 8 +----- .../dotty/semanticdb/SemanticdbConsumer.scala | 19 ++------------ .../fatal-warnings/tasty-parent-unapply.scala | 2 +- 9 files changed, 25 insertions(+), 93 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala index 0ca921dbccad..93a7da792b4f 100644 --- a/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala +++ b/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala @@ -51,8 +51,6 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. // TREES // - type TermOrTypeTree = tpd.Tree - type Tree = tpd.Tree def Tree_pos(self: Tree)(implicit ctx: Context): Position = self.sourcePos @@ -135,14 +133,14 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. } def ClassDef_constructor(self: ClassDef)(implicit ctx: Context): DefDef = ClassDef_rhs(self).constr - def ClassDef_parents(self: ClassDef)(implicit ctx: Context): List[TermOrTypeTree] = ClassDef_rhs(self).parents + def ClassDef_parents(self: ClassDef)(implicit ctx: Context): List[Tree /* Term | TypeTree */] = ClassDef_rhs(self).parents def ClassDef_derived(self: ClassDef)(implicit ctx: Context): List[TypeTree] = ClassDef_rhs(self).derived.asInstanceOf[List[TypeTree]] def ClassDef_self(self: ClassDef)(implicit ctx: Context): Option[ValDef] = optional(ClassDef_rhs(self).self) def ClassDef_body(self: ClassDef)(implicit ctx: Context): List[Statement] = ClassDef_rhs(self).body def ClassDef_symbol(self: ClassDef)(implicit ctx: Context): ClassSymbol = self.symbol.asClass private def ClassDef_rhs(self: ClassDef) = self.rhs.asInstanceOf[tpd.Template] - def ClassDef_copy(original: ClassDef)(name: String, constr: DefDef, parents: List[TermOrTypeTree], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef = { + def ClassDef_copy(original: ClassDef)(name: String, constr: DefDef, parents: List[Tree /* Term | TypeTree */], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef = { val Trees.TypeDef(_, originalImpl: tpd.Template) = original tpd.cpy.TypeDef(original)(name.toTypeName, tpd.cpy.Template(originalImpl)(constr, parents, derived, selfOpt.getOrElse(tpd.EmptyValDef), body)) } @@ -205,10 +203,6 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. case _ => None } - // TODO move to Kernel and use isTerm directly with a cast - def matchTermNotTypeTree(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context): Option[Term] = - if (termOrTypeTree.isTerm) Some(termOrTypeTree) else None - def Term_pos(self: Term)(implicit ctx: Context): Position = self.sourcePos def Term_tpe(self: Term)(implicit ctx: Context): Type = self.tpe def Term_underlyingArgument(self: Term)(implicit ctx: Context): Term = self.underlyingArgument @@ -453,14 +447,14 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. case _ => None } - def Inlined_call(self: Inlined)(implicit ctx: Context): Option[TermOrTypeTree] = optional(self.call) + def Inlined_call(self: Inlined)(implicit ctx: Context): Option[Tree /* Term | TypeTree */] = optional(self.call) def Inlined_bindings(self: Inlined)(implicit ctx: Context): List[Definition] = self.bindings def Inlined_body(self: Inlined)(implicit ctx: Context): Term = self.expansion - def Inlined_apply(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined = + def Inlined_apply(call: Option[Tree /* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined = withDefaultPos(ctx => tpd.Inlined(call.getOrElse(tpd.EmptyTree), bindings.map { case b: tpd.MemberDef => b }, expansion)(ctx)) - def Inlined_copy(original: Tree)(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined = + def Inlined_copy(original: Tree)(call: Option[Tree /* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined = tpd.cpy.Inlined(original)(call.getOrElse(tpd.EmptyTree), bindings.asInstanceOf[List[tpd.MemberDef]], expansion) type Lambda = tpd.Closure @@ -611,12 +605,6 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. case _ => if (x.isType) Some(x) else None } - // TODO move to Kernel and use isTypeTree directly with a cast - def matchTypeTreeNotTerm(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context): Option[TypeTree] = termOrTypeTree match { - case _: tpd.TypeBoundsTree => None - case _ => if (termOrTypeTree.isType) Some(termOrTypeTree) else None - } - def TypeTree_pos(self: TypeTree)(implicit ctx: Context): Position = self.sourcePos def TypeTree_symbol(self: TypeTree)(implicit ctx: Context): Symbol = self.symbol def TypeTree_tpe(self: TypeTree)(implicit ctx: Context): Type = self.tpe.stripTypeVar diff --git a/docs/docs/reference/other-new-features/tasty-reflect.md b/docs/docs/reference/other-new-features/tasty-reflect.md index ac939d81688e..2fdb10a4fedf 100644 --- a/docs/docs/reference/other-new-features/tasty-reflect.md +++ b/docs/docs/reference/other-new-features/tasty-reflect.md @@ -186,8 +186,6 @@ TASTy Reflect provides the following types: +- BindSymbol +- NoSymbol -Aliases: - # TermOrTypeTree = Term | TypeTree ``` ## More Examples diff --git a/library/src/scala/tasty/reflect/Core.scala b/library/src/scala/tasty/reflect/Core.scala index 66d6442be7dc..14ccf22adb27 100644 --- a/library/src/scala/tasty/reflect/Core.scala +++ b/library/src/scala/tasty/reflect/Core.scala @@ -111,9 +111,6 @@ package scala.tasty.reflect * * +- Flags * - * Aliases: - * # TermOrTypeTree = Term | TypeTree - * * ``` */ trait Core { @@ -126,10 +123,6 @@ trait Core { /** Settings */ type Settings = kernel.Settings - // TODO: When bootstrapped, remove and use `Term | TypeTree` type directly in other files - /** Workaround missing `|` types in Scala 2 to represent `Term | TypeTree` */ - type TermOrTypeTree /* Term | TypeTree */ = kernel.TermOrTypeTree - /** Tree representing code written in the source */ type Tree = kernel.Tree diff --git a/library/src/scala/tasty/reflect/Kernel.scala b/library/src/scala/tasty/reflect/Kernel.scala index e116f424bdf4..280b045d0bb4 100644 --- a/library/src/scala/tasty/reflect/Kernel.scala +++ b/library/src/scala/tasty/reflect/Kernel.scala @@ -110,9 +110,6 @@ package scala.tasty.reflect * * +- Flags * - * Aliases: - * # TermOrTypeTree = Term | TypeTree - * * ``` */ trait Kernel { @@ -161,10 +158,6 @@ trait Kernel { // TREES // - // TODO: When bootstrapped, remove and use `Term | TypeTree` type directly in other files - /** Workaround missing `|` types in Scala 2 to represent `Term | TypeTree` */ - type TermOrTypeTree /* Term | TypeTree */ <: AnyRef - /** Tree representing code written in the source */ type Tree <: AnyRef @@ -223,13 +216,13 @@ trait Kernel { def matchClassDef(tree: Tree)(implicit ctx: Context): Option[ClassDef] def ClassDef_constructor(self: ClassDef)(implicit ctx: Context): DefDef - def ClassDef_parents(self: ClassDef)(implicit ctx: Context): List[TermOrTypeTree] + def ClassDef_parents(self: ClassDef)(implicit ctx: Context): List[Tree/* Term | TypeTree */] def ClassDef_derived(self: ClassDef)(implicit ctx: Context): List[TypeTree] def ClassDef_self(self: ClassDef)(implicit ctx: Context): Option[ValDef] def ClassDef_body(self: ClassDef)(implicit ctx: Context): List[Statement] def ClassDef_symbol(self: ClassDef)(implicit ctx: Context): ClassSymbol - def ClassDef_copy(original: ClassDef)(name: String, constr: DefDef, parents: List[TermOrTypeTree], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef + def ClassDef_copy(original: ClassDef)(name: String, constr: DefDef, parents: List[Tree/* Term | TypeTree */], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef /** Tree representing a type (paramter or member) definition in the source code */ type TypeDef <: Definition @@ -273,8 +266,6 @@ trait Kernel { def matchTerm(tree: Tree)(implicit ctx: Context): Option[Term] - def matchTermNotTypeTree(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context): Option[Term] - def Term_pos(self: Term)(implicit ctx: Context): Position def Term_tpe(self: Term)(implicit ctx: Context): Type def Term_underlyingArgument(self: Term)(implicit ctx: Context): Term @@ -488,12 +479,12 @@ trait Kernel { def matchInlined(tree: Tree)(implicit ctx: Context): Option[Inlined] - def Inlined_call(self: Inlined)(implicit ctx: Context): Option[TermOrTypeTree] + def Inlined_call(self: Inlined)(implicit ctx: Context): Option[Tree/* Term | TypeTree */] def Inlined_bindings(self: Inlined)(implicit ctx: Context): List[Definition] def Inlined_body(self: Inlined)(implicit ctx: Context): Term - def Inlined_apply(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined - def Inlined_copy(original: Tree)(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined + def Inlined_apply(call: Option[Tree/* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined + def Inlined_copy(original: Tree)(call: Option[Tree/* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined /** Tree representing a selection of definition with a given name on a given prefix and number of nested scopes of inlined trees */ type SelectOuter <: Term @@ -527,7 +518,6 @@ trait Kernel { type TypeTree <: TypeOrBoundsTree def matchTypeTree(tree: Tree)(implicit ctx: Context): Option[TypeTree] - def matchTypeTreeNotTerm(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context): Option[TypeTree] def TypeTree_pos(self: TypeTree)(implicit ctx: Context): Position def TypeTree_symbol(self: TypeTree)(implicit ctx: Context): Symbol diff --git a/library/src/scala/tasty/reflect/Printers.scala b/library/src/scala/tasty/reflect/Printers.scala index 2f06e8e368b5..fcba4754bf8a 100644 --- a/library/src/scala/tasty/reflect/Printers.scala +++ b/library/src/scala/tasty/reflect/Printers.scala @@ -201,7 +201,7 @@ trait Printers this += "Term.Repeated(" ++= elems += ", " += elemtpt += ")" case Term.Inlined(call, bindings, expansion) => this += "Term.Inlined(" - visitOption(call, visitTermOrTypeTree) + visitOption(call, visitTree) this += ", " ++= bindings += ", " += expansion += ")" case ValDef(name, tpt, rhs) => this += "ValDef(\"" += name += "\", " += tpt += ", " += rhs += ")" @@ -211,7 +211,7 @@ trait Printers this += "TypeDef(\"" += name += "\", " += rhs += ")" case ClassDef(name, constr, parents, derived, self, body) => this += "ClassDef(\"" += name += "\", " += constr += ", " - visitList[TermOrTypeTree](parents, visitTermOrTypeTree) + visitList[Tree](parents, visitTree) this += ", " visitList[TypeTree](derived, visitTree) this += ", " += self += ", " ++= body += ")" @@ -276,11 +276,6 @@ trait Printers this += "Pattern.TypeTest(" += tpt += ")" } - def visitTermOrTypeTree(x: TermOrTypeTree): Buffer = x match { - case IsTerm(termOrTypeTree) => this += termOrTypeTree - case IsTypeTree(termOrTypeTree) => this += termOrTypeTree - } - def visitConstant(x: Constant): Buffer = x match { case Constant.Unit() => this += "Constant.Unit()" case Constant.Null() => this += "Constant.Null()" @@ -618,7 +613,7 @@ trait Printers if (parents1.nonEmpty) this += highlightKeyword(" extends ", color) - def printParent(parent: TermOrTypeTree, needEmptyParens: Boolean = false): Unit = parent match { + def printParent(parent: Tree /* Term | TypeTree */, needEmptyParens: Boolean = false): Unit = parent match { case IsTypeTree(parent) => printTypeTree(parent) case IsTerm(Term.TypeApply(fun, targs)) => @@ -637,7 +632,7 @@ trait Printers throw new MatchError(parent.show) } - def printSeparated(list: List[TermOrTypeTree]): Unit = list match { + def printSeparated(list: List[Tree /* Term | TypeTree */]): Unit = list match { case Nil => case x :: Nil => printParent(x) case x :: xs => diff --git a/library/src/scala/tasty/reflect/TreeOps.scala b/library/src/scala/tasty/reflect/TreeOps.scala index a6d976497791..8c4e7267995e 100644 --- a/library/src/scala/tasty/reflect/TreeOps.scala +++ b/library/src/scala/tasty/reflect/TreeOps.scala @@ -3,11 +3,6 @@ package reflect trait TreeOps extends Core { - // Decorators - - implicit def termAsTermOrTypeTree(term: Term): TermOrTypeTree = term.asInstanceOf[TermOrTypeTree] - implicit def typeTreeAsTermOrTypeTree(term: TypeTree): TermOrTypeTree = term.asInstanceOf[TermOrTypeTree] - // ----- Tree ----------------------------------------------------- implicit class TreeAPI(self: Tree) { @@ -80,15 +75,15 @@ trait TreeOps extends Core { object ClassDef { // TODO def apply(name: String, constr: DefDef, parents: List[TermOrTypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef - def copy(original: ClassDef)(name: String, constr: DefDef, parents: List[TermOrTypeTree], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef = + def copy(original: ClassDef)(name: String, constr: DefDef, parents: List[Tree /* Term | TypeTree */], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef = kernel.ClassDef_copy(original)(name, constr, parents, derived, selfOpt, body) - def unapply(tree: Tree)(implicit ctx: Context): Option[(String, DefDef, List[TermOrTypeTree], List[TypeTree], Option[ValDef], List[Statement])] = + def unapply(tree: Tree)(implicit ctx: Context): Option[(String, DefDef, List[Tree /* Term | TypeTree */], List[TypeTree], Option[ValDef], List[Statement])] = kernel.matchClassDef(tree).map(x => (x.name, x.constructor, x.parents, x.derived, x.self, x.body)) } implicit class ClassDefAPI(self: ClassDef) { def constructor(implicit ctx: Context): DefDef = kernel.ClassDef_constructor(self) - def parents(implicit ctx: Context): List[TermOrTypeTree] = kernel.ClassDef_parents(self) + def parents(implicit ctx: Context): List[Tree /* Term | TypeTree */] = kernel.ClassDef_parents(self) def derived(implicit ctx: Context): List[TypeTree] = kernel.ClassDef_derived(self) def self(implicit ctx: Context): Option[ValDef] = kernel.ClassDef_self(self) def body(implicit ctx: Context): List[Statement] = kernel.ClassDef_body(self) @@ -190,10 +185,6 @@ trait TreeOps extends Core { /** Matches any term */ def unapply(tree: Tree)(implicit ctx: Context): Option[Term] = kernel.matchTerm(tree) - - /** Matches any term */ - def unapply(parent: TermOrTypeTree)(implicit ctx: Context, dummy: DummyImplicit): Option[Term] = - kernel.matchTermNotTypeTree(parent) } /** Scala term. Any tree that can go in expression position. */ @@ -587,13 +578,13 @@ trait TreeOps extends Core { object Inlined { - def apply(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined = + def apply(call: Option[Tree /* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined = kernel.Inlined_apply(call, bindings, expansion) - def copy(original: Tree)(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined = + def copy(original: Tree)(call: Option[Tree /* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined = kernel.Inlined_copy(original)(call, bindings, expansion) - def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[TermOrTypeTree], List[Definition], Term)] = + def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[Tree /* Term | TypeTree */], List[Definition], Term)] = kernel.matchInlined(tree).map(x => (x.call, x.bindings, x.body)) } @@ -726,7 +717,7 @@ trait TreeOps extends Core { } implicit class InlinedAPI(self: Term.Inlined) { - def call(implicit ctx: Context): Option[TermOrTypeTree] = kernel.Inlined_call(self) + def call(implicit ctx: Context): Option[Tree /* Term | TypeTree */] = kernel.Inlined_call(self) def bindings(implicit ctx: Context): List[Definition] = kernel.Inlined_bindings(self) def body(implicit ctx: Context): Term = kernel.Inlined_body(self) } @@ -764,8 +755,6 @@ trait TreeOps extends Core { object IsTypeTree { def unapply(tpt: Tree)(implicit ctx: Context): Option[TypeTree] = kernel.matchTypeTree(tpt) - def unapply(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context, dummy: DummyImplicit): Option[TypeTree] = - kernel.matchTypeTreeNotTerm(termOrTypeTree) } object TypeTree extends TypeTreeCoreModule { diff --git a/library/src/scala/tasty/reflect/TreeUtils.scala b/library/src/scala/tasty/reflect/TreeUtils.scala index 4430d0784a69..f575d61d5dd9 100644 --- a/library/src/scala/tasty/reflect/TreeUtils.scala +++ b/library/src/scala/tasty/reflect/TreeUtils.scala @@ -21,7 +21,6 @@ trait TreeUtils def foldCaseDefs(x: X, trees: Iterable[CaseDef])(implicit ctx: Context): X = (x /: trees)(foldCaseDef) def foldTypeCaseDefs(x: X, trees: Iterable[TypeCaseDef])(implicit ctx: Context): X = (x /: trees)(foldTypeCaseDef) def foldPatterns(x: X, trees: Iterable[Pattern])(implicit ctx: Context): X = (x /: trees)(foldPattern) - private def foldParents(x: X, trees: Iterable[TermOrTypeTree])(implicit ctx: Context): X = (x /: trees)(foldTermOrTypeTree) def foldOverTree(x: X, tree: Tree)(implicit ctx: Context): X = { def localCtx(definition: Definition): Context = definition.symbol.localContext @@ -76,7 +75,7 @@ trait TreeUtils foldTree(x, rhs) case IsDefinition(cdef @ ClassDef(_, constr, parents, derived, self, body)) => implicit val ctx = localCtx(cdef) - foldTrees(foldTrees(foldTrees(foldParents(foldTree(x, constr), parents), derived), self), body) + foldTrees(foldTrees(foldTrees(foldTrees(foldTree(x, constr), parents), derived), self), body) case Import(_, expr, _) => foldTree(x, expr) case IsPackageClause(clause @ PackageClause(pid, stats)) => @@ -116,11 +115,6 @@ trait TreeUtils case Pattern.TypeTest(tpt) => foldTree(x, tpt) } - private def foldTermOrTypeTree(x: X, tree: TermOrTypeTree)(implicit ctx: Context): X = tree match { - case IsTerm(termOrTypeTree) => foldTree(x, termOrTypeTree) - case IsTypeTree(termOrTypeTree) => foldTree(x, termOrTypeTree) - } - } abstract class TreeTraverser extends TreeAccumulator[Unit] { diff --git a/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala b/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala index 0e0298358f6a..c499971a3057 100644 --- a/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala +++ b/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala @@ -99,18 +99,6 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum } } - implicit class TermOrTypeTreeExtender(tree: TermOrTypeTree) { - def pos: Position = tree match { - case IsTerm(t) => t.pos - case IsTypeTree(t) => t.pos - } - - def symbol: Symbol = tree match { - case IsTerm(t) => t.symbol - case IsTypeTree(t) => t.symbol - } - } - implicit class TypeOrBoundsTreeExtender(tree: TypeOrBoundsTree) { def typetree: TypeTree = tree match { case IsTypeTree(t) => t @@ -809,10 +797,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum fittedInitClassRange = None // we add the parents to the symbol list - parents.foreach(_ match { - case IsTypeTree(t) => traverseTree(t) - case IsTerm(t) => traverseTree(t) - }) + parents.foreach(traverseTree) selfopt match { case Some(vdef @ ValDef(name, type_, _)) => { @@ -827,7 +812,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum // 2) Find the first '{' // 3) Iterate until the character we are seeing is a letter val startPosSearch: Int = parents.foldLeft(tree.pos.end)( - (old: Int, ct: TermOrTypeTree) => + (old: Int, ct: Tree) => ct match { case IsTerm(t) if t.pos.end < old => t.pos.end case _ => old diff --git a/tests/pos-special/fatal-warnings/tasty-parent-unapply.scala b/tests/pos-special/fatal-warnings/tasty-parent-unapply.scala index 56d780bb1a0a..af86983884fe 100644 --- a/tests/pos-special/fatal-warnings/tasty-parent-unapply.scala +++ b/tests/pos-special/fatal-warnings/tasty-parent-unapply.scala @@ -8,7 +8,7 @@ object Macros { def impl(reflect: Reflection): Unit = { import reflect._ - def foo(tree: Tree, term: Term, typeTree: TypeTree, parent: TermOrTypeTree) = { + def foo(tree: Tree, term: Term, typeTree: TypeTree, parent: Tree) = { tree match { case IsTerm(tree) => From 938c684d697ce20c92287c92e74afd6992a5588b Mon Sep 17 00:00:00 2001 From: Nicolas Stucki Date: Sun, 10 Mar 2019 09:11:56 +0100 Subject: [PATCH 07/10] Remove TypeOrBoundsTree and use Tree --- .../tools/dotc/tastyreflect/KernelImpl.scala | 58 ++++++++--------- .../other-new-features/tasty-reflect.md | 30 ++++----- library/src/scala/tasty/reflect/Core.scala | 35 +++++----- library/src/scala/tasty/reflect/Kernel.scala | 65 +++++++++---------- .../src/scala/tasty/reflect/Printers.scala | 8 +-- library/src/scala/tasty/reflect/TreeOps.scala | 38 +++++------ .../src/scala/tasty/reflect/TreeUtils.scala | 15 +---- .../dotty/semanticdb/SemanticdbConsumer.scala | 10 +-- 8 files changed, 120 insertions(+), 139 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala index 93a7da792b4f..d25c7085ead8 100644 --- a/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala +++ b/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala @@ -152,11 +152,11 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. case _ => None } - def TypeDef_rhs(self: TypeDef)(implicit ctx: Context): TypeOrBoundsTree = self.rhs + def TypeDef_rhs(self: TypeDef)(implicit ctx: Context): Tree /*TypeTree | TypeBoundsTree*/ = self.rhs def TypeDef_symbol(self: TypeDef)(implicit ctx: Context): TypeSymbol = self.symbol.asType def TypeDef_apply(symbol: TypeSymbol)(implicit ctx: Context): TypeDef = withDefaultPos(ctx => tpd.TypeDef(symbol)(ctx)) - def TypeDef_copy(original: TypeDef)(name: String, rhs: TypeOrBoundsTree)(implicit ctx: Context): TypeDef = + def TypeDef_copy(original: TypeDef)(name: String, rhs: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): TypeDef = tpd.cpy.TypeDef(original)(name.toTypeName, rhs) type DefDef = tpd.DefDef @@ -594,13 +594,9 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. def While_copy(original: Tree)(cond: Term, body: Term)(implicit ctx: Context): While = tpd.cpy.WhileDo(original)(cond, body) - type TypeOrBoundsTree = tpd.Tree - - def TypeOrBoundsTree_tpe(self: TypeOrBoundsTree)(implicit ctx: Context): Type = self.tpe.stripTypeVar - type TypeTree = tpd.Tree - def matchTypeTree(x: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree] = x match { + def matchTypeTree(x: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[TypeTree] = x match { case x: tpd.TypeBoundsTree => None case _ => if (x.isType) Some(x) else None } @@ -611,7 +607,7 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. type TypeTree_Inferred = tpd.TypeTree - def matchTypeTree_Inferred(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Inferred] = tpt match { + def matchTypeTree_Inferred(tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[TypeTree_Inferred] = tpt match { case tpt: tpd.TypeTree if !tpt.tpe.isInstanceOf[Types.TypeBounds] => Some(tpt) case _ => None } @@ -620,7 +616,7 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. type TypeTree_Ident = tpd.Ident - def matchTypeTree_Ident(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Ident] = tpt match { + def matchTypeTree_Ident(tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[TypeTree_Ident] = tpt match { case tpt: tpd.Ident if tpt.isType => Some(tpt) case _ => None } @@ -632,7 +628,7 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. type TypeTree_Select = tpd.Select - def matchTypeTree_Select(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Select] = tpt match { + def matchTypeTree_Select(tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[TypeTree_Select] = tpt match { case tpt: tpd.Select if tpt.isType && tpt.qualifier.isTerm => Some(tpt) case _ => None } @@ -649,7 +645,7 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. type TypeTree_Projection = tpd.Select - def matchTypeTree_Projection(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Projection] = tpt match { + def matchTypeTree_Projection(tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[TypeTree_Projection] = tpt match { case tpt: tpd.Select if tpt.isType && tpt.qualifier.isType => Some(tpt) case _ => None } @@ -662,7 +658,7 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. type TypeTree_Singleton = tpd.SingletonTypeTree - def matchTypeTree_Singleton(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Singleton] = tpt match { + def matchTypeTree_Singleton(tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[TypeTree_Singleton] = tpt match { case tpt: tpd.SingletonTypeTree => Some(tpt) case _ => None } @@ -677,7 +673,7 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. type TypeTree_Refined = tpd.RefinedTypeTree - def matchTypeTree_Refined(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Refined] = tpt match { + def matchTypeTree_Refined(tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[TypeTree_Refined] = tpt match { case tpt: tpd.RefinedTypeTree => Some(tpt) case _ => None } @@ -690,23 +686,23 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. type TypeTree_Applied = tpd.AppliedTypeTree - def matchTypeTree_Applied(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Applied] = tpt match { + def matchTypeTree_Applied(tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[TypeTree_Applied] = tpt match { case tpt: tpd.AppliedTypeTree => Some(tpt) case _ => None } def TypeTree_Applied_tpt(self: TypeTree_Applied)(implicit ctx: Context): TypeTree = self.tpt - def TypeTree_Applied_args(self: TypeTree_Applied)(implicit ctx: Context): List[TypeOrBoundsTree] = self.args + def TypeTree_Applied_args(self: TypeTree_Applied)(implicit ctx: Context): List[Tree /*TypeTree | TypeBoundsTree*/] = self.args - def TypeTree_Applied_apply(tpt: TypeTree, args: List[TypeOrBoundsTree])(implicit ctx: Context): TypeTree_Applied = + def TypeTree_Applied_apply(tpt: TypeTree, args: List[Tree /*TypeTree | TypeBoundsTree*/])(implicit ctx: Context): TypeTree_Applied = withDefaultPos(ctx => tpd.AppliedTypeTree(tpt, args)(ctx)) - def TypeTree_Applied_copy(original: TypeTree_Applied)(tpt: TypeTree, args: List[TypeOrBoundsTree])(implicit ctx: Context): TypeTree_Applied = + def TypeTree_Applied_copy(original: TypeTree_Applied)(tpt: TypeTree, args: List[Tree /*TypeTree | TypeBoundsTree*/])(implicit ctx: Context): TypeTree_Applied = tpd.cpy.AppliedTypeTree(original)(tpt, args) type TypeTree_Annotated = tpd.Annotated - def matchTypeTree_Annotated(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_Annotated] = tpt match { + def matchTypeTree_Annotated(tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[TypeTree_Annotated] = tpt match { case tpt: tpd.Annotated => Some(tpt) case _ => None } @@ -722,7 +718,7 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. type TypeTree_MatchType = tpd.MatchTypeTree - def matchTypeTree_MatchType(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_MatchType] = tpt match { + def matchTypeTree_MatchType(tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[TypeTree_MatchType] = tpt match { case tpt: tpd.MatchTypeTree => Some(tpt) case _ => None } @@ -739,7 +735,7 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. type TypeTree_ByName = tpd.ByNameTypeTree - def matchTypeTree_ByName(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_ByName] = tpt match { + def matchTypeTree_ByName(tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[TypeTree_ByName] = tpt match { case tpt: tpd.ByNameTypeTree => Some(tpt) case _ => None } @@ -754,36 +750,36 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. type TypeTree_LambdaTypeTree = tpd.LambdaTypeTree - def matchTypeTree_LambdaTypeTree(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_LambdaTypeTree] = tpt match { + def matchTypeTree_LambdaTypeTree(tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[TypeTree_LambdaTypeTree] = tpt match { case tpt: tpd.LambdaTypeTree => Some(tpt) case _ => None } def TypeTree_LambdaTypeTree_tparams(self: TypeTree_LambdaTypeTree)(implicit ctx: Context): List[TypeDef] = self.tparams - def TypeTree_LambdaTypeTree_body(self: TypeTree_LambdaTypeTree)(implicit ctx: Context): TypeOrBoundsTree = self.body + def TypeTree_LambdaTypeTree_body(self: TypeTree_LambdaTypeTree)(implicit ctx: Context): Tree /*TypeTree | TypeBoundsTree*/ = self.body - def TypeTree_LambdaTypeTree_apply(tparams: List[TypeDef], body: TypeOrBoundsTree)(implicit ctx: Context): TypeTree_LambdaTypeTree = + def TypeTree_LambdaTypeTree_apply(tparams: List[TypeDef], body: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): TypeTree_LambdaTypeTree = withDefaultPos(ctx => tpd.LambdaTypeTree(tparams, body)(ctx)) - def TypeTree_LambdaTypeTree_copy(original: TypeTree_LambdaTypeTree)(tparams: List[TypeDef], body: TypeOrBoundsTree)(implicit ctx: Context): TypeTree_LambdaTypeTree = + def TypeTree_LambdaTypeTree_copy(original: TypeTree_LambdaTypeTree)(tparams: List[TypeDef], body: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): TypeTree_LambdaTypeTree = tpd.cpy.LambdaTypeTree(original)(tparams, body) type TypeTree_TypeBind = tpd.Bind - def matchTypeTree_TypeBind(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_TypeBind] = tpt match { + def matchTypeTree_TypeBind(tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[TypeTree_TypeBind] = tpt match { case tpt: tpd.Bind if tpt.name.isTypeName => Some(tpt) case _ => None } def TypeTree_TypeBind_name(self: TypeTree_TypeBind)(implicit ctx: Context): String = self.name.toString - def TypeTree_TypeBind_body(self: TypeTree_TypeBind)(implicit ctx: Context): TypeOrBoundsTree = self.body + def TypeTree_TypeBind_body(self: TypeTree_TypeBind)(implicit ctx: Context): Tree /*TypeTree | TypeBoundsTree*/ = self.body - def TypeTree_TypeBind_copy(original: TypeTree_TypeBind)(name: String, tpt: TypeOrBoundsTree)(implicit ctx: Context): TypeTree_TypeBind = + def TypeTree_TypeBind_copy(original: TypeTree_TypeBind)(name: String, tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): TypeTree_TypeBind = tpd.cpy.Bind(original)(name.toTypeName, tpt) type TypeTree_TypeBlock = tpd.Block - def matchTypeTree_TypeBlock(tpt: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree_TypeBlock] = tpt match { + def matchTypeTree_TypeBlock(tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[TypeTree_TypeBlock] = tpt match { case tpt: tpd.Block => Some(tpt) case _ => None } @@ -799,7 +795,7 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. type TypeBoundsTree = tpd.TypeBoundsTree - def matchTypeBoundsTree(x: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeBoundsTree] = x match { + def matchTypeBoundsTree(x: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[TypeBoundsTree] = x match { case x: tpd.TypeBoundsTree => Some(x) case x @ Trees.TypeTree() => // TODO only enums generate this kind of type bounds. Is this possible without enums? If not generate tpd.TypeBoundsTree for enums instead @@ -817,11 +813,13 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. type WildcardTypeTree = tpd.Ident - def matchWildcardTypeTree(x: TypeOrBoundsTree)(implicit ctx: Context): Option[WildcardTypeTree] = x match { + def matchWildcardTypeTree(x: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): Option[WildcardTypeTree] = x match { case x @ Trees.Ident(nme.WILDCARD) => Some(x) case _ => None } + def WildcardTypeTree_tpe(self: WildcardTypeTree)(implicit ctx: Context): TypeOrBounds = self.tpe.stripTypeVar + // // CASES // diff --git a/docs/docs/reference/other-new-features/tasty-reflect.md b/docs/docs/reference/other-new-features/tasty-reflect.md index 2fdb10a4fedf..7a9f0a660f1d 100644 --- a/docs/docs/reference/other-new-features/tasty-reflect.md +++ b/docs/docs/reference/other-new-features/tasty-reflect.md @@ -115,21 +115,21 @@ TASTy Reflect provides the following types: | +- SelectOuter | +- While | - | +- TypeTree ----+- Synthetic - | | +- Ident - | | +- Select - | | +- Project - | | +- Singleton - +- TypeOrBoundsTree ---+ +- Refined - | +- Applied - | +- Annotated - | +- MatchType - | +- ByName - | +- LambdaTypeTree - | +- Bind - | - +- TypeBoundsTree - +- SyntheticBounds + +- TypeTree ----+- Synthetic + | +- Ident + | +- Select + | +- Project + | +- Singleton + | +- Refined + | +- Applied + | +- Annotated + | +- MatchType + | +- ByName + | +- LambdaTypeTree + | +- Bind + | + +- TypeBoundsTree + +- SyntheticBounds +- CaseDef +- TypeCaseDef diff --git a/library/src/scala/tasty/reflect/Core.scala b/library/src/scala/tasty/reflect/Core.scala index 14ccf22adb27..c4238f7f0f44 100644 --- a/library/src/scala/tasty/reflect/Core.scala +++ b/library/src/scala/tasty/reflect/Core.scala @@ -37,22 +37,22 @@ package scala.tasty.reflect * | +- While * | * | - * | +- TypeTree ----+- TypeTree_Inferred - * | | +- TypeTree_Ident - * | | +- TypeTree_Select - * | | +- TypeTree_Project - * | | +- TypeTree_Singleton - * +- TypeOrBoundsTree -+ +- TypeTree_Refined - * | +- TypeTree_Applied - * | +- TypeTree_Annotated - * | +- TypeTree_MatchType - * | +- TypeTree_ByName - * | +- TypeTree_LambdaTypeTree - * | +- TypeTree_TypeBind - * | +- TypeTree_TypeBlock - * | - * +- TypeBoundsTree - * +- WildcardTypeTree + * +- TypeTree ----+- Inferred + * | +- Ident + * | +- Select + * | +- Project + * | +- Singleton + * | +- Refined + * | +- Applied + * | +- Annotated + * | +- MatchType + * | +- ByName + * | +- LambdaTypeTree + * | +- TypeBind + * | +- TypeBlock + * | + * +- TypeBoundsTree + * +- WildcardTypeTree * * +- CaseDef * +- TypeCaseDef @@ -230,9 +230,6 @@ trait Core { } - /** Type tree representing a type or a bounds written in the source */ - type TypeOrBoundsTree = kernel.TypeOrBoundsTree - /** Type tree representing a type written in the source */ type TypeTree = kernel.TypeTree diff --git a/library/src/scala/tasty/reflect/Kernel.scala b/library/src/scala/tasty/reflect/Kernel.scala index 280b045d0bb4..cea82200af47 100644 --- a/library/src/scala/tasty/reflect/Kernel.scala +++ b/library/src/scala/tasty/reflect/Kernel.scala @@ -36,22 +36,22 @@ package scala.tasty.reflect * | +- While * | * | - * | +- TypeTree ----+- TypeTree_Inferred - * | | +- TypeTree_Ident - * | | +- TypeTree_Select - * | | +- TypeTree_Project - * | | +- TypeTree_Singleton - * +- TypeOrBoundsTree -+ +- TypeTree_Refined - * | +- TypeTree_Applied - * | +- TypeTree_Annotated - * | +- TypeTree_MatchType - * | +- TypeTree_ByName - * | +- TypeTree_LambdaTypeTree - * | +- TypeTree_TypeBind - * | +- TypeTree_TypeBlock - * | - * +- TypeBoundsTree - * +- WildcardTypeTree + * +- TypeTree ----+- TypeTree_Inferred + * | +- TypeTree_Ident + * | +- TypeTree_Select + * | +- TypeTree_Project + * | +- TypeTree_Singleton + * | +- TypeTree_Refined + * | +- TypeTree_Applied + * | +- TypeTree_Annotated + * | +- TypeTree_MatchType + * | +- TypeTree_ByName + * | +- TypeTree_LambdaTypeTree + * | +- TypeTree_TypeBind + * | +- TypeTree_TypeBlock + * | + * +- TypeBoundsTree + * +- WildcardTypeTree * * +- CaseDef * +- TypeCaseDef @@ -229,11 +229,11 @@ trait Kernel { def matchTypeDef(tree: Tree)(implicit ctx: Context): Option[TypeDef] - def TypeDef_rhs(self: TypeDef)(implicit ctx: Context): TypeOrBoundsTree + def TypeDef_rhs(self: TypeDef)(implicit ctx: Context): Tree /*TypeTree | TypeBoundsTree*/ def TypeDef_symbol(self: TypeDef)(implicit ctx: Context): TypeSymbol def TypeDef_apply(symbol: TypeSymbol)(implicit ctx: Context): TypeDef - def TypeDef_copy(original: TypeDef)(name: String, rhs: TypeOrBoundsTree)(implicit ctx: Context): TypeDef + def TypeDef_copy(original: TypeDef)(name: String, rhs: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): TypeDef /** Tree representing a method definition in the source code */ type DefDef <: Definition @@ -509,13 +509,8 @@ trait Kernel { def While_apply(cond: Term, body: Term)(implicit ctx: Context): While def While_copy(original: Tree)(cond: Term, body: Term)(implicit ctx: Context): While - /** Type tree representing a type or a bounds written in the source */ - type TypeOrBoundsTree <: Tree - - def TypeOrBoundsTree_tpe(self: TypeOrBoundsTree)(implicit ctx: Context): Type - /** Type tree representing a type written in the source */ - type TypeTree <: TypeOrBoundsTree + type TypeTree <: Tree def matchTypeTree(tree: Tree)(implicit ctx: Context): Option[TypeTree] @@ -586,10 +581,10 @@ trait Kernel { def matchTypeTree_Applied(tree: Tree)(implicit ctx: Context): Option[TypeTree_Applied] def TypeTree_Applied_tpt(self: TypeTree_Applied)(implicit ctx: Context): TypeTree - def TypeTree_Applied_args(self: TypeTree_Applied)(implicit ctx: Context): List[TypeOrBoundsTree] + def TypeTree_Applied_args(self: TypeTree_Applied)(implicit ctx: Context): List[Tree /*TypeTree | TypeBoundsTree*/] - def TypeTree_Applied_apply(tpt: TypeTree, args: List[TypeOrBoundsTree])(implicit ctx: Context): TypeTree_Applied - def TypeTree_Applied_copy(original: TypeTree_Applied)(tpt: TypeTree, args: List[TypeOrBoundsTree])(implicit ctx: Context): TypeTree_Applied + def TypeTree_Applied_apply(tpt: TypeTree, args: List[Tree /*TypeTree | TypeBoundsTree*/])(implicit ctx: Context): TypeTree_Applied + def TypeTree_Applied_copy(original: TypeTree_Applied)(tpt: TypeTree, args: List[Tree /*TypeTree | TypeBoundsTree*/])(implicit ctx: Context): TypeTree_Applied /** Type tree representing an annotated type */ type TypeTree_Annotated <: TypeTree @@ -630,10 +625,10 @@ trait Kernel { def matchTypeTree_LambdaTypeTree(tree: Tree)(implicit ctx: Context): Option[TypeTree_LambdaTypeTree] def TypeTree_LambdaTypeTree_tparams(self: TypeTree_LambdaTypeTree)(implicit ctx: Context): List[TypeDef] - def TypeTree_LambdaTypeTree_body(self: TypeTree_LambdaTypeTree)(implicit ctx: Context): TypeOrBoundsTree + def TypeTree_LambdaTypeTree_body(self: TypeTree_LambdaTypeTree)(implicit ctx: Context): Tree /*TypeTree | TypeBoundsTree*/ - def TypeTree_LambdaTypeTree_apply(tparams: List[TypeDef], body: TypeOrBoundsTree)(implicit ctx: Context): TypeTree_LambdaTypeTree - def TypeTree_LambdaTypeTree_copy(original: TypeTree_LambdaTypeTree)(tparams: List[TypeDef], body: TypeOrBoundsTree)(implicit ctx: Context): TypeTree_LambdaTypeTree + def TypeTree_LambdaTypeTree_apply(tparams: List[TypeDef], body: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): TypeTree_LambdaTypeTree + def TypeTree_LambdaTypeTree_copy(original: TypeTree_LambdaTypeTree)(tparams: List[TypeDef], body: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): TypeTree_LambdaTypeTree /** Type tree representing a type binding */ type TypeTree_TypeBind <: TypeTree @@ -641,9 +636,9 @@ trait Kernel { def matchTypeTree_TypeBind(tree: Tree)(implicit ctx: Context): Option[TypeTree_TypeBind] def TypeTree_TypeBind_name(self: TypeTree_TypeBind)(implicit ctx: Context): String - def TypeTree_TypeBind_body(self: TypeTree_TypeBind)(implicit ctx: Context): TypeOrBoundsTree + def TypeTree_TypeBind_body(self: TypeTree_TypeBind)(implicit ctx: Context): Tree /*TypeTree | TypeBoundsTree*/ - def TypeTree_TypeBind_copy(original: TypeTree_TypeBind)(name: String, tpt: TypeOrBoundsTree)(implicit ctx: Context): TypeTree_TypeBind + def TypeTree_TypeBind_copy(original: TypeTree_TypeBind)(name: String, tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): TypeTree_TypeBind /** Type tree within a block with aliases `{ type U1 = ... ; T[U1, U2] }` */ type TypeTree_TypeBlock <: TypeTree @@ -657,7 +652,7 @@ trait Kernel { def TypeTree_TypeBlock_copy(original: TypeTree_TypeBlock)(aliases: List[TypeDef], tpt: TypeTree)(implicit ctx: Context): TypeTree_TypeBlock /** Type tree representing a type bound written in the source */ - type TypeBoundsTree <: TypeOrBoundsTree + type TypeBoundsTree <: Tree /*TypeTree | TypeBoundsTree*/ def matchTypeBoundsTree(tree: Tree)(implicit ctx: Context): Option[TypeBoundsTree] @@ -669,10 +664,12 @@ trait Kernel { * The wildcard type `_` (for example in in `List[_]`) will be a type tree that * represents a type but has `TypeBound`a inside. */ - type WildcardTypeTree <: TypeOrBoundsTree + type WildcardTypeTree <: Tree def matchWildcardTypeTree(tree: Tree)(implicit ctx: Context): Option[WildcardTypeTree] + def WildcardTypeTree_tpe(self: WildcardTypeTree)(implicit ctx: Context): TypeOrBounds + // // CASES // diff --git a/library/src/scala/tasty/reflect/Printers.scala b/library/src/scala/tasty/reflect/Printers.scala index fcba4754bf8a..2755abfff01c 100644 --- a/library/src/scala/tasty/reflect/Printers.scala +++ b/library/src/scala/tasty/reflect/Printers.scala @@ -1166,10 +1166,10 @@ trait Printers this += argCons.name argCons.rhs match { case IsTypeBoundsTree(rhs) => printBoundsTree(rhs) - case rhs @ WildcardTypeTree() => + case IsWildcardTypeTree(rhs) => printTypeOrBound(rhs.tpe) case rhs @ TypeTree.LambdaTypeTree(tparams, body) => - def printParam(t: TypeOrBoundsTree): Unit = t match { + def printParam(t: Tree /*TypeTree | TypeBoundsTree*/): Unit = t match { case IsTypeBoundsTree(t) => printBoundsTree(t) case IsTypeTree(t) => printTypeTree(t) } @@ -1347,13 +1347,13 @@ trait Printers this += highlightLiteral("'" + v.name, color) } - def printTypeOrBoundsTree(tpt: TypeOrBoundsTree): Buffer = tpt match { + def printTypeOrBoundsTree(tpt: Tree /*TypeTree | TypeBoundsTree*/): Buffer = tpt match { case TypeBoundsTree(lo, hi) => this += "_ >: " printTypeTree(lo) this += " <: " printTypeTree(hi) - case tpt @ WildcardTypeTree() => + case IsWildcardTypeTree(tpt) => printTypeOrBound(tpt.tpe) case IsTypeTree(tpt) => printTypeTree(tpt) diff --git a/library/src/scala/tasty/reflect/TreeOps.scala b/library/src/scala/tasty/reflect/TreeOps.scala index 8c4e7267995e..d60ad0ff9372 100644 --- a/library/src/scala/tasty/reflect/TreeOps.scala +++ b/library/src/scala/tasty/reflect/TreeOps.scala @@ -143,14 +143,14 @@ trait TreeOps extends Core { object TypeDef { def apply(symbol: TypeSymbol)(implicit ctx: Context): TypeDef = kernel.TypeDef_apply(symbol) - def copy(original: TypeDef)(name: String, rhs: TypeOrBoundsTree)(implicit ctx: Context): TypeDef = + def copy(original: TypeDef)(name: String, rhs: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): TypeDef = kernel.TypeDef_copy(original)(name, rhs) - def unapply(tree: Tree)(implicit ctx: Context): Option[(String, TypeOrBoundsTree /* TypeTree | TypeBoundsTree */)] = + def unapply(tree: Tree)(implicit ctx: Context): Option[(String, Tree /*TypeTree | TypeBoundsTree*/ /* TypeTree | TypeBoundsTree */)] = kernel.matchTypeDef(tree).map(x => (x.name, x.rhs)) } implicit class TypeDefAPI(self: TypeDef) { - def rhs(implicit ctx: Context): TypeOrBoundsTree = kernel.TypeDef_rhs(self) + def rhs(implicit ctx: Context): Tree /*TypeTree | TypeBoundsTree*/ = kernel.TypeDef_rhs(self) def symbol(implicit ctx: Context): TypeSymbol = kernel.TypeDef_symbol(self) } @@ -733,12 +733,6 @@ trait TreeOps extends Core { def body(implicit ctx: Context): Term = kernel.While_body(self) } - // ----- TypeOrBoundsTree ------------------------------------------------ - - implicit class TypeOrBoundsTreeAPI(self: TypeOrBoundsTree) { - def tpe(implicit ctx: Context): TypeOrBounds = kernel.TypeOrBoundsTree_tpe(self) - } - // ----- TypeTrees ------------------------------------------------ implicit class TypeTreeAPI(self: TypeTree) { @@ -853,11 +847,11 @@ trait TreeOps extends Core { } object Applied { - def apply(tpt: TypeTree, args: List[TypeOrBoundsTree])(implicit ctx: Context): Applied = + def apply(tpt: TypeTree, args: List[Tree /*TypeTree | TypeBoundsTree*/])(implicit ctx: Context): Applied = kernel.TypeTree_Applied_apply(tpt, args) - def copy(original: Applied)(tpt: TypeTree, args: List[TypeOrBoundsTree])(implicit ctx: Context): Applied = + def copy(original: Applied)(tpt: TypeTree, args: List[Tree /*TypeTree | TypeBoundsTree*/])(implicit ctx: Context): Applied = kernel.TypeTree_Applied_copy(original)(tpt, args) - def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, List[TypeOrBoundsTree])] = + def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, List[Tree /*TypeTree | TypeBoundsTree*/])] = kernel.matchTypeTree_Applied(tree).map(x => (x.tpt, x.args)) } @@ -913,11 +907,11 @@ trait TreeOps extends Core { } object LambdaTypeTree { - def apply(tparams: List[TypeDef], body: TypeOrBoundsTree)(implicit ctx: Context): LambdaTypeTree = + def apply(tparams: List[TypeDef], body: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): LambdaTypeTree = kernel.TypeTree_LambdaTypeTree_apply(tparams, body) - def copy(original: LambdaTypeTree)(tparams: List[TypeDef], body: TypeOrBoundsTree)(implicit ctx: Context): LambdaTypeTree = + def copy(original: LambdaTypeTree)(tparams: List[TypeDef], body: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): LambdaTypeTree = kernel.TypeTree_LambdaTypeTree_copy(original)(tparams, body) - def unapply(tree: Tree)(implicit ctx: Context): Option[(List[TypeDef], TypeOrBoundsTree)] = + def unapply(tree: Tree)(implicit ctx: Context): Option[(List[TypeDef], Tree /*TypeTree | TypeBoundsTree*/)] = kernel.matchTypeTree_LambdaTypeTree(tree).map(x => (x.tparams, x.body)) } @@ -929,9 +923,9 @@ trait TreeOps extends Core { object TypeBind { // TODO def apply(name: String, tree: Tree)(implicit ctx: Context): TypeBind - def copy(original: TypeBind)(name: String, tpt: TypeOrBoundsTree)(implicit ctx: Context): TypeBind = + def copy(original: TypeBind)(name: String, tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): TypeBind = kernel.TypeTree_TypeBind_copy(original)(name, tpt) - def unapply(tree: Tree)(implicit ctx: Context): Option[(String, TypeOrBoundsTree)] = + def unapply(tree: Tree)(implicit ctx: Context): Option[(String, Tree /*TypeTree | TypeBoundsTree*/)] = kernel.matchTypeTree_TypeBind(tree).map(x => (x.name, x.body)) } @@ -976,7 +970,7 @@ trait TreeOps extends Core { implicit class TypeTree_AppliedAPI(self: TypeTree.Applied) { def tpt(implicit ctx: Context): TypeTree = kernel.TypeTree_Applied_tpt(self) - def args(implicit ctx: Context): List[TypeOrBoundsTree] = kernel.TypeTree_Applied_args(self) + def args(implicit ctx: Context): List[Tree /*TypeTree | TypeBoundsTree*/] = kernel.TypeTree_Applied_args(self) } implicit class TypeTree_AnnotatedAPI(self: TypeTree.Annotated) { @@ -996,12 +990,12 @@ trait TreeOps extends Core { implicit class TypeTree_LambdaTypeTreeAPI(self: TypeTree.LambdaTypeTree) { def tparams(implicit ctx: Context): List[TypeDef] = kernel.TypeTree_LambdaTypeTree_tparams(self) - def body(implicit ctx: Context): TypeOrBoundsTree = kernel.TypeTree_LambdaTypeTree_body(self) + def body(implicit ctx: Context): Tree /*TypeTree | TypeBoundsTree*/ = kernel.TypeTree_LambdaTypeTree_body(self) } implicit class TypeTree_TypeBindAPI(self: TypeTree.TypeBind) { def name(implicit ctx: Context): String = kernel.TypeTree_TypeBind_name(self) - def body(implicit ctx: Context): TypeOrBoundsTree = kernel.TypeTree_TypeBind_body(self) + def body(implicit ctx: Context): Tree /*TypeTree | TypeBoundsTree*/ = kernel.TypeTree_TypeBind_body(self) } implicit class TypeTree_TypeBlockAPI(self: TypeTree.TypeBlock) { @@ -1027,6 +1021,10 @@ trait TreeOps extends Core { kernel.matchTypeBoundsTree(tree).map(x => (x.low, x.hi)) } + implicit class WildcardTypeTreeAPI(self: WildcardTypeTree) { + def tpe(implicit ctx: Context): TypeOrBounds = kernel.WildcardTypeTree_tpe(self) + } + object IsWildcardTypeTree { def unapply(tree: Tree)(implicit ctx: Context): Option[WildcardTypeTree] = kernel.matchWildcardTypeTree(tree) diff --git a/library/src/scala/tasty/reflect/TreeUtils.scala b/library/src/scala/tasty/reflect/TreeUtils.scala index f575d61d5dd9..583b24eb2eb2 100644 --- a/library/src/scala/tasty/reflect/TreeUtils.scala +++ b/library/src/scala/tasty/reflect/TreeUtils.scala @@ -167,7 +167,7 @@ trait TreeUtils DefDef.copy(tree)(tree.name, transformSubTrees(tree.typeParams), tree.paramss mapConserve (transformSubTrees(_)), transformTypeTree(tree.returnTpt), tree.rhs.map(x => transformTerm(x))) case IsTypeDef(tree) => implicit val ctx = localCtx(tree) - TypeDef.copy(tree)(tree.name, transformTypeOrBoundsTree(tree.rhs)) + TypeDef.copy(tree)(tree.name, transformTree(tree.rhs)) case IsClassDef(tree) => ClassDef.copy(tree)(tree.name, tree.constructor, tree.parents, tree.derived, tree.self, tree.body) case IsImport(tree) => @@ -220,12 +220,6 @@ trait TreeUtils } } - def transformTypeOrBoundsTree(tree: TypeOrBoundsTree)(implicit ctx: Context): TypeOrBoundsTree = tree match { - case IsTypeTree(tree) => transformTypeTree(tree) - case IsTypeBoundsTree(tree) => tree // TODO traverse tree - case IsWildcardTypeTree(tree) => tree // TODO traverse tree - } - def transformTypeTree(tree: TypeTree)(implicit ctx: Context): TypeTree = tree match { case TypeTree.Inferred() => tree case TypeTree.IsIdent(tree) => tree @@ -240,13 +234,13 @@ trait TreeUtils case TypeTree.IsRefined(tree) => TypeTree.Refined.copy(tree)(transformTypeTree(tree.tpt), transformTrees(tree.refinements).asInstanceOf[List[Definition]]) case TypeTree.IsApplied(tree) => - TypeTree.Applied.copy(tree)(transformTypeTree(tree.tpt), transformTypeOrBoundsTrees(tree.args)) + TypeTree.Applied.copy(tree)(transformTypeTree(tree.tpt), transformTrees(tree.args)) case TypeTree.IsMatchType(tree) => TypeTree.MatchType.copy(tree)(tree.bound.map(b => transformTypeTree(b)), transformTypeTree(tree.selector), transformTypeCaseDefs(tree.cases)) case TypeTree.IsByName(tree) => TypeTree.ByName.copy(tree)(transformTypeTree(tree.result)) case TypeTree.IsLambdaTypeTree(tree) => - TypeTree.LambdaTypeTree.copy(tree)(transformSubTrees(tree.tparams), transformTypeOrBoundsTree(tree.body))(tree.symbol.localContext) + TypeTree.LambdaTypeTree.copy(tree)(transformSubTrees(tree.tparams), transformTree(tree.body))(tree.symbol.localContext) case TypeTree.IsTypeBind(tree) => TypeTree.TypeBind.copy(tree)(tree.name, tree.body) case TypeTree.IsTypeBlock(tree) => @@ -286,9 +280,6 @@ trait TreeUtils def transformTypeTrees(trees: List[TypeTree])(implicit ctx: Context): List[TypeTree] = trees mapConserve (transformTypeTree(_)) - def transformTypeOrBoundsTrees(trees: List[TypeOrBoundsTree])(implicit ctx: Context): List[TypeOrBoundsTree] = - trees mapConserve (transformTypeOrBoundsTree(_)) - def transformCaseDefs(trees: List[CaseDef])(implicit ctx: Context): List[CaseDef] = trees mapConserve (transformCaseDef(_)) diff --git a/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala b/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala index c499971a3057..a4a865722f7e 100644 --- a/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala +++ b/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala @@ -40,7 +40,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum object ChildTraverser extends TreeTraverser { var children: List[Tree] = Nil - var childrenType: List[TypeOrBoundsTree] = Nil + var childrenType: List[Tree /*TypeTree | TypeBoundsTree*/] = Nil override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = tree match { case IsTypeTree(tree) => traverseTypeTree(tree) @@ -50,7 +50,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum } override def traversePattern(pattern: Pattern)( implicit ctx: Context): Unit = () - def traverseTypeTree(tree: TypeOrBoundsTree)( + def traverseTypeTree(tree: Tree /*TypeTree | TypeBoundsTree*/)( implicit ctx: Context): Unit = childrenType = tree :: childrenType override def traverseCaseDef(tree: CaseDef)(implicit ctx: Context): Unit = @@ -64,7 +64,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum traverseTreeChildren(tree)(ctx) return children } - def getChildrenType(tree: TypeOrBoundsTree)(implicit ctx: Context): List[TypeOrBoundsTree] = { + def getChildrenType(tree: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): List[Tree /*TypeTree | TypeBoundsTree*/] = { childrenType = Nil traverseTreeChildren(tree)(ctx) return childrenType @@ -99,7 +99,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum } } - implicit class TypeOrBoundsTreeExtender(tree: TypeOrBoundsTree) { + implicit class TypeOrBoundsTreeExtender(tree: Tree /*TypeTree | TypeBoundsTree*/) { def typetree: TypeTree = tree match { case IsTypeTree(t) => t } @@ -636,7 +636,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum }) } - def traverseTypeTree(tree: TypeOrBoundsTree)( + def traverseTypeTree(tree: Tree /*TypeTree | TypeBoundsTree*/)( implicit ctx: Context): Unit = { tree match { case TypeTree.Ident(_) => { From 57b8dad4eff84c6f5ca14331c299df75ce72653f Mon Sep 17 00:00:00 2001 From: Nicolas Stucki Date: Sun, 10 Mar 2019 09:43:58 +0100 Subject: [PATCH 08/10] Make TASTy reflect CaseDef <: Tree and TypeCaseDef <: Tree --- .../tools/dotc/tastyreflect/KernelImpl.scala | 14 +++++-- .../other-new-features/tasty-reflect.md | 5 +-- .../src/scala/tasty/reflect/CaseDefOps.scala | 18 +++++++-- library/src/scala/tasty/reflect/Core.scala | 5 +-- library/src/scala/tasty/reflect/Kernel.scala | 17 ++++---- .../src/scala/tasty/reflect/Printers.scala | 40 ++----------------- tests/run/tasty-custom-show/quoted_1.scala | 1 - 7 files changed, 40 insertions(+), 60 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala index d25c7085ead8..eda23f2948d7 100644 --- a/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala +++ b/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala @@ -820,12 +820,13 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. def WildcardTypeTree_tpe(self: WildcardTypeTree)(implicit ctx: Context): TypeOrBounds = self.tpe.stripTypeVar - // - // CASES - // - type CaseDef = tpd.CaseDef + def matchCaseDef(tree: Tree)(implicit ctx: Context): Option[CaseDef] = tree match { + case tree: tpd.CaseDef if tree.body.isTerm => Some(tree) + case _ => None + } + def CaseDef_pattern(self: CaseDef)(implicit ctx: Context): Pattern = self.pat def CaseDef_guard(self: CaseDef)(implicit ctx: Context): Option[Term] = optional(self.guard) def CaseDef_rhs(self: CaseDef)(implicit ctx: Context): Term = self.body @@ -838,6 +839,11 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util. type TypeCaseDef = tpd.CaseDef + def matchTypeCaseDef(tree: Tree)(implicit ctx: Context): Option[TypeCaseDef] = tree match { + case tree: tpd.CaseDef if tree.body.isType => Some(tree) + case _ => None + } + def TypeCaseDef_pattern(self: TypeCaseDef)(implicit ctx: Context): TypeTree = self.pat def TypeCaseDef_rhs(self: TypeCaseDef)(implicit ctx: Context): TypeTree = self.body diff --git a/docs/docs/reference/other-new-features/tasty-reflect.md b/docs/docs/reference/other-new-features/tasty-reflect.md index 7a9f0a660f1d..eacbc2b16625 100644 --- a/docs/docs/reference/other-new-features/tasty-reflect.md +++ b/docs/docs/reference/other-new-features/tasty-reflect.md @@ -130,9 +130,8 @@ TASTy Reflect provides the following types: | +- TypeBoundsTree +- SyntheticBounds - -+- CaseDef -+- TypeCaseDef + +- CaseDef + +- TypeCaseDef +- Pattern --+- Value +- Bind diff --git a/library/src/scala/tasty/reflect/CaseDefOps.scala b/library/src/scala/tasty/reflect/CaseDefOps.scala index 5b595f4e337e..3760628d749b 100644 --- a/library/src/scala/tasty/reflect/CaseDefOps.scala +++ b/library/src/scala/tasty/reflect/CaseDefOps.scala @@ -10,6 +10,11 @@ trait CaseDefOps extends Core { def rhs(implicit ctx: Context): Term = kernel.CaseDef_rhs(caseDef) } + object IsCaseDef { + def unapply(self: Tree)(implicit ctx: Context): Option[CaseDef] = + kernel.matchCaseDef(self) + } + object CaseDef { def apply(pattern: Pattern, guard: Option[Term], rhs: Term)(implicit ctx: Context): CaseDef = kernel.CaseDef_module_apply(pattern, guard, rhs) @@ -17,8 +22,8 @@ trait CaseDefOps extends Core { def copy(original: CaseDef)(pattern: Pattern, guard: Option[Term], rhs: Term)(implicit ctx: Context): CaseDef = kernel.CaseDef_module_copy(original)(pattern, guard, rhs) - def unapply(x: CaseDef)(implicit ctx: Context): Option[(Pattern, Option[Term], Term)] = - Some((x.pattern, x.guard, x.rhs)) + def unapply(tree: Tree)(implicit ctx: Context): Option[(Pattern, Option[Term], Term)] = + kernel.matchCaseDef(tree).map( x => (x.pattern, x.guard, x.rhs)) } implicit class TypeCaseDefAPI(caseDef: TypeCaseDef) { @@ -26,6 +31,11 @@ trait CaseDefOps extends Core { def rhs(implicit ctx: Context): TypeTree = kernel.TypeCaseDef_rhs(caseDef) } + object IsTypeCaseDef { + def unapply(self: Tree)(implicit ctx: Context): Option[TypeCaseDef] = + kernel.matchTypeCaseDef(self) + } + object TypeCaseDef { def apply(pattern: TypeTree, rhs: TypeTree)(implicit ctx: Context): TypeCaseDef = kernel.TypeCaseDef_module_apply(pattern, rhs) @@ -33,8 +43,8 @@ trait CaseDefOps extends Core { def copy(original: TypeCaseDef)(pattern: TypeTree, rhs: TypeTree)(implicit ctx: Context): TypeCaseDef = kernel.TypeCaseDef_module_copy(original)(pattern, rhs) - def unapply(x: TypeCaseDef)(implicit ctx: Context): Option[(TypeTree, TypeTree)] = - Some((x.pattern, x.rhs)) + def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, TypeTree)] = + kernel.matchTypeCaseDef(tree).map( x => (x.pattern, x.rhs)) } } diff --git a/library/src/scala/tasty/reflect/Core.scala b/library/src/scala/tasty/reflect/Core.scala index c4238f7f0f44..40c54cb5b66c 100644 --- a/library/src/scala/tasty/reflect/Core.scala +++ b/library/src/scala/tasty/reflect/Core.scala @@ -53,9 +53,8 @@ package scala.tasty.reflect * | * +- TypeBoundsTree * +- WildcardTypeTree - * - * +- CaseDef - * +- TypeCaseDef + * +- CaseDef + * +- TypeCaseDef * * +- Pattern --+- Value * +- Bind diff --git a/library/src/scala/tasty/reflect/Kernel.scala b/library/src/scala/tasty/reflect/Kernel.scala index cea82200af47..0163f510ed8f 100644 --- a/library/src/scala/tasty/reflect/Kernel.scala +++ b/library/src/scala/tasty/reflect/Kernel.scala @@ -52,9 +52,8 @@ package scala.tasty.reflect * | * +- TypeBoundsTree * +- WildcardTypeTree - * - * +- CaseDef - * +- TypeCaseDef + * +- CaseDef + * +- TypeCaseDef * * +- Pattern --+- Value * +- Bind @@ -670,12 +669,10 @@ trait Kernel { def WildcardTypeTree_tpe(self: WildcardTypeTree)(implicit ctx: Context): TypeOrBounds - // - // CASES - // - /** Branch of a pattern match or catch clause */ - type CaseDef <: AnyRef + type CaseDef <: Tree + + def matchCaseDef(tree: Tree)(implicit ctx: Context): Option[CaseDef] def CaseDef_pattern(self: CaseDef)(implicit ctx: Context): Pattern def CaseDef_guard(self: CaseDef)(implicit ctx: Context): Option[Term] @@ -685,7 +682,9 @@ trait Kernel { def CaseDef_module_copy(original: CaseDef)(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef /** Branch of a type pattern match */ - type TypeCaseDef <: AnyRef + type TypeCaseDef <: Tree + + def matchTypeCaseDef(tree: Tree)(implicit ctx: Context): Option[TypeCaseDef] def TypeCaseDef_pattern(self: TypeCaseDef)(implicit ctx: Context): TypeTree def TypeCaseDef_rhs(self: TypeCaseDef)(implicit ctx: Context): TypeTree diff --git a/library/src/scala/tasty/reflect/Printers.scala b/library/src/scala/tasty/reflect/Printers.scala index 2755abfff01c..7ad4227d18c6 100644 --- a/library/src/scala/tasty/reflect/Printers.scala +++ b/library/src/scala/tasty/reflect/Printers.scala @@ -38,14 +38,6 @@ trait Printers def showCode(implicit ctx: Context): String = new SourceCodePrinter().showTypeOrBounds(tpe) } - /** Adds `show` as an extension method of a `CaseDef` */ - implicit class CaseDefShowDeco(caseDef: CaseDef) { - /** Shows the tree as extractors */ - def show(implicit ctx: Context): String = new ExtractorsPrinter().showCaseDef(caseDef) - /** Shows the tree as source code */ - def showCode(implicit ctx: Context): String = new SourceCodePrinter().showCaseDef(caseDef) - } - /** Adds `show` as an extension method of a `Pattern` */ implicit class PatternShowDeco(pattern: Pattern) { /** Shows the tree as extractors */ @@ -82,8 +74,6 @@ trait Printers def showTree(tree: Tree)(implicit ctx: Context): String - def showCaseDef(caseDef: CaseDef)(implicit ctx: Context): String - def showPattern(pattern: Pattern)(implicit ctx: Context): String def showTypeOrBounds(tpe: TypeOrBounds)(implicit ctx: Context): String @@ -101,9 +91,6 @@ trait Printers def showTree(tree: Tree)(implicit ctx: Context): String = new Buffer().visitTree(tree).result() - def showCaseDef(caseDef: CaseDef)(implicit ctx: Context): String = - new Buffer().visitCaseDef(caseDef).result() - def showPattern(pattern: Pattern)(implicit ctx: Context): String = new Buffer().visitPattern(pattern).result() @@ -251,16 +238,10 @@ trait Printers this += s"WildcardTypeTree()" case TypeTree.MatchType(bound, selector, cases) => this += "TypeTree.MatchType(" += bound += ", " += selector += ", " ++= cases += ")" - } - - def visitCaseDef(x: CaseDef): Buffer = { - val CaseDef(pat, guard, body) = x - this += "CaseDef(" += pat += ", " += guard += ", " += body += ")" - } - - def visitTypeCaseDef(x: TypeCaseDef): Buffer = { - val TypeCaseDef(pat, body) = x - this += "TypeCaseDef(" += pat += ", " += body += ")" + case CaseDef(pat, guard, body) => + this += "CaseDef(" += pat += ", " += guard += ", " += body += ")" + case TypeCaseDef(pat, body) => + this += "TypeCaseDef(" += pat += ", " += body += ")" } def visitPattern(x: Pattern): Buffer = x match { @@ -382,16 +363,6 @@ trait Printers def +++=(x: List[List[Tree]]): Buffer = { visitList(x, ++=); buff } } - private implicit class CaseDefOps(buff: Buffer) { - def +=(x: CaseDef): Buffer = { visitCaseDef(x); buff } - def ++=(x: List[CaseDef]): Buffer = { visitList(x, visitCaseDef); buff } - } - - private implicit class TypeCaseDefOps(buff: Buffer) { - def +=(x: TypeCaseDef): Buffer = { visitTypeCaseDef(x); buff } - def ++=(x: List[TypeCaseDef]): Buffer = { visitList(x, visitTypeCaseDef); buff } - } - private implicit class PatternOps(buff: Buffer) { def +=(x: Pattern): Buffer = { visitPattern(x); buff } def ++=(x: List[Pattern]): Buffer = { visitList(x, visitPattern); buff } @@ -459,9 +430,6 @@ trait Printers def showTree(tree: Tree)(implicit ctx: Context): String = (new Buffer).printTree(tree).result() - def showCaseDef(caseDef: CaseDef)(implicit ctx: Context): String = - (new Buffer).printCaseDef(caseDef).result() - def showPattern(pattern: Pattern)(implicit ctx: Context): String = (new Buffer).printPattern(pattern).result() diff --git a/tests/run/tasty-custom-show/quoted_1.scala b/tests/run/tasty-custom-show/quoted_1.scala index 2b9fb7d08156..cc7914565c4a 100644 --- a/tests/run/tasty-custom-show/quoted_1.scala +++ b/tests/run/tasty-custom-show/quoted_1.scala @@ -42,7 +42,6 @@ object Macros { import reflect._ new Printer { def showTree(tree: Tree)(implicit ctx: Context): String = "Tree" - def showCaseDef(caseDef: CaseDef)(implicit ctx: Context): String = "CaseDef" def showPattern(pattern: Pattern)(implicit ctx: Context): String = "Pattern" def showTypeOrBounds(tpe: TypeOrBounds)(implicit ctx: Context): String = "TypeOrBounds" def showConstant(const: Constant)(implicit ctx: Context): String = "Constant" From 3c34dbca0eb84beee414a8d9b087b9c470c111d4 Mon Sep 17 00:00:00 2001 From: Nicolas Stucki Date: Sun, 10 Mar 2019 09:52:07 +0100 Subject: [PATCH 09/10] Simplify TreeAccumulator --- .../src/scala/tasty/reflect/TreeUtils.scala | 30 ++++++------------- 1 file changed, 9 insertions(+), 21 deletions(-) diff --git a/library/src/scala/tasty/reflect/TreeUtils.scala b/library/src/scala/tasty/reflect/TreeUtils.scala index 583b24eb2eb2..ddbeeabd290b 100644 --- a/library/src/scala/tasty/reflect/TreeUtils.scala +++ b/library/src/scala/tasty/reflect/TreeUtils.scala @@ -13,13 +13,9 @@ trait TreeUtils // Ties the knot of the traversal: call `foldOver(x, tree))` to dive in the `tree` node. def foldTree(x: X, tree: Tree)(implicit ctx: Context): X - def foldCaseDef(x: X, tree: CaseDef)(implicit ctx: Context): X - def foldTypeCaseDef(x: X, tree: TypeCaseDef)(implicit ctx: Context): X def foldPattern(x: X, tree: Pattern)(implicit ctx: Context): X def foldTrees(x: X, trees: Iterable[Tree])(implicit ctx: Context): X = (x /: trees)(foldTree) - def foldCaseDefs(x: X, trees: Iterable[CaseDef])(implicit ctx: Context): X = (x /: trees)(foldCaseDef) - def foldTypeCaseDefs(x: X, trees: Iterable[TypeCaseDef])(implicit ctx: Context): X = (x /: trees)(foldTypeCaseDef) def foldPatterns(x: X, trees: Iterable[Pattern])(implicit ctx: Context): X = (x /: trees)(foldPattern) def foldOverTree(x: X, tree: Tree)(implicit ctx: Context): X = { @@ -55,11 +51,11 @@ trait TreeUtils val a = foldTree(x, meth) tpt.fold(a)(b => foldTree(a, b)) case Term.Match(selector, cases) => - foldCaseDefs(foldTree(x, selector), cases) + foldTrees(foldTree(x, selector), cases) case Term.Return(expr) => foldTree(x, expr) case Term.Try(block, handler, finalizer) => - foldTrees(foldCaseDefs(foldTree(x, block), handler), finalizer) + foldTrees(foldTrees(foldTree(x, block), handler), finalizer) case Term.Repeated(elems, elemtpt) => foldTrees(foldTree(x, elemtpt), elems) case Term.Inlined(call, bindings, expansion) => @@ -93,20 +89,14 @@ trait TreeUtils case TypeTree.TypeBind(_, tbt) => foldTree(x, tbt) case TypeTree.TypeBlock(typedefs, tpt) => foldTree(foldTrees(x, typedefs), tpt) case TypeTree.MatchType(boundopt, selector, cases) => - foldTypeCaseDefs(foldTree(boundopt.fold(x)(foldTree(x, _)), selector), cases) + foldTrees(foldTree(boundopt.fold(x)(foldTree(x, _)), selector), cases) case WildcardTypeTree() => x case TypeBoundsTree(lo, hi) => foldTree(foldTree(x, lo), hi) + case CaseDef(pat, guard, body) => foldTree(foldTrees(foldPattern(x, pat), guard), body) + case TypeCaseDef(pat, body) => foldTree(foldTree(x, pat), body) } } - def foldOverCaseDef(x: X, tree: CaseDef)(implicit ctx: Context): X = tree match { - case CaseDef(pat, guard, body) => foldTree(foldTrees(foldPattern(x, pat), guard), body) - } - - def foldOverTypeCaseDef(x: X, tree: TypeCaseDef)(implicit ctx: Context): X = tree match { - case TypeCaseDef(pat, body) => foldTree(foldTree(x, pat), body) - } - def foldOverPattern(x: X, tree: Pattern)(implicit ctx: Context): X = tree match { case Pattern.Value(v) => foldTree(x, v) case Pattern.Bind(_, body) => foldPattern(x, body) @@ -120,18 +110,12 @@ trait TreeUtils abstract class TreeTraverser extends TreeAccumulator[Unit] { def traverseTree(tree: Tree)(implicit ctx: Context): Unit = traverseTreeChildren(tree) - def traverseCaseDef(tree: CaseDef)(implicit ctx: Context): Unit = traverseCaseDefChildren(tree) - def traverseTypeCaseDef(tree: TypeCaseDef)(implicit ctx: Context): Unit = traverseTypeCaseDefChildren(tree) def traversePattern(tree: Pattern)(implicit ctx: Context): Unit = traversePatternChildren(tree) def foldTree(x: Unit, tree: Tree)(implicit ctx: Context): Unit = traverseTree(tree) - def foldCaseDef(x: Unit, tree: CaseDef)(implicit ctx: Context) = traverseCaseDef(tree) - def foldTypeCaseDef(x: Unit, tree: TypeCaseDef)(implicit ctx: Context) = traverseTypeCaseDef(tree) def foldPattern(x: Unit, tree: Pattern)(implicit ctx: Context) = traversePattern(tree) protected def traverseTreeChildren(tree: Tree)(implicit ctx: Context): Unit = foldOverTree((), tree) - protected def traverseCaseDefChildren(tree: CaseDef)(implicit ctx: Context): Unit = foldOverCaseDef((), tree) - protected def traverseTypeCaseDefChildren(tree: TypeCaseDef)(implicit ctx: Context): Unit = foldOverTypeCaseDef((), tree) protected def traversePatternChildren(tree: Pattern)(implicit ctx: Context): Unit = foldOverPattern((), tree) } @@ -149,6 +133,10 @@ trait TreeUtils case IsTypeTree(tree) => transformTypeTree(tree) case IsTypeBoundsTree(tree) => tree // TODO traverse tree case IsWildcardTypeTree(tree) => tree // TODO traverse tree + case IsCaseDef(tree) => + transformCaseDef(tree) + case IsTypeCaseDef(tree) => + transformTypeCaseDef(tree) } } From ae252e1ef4a40be95fc311cb815b62f8e78be98b Mon Sep 17 00:00:00 2001 From: Nicolas Stucki Date: Sun, 10 Mar 2019 09:54:48 +0100 Subject: [PATCH 10/10] Move logic of CaseDefOps into TreeOps --- library/src/scala/tasty/Reflection.scala | 1 - .../src/scala/tasty/reflect/CaseDefOps.scala | 50 ------------------- .../src/scala/tasty/reflect/Printers.scala | 1 - library/src/scala/tasty/reflect/TreeOps.scala | 44 ++++++++++++++++ .../src/scala/tasty/reflect/TreeUtils.scala | 1 - .../dotty/semanticdb/SemanticdbConsumer.scala | 5 -- 6 files changed, 44 insertions(+), 58 deletions(-) delete mode 100644 library/src/scala/tasty/reflect/CaseDefOps.scala diff --git a/library/src/scala/tasty/Reflection.scala b/library/src/scala/tasty/Reflection.scala index e9cdfc0599de..b7fecff9a9d7 100644 --- a/library/src/scala/tasty/Reflection.scala +++ b/library/src/scala/tasty/Reflection.scala @@ -4,7 +4,6 @@ import scala.tasty.reflect._ abstract class Reflection extends Core - with CaseDefOps with ConstantOps with ContextOps with CommentOps diff --git a/library/src/scala/tasty/reflect/CaseDefOps.scala b/library/src/scala/tasty/reflect/CaseDefOps.scala deleted file mode 100644 index 3760628d749b..000000000000 --- a/library/src/scala/tasty/reflect/CaseDefOps.scala +++ /dev/null @@ -1,50 +0,0 @@ -package scala.tasty -package reflect - -/** Tasty reflect case definition */ -trait CaseDefOps extends Core { - - implicit class CaseDefAPI(caseDef: CaseDef) { - def pattern(implicit ctx: Context): Pattern = kernel.CaseDef_pattern(caseDef) - def guard(implicit ctx: Context): Option[Term] = kernel.CaseDef_guard(caseDef) - def rhs(implicit ctx: Context): Term = kernel.CaseDef_rhs(caseDef) - } - - object IsCaseDef { - def unapply(self: Tree)(implicit ctx: Context): Option[CaseDef] = - kernel.matchCaseDef(self) - } - - object CaseDef { - def apply(pattern: Pattern, guard: Option[Term], rhs: Term)(implicit ctx: Context): CaseDef = - kernel.CaseDef_module_apply(pattern, guard, rhs) - - def copy(original: CaseDef)(pattern: Pattern, guard: Option[Term], rhs: Term)(implicit ctx: Context): CaseDef = - kernel.CaseDef_module_copy(original)(pattern, guard, rhs) - - def unapply(tree: Tree)(implicit ctx: Context): Option[(Pattern, Option[Term], Term)] = - kernel.matchCaseDef(tree).map( x => (x.pattern, x.guard, x.rhs)) - } - - implicit class TypeCaseDefAPI(caseDef: TypeCaseDef) { - def pattern(implicit ctx: Context): TypeTree = kernel.TypeCaseDef_pattern(caseDef) - def rhs(implicit ctx: Context): TypeTree = kernel.TypeCaseDef_rhs(caseDef) - } - - object IsTypeCaseDef { - def unapply(self: Tree)(implicit ctx: Context): Option[TypeCaseDef] = - kernel.matchTypeCaseDef(self) - } - - object TypeCaseDef { - def apply(pattern: TypeTree, rhs: TypeTree)(implicit ctx: Context): TypeCaseDef = - kernel.TypeCaseDef_module_apply(pattern, rhs) - - def copy(original: TypeCaseDef)(pattern: TypeTree, rhs: TypeTree)(implicit ctx: Context): TypeCaseDef = - kernel.TypeCaseDef_module_copy(original)(pattern, rhs) - - def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, TypeTree)] = - kernel.matchTypeCaseDef(tree).map( x => (x.pattern, x.rhs)) - } - -} diff --git a/library/src/scala/tasty/reflect/Printers.scala b/library/src/scala/tasty/reflect/Printers.scala index 7ad4227d18c6..4f0a749d94c2 100644 --- a/library/src/scala/tasty/reflect/Printers.scala +++ b/library/src/scala/tasty/reflect/Printers.scala @@ -8,7 +8,6 @@ import scala.tasty.util.Chars trait Printers extends Core - with CaseDefOps with ConstantOps with FlagsOps with IdOps diff --git a/library/src/scala/tasty/reflect/TreeOps.scala b/library/src/scala/tasty/reflect/TreeOps.scala index d60ad0ff9372..2c456949d777 100644 --- a/library/src/scala/tasty/reflect/TreeOps.scala +++ b/library/src/scala/tasty/reflect/TreeOps.scala @@ -1037,4 +1037,48 @@ trait TreeOps extends Core { kernel.matchWildcardTypeTree(tree).isDefined } + // ----- CaseDefs ------------------------------------------------ + + implicit class CaseDefAPI(caseDef: CaseDef) { + def pattern(implicit ctx: Context): Pattern = kernel.CaseDef_pattern(caseDef) + def guard(implicit ctx: Context): Option[Term] = kernel.CaseDef_guard(caseDef) + def rhs(implicit ctx: Context): Term = kernel.CaseDef_rhs(caseDef) + } + + object IsCaseDef { + def unapply(self: Tree)(implicit ctx: Context): Option[CaseDef] = + kernel.matchCaseDef(self) + } + + object CaseDef { + def apply(pattern: Pattern, guard: Option[Term], rhs: Term)(implicit ctx: Context): CaseDef = + kernel.CaseDef_module_apply(pattern, guard, rhs) + + def copy(original: CaseDef)(pattern: Pattern, guard: Option[Term], rhs: Term)(implicit ctx: Context): CaseDef = + kernel.CaseDef_module_copy(original)(pattern, guard, rhs) + + def unapply(tree: Tree)(implicit ctx: Context): Option[(Pattern, Option[Term], Term)] = + kernel.matchCaseDef(tree).map( x => (x.pattern, x.guard, x.rhs)) + } + + implicit class TypeCaseDefAPI(caseDef: TypeCaseDef) { + def pattern(implicit ctx: Context): TypeTree = kernel.TypeCaseDef_pattern(caseDef) + def rhs(implicit ctx: Context): TypeTree = kernel.TypeCaseDef_rhs(caseDef) + } + + object IsTypeCaseDef { + def unapply(self: Tree)(implicit ctx: Context): Option[TypeCaseDef] = + kernel.matchTypeCaseDef(self) + } + + object TypeCaseDef { + def apply(pattern: TypeTree, rhs: TypeTree)(implicit ctx: Context): TypeCaseDef = + kernel.TypeCaseDef_module_apply(pattern, rhs) + + def copy(original: TypeCaseDef)(pattern: TypeTree, rhs: TypeTree)(implicit ctx: Context): TypeCaseDef = + kernel.TypeCaseDef_module_copy(original)(pattern, rhs) + + def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, TypeTree)] = + kernel.matchTypeCaseDef(tree).map( x => (x.pattern, x.rhs)) + } } diff --git a/library/src/scala/tasty/reflect/TreeUtils.scala b/library/src/scala/tasty/reflect/TreeUtils.scala index ddbeeabd290b..4fec048ac8f0 100644 --- a/library/src/scala/tasty/reflect/TreeUtils.scala +++ b/library/src/scala/tasty/reflect/TreeUtils.scala @@ -4,7 +4,6 @@ package reflect /** Tasty reflect case definition */ trait TreeUtils extends Core - with CaseDefOps with PatternOps with SymbolOps with TreeOps { diff --git a/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala b/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala index a4a865722f7e..8bf7e2f39365 100644 --- a/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala +++ b/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala @@ -53,11 +53,6 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum def traverseTypeTree(tree: Tree /*TypeTree | TypeBoundsTree*/)( implicit ctx: Context): Unit = childrenType = tree :: childrenType - override def traverseCaseDef(tree: CaseDef)(implicit ctx: Context): Unit = - () - override def traverseTypeCaseDef(tree: TypeCaseDef)( - implicit ctx: Context): Unit = - () def getChildren(tree: Tree)(implicit ctx: Context): List[Tree] = { children = Nil