Re-enable compile-time errors (#6119)

These were converted to runtime errors in
#6107 to try and work around
problems in intellij highlighting, but we can get the best of both
worlds by turning them into compile errors only in the presence of a
`sys.env`/`sys.props` that Mill itself provides. So people using these
APIs in Mill will get the stricter compile-time checks, but IntelliJ
trying to compile this code will not have these env/props and not result
in (spurious) compile errors

Author: lihaoyi

build.mill

@@ -1,6 +1,6 @@
 //| mill-version: 1.1.0-RC1
 //| mill-jvm-opts: ["-XX:NonProfiledCodeHeapSize=250m", "-XX:ReservedCodeCacheSize=500m"]
-//| mill-opts: ["--jobs=0.5C"]
+//| mill-opts: ["--jobs=0.5C", "-DMILL_ENABLE_STATIC_CHECKS=true"]
 
 package build
 

core/api/src/mill/api/ModuleCtx.scala

@@ -3,6 +3,7 @@ package mill.api
 import mill.api.internal.OverrideMapping
 
 import scala.annotation.implicitNotFound
+import scala.quoted.*
 
 /**
  * The contextual information provided to a [[mill.api.Module]] or [[mill.api.Task]]
@@ -163,10 +164,27 @@ object ModuleCtx extends LowPriCtx {
 }
 
 trait LowPriCtx {
-  // Dummy `Ctx` available in implicit scope but must not be actually used.
+  // Binary compatibility stub
+  def dummyInfo: ModuleCtx = throw new Exception(LowPriCtx.errorMessage)
+
+  // Dummy `Ctx` available in implicit scope but never actually used.
   // as it is provided by the codegen. Defined for IDEs to think that one is available
   // and not show errors in build.mill/package.mill even though they can't see the codegen
-  implicit def dummyInfo: ModuleCtx = sys.error(
+  inline implicit def dummyInfo2: ModuleCtx = ${ LowPriCtx.dummyInfoImpl }
+}
+
+object LowPriCtx {
+  private def errorMessage =
     "Modules and Tasks can only be defined within a mill Module (in `build.mill` or `package.mill` files)"
-  )
+
+  def dummyInfoImpl(using quotes: Quotes): Expr[ModuleCtx] = {
+    import quotes.reflect.*
+
+    if (
+      sys.env.contains(mill.constants.EnvVars.MILL_ENABLE_STATIC_CHECKS) ||
+      sys.props.contains(mill.constants.EnvVars.MILL_ENABLE_STATIC_CHECKS)
+    ) {
+      report.errorAndAbort(errorMessage)
+    } else '{ throw new Exception(${ Expr(errorMessage) }) }
+  }
 }

core/api/src/mill/api/internal/Cacher.scala

@@ -65,16 +65,20 @@ private[mill] object Cacher {
       owner.owner.isClassDef &&
         owner.owner.typeRef.baseClasses.contains(CacherSym)
 
+    val errorMessage = "Task{} members must be defs defined in a Module class/trait/object body"
     if (ownerIsCacherClass && owner.flags.is(Flags.Method)) {
       val enclosingCtx = Expr.summon[sourcecode.Enclosing].getOrElse(
         report.errorAndAbort("Cannot find enclosing context", Position.ofMacroExpansion)
       )
 
       val thisSel = This(owner.owner).asExprOf[Cacher]
       '{ $thisSel.cachedTask[T](${ t })(using $enclosingCtx) }
-    } else '{
+    } else if (
+      sys.env.contains(mill.constants.EnvVars.MILL_ENABLE_STATIC_CHECKS) ||
+      sys.props.contains(mill.constants.EnvVars.MILL_ENABLE_STATIC_CHECKS)
+    ) {
+      report.errorAndAbort(errorMessage, Position.ofMacroExpansion)
       // Use a runtime exception to prevent false error highlighting in IntelliJ
-      throw new Exception("Task{} members must be defs defined in a Module class/trait/object body")
-    }
+    } else '{ throw new Exception(${ Expr(errorMessage) }) }
   }
 }

core/api/test/src/mill/api/MacroErrorTests.scala

@@ -8,6 +8,15 @@ import scala.annotation.unused
 object MacroErrorTests extends TestSuite {
 
   val tests = Tests {
+
+    test("errors") {
+      val expectedMsg =
+        "Task{} members must be defs defined in a Module class/trait/object body"
+
+      val err = assertCompileError("object Foo extends TestRootModule{ val x = Task {1} }")
+      assert(err.msg == expectedMsg)
+    }
+
     test("badParameterSets") {
       test("command") {
         val e = assertCompileError("""
@@ -110,7 +119,19 @@ object MacroErrorTests extends TestSuite {
           lazy val millDiscover = Discover[this.type]
         }
       }
+      test("neg1") {
+        val e = assertCompileError("""def a = Task { 1 }""")
+        assert(e.msg.contains(
+          "Task{} members must be defs defined in a Module class/trait/object body"
+        ))
+      }
 
+      test("neg2") {
+        val e = assertCompileError("object foo extends TestRootModule{ val a = Task { 1 } }")
+        assert(e.msg.contains(
+          "Task{} members must be defs defined in a Module class/trait/object body"
+        ))
+      }
       test("neg3") {
 
         val expectedMsg =

core/constants/src/mill/constants/EnvVars.java

@@ -53,4 +53,10 @@ public class EnvVars {
    * The path to the currently executing Mill launcher executable
    */
   public static final String MILL_EXECUTABLE_PATH = "MILL_EXECUTABLE_PATH";
+
+  /**
+   * Env var used to enable certain compile-time checks only in the actual Mill process,
+   * so that they don't cause false positives in IDEs like IntelliJ.
+   */
+  public static final String MILL_ENABLE_STATIC_CHECKS = "MILL_ENABLE_STATIC_CHECKS";
 }

dist/scripts/test/src/ScriptTests.scala

@@ -347,13 +347,11 @@ object ScriptTests extends TestSuite {
         )
 
         val Seq(downloadUrl, downloadDest) = res.out.lines()
-        println("downloadUrl: " + downloadUrl)
-        println("downloadDest: " + downloadDest)
+
         assert(downloadUrl == versionPaths.downloadUrl)
         if (!scala.util.Properties.isWin) assert(downloadDest == versionPaths.macLinuxDownloadPath)
         else assert(downloadDest == versionPaths.windowsDownloadPath)
       }
     }
   }
-
 }

integration/failure/module-outside-top-level-module/resources/build.mill

@@ -0,0 +1,6 @@
+package build
+import mill._
+
+object invalidModule extends Module
+
+object `package` extends mill.Module

integration/failure/module-outside-top-level-module/src/ModuleOutsideTopLevelModuleTests.scala

@@ -0,0 +1,25 @@
+package mill.integration
+
+import mill.testkit.UtestIntegrationTestSuite
+
+import utest._
+
+object ModuleOutsideTopLevelModuleTests extends UtestIntegrationTestSuite {
+  val tests: Tests = Tests {
+    test("success") - integrationTest { tester =>
+      import tester._
+      val res = eval(("resolve", "_"))
+      assert(!res.isSuccess)
+      assert(
+        res.err.contains(
+          "Modules and Tasks can only be defined within a mill Module (in `build.mill` or `package.mill` files)"
+        )
+      )
+      assert(
+        res.err.contains(
+          "object invalidModule extends Module"
+        )
+      )
+    }
+  }
+}

integration/failure/no-modules-in-helper-file/resources/build.mill

@@ -0,0 +1 @@
+package build

integration/failure/no-modules-in-helper-file/resources/helper.mill

@@ -0,0 +1,3 @@
+package build
+import mill._
+object foo extends Module