Move compiler and compiler tests to compiler dir

1 files changed, 128 insertions, 0 deletions

diff --git a/compiler/test/dotty/tools/dotc/transform/CreateCompanionObjectsTest.scala b/compiler/test/dotty/tools/dotc/transform/CreateCompanionObjectsTest.scala
new file mode 100644
index 000000000..18acb2105
--- /dev/null
+++ b/compiler/test/dotty/tools/dotc/transform/CreateCompanionObjectsTest.scala
@@ -0,0 +1,128 @@
+package dotty.tools
+package dotc
+package transform
+
+import org.junit.{Assert, Test}
+import core._
+import ast.{tpd, Trees}
+import Contexts._
+import Flags._
+import Denotations._
+import NameOps._
+import Symbols._
+import Types._
+import Decorators._
+import Trees._
+import TreeTransforms.{TreeTransform, TreeTransformer}
+
+
+class CreateCompanionObjectsTest extends DottyTest {
+  /* FIXME: re-enable after adapting to new scheme
+
+  import tpd._
+
+  type PostTyperTransformer = TreeTransformer // FIXME do without
+
+  @Test
+  def shouldCreateNonExistingObjectsInPackage = checkCompile("frontend", "class A{} ") {
+    (tree, context) =>
+      implicit val ctx = context
+
+      val transformer = new PostTyperTransformer {
+        override def transformations = Array(new CreateCompanionObjects {
+
+          override def name: String = "create all companion objects"
+          override def predicate(cts: TypeDef)(implicit ctx:Context): Boolean = true
+          init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
+        })
+
+        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 <synthetic>,,List()),A$"
+      val modulePos = transformed.indexOf(moduleClassPattern)
+
+      Assert.assertTrue("should create non-existing objects in package",
+        classPos < modulePos
+      )
+  }
+
+  @Test
+  def shouldCreateNonExistingObjectsInBlock = checkCompile("frontend", "class D {def p = {class A{}; 1}} ") {
+    (tree, context) =>
+      implicit val ctx = context
+      val transformer = new PostTyperTransformer {
+        override def transformations = Array(new CreateCompanionObjects {
+
+          override def name: String = "create all companion modules"
+          override def predicate(cts: TypeDef)(implicit ctx:Context): Boolean = true
+          init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
+        })
+
+        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 <synthetic>,,List()),A$"
+      val modulePos = transformed.indexOf(moduleClassPattern)
+
+      Assert.assertTrue("should create non-existing objects in block",
+        classPos < modulePos
+      )
+  }
+
+  @Test
+  def shouldCreateNonExistingObjectsInTemplate = checkCompile("frontend", "class D {class A{}; } ") {
+    (tree, context) =>
+      implicit val ctx = context
+      val transformer = new PostTyperTransformer {
+        override def transformations = Array(new CreateCompanionObjects {
+          override def name: String = "create all companion modules"
+          override def predicate(cts: TypeDef)(implicit ctx:Context): Boolean = true
+          init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
+        })
+
+        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 <synthetic>,,List()),A$"
+      val modulePos = transformed.indexOf(moduleClassPattern)
+
+      Assert.assertTrue("should create non-existing objects in template",
+        classPos < modulePos
+      )
+  }
+
+  @Test
+  def shouldCreateOnlyIfAskedFor = checkCompile("frontend", "class DONT {class CREATE{}; } ") {
+    (tree, context) =>
+      implicit val ctx = context
+      val transformer = new PostTyperTransformer {
+        override def transformations = Array(new CreateCompanionObjects {
+          override def name: String = "create all companion modules"
+          override def predicate(cts: TypeDef)(implicit ctx:Context): Boolean = cts.name.toString.contains("CREATE")
+          init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
+        })
+
+        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 <synthetic>,,List()),CREATE$"
+      val modulePos = transformed.indexOf(moduleClassPattern)
+
+      val notCreatedModulePattern = "TypeDef(Modifiers(final module <synthetic>,,List()),DONT"
+      val notCreatedPos = transformed.indexOf(notCreatedModulePattern)
+
+      Assert.assertTrue("should create non-existing objects in template",
+        classPos < modulePos && (notCreatedPos < 0)
+      )
+  }
+  */
+}