Move other extractors to objects

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tasty/TastyImpl.scala

@@ -20,9 +20,9 @@ class ConstantExtractor[T <: Tasty with Singleton](val tasty: T) {
 
   def unapply[T](expr: Expr[T])(implicit ctx: Context): Option[T] = {
     def const(tree: Term): Option[T] = tree match {
-      case Literal(c) => Some(c.value.asInstanceOf[T])
-      case Block(Nil, e) => const(e)
-      case Inlined(_, Nil, e) => const(e)
+      case Term.Literal(c) => Some(c.value.asInstanceOf[T])
+      case Term.Block(Nil, e) => const(e)
+      case Term.Inlined(_, Nil, e) => const(e)
       case _  => None
     }
     const(expr.toTasty)

library/src/scala/tasty/Tasty.scala

@@ -27,43 +27,43 @@ class TastyPrinter[T <: Tasty with Singleton](val tasty: T) {
     def result(): String = sb.result()
 
     def visitTree(x: Tree): Buffer = x match {
-      case Ident(name) =>
+      case Term.Ident(name) =>
         this += "Ident(" += name += ")"
-      case Select(qualifier, name, signature) =>
+      case Term.Select(qualifier, name, signature) =>
         this += "Select(" += qualifier += ", " += name += ", " += signature += ")"
-      case This(qual) =>
+      case Term.This(qual) =>
         this += "This(" += qual += ")"
-      case Super(qual, mix) =>
+      case Term.Super(qual, mix) =>
         this += "TypeApply(" += qual += ", " += mix += ")"
-      case Apply(fun, args) =>
+      case Term.Apply(fun, args) =>
         this += "Apply(" += fun += ", " ++= args += ")"
-      case TypeApply(fun, args) =>
+      case Term.TypeApply(fun, args) =>
         this += "TypeApply(" += fun += ", " ++= args += ")"
-      case Literal(const) =>
+      case Term.Literal(const) =>
         this += "Literal(" += const += ")"
-      case New(tpt) =>
+      case Term.New(tpt) =>
         this += "New(" += tpt += ")"
-      case Typed(expr, tpt) =>
+      case Term.Typed(expr, tpt) =>
         this += "Typed(" += expr += ", "  += tpt += ")"
-      case NamedArg(name, arg) =>
+      case Term.NamedArg(name, arg) =>
         this += "NamedArg(" += name += ", " += arg += ")"
-      case Assign(lhs, rhs) =>
+      case Term.Assign(lhs, rhs) =>
         this += "Assign(" += lhs += ", " += rhs += ")"
-      case Block(stats, expr) =>
+      case Term.Block(stats, expr) =>
         this += "Block(" ++= stats += ", " += expr += ")"
-      case If(cond, thenp, elsep) =>
+      case Term.If(cond, thenp, elsep) =>
         this += "If(" += cond += ", " += thenp += ", " += elsep += ")"
-      case Lambda(meth, tpt) =>
+      case Term.Lambda(meth, tpt) =>
         this += "Lambda(" += meth += ", " += tpt += ")"
-      case Match(selector, cases) =>
+      case Term.Match(selector, cases) =>
         this += "Match(" += selector += ", " ++= cases += ")"
-      case Return(expr) =>
+      case Term.Return(expr) =>
         this += "Return(" += expr += ")"
-      case Try(block, handlers, finalizer) =>
+      case Term.Try(block, handlers, finalizer) =>
         this += "Try(" += block += ", " ++= handlers += ", " += finalizer += ")"
-      case Repeated(elems) =>
+      case Term.Repeated(elems) =>
         this += "Repeated(" ++= elems += ")"
-      case Inlined(call, bindings, expansion) =>
+      case Term.Inlined(call, bindings, expansion) =>
         this += "Inlined(" += call += ", " ++= bindings += ", " += expansion += ")"
       case ValDef(name, tpt, rhs) =>
         this += "ValDef(" += name += ", " += tpt += ", " += rhs += ")"
@@ -87,25 +87,25 @@ class TastyPrinter[T <: Tasty with Singleton](val tasty: T) {
     }
 
     def visitTypeTree(x: TypeOrBoundsTree): Buffer = x match {
-      case Synthetic() =>
+      case TypeTree.Synthetic() =>
         this += "Synthetic()"
-      case TypeIdent(name) =>
+      case TypeTree.TypeIdent(name) =>
         this += "TypeIdent(" += name += ")"
-      case TypeSelect(qualifier, name) =>
+      case TypeTree.TypeSelect(qualifier, name) =>
         this += "TypeSelect(" += qualifier += ", " += name += ")"
-      case Singleton(ref) =>
+      case TypeTree.Singleton(ref) =>
         this += "Singleton(" += ref += ")"
-      case And(left, right) =>
+      case TypeTree.And(left, right) =>
         this += "And(" += left += ", " += right += ")"
-      case Or(left, right) =>
+      case TypeTree.Or(left, right) =>
         this += "Or(" += left += ", " += right += ")"
-      case Refined(tpt, refinements) =>
+      case TypeTree.Refined(tpt, refinements) =>
         this += "Refined(" += tpt += ", " ++= refinements += ")"
-      case Applied(tpt, args) =>
+      case TypeTree.Applied(tpt, args) =>
         this += "Applied(" += tpt += ", " ++= args += ")"
-      case ByName(result) =>
+      case TypeTree.ByName(result) =>
         this += "ByName(" += result += ")"
-      case Annotated(arg, annot) =>
+      case TypeTree.Annotated(arg, annot) =>
         this += "Annotated(" += arg += ", " += annot += ")"
       case TypeBoundsTree(lo, hi) =>
         this += "TypeBoundsTree(" += lo += ", " += hi += ")"
@@ -117,15 +117,15 @@ class TastyPrinter[T <: Tasty with Singleton](val tasty: T) {
     }
 
     def visitPattern(x: Pattern): Buffer = x match {
-      case Value(v) =>
+      case Pattern.Value(v) =>
         this += "Value(" += v += ")"
-      case Bind(name, body) =>
+      case Pattern.Bind(name, body) =>
         this += "Bind(" += name += ", " += body += ")"
-      case Unapply(fun, implicits, patterns) =>
+      case Pattern.Unapply(fun, implicits, patterns) =>
         this += "Unapply(" += fun += ", " ++= implicits += ", " ++= patterns += ")"
-      case Alternative(patterns) =>
+      case Pattern.Alternative(patterns) =>
         this += "Alternative(" ++= patterns += ")"
-      case TypeTest(tpt) =>
+      case Pattern.TypeTest(tpt) =>
         this += "TypeTest(" += tpt += ")"
     }
 
@@ -144,9 +144,9 @@ class TastyPrinter[T <: Tasty with Singleton](val tasty: T) {
     }
 
     def visitType(x: TypeOrBounds): Buffer = x match {
-      case ConstantType(value) =>
+      case Type.ConstantType(value) =>
         this += "ConstantType(" += value += ")"
-      case SymRef(sym, qual) =>
+      case Type.SymRef(sym, qual) =>
         def visitName(sym: Definition): Buffer = sym match {
           case ValDef(name, _, _) => this += name
           case DefDef(name, _, _, _, _) => this += name
@@ -158,33 +158,33 @@ class TastyPrinter[T <: Tasty with Singleton](val tasty: T) {
         this += "SymRef("
         visitName(sym)
         this += ", " += qual += ")"
-      case TermRef(name, qual) =>
+      case Type.TermRef(name, qual) =>
         this += "TermRef(" += name += ", " += qual += ")"
-      case TypeRef(name, qual) =>
+      case Type.TypeRef(name, qual) =>
         this += "TypeRef(" += name += ", " += qual += ")"
-      case Refinement(parent, name, info) =>
+      case Type.Refinement(parent, name, info) =>
         this += "Refinement(" += parent += ", " += name += ", " += info += ")"
-      case AppliedType(tycon, args) =>
+      case Type.AppliedType(tycon, args) =>
         this += "AppliedType(" += tycon += ", " ++= args += ")"
-      case AnnotatedType(underlying, annot) =>
+      case Type.AnnotatedType(underlying, annot) =>
         this += "AnnotatedType(" += underlying += ", " += annot += ")"
-      case AndType(left, right) =>
+      case Type.AndType(left, right) =>
         this += "AndType(" += left += ", " += right += ")"
-      case OrType(left, right) =>
+      case Type.OrType(left, right) =>
         this += "OrType(" += left += ", " += right += ")"
-      case ByNameType(underlying) =>
+      case Type.ByNameType(underlying) =>
         this += "ByNameType(" += underlying += ")"
-      case ParamRef(binder, idx) =>
+      case Type.ParamRef(binder, idx) =>
         this += "ParamRef(" += binder+= ", " += idx += ")"
-      case ThisType(tp) =>
+      case Type.ThisType(tp) =>
         this += "ThisType(" += tp += ")"
-      case RecursiveThis(binder) =>
+      case Type.RecursiveThis(binder) =>
         this += "RecursiveThis(" += binder += ")"
-      case MethodType(argNames, argTypes, resType) =>
+      case Type.MethodType(argNames, argTypes, resType) =>
         this += "MethodType(" ++= argNames += ", " ++= argTypes += ", " += resType += ")"
-      case PolyType(argNames, argBounds, resType) =>
+      case Type.PolyType(argNames, argBounds, resType) =>
         this += "PolyType(" ++= argNames += ", " ++= argBounds += ", " += resType += ")"
-      case TypeLambda(argNames, argBounds, resType) =>
+      case Type.TypeLambda(argNames, argBounds, resType) =>
         this += "TypeLambda(" ++= argNames += ", " ++= argBounds += ", " += resType += ")"
       case TypeBounds(lo, hi) =>
         this += "TypeBounds(" += lo += ", " += hi += ")"
@@ -193,10 +193,10 @@ class TastyPrinter[T <: Tasty with Singleton](val tasty: T) {
     }
 
     def visitModifier(x: Modifier): Buffer = x match {
-      case Flags(flags) => this += "Flags(" += flags.toString += ")"
-      case QualifiedPrivate(tp) => this += "QualifiedPrivate(" += tp += ")"
-      case QualifiedProtected(tp) => this += "QualifiedProtected(" += tp += ")"
-      case Annotation(tree) => this += "Annotation(" += tree += ")"
+      case Modifier.Flags(flags) => this += "Flags(" += flags.toString += ")"
+      case Modifier.QualifiedPrivate(tp) => this += "QualifiedPrivate(" += tp += ")"
+      case Modifier.QualifiedProtected(tp) => this += "QualifiedProtected(" += tp += ")"
+      case Modifier.Annotation(tree) => this += "Annotation(" += tree += ")"
     }
 
     def visitId(x: Id): Buffer = {

library/src/scala/tasty/util/ConstantExtractor.scala

@@ -20,46 +20,45 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
   def foldOverTree(x: X, tree: Tree)(implicit ctx: Context): X = {
     def localCtx(definition: Definition): Context = definition.localContext
     tree match {
-      case Ident(_) =>
+      case Term.Ident(_) =>
         x
-      case Select(qualifier, _, _) =>
+      case Term.Select(qualifier, _, _) =>
         foldTree(x, qualifier)
-      case This(qual) =>
+      case Term.This(qual) =>
         x
-      case Super(qual, _) =>
+      case Term.Super(qual, _) =>
         foldTree(x, qual)
-      case Apply(fun, args) =>
+      case Term.Apply(fun, args) =>
         foldTrees(foldTree(x, fun), args)
-      case TypeApply(fun, args) =>
+      case Term.TypeApply(fun, args) =>
         foldTypeTrees(foldTree(x, fun), args)
-      case Literal(const) =>
+      case Term.Literal(const) =>
         x
-      case New(tpt) =>
+      case Term.New(tpt) =>
         foldTypeTree(x, tpt)
-      case Typed(expr, tpt) =>
+      case Term.Typed(expr, tpt) =>
         foldTypeTree(foldTree(x, expr), tpt)
-      case NamedArg(_, arg) =>
+      case Term.NamedArg(_, arg) =>
         foldTree(x, arg)
-      case Assign(lhs, rhs) =>
+      case Term.Assign(lhs, rhs) =>
         foldTree(foldTree(x, lhs), rhs)
-      case Block(stats, expr) =>
+      case Term.Block(stats, expr) =>
         foldTree(foldTrees(x, stats), expr)
-      case If(cond, thenp, elsep) =>
+      case Term.If(cond, thenp, elsep) =>
         foldTree(foldTree(foldTree(x, cond), thenp), elsep)
-      case Lambda(meth, tpt) =>
+      case Term.Lambda(meth, tpt) =>
         val a = foldTree(x, meth)
         tpt.fold(a)(b => foldTypeTree(a, b))
-      case Match(selector, cases) =>
+      case Term.Match(selector, cases) =>
         foldCaseDefs(foldTree(x, selector), cases)
-      case Return(expr) =>
+      case Term.Return(expr) =>
         foldTree(x, expr)
-      case Try(block, handler, finalizer) =>
+      case Term.Try(block, handler, finalizer) =>
         foldTrees(foldCaseDefs(foldTree(x, block), handler), finalizer)
-      case Repeated(elems) =>
+      case Term.Repeated(elems) =>
         foldTrees(x, elems)
-      case Inlined(call, bindings, expansion) =>
+      case Term.Inlined(call, bindings, expansion) =>
         foldTree(foldTrees(x, bindings), expansion)
-
       case vdef @ ValDef(_, tpt, rhs) =>
         implicit val ctx = localCtx(vdef)
         foldTrees(foldTypeTree(x, tpt), rhs)
@@ -80,16 +79,16 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
   }
 
   def foldOverTypeTree(x: X, tree: TypeOrBoundsTree)(implicit ctx: Context): X = tree match {
-    case Synthetic() => x
-    case TypeIdent(_) => x
-    case TypeSelect(qualifier, _) => foldTree(x, qualifier)
-    case Singleton(ref) => foldTree(x, ref)
-    case And(left, right) => foldTypeTree(foldTypeTree(x, left), right)
-    case Or(left, right) => foldTypeTree(foldTypeTree(x, left), right)
-    case Refined(tpt, refinements) => foldTrees(foldTypeTree(x, tpt), refinements)
-    case Applied(tpt, args) => foldTypeTrees(foldTypeTree(x, tpt), args)
-    case ByName(result) => foldTypeTree(x, result)
-    case Annotated(arg, annot) => foldTree(foldTypeTree(x, arg), annot)
+    case TypeTree.Synthetic() => x
+    case TypeTree.TypeIdent(_) => x
+    case TypeTree.TypeSelect(qualifier, _) => foldTree(x, qualifier)
+    case TypeTree.Singleton(ref) => foldTree(x, ref)
+    case TypeTree.And(left, right) => foldTypeTree(foldTypeTree(x, left), right)
+    case TypeTree.Or(left, right) => foldTypeTree(foldTypeTree(x, left), right)
+    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 TypeBoundsTree(lo, hi) => foldTypeTree(foldTypeTree(x, lo), hi)
   }
 
@@ -98,11 +97,11 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
   }
 
   def foldOverPattern(x: X, tree: Pattern)(implicit ctx: Context): X = tree match {
-    case Value(v) => foldTree(x, v)
-    case Bind(_, body) => foldPattern(x, body)
-    case Unapply(fun, implicits, patterns) => foldPatterns(foldTrees(foldTree(x, fun), implicits), patterns)
-    case Alternative(patterns) => foldPatterns(x, patterns)
-    case TypeTest(tpt) => foldTypeTree(x, tpt)
+    case Pattern.Value(v) => foldTree(x, v)
+    case Pattern.Bind(_, body) => foldPattern(x, body)
+    case Pattern.Unapply(fun, implicits, patterns) => foldPatterns(foldTrees(foldTree(x, fun), implicits), patterns)
+    case Pattern.Alternative(patterns) => foldPatterns(x, patterns)
+    case Pattern.TypeTest(tpt) => foldTypeTree(x, tpt)
   }
 
   private def foldOverParent(x: X, tree: Parent)(implicit ctx: Context): X = tree match {

library/src/scala/tasty/util/TastyPrinter.scala

@@ -23,12 +23,12 @@ object Macros {
       import u._
       import u.tasty._
       e.toTasty.tpe match {
-        case SymRef(ValDef(_, tpt, _), pre) =>
+        case Type.SymRef(ValDef(_, tpt, _), pre) =>
           tpt.tpe match {
-            case ConstantType(Constant.Int(i)) => Some(i)
+            case Type.ConstantType(Constant.Int(i)) => Some(i)
             case _ => None
           }
-        case ConstantType(Constant.Int(i)) => Some(i)
+        case Type.ConstantType(Constant.Int(i)) => Some(i)
         case _ => None
       }
     }

library/src/scala/tasty/util/TreeAccumulator.scala

@@ -32,11 +32,11 @@ object Index {
     import u.tasty._
 
     def name(tp: TypeOrBounds): String = tp match {
-      case ConstantType(Constant.String(str)) => str
+      case Type.ConstantType(Constant.String(str)) => str
     }
 
     def names(tp: TypeOrBounds): List[String] = tp match {
-      case AppliedType(_, x1 :: x2 :: Nil) => name(x1) :: names(x2)
+      case Type.AppliedType(_, x1 :: x2 :: Nil) => name(x1) :: names(x2)
       case _ => Nil
     }
 

tests/run/tasty-eval/quoted_1.scala

@@ -23,20 +23,20 @@ object Asserts {
     val tree = cond.toTasty
 
     def isOps(tpe: TypeOrBounds): Boolean = tpe match {
-      case SymRef(DefDef("Ops", _, _, _, _), _) => true // TODO check that the parent is Asserts
+      case Type.SymRef(DefDef("Ops", _, _, _, _), _) => true // TODO check that the parent is Asserts
       case _ => false
     }
 
     object OpsTree {
       def unapply(arg: Term): Option[Term] = arg match {
-        case Apply(TypeApply(term, _), left :: Nil) if isOps(term.tpe) =>
+        case Term.Apply(Term.TypeApply(term, _), left :: Nil) if isOps(term.tpe) =>
           Some(left)
         case _ => None
       }
     }
 
     tree match {
-      case Apply(Select(OpsTree(left), op, _), right :: Nil) =>
+      case Term.Apply(Term.Select(OpsTree(left), op, _), right :: Nil) =>
         // FIXME splice the threes directly
         val printer = new TastyPrinter(tasty)
         val lExpr = printer.stringOfTree(left).toExpr