Use Iterable and rename folds on trees

Author: nicolasstucki

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

@@ -12,11 +12,11 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
   def foldPattern(x: X, tree: Pattern)(implicit ctx: Context): X
   def foldParent(x: X, tree: Parent)(implicit ctx: Context): X
 
-  def foldTree(x: X, trees: Traversable[Tree])(implicit ctx: Context): X = (x /: trees)(foldTree)
-  def foldTypeTree(x: X, trees: Traversable[MaybeTypeTree])(implicit ctx: Context): X = (x /: trees)(foldTypeTree)
-  def foldCaseDef(x: X, trees: Traversable[CaseDef])(implicit ctx: Context): X = (x /: trees)(foldCaseDef)
-  def foldPattern(x: X, trees: Traversable[Pattern])(implicit ctx: Context): X = (x /: trees)(foldPattern)
-  def foldParent(x: X, trees: Traversable[Parent])(implicit ctx: Context): X = (x /: trees)(foldParent)
+  def foldTrees(x: X, trees: Iterable[Tree])(implicit ctx: Context): X = (x /: trees)(foldTree)
+  def foldTypeTrees(x: X, trees: Iterable[MaybeTypeTree])(implicit ctx: Context): X = (x /: trees)(foldTypeTree)
+  def foldCaseDefs(x: X, trees: Iterable[CaseDef])(implicit ctx: Context): X = (x /: trees)(foldCaseDef)
+  def foldPatterns(x: X, trees: Iterable[Pattern])(implicit ctx: Context): X = (x /: trees)(foldPattern)
+  def foldParents(x: X, trees: Iterable[Parent])(implicit ctx: Context): X = (x /: trees)(foldParent)
 
   def foldOverTree(x: X, tree: Tree)(implicit ctx: Context): X = {
     def localCtx(definition: Definition): Context = definition.localContext
@@ -30,9 +30,9 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
       case Super(qual, _) =>
         foldTree(x, qual)
       case Apply(fun, args) =>
-        foldTree(foldTree(x, fun), args)
+        foldTrees(foldTree(x, fun), args)
       case TypeApply(fun, args) =>
-        foldTypeTree(foldTree(x, fun), args)
+        foldTypeTrees(foldTree(x, fun), args)
       case Literal(const) =>
         x
       case New(tpt) =>
@@ -44,39 +44,39 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
       case Assign(lhs, rhs) =>
         foldTree(foldTree(x, lhs), rhs)
       case Block(stats, expr) =>
-        foldTree(foldTree(x, stats), expr)
+        foldTree(foldTrees(x, stats), expr)
       case If(cond, thenp, elsep) =>
         foldTree(foldTree(foldTree(x, cond), thenp), elsep)
       case Lambda(meth, tpt) =>
         val a = foldTree(x, meth)
         tpt.fold(a)(b => foldTypeTree(a, b))
       case Match(selector, cases) =>
-        foldCaseDef(foldTree(x, selector), cases)
+        foldCaseDefs(foldTree(x, selector), cases)
       case Return(expr) =>
         foldTree(x, expr)
       case Try(block, handler, finalizer) =>
-        foldTree(foldCaseDef(foldTree(x, block), handler), finalizer)
+        foldTrees(foldCaseDefs(foldTree(x, block), handler), finalizer)
       case Repeated(elems) =>
-        foldTree(x, elems)
+        foldTrees(x, elems)
       case Inlined(call, bindings, expansion) =>
-        foldTree(foldTree(x, bindings), expansion)
+        foldTree(foldTrees(x, bindings), expansion)
 
       case vdef @ ValDef(_, tpt, rhs) =>
         implicit val ctx = localCtx(vdef)
-        foldTree(foldTypeTree(x, tpt), rhs)
+        foldTrees(foldTypeTree(x, tpt), rhs)
       case ddef @ DefDef(_, tparams, vparamss, tpt, rhs) =>
         implicit val ctx = localCtx(ddef)
-        foldTree(foldTypeTree((foldTree(x, tparams) /: vparamss)(foldTree), tpt), rhs)
+        foldTrees(foldTypeTree((foldTrees(x, tparams) /: vparamss)(foldTrees), tpt), rhs)
       case tdef @ TypeDef(_, rhs) =>
         implicit val ctx = localCtx(tdef)
         foldTypeTree(x, rhs)
       case cdef @ ClassDef(_, constr, parents, self, body) =>
         implicit val ctx = localCtx(cdef)
-        foldTree(foldTree(foldParent(foldTree(x, constr), parents), self), body)
+        foldTrees(foldTrees(foldParents(foldTree(x, constr), parents), self), body)
       case Import(expr, selectors) =>
         foldTree(x, expr)
       case clause @ PackageClause(pid, stats) =>
-        foldTree(foldTree(x, pid), stats)(localCtx(clause.definition))
+        foldTrees(foldTree(x, pid), stats)(localCtx(clause.definition))
     }
   }
 
@@ -87,22 +87,22 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
     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) => foldTree(foldTypeTree(x, tpt), refinements)
-    case Applied(tpt, args) => foldTypeTree(foldTypeTree(x, tpt), args)
+    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 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(foldTree(foldPattern(x, pat), guard), body)
+    case CaseDef(pat, guard, body) => foldTree(foldTrees(foldPattern(x, pat), guard), body)
   }
 
   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) => foldPattern(foldTree(foldTree(x, fun), implicits), patterns)
-    case Alternative(patterns) => foldPattern(x, patterns)
+    case Unapply(fun, implicits, patterns) => foldPatterns(foldTrees(foldTree(x, fun), implicits), patterns)
+    case Alternative(patterns) => foldPatterns(x, patterns)
     case TypeTest(tpt) => foldTypeTree(x, tpt)
   }
 

library/src/scala/tasty/util/TreeTraverser.scala

@@ -7,7 +7,7 @@ abstract class TreeTraverser[T <: Tasty with Singleton](tasty0: T) extends TreeA
 
   def traverseTree(tree: Tree)(implicit ctx: Context): Unit = traverseTreeChildren(tree)
   def traverseTypeTree(tree: MaybeTypeTree)(implicit ctx: Context): Unit = traverseTypeTreeChildren(tree)
-  def traverseCaseDef(tree: CaseDef)(implicit ctx: Context): Unit = traverseCaseDef(tree)
+  def traverseCaseDef(tree: CaseDef)(implicit ctx: Context): Unit = traverseCaseDefChildren(tree)
   def traversePattern(tree: Pattern)(implicit ctx: Context): Unit = traversePatternChildren(tree)
   def traverseParent(tree: Parent)(implicit ctx: Context): Unit = traverseParentChildren(tree)