Add support for universal compiler plugins (#1107)

This is useful if you populate caches using fat binaries so that they
can be shared between aarch64 and x86_64 macs

Author: keith

doc/BUILD.bazel

@@ -19,6 +19,7 @@ _DOC_SRCS = {
         "swift_binary",
         "swift_c_module",
         "swift_compiler_plugin",
+        "universal_swift_compiler_plugin",
         "swift_feature_allowlist",
         "swift_grpc_library",
         "swift_import",

doc/rules.md

@@ -19,6 +19,7 @@ On this page:
   * [swift_binary](#swift_binary)
   * [swift_c_module](#swift_c_module)
   * [swift_compiler_plugin](#swift_compiler_plugin)
+  * [universal_swift_compiler_plugin](#universal_swift_compiler_plugin)
   * [swift_feature_allowlist](#swift_feature_allowlist)
   * [swift_grpc_library](#swift_grpc_library)
   * [swift_import](#swift_import)
@@ -623,3 +624,55 @@ bazel test //:Tests --test_filter=TestModuleName.TestClassName/testMethodName
 | <a id="swift_test-swiftc_inputs"></a>swiftc_inputs |  Additional files that are referenced using <code>$(location ...)</code> in attributes that support location expansion.   | <a href="https://bazel.build/concepts/labels">List of labels</a> | optional | <code>[]</code> |
 
 
+<a id="universal_swift_compiler_plugin"></a>
+
+## universal_swift_compiler_plugin
+
+<pre>
+universal_swift_compiler_plugin(<a href="#universal_swift_compiler_plugin-name">name</a>, <a href="#universal_swift_compiler_plugin-plugin">plugin</a>)
+</pre>
+
+Wraps an existing `swift_compiler_plugin` target to produce a universal binary.
+
+This is useful to allow sharing of caches between Intel and Apple Silicon Macs
+at the cost of building everything twice.
+
+Example:
+
+```bzl
+# The actual macro code, using SwiftSyntax, as usual.
+swift_compiler_plugin(
+    name = "Macros",
+    srcs = glob(["Macros/*.swift"]),
+    deps = [
+        "@SwiftSyntax",
+        "@SwiftSyntax//:SwiftCompilerPlugin",
+        "@SwiftSyntax//:SwiftSyntaxMacros",
+    ],
+)
+
+# Wrap your compiler plugin in this universal shim.
+universal_swift_compiler_plugin(
+    name = "Macros.universal",
+    plugin = ":Macros",
+)
+
+# The library that defines the macro hook for use in your project, this
+# references the universal_swift_compiler_plugin.
+swift_library(
+    name = "MacroLibrary",
+    srcs = glob(["MacroLibrary/*.swift"]),
+    plugins = [":Macros.universal"],
+)
+```
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="universal_swift_compiler_plugin-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/concepts/labels#target-names">Name</a> | required |  |
+| <a id="universal_swift_compiler_plugin-plugin"></a>plugin |  Target to generate a 'fat' binary from.   | <a href="https://bazel.build/concepts/labels">Label</a> | required |  |
+
+

examples/xplatform/macros/BUILD

@@ -1,5 +1,5 @@
 load("//swift:swift.bzl", "swift_binary", "swift_library", "swift_test")
-load("//swift:swift_compiler_plugin.bzl", "swift_compiler_plugin")
+load("//swift:swift_compiler_plugin.bzl", "swift_compiler_plugin", "universal_swift_compiler_plugin")
 
 licenses(["notice"])
 
@@ -15,6 +15,13 @@ swift_library(
     plugins = [":stringify_macro"],
 )
 
+swift_library(
+    name = "stringify_universal",
+    srcs = ["Stringify.swift"],
+    module_name = "StringifyUniversal",
+    plugins = [":stringify_macro_universal"],
+)
+
 swift_compiler_plugin(
     name = "stringify_macro",
     srcs = [
@@ -34,12 +41,23 @@ swift_compiler_plugin(
     ],
 )
 
+universal_swift_compiler_plugin(
+    name = "stringify_macro_universal",
+    plugin = ":stringify_macro",
+)
+
 swift_binary(
     name = "stringify_client",
     srcs = ["StringifyClient.swift"],
     deps = [":stringify"],
 )
 
+swift_binary(
+    name = "stringify_universal_client",
+    srcs = ["StringifyUniversalClient.swift"],
+    deps = [":stringify_universal"],
+)
+
 swift_test(
     name = "stringify_macro_test",
     srcs = ["StringifyMacroTests.swift"],

examples/xplatform/macros/StringifyUniversalClient.swift

@@ -0,0 +1,22 @@
+// Copyright 2023 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import StringifyUniversal
+
+@main
+struct Main {
+  static func main() {
+    print(#stringify(1 + 2))
+  }
+}

swift/BUILD

@@ -42,6 +42,9 @@ bzl_library(
         "//swift/internal:swift_common",
         "//swift/internal:utils",
         "@bazel_skylib//lib:dicts",
+        "@build_bazel_apple_support//lib:apple_support",
+        "@build_bazel_apple_support//lib:lipo",
+        "@build_bazel_apple_support//lib:transitions",
     ],
 )
 

swift/swift.bzl

@@ -54,6 +54,7 @@ load(
 load(
     "@build_bazel_rules_swift//swift:swift_compiler_plugin.bzl",
     _swift_compiler_plugin = "swift_compiler_plugin",
+    _universal_swift_compiler_plugin = "universal_swift_compiler_plugin",
 )
 load(
     "@build_bazel_rules_swift//swift/internal:swift_feature_allowlist.bzl",
@@ -101,6 +102,7 @@ swift_common = _swift_common
 swift_binary = _swift_binary
 swift_c_module = _swift_c_module
 swift_compiler_plugin = _swift_compiler_plugin
+universal_swift_compiler_plugin = _universal_swift_compiler_plugin
 swift_feature_allowlist = _swift_feature_allowlist
 swift_grpc_library = _swift_grpc_library
 swift_import = _swift_import

swift/swift_compiler_plugin.bzl

@@ -14,6 +14,9 @@
 
 """Implementation of the `swift_compiler_plugin` rule."""
 
+load("@build_bazel_apple_support//lib:apple_support.bzl", "apple_support")
+load("@build_bazel_apple_support//lib:lipo.bzl", "lipo")
+load("@build_bazel_apple_support//lib:transitions.bzl", "macos_universal_transition")
 load(
     "@build_bazel_rules_swift//swift/internal:compiling.bzl",
     "output_groups_from_other_compilation_outputs",
@@ -254,3 +257,121 @@ swift_library(
     fragments = ["cpp"],
     implementation = _swift_compiler_plugin_impl,
 )
+
+def _universal_swift_compiler_plugin_impl(ctx):
+    inputs = [
+        plugin.files.to_list()[0]
+        for plugin in ctx.split_attr.plugin.values()
+    ]
+
+    if not inputs:
+        fail("Target (%s) `plugin` label ('%s') does not provide any " +
+             "file for universal binary" % (ctx.attr.name, ctx.attr.plugin))
+
+    output = ctx.actions.declare_file(ctx.label.name)
+    if len(inputs) > 1:
+        lipo.create(
+            actions = ctx.actions,
+            apple_fragment = ctx.fragments.apple,
+            inputs = inputs,
+            output = output,
+            xcode_config = ctx.attr._xcode_config[apple_common.XcodeVersionConfig],
+        )
+    else:
+        ctx.actions.symlink(target_file = inputs[0], output = output)
+
+    cc_infos = []
+    direct_swift_modules = []
+    module_name = None
+    swift_infos = []
+    for plugin in ctx.split_attr.plugin.values():
+        cc_infos.append(plugin[SwiftCompilerPluginInfo].cc_info)
+        direct_swift_modules.extend(plugin[SwiftCompilerPluginInfo].swift_info.direct_modules)
+        module_name = plugin[SwiftCompilerPluginInfo].module_names.to_list()[0]
+        swift_infos.append(plugin[SwiftCompilerPluginInfo].swift_info)
+
+    first_output_group_info = ctx.split_attr.plugin.values()[0][OutputGroupInfo]
+    combined_output_group_info = {}
+    for key in first_output_group_info:
+        all_values = []
+        for plugin in ctx.split_attr.plugin.values():
+            all_values.append(plugin[OutputGroupInfo][key])
+        combined_output_group_info[key] = depset(transitive = all_values)
+
+    transitive_runfiles = [
+        plugin[DefaultInfo].default_runfiles
+        for plugin in ctx.split_attr.plugin.values()
+    ]
+
+    return [
+        DefaultInfo(
+            executable = output,
+            files = depset([output]),
+            runfiles = ctx.runfiles().merge_all(transitive_runfiles),
+        ),
+        OutputGroupInfo(**combined_output_group_info),
+        SwiftCompilerPluginInfo(
+            cc_info = cc_common.merge_cc_infos(cc_infos = cc_infos),
+            executable = output,
+            module_names = depset([module_name]),
+            swift_info = swift_common.create_swift_info(
+                modules = direct_swift_modules,
+                swift_infos = swift_infos,
+            ),
+        ),
+    ]
+
+universal_swift_compiler_plugin = rule(
+    attrs = dicts.add(
+        apple_support.action_required_attrs(),
+        {
+            "plugin": attr.label(
+                cfg = macos_universal_transition,
+                doc = "Target to generate a 'fat' binary from.",
+                mandatory = True,
+                providers = [SwiftCompilerPluginInfo],
+            ),
+            "_allowlist_function_transition": attr.label(
+                default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
+            ),
+        },
+    ),
+    executable = True,
+    fragments = ["cpp", "apple"],
+    implementation = _universal_swift_compiler_plugin_impl,
+    doc = """\
+Wraps an existing `swift_compiler_plugin` target to produce a universal binary.
+
+This is useful to allow sharing of caches between Intel and Apple Silicon Macs
+at the cost of building everything twice.
+
+Example:
+
+```bzl
+# The actual macro code, using SwiftSyntax, as usual.
+swift_compiler_plugin(
+    name = "Macros",
+    srcs = glob(["Macros/*.swift"]),
+    deps = [
+        "@SwiftSyntax",
+        "@SwiftSyntax//:SwiftCompilerPlugin",
+        "@SwiftSyntax//:SwiftSyntaxMacros",
+    ],
+)
+
+# Wrap your compiler plugin in this universal shim.
+universal_swift_compiler_plugin(
+    name = "Macros.universal",
+    plugin = ":Macros",
+)
+
+# The library that defines the macro hook for use in your project, this
+# references the universal_swift_compiler_plugin.
+swift_library(
+    name = "MacroLibrary",
+    srcs = glob(["MacroLibrary/*.swift"]),
+    plugins = [":Macros.universal"],
+)
+```
+""",
+)