PostTyper transformers

1) reorders companion objects so that they allways follow matching
classes
2) removes imports and named arguments
3) rewrites all trees holding types are to TypeTrees

Author: DarkDimius

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

@@ -278,7 +278,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
    */
   def ModuleDef(sym: TermSymbol, body: List[Tree])(implicit ctx: Context): tpd.Thicket = {
     val modcls = sym.moduleClass.asClass
-    val constr = DefDef(modcls.primaryConstructor.asTerm, EmptyTree)
+    val constrSym = modcls.primaryConstructor orElse ctx.newDefaultConstructor(modcls).entered
+    val constr = DefDef(constrSym.asTerm, EmptyTree)
     val clsdef = ClassDef(modcls, constr, body)
     val valdef = ValDef(sym, New(modcls.typeRef))
     Thicket(valdef, clsdef)

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

@@ -0,0 +1,62 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.core._
+import Symbols._
+import scala.Some
+import dotty.tools.dotc.transform.TreeTransforms.{NXTransformations, TransformerInfo, TreeTransform, TreeTransformer}
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts.Context
+import scala.collection.mutable
+import dotty.tools.dotc.core.Names.Name
+import NameOps._
+
+object PostTyperTransformers {
+
+  import tpd.{TreeTransformer => _, _}
+
+
+  /** A trait that's assumed by the transformers that run right after typer.
+    * Ensures that trees are normalized when seen by other transforms. This means:
+    * (1) All module class definitions appear after their companion class definitions
+    * (2) There are no import clauses or named arguments
+    * (3) All trees designating types are instances of TypeTree
+    */
+  abstract class PostTyperTransformer extends TreeTransformer {
+
+    /** Reorder statements so that module classes always come after their companion classes, add missing companion classes */
+    def reorder(stats: List[Tree])(implicit ctx: Context, info: TransformerInfo): List[Tree] = {
+      val moduleClassDefs = mutable.Map[Name, Tree]()
+      def reorder0(stats: List[Tree]): List[Tree] = {
+        stats match {
+          case (stat: TypeDef) :: stats1 if stat.symbol.isClass =>
+            if (stat.symbol is Flags.Module) {
+              moduleClassDefs += (stat.name -> stat)
+              val stats1r = reorder0(stats1)
+              if (moduleClassDefs contains stat.name) stat :: stats1r else stats1r
+            }
+            else {
+              val mclsName = stat.name.moduleClassName
+              moduleClassDefs remove mclsName match {
+                case Some(mcdef) => stat :: mcdef :: reorder0(stats1)
+                case None => stat :: reorder0(stats1)
+              }
+            }
+          case stat :: stats1 => stat :: reorder0(stats1)
+          case Nil => Nil
+        }
+      }
+      reorder0(stats)
+    }
+
+    override def transformStats(trees: List[tpd.Tree], info: TransformerInfo, current: Int)(implicit ctx: Context): List[tpd.Tree] =
+      super.transformStats(reorder(trees)(ctx, info), info, current)
+
+    override def transform(tree: tpd.Tree, info: TransformerInfo, cur: Int)(implicit ctx: Context): tpd.Tree = tree match {
+      case tree: Import => EmptyTree
+      case tree: NamedArg => super.transform(tree.arg, info, cur)
+      case tree: TypeTree => super.transform(tree, info, cur)
+      case tree => super.transform(if (tree.isType) TypeTree(tree.tpe) else tree, info, cur)
+    }
+  }
+
+}

test/test/transform/PostTyperTransformerTest.scala

@@ -0,0 +1,117 @@
+package test.transform
+
+
+import org.junit.{Assert, Test}
+import test.DottyTest
+import dotty.tools.dotc.core._
+import dotty.tools.dotc.ast.Trees
+import Contexts._
+import Flags._
+import Denotations._
+import NameOps._
+import Symbols._
+import Types._
+import Decorators._
+import Trees._
+import dotty.tools.dotc.transform.TreeTransforms.{TreeTransform, TreeTransformer}
+import dotty.tools.dotc.transform.PostTyperTransformers.PostTyperTransformer
+
+class PostTyperTransformerTest extends DottyTest {
+
+  @Test
+  def shouldStripImports = checkCompile("frontend", "class A{ import scala.collection.mutable._; val d = 1}") {
+    (tree, context) =>
+      implicit val ctx = context
+      class EmptyTransform(group: TreeTransformer, idx: Int) extends TreeTransform(group, idx) {}
+      val transformer = new PostTyperTransformer {
+        override def transformations = Array(new EmptyTransform(_, _))
+
+        override def name: String = "test"
+      }
+      val transformed = transformer.transform(tree)
+
+      Assert.assertTrue("should strip imports",
+        !transformed.toString.toLowerCase.contains("import")
+      )
+  }
+
+  @Test
+  def shouldStripNamedArgs = checkCompile("frontend", "class A{ def p(x:Int, y:Int= 2) = 1; p(1, y = 2)}") {
+    (tree, context) =>
+      implicit val ctx = context
+      class EmptyTransform(group: TreeTransformer, idx: Int) extends TreeTransform(group, idx) {}
+      val transformer = new PostTyperTransformer {
+        override def transformations = Array(new EmptyTransform(_, _))
+
+        override def name: String = "test"
+      }
+      val transformed = transformer.transform(tree)
+
+      Assert.assertTrue("should string named arguments",
+        !transformed.toString.contains("NamedArg")
+      )
+  }
+
+  @Test
+  def shouldReorderExistingObjectsInPackage = checkCompile("frontend", "object A{}; class A{} ") {
+    (tree, context) =>
+      implicit val ctx = context
+      class EmptyTransform(group: TreeTransformer, idx: Int) extends TreeTransform(group, idx) {}
+      val transformer = new PostTyperTransformer {
+        override def transformations = Array(new EmptyTransform(_, _))
+
+        override def name: String = "test"
+      }
+      val transformed = transformer.transform(tree).toString
+      val classPattern = "TypeDef(Modifiers(,,List()),A,"
+      val classPos = transformed.indexOf(classPattern)
+      val moduleClassPattern = "TypeDef(Modifiers(final module,,List()),A$,"
+      val modulePos = transformed.indexOf(moduleClassPattern)
+
+      Assert.assertTrue("should reorder existing objects in package",
+        classPos < modulePos
+      )
+  }
+
+  @Test
+  def shouldReorderExistingObjectsInBlock = checkCompile("frontend", "class D {def p = {object A{}; class A{}; 1}} ") {
+    (tree, context) =>
+      implicit val ctx = context
+      class EmptyTransform(group: TreeTransformer, idx: Int) extends TreeTransform(group, idx) {}
+      val transformer = new PostTyperTransformer {
+        override def transformations = Array(new EmptyTransform(_, _))
+
+        override def name: String = "test"
+      }
+      val transformed = transformer.transform(tree).toString
+      val classPattern = "TypeDef(Modifiers(,,List()),A,"
+      val classPos = transformed.indexOf(classPattern)
+      val moduleClassPattern = "TypeDef(Modifiers(final module,,List()),A$,"
+      val modulePos = transformed.indexOf(moduleClassPattern)
+
+      Assert.assertTrue("should reorder existing objects in block",
+        classPos < modulePos
+      )
+  }
+
+  @Test
+  def shouldReorderExistingObjectsInTemplate = checkCompile("frontend", "class D {object A{}; class A{}; } ") {
+    (tree, context) =>
+      implicit val ctx = context
+      class EmptyTransform(group: TreeTransformer, idx: Int) extends TreeTransform(group, idx) {}
+      val transformer = new PostTyperTransformer {
+        override def transformations = Array(new EmptyTransform(_, _))
+
+        override def name: String = "test"
+      }
+      val transformed = transformer.transform(tree).toString
+      val classPattern = "TypeDef(Modifiers(,,List()),A,"
+      val classPos = transformed.indexOf(classPattern)
+      val moduleClassPattern = "TypeDef(Modifiers(final module,,List()),A$,"
+      val modulePos = transformed.indexOf(moduleClassPattern)
+
+      Assert.assertTrue("should reorder existing objects in template",
+        classPos < modulePos
+      )
+  }
+}