Create a new swift_common.compile API to replace the existing two compilation APIs (compile_as_library and compile_as_objects).

This is the first of a multi-CL process to get rid of those two functions and simplify the overall APIs. The major goals here are:

* The APIs shouldn't return providers; rules should construct those from structured outputs. This creates a bit of duplication in the short-term, but there are other plans to reduce the providers currently being used (SwiftClangModuleInfo can go away, and ObjcProvider will go away with the Objective-C -> C++ sandwich migration.)
* Linking of libraries should be a separate call; swift_common shouldn't be involved in that.
* Make it easier to explore different compilation models, like separating object and module compilation.

RELNOTES: Introduce `swift_common.compile`, which will eventually replace `swift_common.compile_as_{library,objects}`.
PiperOrigin-RevId: 246203838

Author: allevato

swift/internal/api.bzl

@@ -35,7 +35,6 @@ load(
     "run_toolchain_shell_action",
     "run_toolchain_swift_action",
 )
-load(":archiving.bzl", "register_static_archive_action")
 load(":attrs.bzl", "swift_common_rule_attrs")
 load(
     ":compiling.bzl",
@@ -69,6 +68,7 @@ load(
     "SWIFT_FEATURE_USE_GLOBAL_MODULE_CACHE",
     "SWIFT_FEATURE_USE_RESPONSE_FILES",
 )
+load(":linking.bzl", "register_libraries_to_link")
 load(
     ":providers.bzl",
     "SwiftClangModuleInfo",
@@ -413,6 +413,254 @@ def _cc_feature_configuration(feature_configuration):
     """
     return feature_configuration.cc_feature_configuration
 
+def _compile(
+        actions,
+        feature_configuration,
+        module_name,
+        srcs,
+        swift_toolchain,
+        target_name,
+        additional_inputs = [],
+        bin_dir = None,
+        copts = [],
+        defines = [],
+        deps = [],
+        genfiles_dir = None):
+    """Compiles a Swift module.
+
+    Args:
+        actions: The context's `actions` object.
+        feature_configuration: A feature configuration obtained from
+            `swift_common.configure_features`.
+        module_name: The name of the Swift module being compiled. This must be present and valid;
+            use `swift_common.derive_module_name` to generate a default from the target's label if
+            needed.
+        srcs: The Swift source files to compile.
+        swift_toolchain: The `SwiftToolchainInfo` provider of the toolchain.
+        target_name: The name of the target for which the code is being compiled, which is used to
+            determine unique file paths for the outputs.
+        additional_inputs: A list of `File`s representing additional input files that need to be
+            passed to the Swift compile action because they are referenced by compiler flags.
+        bin_dir: The Bazel `*-bin` directory root. If provided, its path is used to store the cache
+            for modules precompiled by Swift's ClangImporter.
+        copts: A list of compiler flags that apply to the target being built. These flags, along
+            with those from Bazel's Swift configuration fragment (i.e., `--swiftcopt` command line
+            flags) are scanned to determine whether whole module optimization is being requested,
+            which affects the nature of the output files.
+        defines: Symbols that should be defined by passing `-D` to the compiler.
+        deps: Dependencies of the target being compiled. These targets must propagate one of the
+            following providers: `CcInfo`, `SwiftClangModuleInfo`, `SwiftInfo`, or
+            `apple_common.Objc`.
+        genfiles_dir: The Bazel `*-genfiles` directory root. If provided, its path is added to
+            ClangImporter's header search paths for compatibility with Bazel's C++ and Objective-C
+            rules which support inclusions of generated headers from that location.
+
+    Returns:
+        A `struct` containing the following fields:
+
+        *   `generated_header`: A `File` representing the Objective-C header that was generated for
+            the compiled module. If no header was generated, this field will be None.
+        *   `generated_header_module_map`: A `File` representing the module map that was generated
+            to correspond to the generated Objective-C header. If no module map was generated, this
+            field will be None.
+        *   `indexstore`: A `File` representing the directory that contains the index store data
+            generated by the compiler if index-while-building is enabled. May be None if no
+            indexing was requested.
+        *   `linker_flags`: A list of strings representing additional flags that should be passed
+            to the linker when linking these objects into a binary. If there are none, this field
+            will always be an empty list, never None.
+        *   `linker_inputs`: A list of `File`s representing additional input files (such as those
+            referenced in `linker_flags`) that need to be available to the link action when linking
+            these objects into a binary. If there are none, this field will always be an empty
+            list, never None.
+        *   `object_files`: A list of `.o` files that were produced by the compiler.
+        *   `swiftdoc`: The `.swiftdoc` file that was produced by the compiler.
+        *   `swiftmodule`: The `.swiftmodule` file that was produced by the compiler.
+    """
+
+    # Force threaded mode for WMO builds, using the same number of cores that is
+    # on a Mac Pro for historical reasons.
+    # TODO(b/32571265): Generalize this based on platform and core count when an
+    # API to obtain this is available.
+    if _is_wmo(copts + swift_toolchain.command_line_copts, feature_configuration):
+        # We intentionally don't use `+=` or `extend` here to ensure that a
+        # copy is made instead of extending the original.
+        copts = copts + ["-num-threads", "12"]
+
+    compile_reqs = declare_compile_outputs(
+        actions = actions,
+        copts = copts + swift_toolchain.command_line_copts,
+        srcs = srcs,
+        target_name = target_name,
+        index_while_building = swift_common.is_enabled(
+            feature_configuration = feature_configuration,
+            feature_name = SWIFT_FEATURE_INDEX_WHILE_BUILDING,
+        ),
+    )
+    output_objects = compile_reqs.output_objects
+
+    swiftmodule = derived_files.swiftmodule(actions, module_name = module_name)
+    swiftdoc = derived_files.swiftdoc(actions, module_name = module_name)
+
+    wrapper_args = actions.args()
+    if _is_enabled(
+        feature_configuration = feature_configuration,
+        feature_name = SWIFT_FEATURE_USE_GLOBAL_MODULE_CACHE,
+    ):
+        # If bin_dir is not provided, then we don't pass any special flags to the compiler,
+        # letting it decide where the cache should live. This is usually somewhere in the system
+        # temporary directory.
+        if bin_dir:
+            wrapper_args.add("-module-cache-path", _global_module_cache_path(bin_dir))
+    else:
+        wrapper_args.add("-Xwrapped-swift=-ephemeral-module-cache")
+
+    if _is_enabled(
+        feature_configuration = feature_configuration,
+        feature_name = SWIFT_FEATURE_DEBUG_PREFIX_MAP,
+    ):
+        wrapper_args.add("-Xwrapped-swift=-debug-prefix-pwd-is-dot")
+
+    compile_args = actions.args()
+    if _is_enabled(
+        feature_configuration = feature_configuration,
+        feature_name = SWIFT_FEATURE_USE_RESPONSE_FILES,
+    ):
+        compile_args.use_param_file("@%s", use_always = True)
+
+    compile_args.add("-emit-object")
+    compile_args.add_all(compile_reqs.args)
+    compile_args.add("-emit-module-path")
+    compile_args.add(swiftmodule)
+
+    # Add any command line arguments that do *not* have to do with emitting outputs.
+    basic_inputs = _swiftc_command_line_and_inputs(
+        # TODO(allevato): Make this argument a list of files instead.
+        additional_input_depsets = [depset(additional_inputs)],
+        args = compile_args,
+        copts = copts,
+        defines = defines,
+        deps = deps,
+        feature_configuration = feature_configuration,
+        genfiles_dir = genfiles_dir,
+        module_name = module_name,
+        srcs = srcs,
+        toolchain = swift_toolchain,
+    )
+
+    additional_outputs = []
+
+    # If the toolchain supports Objective-C interop, generate a Swift header for this library so
+    # that it can be included by Objective-C code that depends on it.
+    generates_header = not _is_enabled(
+        feature_configuration = feature_configuration,
+        feature_name = SWIFT_FEATURE_NO_GENERATED_HEADER,
+    )
+    if generates_header and swift_toolchain.supports_objc_interop:
+        generated_header = derived_files.objc_header(actions = actions, target_name = target_name)
+        compile_args.add("-emit-objc-header-path")
+        compile_args.add(generated_header)
+        additional_outputs.append(generated_header)
+
+        # Create a module map for the generated header file. This ensures that inclusions of it are
+        # treated modularly, not textually.
+        #
+        # Caveat: Generated module maps are incompatible with the hack that some folks are using to
+        # support mixed Objective-C and Swift modules. This trap door lets them escape the module
+        # redefinition error, with the caveat that certain import scenarios could lead to incorrect
+        # behavior because a header can be imported textually instead of modularly.
+        if not _is_enabled(
+            feature_configuration = feature_configuration,
+            feature_name = SWIFT_FEATURE_NO_GENERATED_MODULE_MAP,
+        ):
+            generated_module_map = derived_files.module_map(
+                actions = actions,
+                target_name = target_name,
+            )
+            write_objc_header_module_map(
+                actions = actions,
+                module_name = module_name,
+                objc_header = generated_header,
+                output = generated_module_map,
+            )
+        else:
+            generated_module_map = None
+    else:
+        generated_header = None
+        generated_module_map = None
+
+    all_inputs = depset(
+        transitive = [basic_inputs, depset(direct = compile_reqs.compile_inputs)],
+    )
+    compile_outputs = ([swiftmodule, swiftdoc] + output_objects +
+                       compile_reqs.other_outputs) + additional_outputs
+
+    if swift_toolchain.swift_worker:
+        execution_requirements = {"supports-workers": "1"}
+        tools = [swift_toolchain.swift_worker]
+    else:
+        execution_requirements = {}
+        tools = []
+
+    run_toolchain_swift_action(
+        actions = actions,
+        arguments = [wrapper_args, compile_args],
+        execution_requirements = execution_requirements,
+        inputs = all_inputs,
+        mnemonic = "SwiftCompile",
+        outputs = compile_outputs,
+        progress_message = "Compiling Swift module {}".format(module_name),
+        swift_tool = "swiftc",
+        toolchain = swift_toolchain,
+        tools = tools,
+    )
+
+    linker_flags = []
+    linker_inputs = []
+
+    # Ensure that the .swiftmodule file is embedded in the final library or binary
+    # for debugging purposes.
+    if _is_debugging(feature_configuration = feature_configuration):
+        module_embed_results = ensure_swiftmodule_is_embedded(
+            actions = actions,
+            swiftmodule = swiftmodule,
+            target_name = target_name,
+            toolchain = swift_toolchain,
+        )
+        linker_flags.extend(module_embed_results.linker_flags)
+        linker_inputs.extend(module_embed_results.linker_inputs)
+        output_objects.extend(module_embed_results.objects_to_link)
+
+    # Invoke an autolink-extract action for toolchains that require it.
+    if swift_common.is_enabled(
+        feature_configuration = feature_configuration,
+        feature_name = SWIFT_FEATURE_AUTOLINK_EXTRACT,
+    ):
+        autolink_file = derived_files.autolink_flags(
+            actions,
+            target_name = target_name,
+        )
+        register_autolink_extract_action(
+            actions = actions,
+            module_name = module_name,
+            objects = output_objects,
+            output = autolink_file,
+            toolchain = swift_toolchain,
+        )
+        linker_flags.append("@{}".format(autolink_file.path))
+        linker_inputs.append(autolink_file)
+
+    return struct(
+        generated_header = generated_header,
+        generated_module_map = generated_module_map,
+        indexstore = compile_reqs.indexstore,
+        linker_flags = linker_flags,
+        linker_inputs = linker_inputs,
+        object_files = output_objects,
+        swiftdoc = swiftdoc,
+        swiftmodule = swiftmodule,
+    )
+
 def _compile_as_objects(
         actions,
         arguments,
@@ -430,6 +678,8 @@ def _compile_as_objects(
         genfiles_dir = None):
     """Compiles Swift source files into object files (and optionally a module).
 
+    NOTE: This API is deprecated. Use `swift_common.compile` instead.
+
     Args:
       actions: The context's `actions` object.
       arguments: A list of `Args` objects that provide additional arguments to the
@@ -641,6 +891,8 @@ def _compile_as_library(
         linkopts = []):
     """Compiles Swift source files into static and/or shared libraries.
 
+    NOTE: This API is deprecated. Use `swift_common.compile` instead.
+
     This is a high-level API that wraps the compilation and library creation steps
     based on the provided input arguments, and is likely suitable for most common
     purposes.
@@ -713,11 +965,6 @@ def _compile_as_library(
 
     if not library_name:
         library_name = label.name
-    out_archive = derived_files.static_archive(
-        actions,
-        alwayslink = alwayslink,
-        link_name = library_name,
-    )
 
     # Register the compilation actions to get an object file (.o) for the Swift
     # code, along with its swiftmodule and swiftdoc.
@@ -800,17 +1047,19 @@ def _compile_as_library(
     )
 
     # Create an archive that contains the compiled .o files.
-    register_static_archive_action(
+    library_to_link = register_libraries_to_link(
         actions = actions,
+        alwayslink = alwayslink,
         cc_feature_configuration = _cc_feature_configuration(
             feature_configuration = feature_configuration,
         ),
-        mnemonic = "SwiftArchive",
+        is_dynamic = False,
+        is_static = True,
+        library_name = library_name,
         objects = compile_results.output_objects,
-        output = out_archive,
-        progress_message = "Linking {}".format(out_archive.short_path),
         swift_toolchain = toolchain,
     )
+    out_archive = library_to_link.pic_static_library
 
     # TODO(b/130741225): Move this logic out of the API and have the rules themselves manipulate
     # providers.
@@ -1265,6 +1514,7 @@ def _toolchain_attrs(toolchain_attr_name = "_toolchain"):
 swift_common = struct(
     cc_feature_configuration = _cc_feature_configuration,
     compilation_attrs = _compilation_attrs,
+    compile = _compile,
     compile_as_library = _compile_as_library,
     compile_as_objects = _compile_as_objects,
     configure_features = _configure_features,