Include macros' transitive runtime dependencies on the compile classpath

Author: Jaden Peterson

scala/private/common.bzl

@@ -1,5 +1,6 @@
 load("@io_bazel_rules_scala//scala:jars_to_labels.bzl", "JarsToLabelsInfo")
 load("@io_bazel_rules_scala//scala:plusone.bzl", "PlusOneDeps")
+load("@io_bazel_rules_scala//scala:providers.bzl", "ScalaInfo")
 load("@bazel_skylib//lib:paths.bzl", "paths")
 
 def write_manifest_file(actions, output_file, main_class):
@@ -22,6 +23,7 @@ def collect_jars(
     compile_jars = []
     runtime_jars = []
     deps_providers = []
+    macro_classpath = []
 
     for dep_target in dep_targets:
         # we require a JavaInfo for dependencies
@@ -50,11 +52,34 @@ def collect_jars(
                 java_provider.compile_jars.to_list(),
             )
 
+        # Macros are different from ordinary targets in that they’re used at compile time instead of at runtime. That
+        # means that both their compile-time classpath and runtime classpath are needed at compile time. We could have
+        # `scala_macro_library` targets include their runtime dependencies in their compile-time dependencies, but then
+        # we wouldn't have any guarantees classpath order.
+        #
+        # Consider the following scenario. Target A depends on targets B and C. Target C is a macro target, whereas
+        # target B isn't. Targets C depends on target B. If target A doesn't include the runtime version of target C on
+        # the compile classpath before the compile (`ijar`d) version of target B that target C depends on, then target A
+        # won't use the correct version of target B at compile-time when evaluating the macros contained in target C.
+        #
+        # For that reason, we opt for a different approach: have `scala_macro_library` targets export `JavaInfo`
+        # providers as normal, but put their transitive runtime dependencies first on the classpath. Note that we
+        # shouldn't encounter any issues with external dependencies, so long as they aren't `ijar`d.
+        if ScalaInfo in dep_target and dep_target[ScalaInfo].contains_macros:
+            macro_classpath.append(java_provider.transitive_runtime_jars)
+
+            add_labels_of_jars_to(
+                jars2labels,
+                dep_target,
+                [],
+                java_provider.transitive_runtime_jars.to_list(),
+            )
+
     return struct(
-        compile_jars = depset(transitive = compile_jars),
+        compile_jars = depset(order = "preorder", transitive = macro_classpath + compile_jars),
         transitive_runtime_jars = depset(transitive = runtime_jars),
         jars2labels = JarsToLabelsInfo(jars_to_labels = jars2labels),
-        transitive_compile_jars = depset(transitive = transitive_compile_jars),
+        transitive_compile_jars = depset(order = "preorder", transitive = macro_classpath + transitive_compile_jars),
         deps_providers = deps_providers,
     )
 

test/macros/BUILD

@@ -0,0 +1,25 @@
+load("//scala:scala.bzl", "scala_library", "scala_macro_library")
+
+scala_library(
+    name = "macro-dependency",
+    srcs = ["MacroDependency.scala"],
+)
+
+scala_macro_library(
+    name = "macro-with-dependencies",
+    srcs = ["MacroWithDependencies.scala"],
+    deps = [":macro-dependency"],
+)
+
+scala_library(
+    name = "macro-with-dependencies-user",
+    srcs = ["MacroWithDependenciesUser.scala"],
+    # Without this, `:macro-dependency` will be flagged as an unused dependency. But we want to test that despite it
+    # appearing before `:macro-with-dependencies` in `deps`, its runtime JAR is included before its compile JAR in the
+    # compile classpath
+    unused_dependency_checker_mode = "off",
+    deps = [
+        ":macro-dependency",
+        ":macro-with-dependencies",
+    ],
+)

test/macros/MacroDependency.scala

@@ -0,0 +1,5 @@
+package macros
+
+object MacroDependency {
+  def isEven(number: Int): Boolean = number % 2 == 0
+}

test/macros/MacroWithDependencies.scala

@@ -0,0 +1,18 @@
+package macros
+
+import scala.language.experimental.macros
+import scala.reflect.macros.blackbox
+
+object MacroWithDependencies {
+  def isEvenMacro(number: Int): Boolean = macro isEvenMacroImpl
+  def isEvenMacroImpl(context: blackbox.Context)(number: context.Expr[Int]): context.Expr[Boolean] = {
+    import context.universe._
+
+    val value = number.tree match {
+      case Literal(Constant(value: Int)) => value
+      case _ => throw new Exception(s"Expected ${number.tree} to be a literal.")
+    }
+
+    context.Expr(Literal(Constant(MacroDependency.isEven(value))))
+  }
+}

test/macros/MacroWithDependenciesUser.scala

@@ -0,0 +1,9 @@
+package macros
+
+object MacroWithDependenciesUser {
+  def main(arguments: Array[String]): Unit = {
+    println(s"0 is even via macro: ${MacroWithDependencies.isEvenMacro(0)}")
+    println(s"1 is even via macro: ${MacroWithDependencies.isEvenMacro(1)}")
+    println(s"1 + 1 is even macro: ${MacroWithDependencies.isEvenMacro(1 + 1)}")
+  }
+}

test/shell/test_macros.sh

@@ -0,0 +1,11 @@
+# shellcheck source=./test_runner.sh
+dir=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
+. "${dir}"/test_runner.sh
+. "${dir}"/test_helper.sh
+runner=$(get_test_runner "${1:-local}")
+
+macros_can_have_dependencies() {
+  bazel build //test/macros:macro-with-dependencies-user
+}
+
+$runner macros_can_have_dependencies