Fix #2566: Ycheck that New node is always enclosed in a Select

Tested:
Verified that the test case in #2564
triggers the assert.
Verified that the check doesn't run when we ycheck a phase before frontend.

Author: abeln

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -26,6 +26,7 @@ import ast.Trees._
 import ast.{tpd, untpd}
 import util.SourcePosition
 import util.Chars._
+
 import collection.mutable
 import ProtoTypes._
 import config.Printers
@@ -122,6 +123,10 @@ class TreeChecker extends Phase with SymTransformer {
     val squahsedPhase = ctx.squashed(prevPhase)
     ctx.echo(s"checking ${ctx.compilationUnit} after phase ${squahsedPhase}")
 
+    if (ctx.isAfterTyper) {
+      WrappedNewChecker.assertSelectWrapsNew(ctx.compilationUnit.tpdTree)(ctx)
+    }
+
     val checkingCtx = ctx
         .fresh
         .setMode(Mode.ImplicitsEnabled)
@@ -449,6 +454,53 @@ class TreeChecker extends Phase with SymTransformer {
       tree
     }
   }
+
+  /**
+    * Checks that `New` nodes are always wrapped inside `Select` nodes.
+    */
+  private object WrappedNewChecker {
+
+    // Current state of the search. We return as soon as we see the first improperly wrapped `New`.
+    sealed trait State
+    case class NotFound(parent: Option[tpd.Tree]) extends State
+    case class Found(parent: Option[tpd.Tree], child: tpd.New) extends State
+
+    def assertSelectWrapsNew(tree: tpd.Tree)(implicit ctx: Context): Unit = {
+      val detect = new TreeAccumulator[State] {
+        override def apply(st: State, tree: tpd.Tree)(implicit ctx: Context): State = {
+          st match {
+            case _: Found => st // thread the found pair
+            case NotFound(oldParent) =>
+              tree match {
+                case tree: tpd.New if !canWrapNew(oldParent) => Found(oldParent, tree)
+                case _ =>
+                  // replace the parent when folding over the children
+                  foldOver(NotFound(Some(tree)), tree) match {
+                    case found: Found => found
+                    case _ => st // return the old parent so that my siblings see it
+                  }
+              }
+          }
+        }
+      }
+
+      detect(NotFound(None), tree) match {
+        case Found(Some(parent), child) =>
+          assert(assertion = false, i"`New` node must be wrapped in a `Select`:\n  parent = ${parent.show}\n  child = ${child.show}")
+        case Found(None, child) =>
+          assert(assertion = false, i"`New` node without a parent:\n  ${child.show}")
+        case _ => ()
+      }
+    }
+
+    def canWrapNew(tree: Option[tpd.Tree]): Boolean = {
+      tree match {
+        case Some(_: tpd.Select) => true
+        case _ => false
+      }
+    }
+  }
+
 }
 
 object TreeChecker {