Make use of `CrossScalaModule` in `HelloWorldTests`

Also standardize the `HelloWorldTests` onto the typical project layout, where the module of interest is nested within a top-level `BaseModule`

15 files changed, 166 insertions, 108 deletions

diff --git a/core/src/mill/eval/Evaluator.scala b/core/src/mill/eval/Evaluator.scala
index 9d65e95f..bb78a020 100644
--- a/core/src/mill/eval/Evaluator.scala
+++ b/core/src/mill/eval/Evaluator.scala
@@ -6,6 +6,7 @@ import ammonite.main.Router.EntryPoint
 import ammonite.ops._
 import ammonite.runtime.SpecialClassLoader
 import mill.define.{Ctx => _, _}
+import mill.eval.Result.OuterStack
 import mill.util
 import mill.util._
 import mill.util.Strict.Agg
@@ -274,7 +275,7 @@ class Evaluator[T](val outPath: Path,
             }
           }catch{ case NonFatal(e) =>
 
-            Result.Exception(e, currentStack)
+            Result.Exception(e, new OuterStack(currentStack))
           }finally{
             System.setErr(err)
             System.setOut(out)
diff --git a/core/src/mill/eval/Result.scala b/core/src/mill/eval/Result.scala
index 174dfcd1..f5293c8c 100644
--- a/core/src/mill/eval/Result.scala
+++ b/core/src/mill/eval/Result.scala
@@ -10,11 +10,19 @@ sealed trait Result[+T]{
 object Result{
   implicit def create[T](t: => T): Result[T] = {
     try Success(t)
-    catch { case e: Throwable => Exception(e, new java.lang.Exception().getStackTrace) }
+    catch { case e: Throwable => Exception(e, new OuterStack(new java.lang.Exception().getStackTrace)) }
   }
   case class Success[T](value: T) extends Result[T]
   case object Skipped extends Result[Nothing]
   sealed trait Failing extends Result[Nothing]
   case class Failure(msg: String) extends Failing
-  case class Exception(throwable: Throwable, outerStack: Seq[StackTraceElement]) extends Failing
+  case class Exception(throwable: Throwable, outerStack: OuterStack) extends Failing
+  class OuterStack(val value: Seq[StackTraceElement]){
+    override def hashCode() = value.hashCode()
+
+    override def equals(obj: scala.Any) = obj match{
+      case o: OuterStack => value.equals(o.value)
+      case _ => false
+    }
+  }
 }
\ No newline at end of file
diff --git a/core/src/mill/main/ReplApplyHandler.scala b/core/src/mill/main/ReplApplyHandler.scala
index 387951b2..66f80630 100644
--- a/core/src/mill/main/ReplApplyHandler.scala
+++ b/core/src/mill/main/ReplApplyHandler.scala
@@ -54,7 +54,9 @@ class ReplApplyHandler(pprinter0: pprint.PPrinter,
               case Result.Failure(m) => msg.append(m + "\n")
               case Result.Exception(t, outerStack) =>
                 msg.append(
-                  t.toString + t.getStackTrace.dropRight(outerStack.length).map("\n    " + _).mkString + "\n"
+                  t.toString +
+                  t.getStackTrace.dropRight(outerStack.value.length).map("\n    " + _).mkString +
+                  "\n"
                 )
 
             }
diff --git a/core/src/mill/main/RunScript.scala b/core/src/mill/main/RunScript.scala
index 55fd8937..e5c92e3e 100644
--- a/core/src/mill/main/RunScript.scala
+++ b/core/src/mill/main/RunScript.scala
@@ -173,7 +173,8 @@ object RunScript{
         }
         val fss = fs.map{
           case Result.Exception(t, outerStack) =>
-            t.toString + t.getStackTrace.dropRight(outerStack.length).map("\n    " + _).mkString
+            t.toString +
+            t.getStackTrace.dropRight(outerStack.value.length).map("\n    " + _).mkString
           case Result.Failure(t) => t
         }
         s"$ks ${fss.mkString(", ")}"
diff --git a/core/test/src/mill/eval/FailureTests.scala b/core/test/src/mill/eval/FailureTests.scala
index 48209b4e..91b1851d 100644
--- a/core/test/src/mill/eval/FailureTests.scala
+++ b/core/test/src/mill/eval/FailureTests.scala
@@ -2,6 +2,7 @@ package mill.eval
 import mill.T
 import mill.util.{TestEvaluator, TestUtil}
 import ammonite.ops.{Path, pwd, rm}
+import mill.eval.Result.OuterStack
 import utest._
 import utest.framework.TestPath
 import mill.util.TestEvaluator.implicitDisover
@@ -43,7 +44,7 @@ object FailureTests extends TestSuite{
       check.fail(
         target = singleton.single,
         expectedFailCount = 1,
-        expectedRawValues = Seq(Result.Exception(ex, Nil))
+        expectedRawValues = Seq(Result.Exception(ex, new OuterStack(Nil)))
       )
     }
     'evaluatePair - {
diff --git a/core/test/src/mill/util/TestEvaluator.scala b/core/test/src/mill/util/TestEvaluator.scala
index ee92c2c2..8ef12417 100644
--- a/core/test/src/mill/util/TestEvaluator.scala
+++ b/core/test/src/mill/util/TestEvaluator.scala
@@ -3,6 +3,7 @@ package mill.util
 import ammonite.ops.{Path, pwd}
 import mill.define.Discover.applyImpl
 import mill.define.{Discover, Input, Target, Task}
+import mill.eval.Result.OuterStack
 import mill.eval.{Evaluator, Result}
 import mill.util.Strict.Agg
 import utest.assert
@@ -57,7 +58,7 @@ class TestEvaluator[T <: TestUtil.TestBuild](module: T)
     val res = evaluator.evaluate(Agg(target))
 
     val cleaned = res.rawValues.map{
-      case Result.Exception(ex, _) => Result.Exception(ex, Nil)
+      case Result.Exception(ex, _) => Result.Exception(ex, new OuterStack(Nil))
       case x => x
     }
 
diff --git a/core/test/src/mill/util/TestUtil.scala b/core/test/src/mill/util/TestUtil.scala
index 1413e9c6..59ef74df 100644
--- a/core/test/src/mill/util/TestUtil.scala
+++ b/core/test/src/mill/util/TestUtil.scala
@@ -4,6 +4,7 @@ import ammonite.main.Router.Overrides
 import ammonite.ops.pwd
 import mill.define._
 import mill.eval.Result
+import mill.eval.Result.OuterStack
 import utest.assert
 import mill.util.Strict.Agg
 import utest.framework.TestPath
@@ -49,7 +50,7 @@ object TestUtil {
     var exception = Option.empty[Throwable]
     override def evaluate(args: Ctx) = {
       failure.map(Result.Failure) orElse
-        exception.map(Result.Exception(_, Nil)) getOrElse
+        exception.map(Result.Exception(_, new OuterStack(Nil))) getOrElse
         Result.Success(counter + args.args.map(_.asInstanceOf[Int]).sum)
     }
     override def sideHash = counter + failure.hashCode() + exception.hashCode()
diff --git a/scalalib/src/mill/scalalib/MiscModule.scala b/scalalib/src/mill/scalalib/MiscModule.scala
index 440b7dcd..e4d8a8b0 100644
--- a/scalalib/src/mill/scalalib/MiscModule.scala
+++ b/scalalib/src/mill/scalalib/MiscModule.scala
@@ -14,6 +14,8 @@ object CrossModuleBase{
 }
 trait CrossModuleBase extends mill.Module{
   def crossScalaVersion: String
+  def scalaVersion = T{ crossScalaVersion }
+
   override def millSourcePath = super.millSourcePath / ammonite.ops.up
   implicit def crossSbtModuleResolver: Resolver[CrossModuleBase] = new Resolver[CrossModuleBase]{
     def resolve[V <: CrossModuleBase](c: Cross[V]): V = {
@@ -71,7 +73,6 @@ trait SbtModule extends ScalaModule { outer =>
 
 trait CrossSbtModule extends SbtModule with CrossModuleBase{ outer =>
 
-  def scalaVersion = crossScalaVersion
   override def sources = T.input{
     super.sources() ++
     CrossModuleBase.scalaVersionPaths(
diff --git a/scalalib/test/resources/hello-world/core/src-2.10/Shim.scala b/scalalib/test/resources/hello-world/core/src-2.10/Shim.scala
new file mode 100644
index 00000000..025cff5c
--- /dev/null
+++ b/scalalib/test/resources/hello-world/core/src-2.10/Shim.scala
@@ -0,0 +1,5 @@
+object Shim{
+  def main(args: Array[String]): Unit = {
+    Main0(args(0), scala.util.Properties.versionNumberString + " rox")
+  }
+}
\ No newline at end of file
diff --git a/scalalib/test/resources/hello-world/core/src-2.11/Shim.scala b/scalalib/test/resources/hello-world/core/src-2.11/Shim.scala
new file mode 100644
index 00000000..d98a6de1
--- /dev/null
+++ b/scalalib/test/resources/hello-world/core/src-2.11/Shim.scala
@@ -0,0 +1,5 @@
+object Shim{
+  def main(args: Array[String]): Unit = {
+    Main0(args(0), scala.util.Properties.versionNumberString + " pwns")
+  }
+}
\ No newline at end of file
diff --git a/scalalib/test/resources/hello-world/core/src-2.12/Shim.scala b/scalalib/test/resources/hello-world/core/src-2.12/Shim.scala
new file mode 100644
index 00000000..1f3e1c0f
--- /dev/null
+++ b/scalalib/test/resources/hello-world/core/src-2.12/Shim.scala
@@ -0,0 +1,5 @@
+object Shim{
+  def main(args: Array[String]): Unit = {
+    Main0(args(0), scala.util.Properties.versionNumberString + " leet")
+  }
+}
\ No newline at end of file
diff --git a/scalalib/test/resources/hello-world/core/src/Main.scala b/scalalib/test/resources/hello-world/core/src/Main.scala
new file mode 100644
index 00000000..32706d44
--- /dev/null
+++ b/scalalib/test/resources/hello-world/core/src/Main.scala
@@ -0,0 +1,18 @@
+import scala.collection._
+import java.nio.file.{Files, Paths}
+
+import Main.{args, greeting}
+object Main0{
+  def apply(s: String, greeting: String) = {
+    val resultPath = Paths.get(s)
+    Files.createDirectories(resultPath.getParent)
+    Files.write(resultPath, greeting.getBytes)
+  }
+}
+object Main extends App {
+
+  val person = Person.fromString("rockjam:25")
+  val greeting = s"hello ${person.name}, your age is: ${person.age}"
+  println(greeting)
+  Main0(args(0), greeting)
+}
diff --git a/scalalib/test/resources/hello-world/src/Result.scala b/scalalib/test/resources/hello-world/core/src/Result.scala
index d7d29a51..d7d29a51 100644
--- a/scalalib/test/resources/hello-world/src/Result.scala
+++ b/scalalib/test/resources/hello-world/core/src/Result.scala
diff --git a/scalalib/test/resources/hello-world/src/Main.scala b/scalalib/test/resources/hello-world/src/Main.scala
deleted file mode 100644
index 14139d6f..00000000
--- a/scalalib/test/resources/hello-world/src/Main.scala
+++ /dev/null
@@ -1,12 +0,0 @@
-import scala.collection._ // unused import to check unused imports warning
-import java.nio.file.{Files, Paths}
-
-object Main extends App {
-
-  val person = Person.fromString("rockjam:25")
-  val greeting = s"hello ${person.name}, your age is: ${person.age}"
-  println(greeting)
-  val resultPath = Paths.get(args(0))
-  Files.createDirectories(resultPath.getParent)
-  Files.write(resultPath, greeting.getBytes)
-}
diff --git a/scalalib/test/src/mill/scalalib/HelloWorldTests.scala b/scalalib/test/src/mill/scalalib/HelloWorldTests.scala
index 6afcef5e..fd8517f3 100644
--- a/scalalib/test/src/mill/scalalib/HelloWorldTests.scala
+++ b/scalalib/test/src/mill/scalalib/HelloWorldTests.scala
@@ -17,66 +17,83 @@ import scala.collection.JavaConverters._
 
 
 object HelloWorldTests extends TestSuite {
-  trait HelloWorldModule
-  extends TestUtil.BaseModule with scalalib.ScalaModule {
-    def scalaVersion = "2.12.4"
+  trait HelloBase extends TestUtil.BaseModule{
     def millSourcePath =  TestUtil.getSrcPathBase() / millOuterCtx.enclosing.split('.')
   }
+  trait HelloWorldModule extends scalalib.ScalaModule {
+    def scalaVersion = "2.12.4"
+  }
 
 
-  object HelloWorld extends HelloWorldModule
-  object CrossHelloWorld extends TestUtil.BaseModule {
-    object cross extends Cross[HelloWorldCross]("2.10.6", "2.11.11", "2.12.3", "2.12.4")
-    class HelloWorldCross(v: String) extends HelloWorldModule {
-      def millSourcePath = super.millSourcePath / up
-      def scalaVersion = v
-    }
+  object HelloWorld extends HelloBase {
+    object core extends HelloWorldModule
+  }
+  object CrossHelloWorld extends HelloBase {
+    object core extends Cross[HelloWorldCross]("2.10.6", "2.11.11", "2.12.3", "2.12.4")
+    class HelloWorldCross(val crossScalaVersion: String) extends CrossScalaModule
   }
 
-  object HelloWorldWithMain extends HelloWorldModule {
-    def mainClass = Some("Main")
+
+  object HelloWorldWithMain extends HelloBase {
+    object core extends HelloWorldModule{
+      def mainClass = Some("Main")
+    }
   }
 
-  object HelloWorldWithMainAssembly extends HelloWorldModule {
-    def mainClass = Some("Main")
-    def assembly = T{
-      mill.modules.Jvm.createAssembly(
-        runClasspath().map(_.path).filter(exists),
-        prependShellScript = prependShellScript(),
-        mainClass = mainClass()
-      )
+  object HelloWorldWithMainAssembly extends HelloBase {
+    object core extends HelloWorldModule{
+      def mainClass = Some("Main")
+      def assembly = T{
+        mill.modules.Jvm.createAssembly(
+          runClasspath().map(_.path).filter(exists),
+          prependShellScript = prependShellScript(),
+          mainClass = mainClass()
+        )
+      }
     }
   }
 
-  object HelloWorldWarnUnused extends HelloWorldModule {
-    def scalacOptions = T(Seq("-Ywarn-unused"))
+  object HelloWorldWarnUnused extends HelloBase{
+    object core extends HelloWorldModule {
+      def scalacOptions = T(Seq("-Ywarn-unused"))
+    }
   }
 
-  object HelloWorldFatalWarnings extends HelloWorldModule {
-    def scalacOptions = T(Seq("-Ywarn-unused", "-Xfatal-warnings"))
+  object HelloWorldFatalWarnings extends HelloBase{
+    object core extends HelloWorldModule {
+      def scalacOptions = T(Seq("-Ywarn-unused", "-Xfatal-warnings"))
+    }
+
   }
 
-  object HelloWorldWithPublish extends HelloWorldModule with PublishModule {
-    def artifactName = "hello-world"
-    def publishVersion = "0.0.1"
-
-    def pomSettings = PomSettings(
-      organization = "com.lihaoyi",
-      description = "hello world ready for real world publishing",
-      url = "https://github.com/lihaoyi/hello-world-publish",
-      licenses = Seq(
-        License("Apache License, Version 2.0",
-          "http://www.apache.org/licenses/LICENSE-2.0")),
-      scm = SCM(
-        "https://github.com/lihaoyi/hello-world-publish",
-        "scm:git:https://github.com/lihaoyi/hello-world-publish"
-      ),
-      developers =
-        Seq(Developer("lihaoyi", "Li Haoyi", "https://github.com/lihaoyi"))
-    )
+  object HelloWorldWithPublish extends HelloBase{
+    object core extends HelloWorldModule with PublishModule{
+
+      def artifactName = "hello-world"
+      def publishVersion = "0.0.1"
+
+      def pomSettings = PomSettings(
+        organization = "com.lihaoyi",
+        description = "hello world ready for real world publishing",
+        url = "https://github.com/lihaoyi/hello-world-publish",
+        licenses = Seq(
+          License("Apache License, Version 2.0",
+            "http://www.apache.org/licenses/LICENSE-2.0")),
+        scm = SCM(
+          "https://github.com/lihaoyi/hello-world-publish",
+          "scm:git:https://github.com/lihaoyi/hello-world-publish"
+        ),
+        developers =
+          Seq(Developer("lihaoyi", "Li Haoyi", "https://github.com/lihaoyi"))
+      )
+    }
   }
-  object HelloWorldScalaOverride extends HelloWorldModule {
-    override def scalaVersion: Target[String] = "2.11.11"
+
+  object HelloWorldScalaOverride extends HelloBase{
+    object core extends HelloWorldModule {
+
+      override def scalaVersion: Target[String] = "2.11.11"
+    }
   }
   val resourcePath = pwd / 'scalalib / 'test / 'resources / "hello-world"
 
@@ -89,6 +106,8 @@ object HelloWorldTests extends TestSuite {
   def compileClassfiles = Seq[RelPath](
     "Main.class",
     "Main$.class",
+    "Main0.class",
+    "Main0$.class",
     "Main$delayedInit$body.class",
     "Person.class",
     "Person$.class"
@@ -112,7 +131,7 @@ object HelloWorldTests extends TestSuite {
     'scalaVersion - {
       
       'fromBuild - workspaceTest(HelloWorld){eval => 
-        val Right((result, evalCount)) = eval.apply(HelloWorld.scalaVersion)
+        val Right((result, evalCount)) = eval.apply(HelloWorld.core.scalaVersion)
 
         assert(
           result == "2.12.4",
@@ -120,7 +139,7 @@ object HelloWorldTests extends TestSuite {
         )
       }
       'override - workspaceTest(HelloWorldScalaOverride){eval =>
-        val Right((result, evalCount)) = eval.apply(HelloWorldScalaOverride.scalaVersion)
+        val Right((result, evalCount)) = eval.apply(HelloWorldScalaOverride.core.scalaVersion)
 
         assert(
           result == "2.11.11",
@@ -130,7 +149,7 @@ object HelloWorldTests extends TestSuite {
     }
     'scalacOptions - {
       'emptyByDefault - workspaceTest(HelloWorld){eval =>
-        val Right((result, evalCount)) = eval.apply(HelloWorld.scalacOptions)
+        val Right((result, evalCount)) = eval.apply(HelloWorld.core.scalacOptions)
 
         assert(
           result.isEmpty,
@@ -138,7 +157,7 @@ object HelloWorldTests extends TestSuite {
         )
       }
       'override - workspaceTest(HelloWorldFatalWarnings){ eval =>
-        val Right((result, evalCount)) = eval.apply(HelloWorldFatalWarnings.scalacOptions)
+        val Right((result, evalCount)) = eval.apply(HelloWorldFatalWarnings.core.scalacOptions)
 
         assert(
           result == Seq("-Ywarn-unused", "-Xfatal-warnings"),
@@ -148,13 +167,15 @@ object HelloWorldTests extends TestSuite {
     }
     'compile - {
       'fromScratch - workspaceTest(HelloWorld){eval =>
-        val Right((result, evalCount)) = eval.apply(HelloWorld.compile)
+        val Right((result, evalCount)) = eval.apply(HelloWorld.core.compile)
 
         val analysisFile = result.analysisFile
         val outputFiles = ls.rec(result.classes.path)
-        val expectedClassfiles = compileClassfiles.map(eval.outPath / 'compile / 'dest / 'classes / _)
+        val expectedClassfiles = compileClassfiles.map(
+          eval.outPath / 'core / 'compile / 'dest / 'classes / _
+        )
         assert(
-          result.classes.path == eval.outPath / 'compile / 'dest / 'classes,
+          result.classes.path == eval.outPath / 'core / 'compile / 'dest / 'classes,
           exists(analysisFile),
           outputFiles.nonEmpty,
           outputFiles.forall(expectedClassfiles.contains),
@@ -162,29 +183,29 @@ object HelloWorldTests extends TestSuite {
         )
 
         // don't recompile if nothing changed
-        val Right((_, unchangedEvalCount)) = eval.apply(HelloWorld.compile)
+        val Right((_, unchangedEvalCount)) = eval.apply(HelloWorld.core.compile)
 
         assert(unchangedEvalCount == 0)
       }
       'recompileOnChange - workspaceTest(HelloWorld){eval =>
-        val Right((_, freshCount)) = eval.apply(HelloWorld.compile)
+        val Right((_, freshCount)) = eval.apply(HelloWorld.core.compile)
         assert(freshCount > 0)
 
-        write.append(HelloWorld.millSourcePath / 'src / "Main.scala", "\n")
+        write.append(HelloWorld.millSourcePath / 'core / 'src / "Main.scala", "\n")
 
-        val Right((_, incCompileCount)) = eval.apply(HelloWorld.compile)
+        val Right((_, incCompileCount)) = eval.apply(HelloWorld.core.compile)
         assert(incCompileCount > 0, incCompileCount < freshCount)
       }
       'failOnError - workspaceTest(HelloWorld){eval =>
-        write.append(HelloWorld.millSourcePath / 'src / "Main.scala", "val x: ")
+        write.append(HelloWorld.millSourcePath / 'core / 'src / "Main.scala", "val x: ")
 
-        val Left(Result.Exception(err, _)) = eval.apply(HelloWorld.compile)
+        val Left(Result.Exception(err, _)) = eval.apply(HelloWorld.core.compile)
 
 //        assert(err.isInstanceOf[CompileFailed])
 
         val paths = Evaluator.resolveDestPaths(
           eval.outPath,
-          HelloWorld.compile.ctx.segments
+          HelloWorld.core.compile.ctx.segments
         )
 
         assert(
@@ -193,24 +214,24 @@ object HelloWorldTests extends TestSuite {
         )
         // Works when fixed
         write.over(
-          HelloWorld.millSourcePath / 'src / "Main.scala",
-          read(HelloWorld.millSourcePath / 'src / "Main.scala").dropRight("val x: ".length)
+          HelloWorld.millSourcePath / 'core / 'src / "Main.scala",
+          read(HelloWorld.millSourcePath / 'core / 'src / "Main.scala").dropRight("val x: ".length)
         )
 
-        val Right((result, evalCount)) = eval.apply(HelloWorld.compile)
+        val Right((result, evalCount)) = eval.apply(HelloWorld.core.compile)
       }
       'passScalacOptions - workspaceTest(HelloWorldFatalWarnings){ eval =>
         // compilation fails because of "-Xfatal-warnings" flag
-        val Left(Result.Exception(err, _)) = eval.apply(HelloWorldFatalWarnings.compile)
+        val Left(Result.Exception(err, _)) = eval.apply(HelloWorldFatalWarnings.core.compile)
 
 //        assert(err.isInstanceOf[CompileFailed])
       }
     }
     'runMain - {
       'runMainObject - workspaceTest(HelloWorld){eval =>
-        val runResult = eval.outPath/ 'runMain / 'dest / "hello-mill"
+        val runResult = eval.outPath / 'core / 'runMain / 'dest / "hello-mill"
 
-        val Right((_, evalCount)) = eval.apply(HelloWorld.runMain("Main", runResult.toString))
+        val Right((_, evalCount)) = eval.apply(HelloWorld.core.runMain("Main", runResult.toString))
         assert(evalCount > 0)
 
         assert(
@@ -219,12 +240,12 @@ object HelloWorldTests extends TestSuite {
         )
       }
       'runCross - {
-        def cross(eval: TestEvaluator[_], v: String) {
+        def cross(eval: TestEvaluator[_], v: String, expectedOut: String) {
 
-          val runResult = eval.outPath / 'cross / v / 'runMain / 'dest / "hello-mill"
+          val runResult = eval.outPath / "hello-mill"
 
           val Right((_, evalCount)) = eval.apply(
-            CrossHelloWorld.cross(v).runMain("Main", runResult.toString)
+            CrossHelloWorld.core(v).runMain("Shim", runResult.toString)
           )
 
           assert(evalCount > 0)
@@ -232,27 +253,27 @@ object HelloWorldTests extends TestSuite {
 
           assert(
             exists(runResult),
-            read(runResult) == "hello rockjam, your age is: 25"
+            read(runResult) == expectedOut
           )
         }
-        'v210 - workspaceTest(CrossHelloWorld)(cross(_, "2.10.6"))
-        'v211 - workspaceTest(CrossHelloWorld)(cross(_, "2.11.11"))
-        'v2123 - workspaceTest(CrossHelloWorld)(cross(_, "2.12.3"))
-        'v2124 - workspaceTest(CrossHelloWorld)(cross(_, "2.12.4"))
+        'v210 - workspaceTest(CrossHelloWorld)(cross(_, "2.10.6", "2.10.6 rox"))
+        'v211 - workspaceTest(CrossHelloWorld)(cross(_, "2.11.11", "2.11.11 pwns"))
+        'v2123 - workspaceTest(CrossHelloWorld)(cross(_, "2.12.3", "2.12.3 leet"))
+        'v2124 - workspaceTest(CrossHelloWorld)(cross(_, "2.12.4", "2.12.4 leet"))
       }
 
 
       'notRunInvalidMainObject - workspaceTest(HelloWorld){eval =>
-        val Left(Result.Exception(err, _)) = eval.apply(HelloWorld.runMain("Invalid"))
+        val Left(Result.Exception(err, _)) = eval.apply(HelloWorld.core.runMain("Invalid"))
 
         assert(
           err.isInstanceOf[InteractiveShelloutException]
         )
       }
-      'notRunWhenComplileFailed - workspaceTest(HelloWorld){eval =>
-        write.append(HelloWorld.millSourcePath / 'src / "Main.scala", "val x: ")
+      'notRunWhenCompileFailed - workspaceTest(HelloWorld){eval =>
+        write.append(HelloWorld.millSourcePath / 'core / 'src / "Main.scala", "val x: ")
 
-        val Left(Result.Exception(err, _)) = eval.apply(HelloWorld.runMain("Main"))
+        val Left(Result.Exception(err, _)) = eval.apply(HelloWorld.core.runMain("Main"))
 
 //        assert(
 //          err.isInstanceOf[CompileFailed]
@@ -262,9 +283,9 @@ object HelloWorldTests extends TestSuite {
 
     'forkRun - {
       'runIfMainClassProvided - workspaceTest(HelloWorldWithMain){eval =>
-        val runResult = eval.outPath / 'run / 'dest / "hello-mill"
+        val runResult = eval.outPath / 'core / 'run / 'dest / "hello-mill"
         val Right((_, evalCount)) = eval.apply(
-          HelloWorldWithMain.run(runResult.toString)
+          HelloWorldWithMain.core.run(runResult.toString)
         )
 
         assert(evalCount > 0)
@@ -276,7 +297,7 @@ object HelloWorldTests extends TestSuite {
         )
       }
       'notRunWithoutMainClass - workspaceTest(HelloWorld){eval =>
-        val Left(Result.Exception(err, _)) = eval.apply(HelloWorld.run())
+        val Left(Result.Exception(err, _)) = eval.apply(HelloWorld.core.run())
 
         assert(
           err.isInstanceOf[RuntimeException]
@@ -285,9 +306,9 @@ object HelloWorldTests extends TestSuite {
     }
     'run - {
       'runIfMainClassProvided - workspaceTest(HelloWorldWithMain){eval =>
-        val runResult = eval.outPath / 'run / 'dest / "hello-mill"
+        val runResult = eval.outPath / 'core / 'run / 'dest / "hello-mill"
         val Right((_, evalCount)) = eval.apply(
-          HelloWorldWithMain.runLocal(runResult.toString)
+          HelloWorldWithMain.core.runLocal(runResult.toString)
         )
 
         assert(evalCount > 0)
@@ -299,7 +320,7 @@ object HelloWorldTests extends TestSuite {
         )
       }
       'notRunWithoutMainClass - workspaceTest(HelloWorld){eval =>
-        val Left(Result.Exception(err, _)) = eval.apply(HelloWorld.runLocal())
+        val Left(Result.Exception(err, _)) = eval.apply(HelloWorld.core.runLocal())
 
         assert(
           err.isInstanceOf[RuntimeException]
@@ -308,7 +329,7 @@ object HelloWorldTests extends TestSuite {
     }
     'jar - {
       'nonEmpty - workspaceTest(HelloWorldWithMain){eval =>
-        val Right((result, evalCount)) = eval.apply(HelloWorldWithMain.jar)
+        val Right((result, evalCount)) = eval.apply(HelloWorldWithMain.core.jar)
 
         assert(
           exists(result.path),
@@ -333,16 +354,16 @@ object HelloWorldTests extends TestSuite {
       }
       'logOutputToFile - workspaceTest(HelloWorld){eval =>
         val outPath = eval.outPath
-        eval.apply(HelloWorld.compile)
+        eval.apply(HelloWorld.core.compile)
 
-        val logFile = outPath / 'compile / 'log
+        val logFile = outPath / 'core / 'compile / 'log
         assert(exists(logFile))
       }
     }
 
     'assembly - {
       'assembly - workspaceTest(HelloWorldWithMainAssembly){ eval =>
-        val Right((result, evalCount)) = eval.apply(HelloWorldWithMainAssembly.assembly)
+        val Right((result, evalCount)) = eval.apply(HelloWorldWithMainAssembly.core.assembly)
         assert(
           exists(result.path),
           evalCount > 0
@@ -357,7 +378,7 @@ object HelloWorldTests extends TestSuite {
         assert(mainClass.contains("Main"))
       }
       'run - workspaceTest(HelloWorldWithMainAssembly){eval =>
-        val Right((result, evalCount)) = eval.apply(HelloWorldWithMainAssembly.assembly)
+        val Right((result, evalCount)) = eval.apply(HelloWorldWithMainAssembly.core.assembly)
 
         assert(
           exists(result.path),