Add support for generating an indexstore from a .swiftinterface file.

Starting with Swift 6.1 (Xcode 16.3), the frontend correctly generates an indexstore from a `.swiftinterface` file when it is build with `-explicit-interface-module-build` (swiftlang/swift#79485). Collect that indexstore if requested.

To do this, the worker has to find the `.swiftinterface` file and extract the flags from it in order to pass them to the frontend. For system frameworks, this is a bit more delicate, because we don't know the path to the actual `.swiftinterface` file at analysis time (it may be a _variant_ of the current architecture, like `arm64e` for `arm64`). So we add logic to the worker that infers the right file given the path to the parent `.swiftmodule` directory, using similar logic to the compiler itself.

PiperOrigin-RevId: 742225315

Author: allevato

swift/internal/compiling.bzl

@@ -99,7 +99,7 @@ def compile_module_interface(
         swiftinterface_file,
         swift_infos,
         swift_toolchain,
-        target_name,  # @unused
+        target_name,
         toolchain_type = SWIFT_TOOLCHAIN_TYPE):
     """Compiles a Swift module interface.
 
@@ -150,7 +150,10 @@ def compile_module_interface(
                 the indexstore output files created when the feature
                 `swift.index_while_building` is enabled.
     """
-    swiftmodule_file = actions.declare_file("{}.swiftmodule".format(module_name))
+    swiftmodule_file = actions.declare_file(
+        "{}_outs/{}.swiftmodule".format(target_name, module_name),
+    )
+    outputs = [swiftmodule_file]
 
     implicit_swift_infos, implicit_cc_infos = get_swift_implicit_deps(
         feature_configuration = feature_configuration,
@@ -201,11 +204,23 @@ def compile_module_interface(
     else:
         explicit_swift_module_map_file = None
 
+    if is_feature_enabled(
+        feature_configuration = feature_configuration,
+        feature_name = SWIFT_FEATURE_INDEX_WHILE_BUILDING,
+    ):
+        indexstore_directory = actions.declare_directory(
+            "{}.swiftinterface.indexstore".format(target_name),
+        )
+        outputs.append(indexstore_directory)
+    else:
+        indexstore_directory = None
+
     prerequisites = struct(
         bin_dir = feature_configuration._bin_dir,
         cc_compilation_context = merged_compilation_context,
         explicit_swift_module_map_file = explicit_swift_module_map_file,
         genfiles_dir = feature_configuration._genfiles_dir,
+        indexstore_directory = indexstore_directory,
         is_swift = True,
         module_name = module_name,
         source_files = [swiftinterface_file],
@@ -220,7 +235,7 @@ def compile_module_interface(
         action_name = SWIFT_ACTION_COMPILE_MODULE_INTERFACE,
         exec_group = exec_group,
         feature_configuration = feature_configuration,
-        outputs = [swiftmodule_file],
+        outputs = outputs,
         prerequisites = prerequisites,
         progress_message = "Compiling Swift module {} from textual interface".format(module_name),
         swift_toolchain = swift_toolchain,
@@ -248,8 +263,7 @@ def compile_module_interface(
     return struct(
         module_context = module_context,
         supplemental_outputs = struct(
-            # TODO: b/401305010 - Generate indexstore when requested.
-            indexstore_directory = None,
+            indexstore_directory = indexstore_directory,
         ),
     )
 

swift/internal/feature_names.bzl

@@ -196,6 +196,13 @@ SWIFT_FEATURE_ENABLE_LIBRARY_EVOLUTION = "swift.enable_library_evolution"
 # invocation.
 SWIFT_FEATURE_EMIT_SWIFTINTERFACE = "swift.emit_swiftinterface"
 
+# If enabled, the `-explicit-module-interface-build` flag should be passed to
+# the compiler when compiling a .swiftinterface file. To support this, the
+# worker must extract the correct flags from the interface file manually and
+# pass them to the compiler.
+# TODO: b/401511920 - Make this the default behavior.
+SWIFT_FEATURE_EXPLICIT_INTERFACE_BUILD = "swift.explicit_interface_build"
+
 # If enabled, declare `.swiftsourceinfo` files as outputs that Bazel will track.
 # Note that at the time of this writing (Swift 5.10), `.swiftsourceinfo` files
 # are non-deterministic: they contain absolute paths that are not remapped by

swift/toolchains/config/BUILD

@@ -43,6 +43,7 @@ bzl_library(
     deps = [
         ":action_config",
         "//swift/internal:action_names",
+        "//swift/internal:feature_names",
     ],
 )
 

swift/toolchains/config/compile_config.bzl

@@ -42,6 +42,7 @@ load(
     "SWIFT_FEATURE_ENABLE_LIBRARY_EVOLUTION",
     "SWIFT_FEATURE_ENABLE_TESTING",
     "SWIFT_FEATURE_ENABLE_V6",
+    "SWIFT_FEATURE_EXPLICIT_INTERFACE_BUILD",
     "SWIFT_FEATURE_FASTBUILD",
     "SWIFT_FEATURE_FILE_PREFIX_MAP",
     "SWIFT_FEATURE_FULL_DEBUG_INFO",
@@ -775,12 +776,16 @@ def compile_action_configs(
 
         # Configure index-while-building.
         ActionConfigInfo(
-            actions = all_compile_action_names(),
+            actions = all_compile_action_names() + [
+                SWIFT_ACTION_COMPILE_MODULE_INTERFACE,
+            ],
             configurators = [_index_while_building_configurator],
             features = [SWIFT_FEATURE_INDEX_WHILE_BUILDING],
         ),
         ActionConfigInfo(
-            actions = all_compile_action_names(),
+            actions = all_compile_action_names() + [
+                SWIFT_ACTION_COMPILE_MODULE_INTERFACE,
+            ],
             configurators = [add_arg("-index-include-locals")],
             features = [
                 SWIFT_FEATURE_INDEX_WHILE_BUILDING,
@@ -850,6 +855,15 @@ def compile_action_configs(
                 SWIFT_FEATURE_DISABLE_AVAILABILITY_CHECKING,
             ],
         ),
+        ActionConfigInfo(
+            actions = [
+                SWIFT_ACTION_COMPILE_MODULE_INTERFACE,
+            ],
+            configurators = [add_arg("-disable-availability-checking")],
+            features = [
+                SWIFT_FEATURE_DISABLE_AVAILABILITY_CHECKING,
+            ],
+        ),
         ActionConfigInfo(
             actions = all_compile_action_names(),
             configurators = [_upcoming_and_experimental_features_configurator],
@@ -918,15 +932,25 @@ def compile_action_configs(
             ),
         )
 
-    action_configs.append(
+    action_configs.extend([
         ActionConfigInfo(
             actions = all_compile_action_names() + [
-                SWIFT_ACTION_COMPILE_MODULE_INTERFACE,
                 SWIFT_ACTION_PRECOMPILE_C_MODULE,
             ],
             configurators = [_source_files_configurator],
         ),
-    )
+
+        # We don't add the path as a source file if this is an explicit
+        # interface build, because we let the worker infer it in the event that
+        # it is a system module.
+        ActionConfigInfo(
+            actions = [
+                SWIFT_ACTION_COMPILE_MODULE_INTERFACE,
+            ],
+            configurators = [_source_files_configurator],
+            not_features = [SWIFT_FEATURE_EXPLICIT_INTERFACE_BUILD],
+        ),
+    ])
 
     # Add additional input files to the sandbox (does not modify flags).
     action_configs.append(

swift/toolchains/config/compile_module_interface_config.bzl

@@ -18,6 +18,10 @@ load(
     "@build_bazel_rules_swift//swift/internal:action_names.bzl",
     "SWIFT_ACTION_COMPILE_MODULE_INTERFACE",
 )
+load(
+    "@build_bazel_rules_swift//swift/internal:feature_names.bzl",
+    "SWIFT_FEATURE_EXPLICIT_INTERFACE_BUILD",
+)
 load(":action_config.bzl", "ActionConfigInfo", "add_arg")
 
 visibility([
@@ -35,16 +39,34 @@ def compile_module_interface_action_configs():
         ),
         ActionConfigInfo(
             actions = [SWIFT_ACTION_COMPILE_MODULE_INTERFACE],
-            configurators = [_emit_module_path_from_module_interface_configurator],
+            configurators = [
+                _emit_module_path_from_module_interface_configurator,
+            ],
         ),
         ActionConfigInfo(
             actions = [SWIFT_ACTION_COMPILE_MODULE_INTERFACE],
             configurators = [
                 add_arg("-compile-module-from-interface"),
             ],
         ),
+        ActionConfigInfo(
+            actions = [SWIFT_ACTION_COMPILE_MODULE_INTERFACE],
+            configurators = [
+                _emit_explicit_module_interface_build_configurator,
+            ],
+            features = [SWIFT_FEATURE_EXPLICIT_INTERFACE_BUILD],
+        ),
     ]
 
 def _emit_module_path_from_module_interface_configurator(prerequisites, args):
     """Adds the `.swiftmodule` output path to the command line."""
     args.add("-o", prerequisites.swiftmodule_file)
+
+def _emit_explicit_module_interface_build_configurator(prerequisites, args):
+    """Adds flags to perform an explicit interface build to the command line."""
+
+    args.add("-explicit-interface-module-build")
+    args.add(
+        prerequisites.source_files[0],
+        format = "-Xwrapped-swift=-explicit-compile-module-from-interface=%s",
+    )

tools/common/BUILD

@@ -68,6 +68,12 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "target_triple",
+    hdrs = ["target_triple.h"],
+    deps = ["@com_google_absl//absl/strings"],
+)
+
 cc_library(
     name = "temp_file",
     hdrs = ["temp_file.h"],

tools/common/file_system.cc

@@ -156,4 +156,10 @@ absl::Status MakeDirs(absl::string_view path, int mode) {
   return MakeFailingStatus("unexpected error");
 }
 
+bool PathExists(absl::string_view path) {
+  struct stat stats;
+  std::string null_terminated_path{path};
+  return stat(null_terminated_path.c_str(), &stats) == 0;
+}
+
 }  // namespace bazel_rules_swift

tools/common/file_system.h

@@ -32,6 +32,9 @@ absl::Status CopyFile(absl::string_view src, absl::string_view dest);
 // don't already exist. Returns true if successful.
 absl::Status MakeDirs(absl::string_view path, int mode);
 
+// Returns true if the given path exists.
+bool PathExists(absl::string_view path);
+
 }  // namespace bazel_rules_swift
 
 #endif  // BUILD_BAZEL_RULES_SWIFT_TOOLS_COMMON_FILE_SYSTEM_H_

tools/common/target_triple.h

@@ -0,0 +1,97 @@
+// Copyright 2025 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.
+
+#ifndef BUILD_BAZEL_RULES_SWIFT_TOOLS_COMMON_TARGET_TRIPLE_H
+#define BUILD_BAZEL_RULES_SWIFT_TOOLS_COMMON_TARGET_TRIPLE_H
+
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/str_split.h"
+#include "absl/strings/string_view.h"
+
+namespace bazel_rules_swift {
+
+// Represents a target triple as used by LLVM/Swift and provides operations to
+// query and modify it.
+class TargetTriple {
+ public:
+  // Creates a new target triple from the given components.
+  TargetTriple(absl::string_view arch, absl::string_view vendor,
+               absl::string_view os, absl::string_view environment)
+      : arch_(arch),
+        vendor_(vendor),
+        os_(os),
+        environment_(environment) {}
+
+  // Parses the given target triple string into its component parts.
+  static std::optional<TargetTriple> Parse(absl::string_view target_triple) {
+    std::vector<absl::string_view> components =
+        absl::StrSplit(target_triple, '-');
+    if (components.size() < 3) {
+      return std::nullopt;
+    }
+    return TargetTriple(components[0], components[1], components[2],
+                        components.size() > 3 ? components[3] : "");
+  }
+
+  // Returns the architecture component of the target triple.
+  std::string Arch() const { return arch_; }
+
+  // Returns the vendor component of the target triple.
+  std::string Vendor() const { return vendor_; }
+
+  // Returns the OS component of the target triple.
+  std::string OS() const { return os_; }
+
+  // Returns the environment component of the target triple.
+  std::string Environment() const { return environment_; }
+
+  // Returns this target triple as a string.
+  std::string TripleString() const {
+    std::string result = absl::StrJoin({arch_, vendor_, os_}, "-");
+    if (!environment_.empty()) {
+      absl::StrAppend(&result, "-", environment_);
+    }
+    return result;
+  }
+
+  // Returns a copy of this target triple with the version number removed from
+  // the OS component (if any).
+  TargetTriple WithoutOSVersion() const {
+    std::pair<absl::string_view, absl::string_view> os_and_version =
+    absl::StrSplit(os_, absl::MaxSplits(absl::ByAnyChar("0123456789"), 1));
+    return TargetTriple(arch_, vendor_, os_and_version.first, environment_);
+  }
+
+  // Returns a copy of this target triple, replacing its architecture with the
+  // given value.
+  TargetTriple WithArch(absl::string_view arch) const {
+    return TargetTriple(arch, vendor_, os_, environment_);
+  }
+
+ private:
+  std::string arch_;
+  std::string vendor_;
+  std::string os_;
+  std::string environment_;
+};
+
+}  // namespace bazel_rules_swift
+
+#endif  // BUILD_BAZEL_RULES_SWIFT_TOOLS_COMMON_TARGET_TRIPLE_H

tools/worker/BUILD

@@ -10,7 +10,9 @@ cc_library(
         "//tools/common:file_system",
         "//tools/common:path_utils",
         "//tools/common:process",
+        "//tools/common:target_triple",
         "//tools/common:temp_file",
+        "@com_google_absl//absl/base:nullability",
         "@com_google_absl//absl/container:btree",
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/container:flat_hash_set",