Test case for TreeInfo#defPath

I'm about to refactor that method in terms of a TreeAccumulator.

Note that I've packaged the test case in `dotty.tools.dotc.ast`
 I believe this is the best approach for organizing unit tests:
 the import tax is minimized, and use of relative imports is
 made less fragile by avoiding creating new packages to test code.

I'll reorganize the other unit tests like this if others agree.

Author: retronym

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

@@ -330,6 +330,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def deepFold[T](z: T)(op: (T, tpd.Tree) => T) =
       new DeepFolder(op).apply(z, tree)
 
+    def find[T](pred: (tpd.Tree) => Boolean): Option[tpd.Tree] =
+      shallowFold[Option[tpd.Tree]](None)((accum, tree) => if (pred(tree)) Some(tree) else accum)
+
     def subst(from: List[Symbol], to: List[Symbol])(implicit ctx: Context): ThisTree =
       new TreeMapper(typeMap = new ctx.SubstSymMap(from, to)).apply(tree)
 

test/dotty/tools/dotc/ast/TreeInfoTest.scala

@@ -0,0 +1,30 @@
+package dotty.tools.dotc
+package ast
+
+import org.junit.Test
+import test.DottyTest
+import core.Names._
+import core.Types._
+import core.Symbols._
+import org.junit.Assert._
+
+class TreeInfoTest extends DottyTest {
+
+  import tpd._
+
+  @Test
+  def testDefPath = checkCompile("frontend", "class A { def bar = { val x = { val z = 0; 0} }} ") {
+    (tree, context) =>
+      implicit val ctx = context
+      val xTree = tree.find(tree => tree.symbol.name == termName("x")).get
+      val path = defPath(xTree.symbol, tree)
+      assertEquals(List(
+        ("PackageDef", EMPTY_PACKAGE),
+        ("TypeDef", typeName("A")),
+        ("Template", termName("<local A>")),
+        ("DefDef", termName("bar")),
+        ("Block", NoSymbol.name),
+        ("ValDef", termName("x"))
+      ), path.map(x => (x.productPrefix, x.symbol.name)))
+  }
+}