swift-syntax-rs: Address PR review feedback

- BUILD.bazel: require x86_64 on the Linux branch of the compatibility
  select. The only registered standalone Linux Swift toolchain is
  x86_64-only, so without the CPU constraint Linux/aarch64 targets
stayed
  "compatible" and then failed toolchain resolution instead of being
  skipped cleanly.
- build.rs: emitting `rerun-if-changed` disables Cargo's default
  whole-package scan, so list every input to `swift build` — the package
  manifests, `Package.resolved`, `.swift-version`, and the whole Sources
  tree — so stale shim/toolchain output can't linger. (`.build/` is left
  unwatched, as it is this build's own output.)
- src/lib.rs: a null result from the shim is not a parse failure —
  SwiftParser recovers from invalid syntax and always yields a tree — so
it
  means the shim failed to serialize/allocate the JSON. Fix the error
  message and the variant doc accordingly.
- README.md: `.swift-version` is not honored by the macOS Bazel build
  (which uses the host Xcode toolchain); document that it pins the Linux
  and local builds only.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: tausbn

unified/swift-syntax-rs/BUILD.bazel

@@ -10,8 +10,21 @@ exports_files([".swift-version"])
 # Targets in this package require a Swift toolchain (Linux or macOS).
 # `select()` gives us OR-of-OSes; other platforms get marked incompatible
 # so `bazel build/test //...` skips them cleanly.
+#
+# The Linux branch additionally requires x86_64: the only registered standalone
+# Linux Swift toolchain (`swift_toolchain_exec_ubuntu24.04`, see //:MODULE.bazel)
+# is x86_64-only. Without the CPU constraint, Linux/aarch64 targets would stay
+# "compatible" and then fail toolchain resolution instead of being skipped.
+config_setting(
+    name = "linux_x86_64",
+    constraint_values = [
+        "@platforms//os:linux",
+        "@platforms//cpu:x86_64",
+    ],
+)
+
 _SWIFT_SUPPORTED_PLATFORMS = select({
-    "@platforms//os:linux": [],
+    ":linux_x86_64": [],
     "@platforms//os:macos": [],
     "//conditions:default": ["@platforms//:incompatible"],
 })

unified/swift-syntax-rs/README.md

@@ -155,10 +155,15 @@ Requirements:
   [`xcode_transition.bzl`](xcode_transition.bzl)), so other targets on macOS
   keep using Bazel's default CC toolchain.
 
-The Swift compiler version is read from [`.swift-version`](.swift-version) by
-both the Bazel toolchain (`swift.toolchain(swift_version_file = …)`) and the
-local build, and is kept in sync with the `swift-syntax` release pinned in
-`swift/Package.swift`, so local and CI builds behave identically.
+The Swift compiler version in [`.swift-version`](.swift-version) is kept in sync
+with the `swift-syntax` release pinned in `swift/Package.swift`. It is honored on
+**Linux**, where the hermetic swift.org Bazel toolchain
+(`swift.toolchain(swift_version_file = …)`) and the local `cargo`/`swift build`
+both read it. On **macOS** it is *not* honored by the Bazel build: `rules_swift`
+auto-registers the host `xcode_swift_toolchain`, which uses whichever Swift ships
+with the installed Xcode and ignores `.swift-version`. So the pinned version
+governs Linux (and local) builds, while the macOS compiler version depends on the
+host Xcode.
 
 ## Usage
 

unified/swift-syntax-rs/build.rs

@@ -6,16 +6,20 @@ fn main() {
     let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
     let swift_dir = manifest_dir.join("swift");
 
-    println!(
-        "cargo:rerun-if-changed={}",
-        swift_dir.join("Package.swift").display()
-    );
-    println!(
-        "cargo:rerun-if-changed={}",
-        swift_dir
-            .join("Sources/SwiftSyntaxFFI/SwiftSyntaxFFI.swift")
-            .display()
-    );
+    // Emitting any `rerun-if-changed` disables Cargo's default whole-package
+    // scan, so we must list every input to the `swift build` below. Watch the
+    // package manifests, the pinned dependency lockfile, the pinned compiler
+    // version, and the entire Swift sources tree (a directory is scanned
+    // recursively). `.build/` is intentionally *not* watched (it is this
+    // build's output; watching it would cause perpetual rebuilds).
+    for input in [
+        swift_dir.join("Package.swift"),
+        swift_dir.join("Package.resolved"),
+        swift_dir.join("Sources"),
+        manifest_dir.join(".swift-version"),
+    ] {
+        println!("cargo:rerun-if-changed={}", input.display());
+    }
     println!("cargo:rerun-if-env-changed=SWIFT");
     println!("cargo:rerun-if-env-changed=SWIFTC");
 

unified/swift-syntax-rs/src/lib.rs

@@ -29,15 +29,20 @@ unsafe extern "C" {
 pub enum ParseError {
     /// The provided source contained an interior NUL byte.
     NulByte,
-    /// The Swift side failed to produce a result.
+    /// The Swift shim returned no result. `SwiftParser` recovers from invalid
+    /// syntax (it always produces a tree, possibly with error nodes), so this
+    /// does *not* indicate a syntax error in the source — it means the shim
+    /// failed to serialize the tree to JSON or to allocate the result string.
     SwiftFailure,
 }
 
 impl std::fmt::Display for ParseError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             ParseError::NulByte => write!(f, "source contained an interior NUL byte"),
-            ParseError::SwiftFailure => write!(f, "swift-syntax failed to parse the source"),
+            ParseError::SwiftFailure => {
+                write!(f, "the swift-syntax shim failed to produce a JSON result")
+            }
         }
     }
 }