Add rpaths for the toolchain's compatibility back-deployment libraries to binaries built with swift_{binary, compiler_plugin, test}.

This is necessary to ensure that these binaries run correctly when using APIs like `Span` that are back-deployed on older OSes. Since the `swift_*` rules don't do bundling of their own, we simply point to the libraries in the toolchain itself (using the `xcode-select`-dependent symlinks, as we were already doing for tests). To actually distribute such a binary, it's the responsibility of the user to include the required dylibs with it (or, better, use a rule from rules_apple to perform the bundling).

I've explicitly ignored the swift-5.0 and swift-5.5 directory since we have no plans to deploy anything from these rules to such old OSes.

PiperOrigin-RevId: 817593332
(cherry picked from commit 2f5aa6e)

Author: allevato

swift/toolchains/xcode_swift_toolchain.bzl

@@ -108,21 +108,45 @@ load(
 )
 load("//swift/toolchains/config:tool_config.bzl", "ToolConfigInfo")
 
-def _platform_developer_framework_dir(
-        apple_toolchain,
-        target_triple):
+visibility("public")
+
+# These are symlink locations known to be used by xcode-select in various Xcode
+# and macOS versions to point to the selected `Developer` directory.
+_DEVELOPER_DIR_SYMLINKS = [
+    "/private/var/select/developer_dir",
+    "/var/db/xcode_select_link",
+]
+
+def _swift_developer_lib_dir(platform_framework_dir):
+    """Returns the directory containing extra Swift developer libraries.
+
+    Args:
+        platform_framework_dir: The developer platform framework directory for
+            the current platform.
+
+    Returns:
+        The directory containing extra Swift-specific development libraries and
+        swiftmodules.
+    """
+    return paths.join(
+        paths.dirname(paths.dirname(platform_framework_dir)),
+        "usr",
+        "lib",
+    )
+
+def _platform_developer_framework_dir(developer_dir, target_triple):
     """Returns the Developer framework directory for the platform.
 
     Args:
-        apple_toolchain: The `apple_common.apple_toolchain()` object.
+        developer_dir: The developer directory.
         target_triple: The triple of the platform being targeted.
 
     Returns:
         The path to the Developer framework directory for the platform if one
         exists, otherwise `None`.
     """
     return paths.join(
-        apple_toolchain.developer_dir(),
+        developer_dir,
         "Platforms",
         "{}.platform".format(
             target_triples.bazel_apple_platform(target_triple).name_in_plist,
@@ -150,11 +174,46 @@ def _sdk_developer_framework_dir(apple_toolchain, target_triple):
 
     return paths.join(apple_toolchain.sdk_dir(), "Developer/Library/Frameworks")
 
+def _swift_compatibility_lib_paths(*, target_triple, xcode_config):
+    """Returns the paths to the Swift compatibility libraries in the toolchain.
+
+    The returned paths are relative to the `Developer` directory; they do not
+    contain the Bazel placeholder that would be substituted with the actual
+    `Developer` directory at execution time.
+
+    Args:
+        target_triple: The target triple `struct`.
+        xcode_config: The `apple_common.XcodeVersionConfig` provider.
+
+    Returns:
+        A list of paths to the Swift compatibility libraries in the toolchain.
+    """
+
+    # We choose to ignore swift-5.0 and swift-5.5 because they correspond to
+    # such old OS versions that nobody is targeting with rules like
+    # `swift_binary` and `swift_test`. (And if they were, they would already be
+    # broken before this addition.)
+    versions = []
+    if _is_xcode_at_least_version(xcode_config, "26.0"):
+        versions.append("6.2")
+
+    platform_name = target_triples.platform_name_for_swift(target_triple)
+    return [
+        "Toolchains/XcodeDefault.xctoolchain/usr/lib/swift-{}/{}".format(
+            version,
+            platform_name,
+        )
+        for version in versions
+    ]
+
 def _swift_linkopts_cc_info(
         apple_toolchain,
+        platform_developer_framework_dir,
+        sdk_developer_framework_dir,
         target_triple,
         toolchain_label,
-        toolchain_root):
+        toolchain_root,
+        xcode_config):
     """Returns a `CcInfo` containing flags that should be passed to the linker.
 
     The providers returned by this function will be used as implicit
@@ -163,11 +222,14 @@ def _swift_linkopts_cc_info(
 
     Args:
         apple_toolchain: The `apple_common.apple_toolchain()` object.
+        platform_developer_framework_dir: The platform developer framework dir.
+        sdk_developer_framework_dir: The SDK developer framework dir.
         target_triple: The target triple `struct`.
         toolchain_label: The label of the Swift toolchain that will act as the
             owner of the linker input propagating the flags.
         toolchain_root: The path to a custom Swift toolchain that could contain
             libraries required to link the binary
+        xcode_config: The `apple_common.XcodeVersionConfig` provider.
 
     Returns:
         A `CcInfo` provider that will provide linker flags to binaries that
@@ -189,6 +251,12 @@ def _swift_linkopts_cc_info(
     )
 
     linkopts.extend([
+        "-F{}".format(path)
+        for path in compact([
+            platform_developer_framework_dir,
+            sdk_developer_framework_dir,
+        ])
+    ] + [
         "-L{}".format(swift_lib_dir),
         "-L/usr/lib/swift",
         # TODO(b/112000244): This should get added by the C++ Starlark API,
@@ -197,9 +265,41 @@ def _swift_linkopts_cc_info(
         # variables not provided by cc_common. Figure out how to handle this
         # correctly.
         "-Wl,-objc_abi_version,2",
-        "-Wl,-rpath,/usr/lib/swift",
     ])
 
+    # Compute the necessary rpaths for back-deployed compatibility libraries.
+    # Note that this implies that a `swift_{binary,compiler_plugin,test}` isn't
+    # portable to a different machine unless that machine also has the correct
+    # version of Xcode selected. Users who need to build a binary that can be
+    # moved to machines with different or no Xcode should use an appropriate
+    # rule from rules_apple, which ensures that the dylibs are bundled as part
+    # of the application.
+    #
+    # The system `/usr/lib/swift` must always be first in the list, to ensure
+    # that system libraries are preferred over those in the toolchain.
+    swift_compatibility_lib_dirs = _swift_compatibility_lib_paths(
+        target_triple = target_triple,
+        xcode_config = xcode_config,
+    )
+    rpaths = ["/usr/lib/swift"] + [
+        paths.join(developer_dir_symlink, compatibility_dir)
+        for developer_dir_symlink in _DEVELOPER_DIR_SYMLINKS
+        for compatibility_dir in swift_compatibility_lib_dirs
+    ]
+    linkopts += [
+        "-Wl,-rpath,{}".format(rpath)
+        for rpath in rpaths
+    ]
+
+    # Add the linker path to the directory containing the dylib with Swift
+    # extensions for the XCTest module.
+    if platform_developer_framework_dir:
+        linkopts.extend([
+            "-L{}".format(
+                _swift_developer_lib_dir(platform_developer_framework_dir),
+            ),
+        ])
+
     return CcInfo(
         linking_context = cc_common.create_linking_context(
             linker_inputs = depset([
@@ -211,41 +311,28 @@ def _swift_linkopts_cc_info(
         ),
     )
 
-def _test_linking_context(
-        apple_toolchain,
-        target_triple,
-        toolchain_label,
-        xcode_config):
+def _test_linking_context(target_triple, toolchain_label):
     """Returns a `CcLinkingContext` containing linker flags for test binaries.
 
     Args:
-        apple_toolchain: The `apple_common.apple_toolchain()` object.
         target_triple: The target triple `struct`.
         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.
 
     Returns:
         A `CcLinkingContext` that will provide linker flags to `swift_test`
         binaries.
     """
-    platform_developer_framework_dir = _platform_developer_framework_dir(
-        apple_toolchain,
-        target_triple,
-    )
-
-    # Weakly link to XCTest. It's possible that machine that links the test
-    # binary will have Xcode installed at a different path than the machine that
-    # runs the binary. To handle this, the binary `dlopen`s XCTest at startup
-    # using the path Bazel passes in the test action's environment.
-    linkopts = [
-        "-Wl,-weak_framework,XCTest",
-        "-Wl,-weak-lXCTestSwiftSupport",
-    ]
-    if _is_xcode_at_least_version(xcode_config, "16.0"):
-        linkopts.append("-Wl,-weak_framework,Testing")
 
-    if platform_developer_framework_dir:
+    # We use these as the rpaths for linking tests so that the required
+    # libraries are found if Xcode is installed in a different location on the
+    # machine that runs the tests than the machine used to link them.
+    linkopts = []
+    for developer_dir in _DEVELOPER_DIR_SYMLINKS:
+        platform_developer_framework_dir = _platform_developer_framework_dir(
+            developer_dir,
+            target_triple,
+        )
         linkopts.extend([
             "-Wl,-rpath,{}".format(path)
             for path in compact([
@@ -646,10 +733,8 @@ def _xcode_swift_toolchain_impl(ctx):
         swiftcopts.extend(ctx.attr._copts[BuildSettingInfo].value)
 
     test_linking_context = _test_linking_context(
-        apple_toolchain = apple_toolchain,
         target_triple = target_triple,
         toolchain_label = ctx.label,
-        xcode_config = xcode_config,
     )
 
     # `--define=SWIFT_USE_TOOLCHAIN_ROOT=<path>` is a rapid development feature
@@ -675,11 +760,23 @@ def _xcode_swift_toolchain_impl(ctx):
     elif custom_toolchain:
         custom_xcode_toolchain_root = "__BAZEL_CUSTOM_XCODE_TOOLCHAIN_PATH__"
 
+    platform_developer_framework_dir = _platform_developer_framework_dir(
+        apple_toolchain.developer_dir(),
+        target_triple,
+    )
+    sdk_developer_framework_dir = _sdk_developer_framework_dir(
+        apple_toolchain,
+        target_triple,
+    )
+
     swift_linkopts_cc_info = _swift_linkopts_cc_info(
         apple_toolchain = apple_toolchain,
+        platform_developer_framework_dir = platform_developer_framework_dir,
+        sdk_developer_framework_dir = sdk_developer_framework_dir,
         target_triple = target_triple,
         toolchain_label = ctx.label,
         toolchain_root = toolchain_root or custom_xcode_toolchain_root,
+        xcode_config = xcode_config,
     )
 
     # Compute the default requested features and conditional ones based on Xcode
@@ -759,21 +856,13 @@ def _xcode_swift_toolchain_impl(ctx):
         xcode_config = xcode_config,
     )
     swift_toolchain_developer_paths = []
-    platform_developer_framework_dir = _platform_developer_framework_dir(
-        apple_toolchain,
-        target_triple,
-    )
     if platform_developer_framework_dir:
         swift_toolchain_developer_paths.append(
             struct(
                 developer_path_label = "platform",
                 path = platform_developer_framework_dir,
             ),
         )
-    sdk_developer_framework_dir = _sdk_developer_framework_dir(
-        apple_toolchain,
-        target_triple,
-    )
     if sdk_developer_framework_dir:
         swift_toolchain_developer_paths.append(
             struct(