Propagate Swift-specific linker flags as an implicit dependency of the toolchain.

Apple binaries/bundles will automatically get these linker flags if they have any Swift target in their dependencies; this eliminates the need to pass them separately at the top level.

PiperOrigin-RevId: 378024438

Author: allevato

swift/internal/providers.bzl

@@ -165,19 +165,6 @@ linking target (but not to precompiled explicit C/Objective-C modules):
 
 For ease of use, this field is never `None`; it will always be a valid `struct`
 containing the fields described above, even if those lists are empty.
-""",
-        "linker_opts_producer": """\
-Skylib `partial`. A partial function that returns the flags that should be
-passed to Clang to link a binary or test target with the Swift runtime
-libraries.
-
-The partial should be called with two arguments:
-
-*   `is_static`: A `Boolean` value indicating whether to link against the static
-    or dynamic runtime libraries.
-
-*   `is_test`: A `Boolean` value indicating whether the target being linked is a
-    test target.
 """,
         "object_format": """\
 `String`. The object file format of the platform that the toolchain is

swift/internal/swift_binary_test.bzl

@@ -15,7 +15,6 @@
 """Implementation of the `swift_binary` and `swift_test` rules."""
 
 load("@bazel_skylib//lib:dicts.bzl", "dicts")
-load("@bazel_skylib//lib:partial.bzl", "partial")
 load(":compiling.bzl", "output_groups_from_compilation_outputs")
 load(":derived_files.bzl", "derived_files")
 load(":feature_names.bzl", "SWIFT_FEATURE_BUNDLED_XCTESTS")
@@ -208,16 +207,6 @@ def _swift_linking_rule_impl(
             compilation_outputs = compilation_outputs,
         )
 
-    # Retrieve any additional linker flags required by the Swift toolchain.
-    # TODO(b/70228246): Also support mostly-static and fully-dynamic modes,
-    # here and for the C++ toolchain args below.
-    toolchain_linker_flags = partial.call(
-        swift_toolchain.linker_opts_producer,
-        is_static = True,
-        is_test = is_test,
-    )
-    user_link_flags.extend(toolchain_linker_flags)
-
     # Collect linking contexts from any of the toolchain's implicit
     # dependencies.
     for cc_info in swift_toolchain.implicit_deps_providers.cc_infos:

swift/internal/swift_toolchain.bzl

@@ -20,7 +20,6 @@ toolchain, see `swift.bzl`.
 """
 
 load("@bazel_skylib//lib:dicts.bzl", "dicts")
-load("@bazel_skylib//lib:partial.bzl", "partial")
 load("@bazel_tools//tools/cpp:toolchain_utils.bzl", "find_cpp_toolchain")
 load(":actions.bzl", "swift_action_names")
 load(":attrs.bzl", "swift_toolchain_driver_attrs")
@@ -107,37 +106,33 @@ def _all_action_configs(additional_swiftc_copts):
         autolink_extract_action_configs()
     )
 
-def _default_linker_opts(
+def _swift_linkopts_cc_info(
         cc_toolchain,
         cpu,
         os,
-        toolchain_root,
-        is_static,
-        is_test):
-    """Returns options that should be passed by default to `clang` when linking.
+        toolchain_label,
+        toolchain_root):
+    """Returns a `CcInfo` containing flags that should be passed to the linker.
 
-    This function is wrapped in a `partial` that will be propagated as part of
-    the toolchain provider. The first three arguments are pre-bound; the
-    `is_static` and `is_test` arguments are expected to be passed by the caller.
+    The provider returned by this function will be used as an implicit
+    dependency of the toolchain to ensure that any binary containing Swift code
+    will link to the standard libraries correctly.
 
     Args:
         cc_toolchain: The cpp toolchain from which the `ld` executable is
             determined.
         cpu: The CPU architecture, which is used as part of the library path.
         os: The operating system name, which is used as part of the library
             path.
+        toolchain_label: The label of the Swift toolchain that will act as the
+            owner of the linker input propagating the flags.
         toolchain_root: The toolchain's root directory.
-        is_static: `True` to link against the static version of the Swift
-            runtime, or `False` to link against dynamic/shared libraries.
-        is_test: `True` if the target being linked is a test target.
 
     Returns:
-        The command line options to pass to `clang` to link against the desired
-        variant of the Swift runtime libraries.
+        A `CcInfo` provider that will provide linker flags to binaries that
+        depend on Swift targets.
     """
 
-    _ignore = is_test
-
     # TODO(#8): Support statically linking the Swift runtime.
     platform_lib_dir = "{toolchain_root}/lib/swift/{os}".format(
         os = os,
@@ -158,22 +153,29 @@ def _default_linker_opts(
         "-lrt",
         "-ldl",
         runtime_object_path,
+        "-static-libgcc",
     ]
 
-    if is_static:
-        linkopts.append("-static-libgcc")
-
-    return linkopts
+    return CcInfo(
+        linking_context = cc_common.create_linking_context(
+            linker_inputs = depset([
+                cc_common.create_linker_input(
+                    owner = toolchain_label,
+                    user_link_flags = depset(linkopts),
+                ),
+            ]),
+        ),
+    )
 
 def _swift_toolchain_impl(ctx):
     toolchain_root = ctx.attr.root
     cc_toolchain = find_cpp_toolchain(ctx)
 
-    linker_opts_producer = partial.make(
-        _default_linker_opts,
+    swift_linkopts_cc_info = _swift_linkopts_cc_info(
         cc_toolchain,
         ctx.attr.arch,
         ctx.attr.os,
+        ctx.label,
         toolchain_root,
     )
 
@@ -223,10 +225,10 @@ def _swift_toolchain_impl(ctx):
             generated_header_module_implicit_deps_providers = (
                 collect_implicit_deps_providers([])
             ),
-            implicit_deps_providers = (
-                collect_implicit_deps_providers([])
+            implicit_deps_providers = collect_implicit_deps_providers(
+                [],
+                additional_cc_infos = [swift_linkopts_cc_info],
             ),
-            linker_opts_producer = linker_opts_producer,
             object_format = "elf",
             requested_features = requested_features,
             root_dir = toolchain_root,

swift/internal/utils.bzl

@@ -59,14 +59,21 @@ def collect_cc_libraries(
 
     return libraries
 
-def collect_implicit_deps_providers(targets):
+def collect_implicit_deps_providers(
+        targets,
+        additional_cc_infos = [],
+        additional_objc_infos = []):
     """Returns a struct with important providers from a list of implicit deps.
 
     Note that the relationship between each provider in the list and the target
     it originated from is no longer retained.
 
     Args:
         targets: A list (possibly empty) of `Target`s.
+        additional_cc_infos: A `list` of additional `CcInfo` providers that
+            should be included in the returned value.
+        additional_objc_infos: A `list` of additional `apple_common.Objc`
+            providers that should be included in the returned value.
 
     Returns:
         A `struct` containing three fields:
@@ -90,8 +97,8 @@ def collect_implicit_deps_providers(targets):
             swift_infos.append(target[SwiftInfo])
 
     return struct(
-        cc_infos = cc_infos,
-        objc_infos = objc_infos,
+        cc_infos = cc_infos + additional_cc_infos,
+        objc_infos = objc_infos + additional_objc_infos,
         swift_infos = swift_infos,
     )
 

swift/internal/xcode_swift_toolchain.bzl

@@ -172,33 +172,35 @@ def _sdk_developer_framework_dir(apple_toolchain, apple_fragment, xcode_config):
 
     return paths.join(apple_toolchain.sdk_dir(), "Developer/Library/Frameworks")
 
-def _default_linker_opts(
+def _swift_linkopts_providers(
         apple_fragment,
         apple_toolchain,
         platform,
         target,
-        xcode_config,
-        is_static,
-        is_test):
-    """Returns options that should be passed by default to `clang` when linking.
+        toolchain_label,
+        xcode_config):
+    """Returns providers containing flags that should be passed to the linker.
 
-    This function is wrapped in a `partial` that will be propagated as part of
-    the toolchain provider. The first five arguments are pre-bound; the
-    `is_static` and `is_test` arguments are expected to be passed by the caller.
+    The providers returned by this function will be used as implicit
+    dependencies of the toolchain to ensure that any binary containing Swift code
+    will link to the standard libraries correctly.
 
     Args:
         apple_fragment: The `apple` configuration fragment.
         apple_toolchain: The `apple_common.apple_toolchain()` object.
         platform: The `apple_platform` value describing the target platform.
         target: The target triple.
+        toolchain_label: The label of the Swift toolchain that will act as the
+            owner of the linker input propagating the flags.
         xcode_config: The Xcode configuration.
-        is_static: `True` to link against the static version of the Swift
-            runtime, or `False` to link against dynamic/shared libraries.
-        is_test: `True` if the target being linked is a test target.
 
     Returns:
-        The command line options to pass to `clang` to link against the desired
-        variant of the Swift runtime libraries.
+        A `struct` containing the following fields:
+
+        *   `cc_info`: A `CcInfo` provider that will provide linker flags to
+            binaries that depend on Swift targets.
+        *   `objc_info`: An `apple_common.Objc` provider that will provide
+            linker flags to binaries that depend on Swift targets.
     """
     platform_developer_framework_dir = _platform_developer_framework_dir(
         apple_toolchain,
@@ -241,15 +243,27 @@ def _default_linker_opts(
     # So, we need to explicitly add that to test binaries' rpaths. We also need
     # to add the linker path to the directory containing the dylib with Swift
     # extensions for the XCTest module.
-    if is_test and platform_developer_framework_dir:
+    if platform_developer_framework_dir:
         linkopts.extend([
             "-Wl,-rpath,{}".format(platform_developer_framework_dir),
             "-L{}".format(
                 _swift_developer_lib_dir(platform_developer_framework_dir),
             ),
         ])
 
-    return linkopts
+    return struct(
+        cc_info = CcInfo(
+            linking_context = cc_common.create_linking_context(
+                linker_inputs = depset([
+                    cc_common.create_linker_input(
+                        owner = toolchain_label,
+                        user_link_flags = depset(linkopts),
+                    ),
+                ]),
+            ),
+        ),
+        objc_info = apple_common.new_objc_provider(linkopt = depset(linkopts)),
+    )
 
 def _features_for_bitcode_mode(bitcode_mode):
     """Gets the list of features to enable for the selected Bitcode mode.
@@ -590,12 +604,12 @@ def _xcode_swift_toolchain_impl(ctx):
     )
     target = _swift_apple_target_triple(cpu, platform, target_os_version)
 
-    linker_opts_producer = partial.make(
-        _default_linker_opts,
+    swift_linkopts_providers = _swift_linkopts_providers(
         apple_fragment,
         apple_toolchain,
         platform,
         target,
+        ctx.label,
         xcode_config,
     )
 
@@ -698,8 +712,9 @@ def _xcode_swift_toolchain_impl(ctx):
             ),
             implicit_deps_providers = collect_implicit_deps_providers(
                 ctx.attr.implicit_deps,
+                additional_cc_infos = [swift_linkopts_providers.cc_info],
+                additional_objc_infos = [swift_linkopts_providers.objc_info],
             ),
-            linker_opts_producer = linker_opts_producer,
             object_format = "macho",
             requested_features = requested_features,
             supports_objc_interop = True,