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,
     )
 

scala/private/rules/scala_doc.bzl

@@ -1,10 +1,12 @@
 """Scaladoc support"""
 
+load("@io_bazel_rules_scala//scala:providers.bzl", "ScalaInfo")
 load("@io_bazel_rules_scala//scala/private:common.bzl", "collect_plugin_paths")
 
 ScaladocAspectInfo = provider(fields = [
     "src_files",  #depset[File]
     "compile_jars",  #depset[File]
+    "macro_classpath",  #depset[File]
     "plugins",  #depset[Target]
 ])
 
@@ -29,23 +31,28 @@ def _scaladoc_aspect_impl(target, ctx, transitive = True):
         if hasattr(ctx.rule.attr, "plugins"):
             plugins = depset(ctx.rule.attr.plugins)
 
+    macro_classpath = []
+
+    for dependency in ctx.rule.attr.deps:
+        if ScalaInfo in dependency and dependency[ScalaInfo].contains_macros:
+            macro_classpath.append(dependency[JavaInfo].transitive_runtime_jars)
+
     # Sometimes we only want to generate scaladocs for a single target and not all of its
     # dependencies
     transitive_srcs = depset()
-    transitive_compile_jars = depset()
     transitive_plugins = depset()
 
     if transitive:
         for dep in ctx.rule.attr.deps:
             if ScaladocAspectInfo in dep:
                 aspec_info = dep[ScaladocAspectInfo]
                 transitive_srcs = aspec_info.src_files
-                transitive_compile_jars = aspec_info.compile_jars
                 transitive_plugins = aspec_info.plugins
 
     return [ScaladocAspectInfo(
         src_files = depset(transitive = [src_files, transitive_srcs]),
-        compile_jars = depset(transitive = [compile_jars, transitive_compile_jars]),
+        compile_jars = depset(transitive = [compile_jars]),
+        macro_classpath = depset(transitive = macro_classpath),
         plugins = depset(transitive = [plugins, transitive_plugins]),
     )]
 
@@ -73,11 +80,15 @@ def _scala_doc_impl(ctx):
     src_files = depset(transitive = [dep[ScaladocAspectInfo].src_files for dep in ctx.attr.deps])
     compile_jars = depset(transitive = [dep[ScaladocAspectInfo].compile_jars for dep in ctx.attr.deps])
 
+    # See the documentation for `collect_jars` in `scala/private/common.bzl` to understand why this is prepended to the
+    # classpath
+    macro_classpath = depset(transitive = [dep[ScaladocAspectInfo].macro_classpath for dep in ctx.attr.deps])
+
     # Get the 'real' paths to the plugin jars.
     plugins = collect_plugin_paths(depset(transitive = [dep[ScaladocAspectInfo].plugins for dep in ctx.attr.deps]).to_list())
 
     # Construct the full classpath depset since we need to add compiler plugins too.
-    classpath = depset(transitive = [plugins, compile_jars])
+    classpath = depset(transitive = [macro_classpath, plugins, compile_jars])
 
     # Construct scaladoc args, which also include scalac args.
     # See `scaladoc -help` for more information.

test/macros/BUILD

@@ -22,3 +22,27 @@ scala_library(
     srcs = ["MacroUser.scala"],
     deps = [":correct-macro"],
 )
+
+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

@@ -13,5 +13,10 @@ correct_macro_user_builds() {
   bazel build //test/macros:correct-macro-user
 }
 
+macros_can_have_dependencies() {
+  bazel build //test/macros:macro-with-dependencies-user
+}
+
 $runner incorrect_macro_user_does_not_build
 $runner correct_macro_user_builds
+$runner macros_can_have_dependencies