Make foreach/exsists into tree infix methods

foreachSubTree and existsSubTree are now infix methods. Streamlines their use
somewhat.

Author: odersky

src/dotty/tools/dotc/ast/tpd.scala

@@ -356,22 +356,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       } else foldOver(sym, tree)
   }
 
-  // --- Higher order traversal methods -------------------------------
-
-  def foreachSubTreeOf(tree: Tree)(f: Tree => Unit): Unit = { //TODO should go in tpd.
-    val traverser = new TreeTraverser {
-      def traverse(tree: Tree) = foldOver(f(tree), tree)
-    }
-    traverser.traverse(tree)
-  }
-
-  def existsSubTreeOf(tree: Tree)(p: Tree => Boolean): Boolean = {
-    val acc = new TreeAccumulator[Boolean] {
-      def apply(x: Boolean, t: Tree) = x || p(t) || foldOver(x, t)
-    }
-    acc(false, tree)
-  }
-
   override val cpy = new TypedTreeCopier
 
   class TypedTreeCopier extends TreeCopier {
@@ -583,6 +567,22 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     def or(that: Tree)(implicit ctx: Context): Tree =
       tree.select(defn.Boolean_||).appliedTo(that)
+
+    // --- Higher order traversal methods -------------------------------
+
+    def foreachSubTree(f: Tree => Unit): Unit = { //TODO should go in tpd.
+      val traverser = new TreeTraverser {
+        def traverse(tree: Tree) = foldOver(f(tree), tree)
+      }
+      traverser.traverse(tree)
+    }
+
+    def existsSubTree(p: Tree => Boolean): Boolean = {
+      val acc = new TreeAccumulator[Boolean] {
+        def apply(x: Boolean, t: Tree) = x || p(t) || foldOver(x, t)
+      }
+      acc(false, tree)
+    }
   }
 
   implicit class ListOfTreeDecorator(val xs: List[tpd.Tree]) extends AnyVal {

src/dotty/tools/dotc/transform/ExplicitOuter.scala

@@ -85,7 +85,7 @@ class ExplicitOuter extends MiniPhaseTransform with InfoTransformer { thisTransf
     val isTrait = cls.is(Trait)
     if (needsOuterIfReferenced(cls) &&
         !needsOuterAlways(cls) &&
-        existsSubTreeOf(impl)(referencesOuter(cls, _)))
+        impl.existsSubTree(referencesOuter(cls, _)))
       newOuterAccessors(cls).foreach(_.enteredAfter(thisTransformer))
     if (hasOuter(cls)) {
       val newDefs = new mutable.ListBuffer[Tree]

src/dotty/tools/dotc/typer/Typer.scala

@@ -615,7 +615,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         def typedCase(tree: untpd.CaseDef): CaseDef = track("typedCase") {
           def caseRest(pat: Tree)(implicit ctx: Context) = {
             gadtSyms foreach (_.resetGADTFlexType)
-            foreachSubTreeOf(pat) {
+            pat foreachSubTree {
               case b: Bind =>
                 if (ctx.scope.lookup(b.name) == NoSymbol) ctx.enter(b.symbol)
                 else ctx.error(d"duplicate pattern variable: ${b.name}", b.pos)
@@ -732,7 +732,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       def checkRef(tree: Tree, sym: Symbol) =
         if (sym.maybeOwner == refineCls && tree.pos.start <= sym.pos.end)
           ctx.error("illegal forward reference in refinement", tree.pos)
-      foreachSubTreeOf(refinement) {
+      refinement foreachSubTree {
         case tree: RefTree => checkRef(tree, tree.symbol)
         case tree: TypeTree => checkRef(tree, tree.tpe.typeSymbol)
         case _ =>