Fixed inability to use crate attribute in wrapper rules with proc-macro targets. (#807)

UebelAndre · web-flow · commit 01cc76ba58e2 · 2021-07-01T13:19:28.000-07:00
* Fixed inability to use `rust_test::crate` with proc-macro targets.

* Updated example

* Renamed to `transitive_type` to `wrapped_crate_type`

* Buildifier fixes

* Added unittests

* Updated examples and addressed feedback

* Updated examples again

* Addressed feedback

* Fixed optional argument not being optional

* Addressed feedback

* Moved integration tests

* Addressed nit
diff --git a/examples/proc_macro/BUILD.bazel b/examples/proc_macro/BUILD.bazel
@@ -9,14 +9,14 @@ load(
 package(default_visibility = ["//visibility:public"])
 
 rust_proc_macro(
-    name = "proc_macro_lib",
+    name = "proc_macro_lib_2015",
     srcs = [
         "src/lib_2015.rs",
     ],
 )
 
 rust_proc_macro(
-    name = "proc_macro_lib_2018",
+    name = "proc_macro_lib",
     srcs = [
         "src/lib.rs",
     ],
diff --git a/proto/proto.bzl b/proto/proto.bzl
@@ -234,6 +234,7 @@ def _rust_proto_compile(protos, descriptor_sets, imports, crate_name, ctx, is_gr
             edition = proto_toolchain.edition,
             rustc_env = {},
             is_test = False,
+            wrapped_crate_type = None,
         ),
         output_hash = output_hash,
     )
diff --git a/rust/private/common.bzl b/rust/private/common.bzl
@@ -37,6 +37,8 @@ def _create_crate_info(**kwargs):
     Returns:
         CrateInfo: A provider
     """
+    if not "wrapped_crate_type" in kwargs:
+        kwargs.update({"wrapped_crate_type": None})
     return CrateInfo(**kwargs)
 
 rust_common = struct(
diff --git a/rust/private/providers.bzl b/rust/private/providers.bzl
@@ -28,6 +28,10 @@ CrateInfo = provider(
         "rustc_env": "Dict[String, String]: Additional `\"key\": \"value\"` environment variables to set for rustc.",
         "srcs": "depset[File]: All source Files that are part of the crate.",
         "type": "str: The type of this crate. eg. lib or bin",
+        "wrapped_crate_type": (
+            "str, optional: The original crate type for targets generated using a previously defined " +
+            "crate (typically tests using the `rust_test::crate` attribute)"
+        ),
     },
 )
 
diff --git a/rust/private/rust.bzl b/rust/private/rust.bzl
@@ -418,6 +418,7 @@ def _rust_test_common(ctx, toolchain, output):
             edition = crate.edition,
             rustc_env = ctx.attr.rustc_env,
             is_test = True,
+            wrapped_crate_type = crate.type,
         )
     else:
         # Target is a standalone crate. Build the test binary as its own crate.
diff --git a/rust/private/rustc.bzl b/rust/private/rustc.bzl
@@ -467,7 +467,9 @@ def construct_arguments(
     # These always need to be added, even if not linking this crate.
     add_crate_link_flags(args, dep_info)
 
-    if crate_info.type == "proc-macro" and crate_info.edition != "2015":
+    needs_extern_proc_macro_flag = "proc-macro" in [crate_info.type, crate_info.wrapped_crate_type] and \
+                                   crate_info.edition != "2015"
+    if needs_extern_proc_macro_flag:
         args.add("--extern")
         args.add("proc_macro")
 
diff --git a/rust/private/rustdoc.bzl b/rust/private/rustdoc.bzl
@@ -85,6 +85,9 @@ def _rust_doc_impl(ctx):
     args.add(crate.root.path)
     args.add("--crate-name", crate.name)
     args.add("--crate-type", crate.type)
+    if crate.type == "proc-macro":
+        args.add("--extern")
+        args.add("proc_macro")
     args.add("--output", output_dir.path)
     add_edition_flags(args, crate)
 
diff --git a/rust/private/rustdoc_test.bzl b/rust/private/rustdoc_test.bzl
@@ -109,6 +109,9 @@ def _build_rustdoc_flags(dep_info, crate):
         link_flags.append("-Lnative={}".format(_dirname(f.short_path)))
         link_search_flags.append("-Lnative={}".format(_dirname(f.short_path)))
 
+    if crate.type == "proc-macro":
+        link_flags.extend(["--extern", "proc_macro"])
+
     edition_flags = ["--edition={}".format(crate.edition)] if crate.edition != "2015" else []
 
     return link_search_flags + link_flags + edition_flags
diff --git a/test/proc_macro/BUILD.bazel b/test/proc_macro/BUILD.bazel
@@ -0,0 +1,14 @@
+load("//rust:defs.bzl", "rust_test")
+
+[
+    rust_test(
+        name = "proc_macro_{}_integration_test".format(edition),
+        srcs = ["proc_macro_{}_test.rs".format(edition)],
+        edition = edition,
+        proc_macro_deps = ["//test/unit/proc_macro:proc_macro_{}".format(edition)],
+    )
+    for edition in [
+        "2015",
+        "2018",
+    ]
+]
diff --git a/test/proc_macro/proc_macro_2015_test.rs b/test/proc_macro/proc_macro_2015_test.rs
@@ -0,0 +1,8 @@
+extern crate proc_macro_2015;
+use proc_macro_2015::make_answer;
+
+make_answer!();
+
+fn main() {
+    println!("{}", answer());
+}
diff --git a/test/proc_macro/proc_macro_2018_test.rs b/test/proc_macro/proc_macro_2018_test.rs
@@ -0,0 +1,8 @@
+use proc_macro_2018::make_answer;
+
+make_answer!();
+
+#[test]
+fn test_answer_macro() {
+    println!("{}", answer());
+}
diff --git a/test/unit/proc_macro/BUILD.bazel b/test/unit/proc_macro/BUILD.bazel
@@ -0,0 +1,5 @@
+load(":proc_macro_test.bzl", "proc_macro_test_suite")
+
+proc_macro_test_suite(
+    name = "proc_macro_test_suite",
+)
diff --git a/test/unit/proc_macro/proc_macro_2015.rs b/test/unit/proc_macro/proc_macro_2015.rs
@@ -0,0 +1,7 @@
+extern crate proc_macro;
+use proc_macro::TokenStream;
+
+#[proc_macro]
+pub fn make_answer(_item: TokenStream) -> TokenStream {
+    "fn answer() -> u32 { 42 }".parse().unwrap()
+}
diff --git a/test/unit/proc_macro/proc_macro_2018.rs b/test/unit/proc_macro/proc_macro_2018.rs
@@ -0,0 +1,9 @@
+// This differs from the edition 2015 version because it does not have an `extern proc_macro`
+// statement, which became optional in edition 2018.
+
+use proc_macro::TokenStream;
+
+#[proc_macro]
+pub fn make_answer(_item: TokenStream) -> TokenStream {
+    "fn answer() -> u32 { 42 }".parse().unwrap()
+}
diff --git a/test/unit/proc_macro/proc_macro_test.bzl b/test/unit/proc_macro/proc_macro_test.bzl
@@ -0,0 +1,110 @@
+"""Unittest to verify proc-macro targets"""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest")
+load("//rust:defs.bzl", "rust_proc_macro", "rust_test")
+load(
+    "//test/unit:common.bzl",
+    "assert_action_mnemonic",
+    "assert_argv_contains",
+    "assert_list_contains_adjacent_elements",
+    "assert_list_contains_adjacent_elements_not",
+)
+
+def _proc_macro_test_targets(edition):
+    """Define a set of `rust_proc_macro` targets for testing
+
+    Args:
+        edition (str): The rust edition to use for the new targets
+    """
+    rust_proc_macro(
+        name = "proc_macro_{}".format(edition),
+        srcs = [
+            "proc_macro_{}.rs".format(edition),
+        ],
+        edition = edition,
+        visibility = ["//test:__subpackages__"],
+    )
+
+    rust_test(
+        name = "wrapper_rule_for_macro_{}".format(edition),
+        crate = ":proc_macro_{}".format(edition),
+        edition = edition,
+    )
+
+def _unit_test_impl(ctx, edition, is_wrapper):
+    env = analysistest.begin(ctx)
+    actions = analysistest.target_under_test(env).actions
+    action = actions[0]
+    assert_action_mnemonic(env, action, "Rustc")
+
+    if edition == "2015":
+        # Edition 2015 does not use `--extern proc_macro` instead this
+        # must be explicitly set in Rust code.
+        assert_list_contains_adjacent_elements_not(env, action.argv, ["--extern", "proc_macro"])
+    elif edition == "2018":
+        # `--extern proc_macro` is required to resolve build proc-macro
+        assert_list_contains_adjacent_elements(env, action.argv, ["--extern", "proc_macro"])
+        if not is_wrapper:
+            assert_argv_contains(env, action, "--edition=2018")
+    else:
+        fail("Unexpected edition")
+
+    return analysistest.end(env)
+
+def _extern_flag_not_passed_when_compiling_macro_2015_impl(ctx):
+    return _unit_test_impl(ctx, "2015", False)
+
+def _extern_flag_passed_when_compiling_macro_2018_impl(ctx):
+    return _unit_test_impl(ctx, "2018", False)
+
+def _extern_flag_not_passed_when_compiling_macro_wrapper_rule_2015_impl(ctx):
+    return _unit_test_impl(ctx, "2015", True)
+
+def _extern_flag_passed_when_compiling_macro_wrapper_rule_2018_impl(ctx):
+    return _unit_test_impl(ctx, "2018", True)
+
+extern_flag_not_passed_when_compiling_macro_2015_test = analysistest.make(_extern_flag_not_passed_when_compiling_macro_2015_impl)
+extern_flag_passed_when_compiling_macro_2018_test = analysistest.make(_extern_flag_passed_when_compiling_macro_2018_impl)
+extern_flag_not_passed_when_compiling_macro_wrapper_rule_2015_test = analysistest.make(_extern_flag_not_passed_when_compiling_macro_wrapper_rule_2015_impl)
+extern_flag_passed_when_compiling_macro_wrapper_rule_2018_test = analysistest.make(_extern_flag_passed_when_compiling_macro_wrapper_rule_2018_impl)
+
+def _proc_macro_test():
+    """Generate targets and tests"""
+
+    _proc_macro_test_targets("2015")
+    _proc_macro_test_targets("2018")
+
+    extern_flag_not_passed_when_compiling_macro_2015_test(
+        name = "extern_flag_not_passed_when_compiling_macro_2015",
+        target_under_test = ":proc_macro_2015",
+    )
+    extern_flag_passed_when_compiling_macro_2018_test(
+        name = "extern_flag_passed_when_compiling_macro_2018",
+        target_under_test = ":proc_macro_2018",
+    )
+    extern_flag_not_passed_when_compiling_macro_wrapper_rule_2015_test(
+        name = "extern_flag_not_passed_when_compiling_macro_wrapper_rule_2015",
+        target_under_test = ":wrapper_rule_for_macro_2015",
+    )
+    extern_flag_passed_when_compiling_macro_wrapper_rule_2018_test(
+        name = "extern_flag_passed_when_compiling_macro_wrapper_rule_2018",
+        target_under_test = ":wrapper_rule_for_macro_2018",
+    )
+
+def proc_macro_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name: Name of the macro.
+    """
+    _proc_macro_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":extern_flag_not_passed_when_compiling_macro_2015",
+            ":extern_flag_passed_when_compiling_macro_2018",
+            ":extern_flag_not_passed_when_compiling_macro_wrapper_rule_2015",
+            ":extern_flag_passed_when_compiling_macro_wrapper_rule_2018",
+        ],
+    )

Original file line number	Diff line number	Diff line change
`@@ -234,6 +234,7 @@ def _rust_proto_compile(protos, descriptor_sets, imports, crate_name, ctx, is_gr`
`234`	`234`	`edition = proto_toolchain.edition,`
`235`	`235`	`rustc_env = {},`
`236`	`236`	`is_test = False,`
	`237`	`+ wrapped_crate_type = None,`
`237`	`238`	`),`
`238`	`239`	`output_hash = output_hash,`
`239`	`240`	`)`
Original file line number	Diff line number	Diff line change
`@@ -418,6 +418,7 @@ def _rust_test_common(ctx, toolchain, output):`
`418`	`418`	`edition = crate.edition,`
`419`	`419`	`rustc_env = ctx.attr.rustc_env,`
`420`	`420`	`is_test = True,`
	`421`	`+ wrapped_crate_type = crate.type,`
`421`	`422`	`)`
`422`	`423`	`else:`
`423`	`424`	`# Target is a standalone crate. Build the test binary as its own crate.`