unified: Build the Swift parser without a local toolchain

Now that the corpus tests no longer skip themselves, running them
requires a `swift-syntax-parse` binary — and so far the only way to get
one was `cargo build`, which needs Swift installed locally. Bazel
already builds the same binary against a hermetic swift.org toolchain,
so offer that instead and make it the default.

The wrapper script locates its Swift runtime libraries beside itself, so
it only works in the flattened layout the extractor pack uses; under
`bazel-bin`, and in the runfiles tree, the libraries are in a different
directory and it fails to start. Add a `pkg_install` target that stages
that layout into a directory, and `scripts/build-parser.sh` to run it
and print the resulting path:

    export
CODEQL_EXTRACTOR_UNIFIED_SWIFT_SYNTAX_PARSE=$(scripts/build-parser.sh)

`--cargo` selects the previous behaviour, which is quicker to iterate on
when a local toolchain is available. Both pin swift-syntax 603.0.2, so
either parser produces the same trees.

`scripts/update-corpus.sh` now goes through the script and forwards its
arguments, so regenerating the corpus needs only Bazel. The staging
directory sits under `unified/target`, which is already ignored.

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

Author: tausbn

unified/AGENTS.md

@@ -17,7 +17,7 @@ This is a CodeQL extractor based on tree-sitter.
 
 - The mapping from the parse tree to the target AST is found in `extractor/src/languages/swift/swift.rs`
 
-- To run tests for the parser and mapping, run `cargo test` in the `extractor` directory. The corpus tests shell out to the `swift-syntax-parse` binary, which lives in a separate crate that `cargo test` does not build, so build it first with `cargo build -p swift-syntax-rs --bin swift-syntax-parse` (this needs a Swift toolchain; `scripts/update-corpus.sh` does it for you).
+- To run tests for the parser and mapping, run `cargo test` in the `extractor` directory. The corpus tests shell out to the `swift-syntax-parse` binary, which lives in a separate crate that `cargo test` does not build; build it and point the tests at it with `export CODEQL_EXTRACTOR_UNIFIED_SWIFT_SYNTAX_PARSE=$(scripts/build-parser.sh)`. That builds with Bazel, whose Swift toolchain is hermetic, so no local Swift installation is needed; pass `--cargo` to build with a local toolchain instead. `scripts/update-corpus.sh` does this for you.
 
 - Extractor test cases are located at `extractor/tests/corpus/swift/*/*.swift`.
 

unified/extractor/src/languages/swift/parse.rs

@@ -74,9 +74,9 @@ fn spawn_error(bin: &str, error: std::io::Error) -> String {
     if error.kind() == std::io::ErrorKind::NotFound {
         format!(
             "could not find the Swift parser `{bin}`. Build it with \
-             `cargo build -p swift-syntax-rs --bin swift-syntax-parse` (this needs a Swift \
-             toolchain — see `unified/swift-syntax-rs/.swift-version` for the pinned version), \
-             or point `{PARSE_BIN_ENV}` at an existing copy."
+             `unified/scripts/build-parser.sh`, which prints the path to set \
+             `{PARSE_BIN_ENV}` to (it uses Bazel's Swift toolchain, so no local \
+             Swift installation is needed)."
         )
     } else {
         format!("failed to spawn Swift parser `{bin}`: {error}")

unified/scripts/build-parser.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+# Build `swift-syntax-parse`, the binary the Swift front-end shells out to, and
+# print the path to it.
+#
+# By default this builds with Bazel, whose Swift toolchain is hermetic: nothing
+# has to be installed locally. Pass `--cargo` to build through cargo instead,
+# which is quicker to iterate on but needs a local Swift toolchain matching
+# `swift-syntax-rs/.swift-version`. Both pin the same swift-syntax release, so
+# the two produce equivalent parsers.
+#
+# Typical use:
+#
+#     export CODEQL_EXTRACTOR_UNIFIED_SWIFT_SYNTAX_PARSE=$(scripts/build-parser.sh)
+#
+# Progress output goes to stderr so that only the path lands on stdout.
+set -euo pipefail
+IFS=$'\n\t'
+
+cd "$(dirname "$0")/.."
+
+mode=bazel
+case "${1:-}" in
+    "" | --bazel) ;;
+    --cargo) mode=cargo ;;
+    *)
+        echo "usage: $(basename "$0") [--bazel | --cargo]" >&2
+        exit 2
+        ;;
+esac
+
+if [[ $mode == cargo ]]; then
+    cargo build -p swift-syntax-rs --bin swift-syntax-parse >&2
+    # Cargo builds workspace members into the target directory at the
+    # repository root, one level above this directory.
+    echo "$(cd .. && pwd)/target/debug/swift-syntax-parse"
+    exit 0
+fi
+
+# The wrapper script finds its Swift runtime libraries beside itself, so it only
+# works in the flattened layout the installer produces; under `bazel-bin` and in
+# the runfiles tree the libraries sit in a different directory.
+dest=$PWD/target/swift-syntax-parse
+bazel run //unified/swift-syntax-rs:install-parser -- --destdir "$dest" >&2
+echo "$dest/swift-syntax-parse"

unified/scripts/update-corpus.sh

@@ -8,8 +8,10 @@ cd "$(dirname "$0")/.."
 # separate crate which `cargo test` does not build (the extractor deliberately
 # does not depend on it, so working on other languages needs no Swift
 # toolchain), so build it up front — otherwise the tests below fail on a
-# missing binary.
-cargo build -p swift-syntax-rs --bin swift-syntax-parse
+# missing binary. This defaults to Bazel's hermetic Swift toolchain; pass
+# `--cargo` to use a local one instead.
+CODEQL_EXTRACTOR_UNIFIED_SWIFT_SYNTAX_PARSE=$(scripts/build-parser.sh "$@")
+export CODEQL_EXTRACTOR_UNIFIED_SWIFT_SYNTAX_PARSE
 
 cd extractor
 UNIFIED_UPDATE_CORPUS=1 cargo test

unified/swift-syntax-rs/BUILD.bazel

@@ -1,3 +1,4 @@
+load("@rules_pkg//pkg:install.bzl", "pkg_install")
 load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_library", "rust_test")
 load("@rules_shell//shell:sh_binary.bzl", "sh_binary")
 load("//misc/bazel:pkg.bzl", "codeql_pkg_runfiles")
@@ -105,3 +106,18 @@ rust_test(
     edition = "2024",
     target_compatible_with = _SWIFT_SUPPORTED_PLATFORMS,
 )
+
+# Stage the packaged parser into a directory, so it can be run outside Bazel:
+#
+#     bazel run //unified/swift-syntax-rs:install-parser -- --destdir <dir>
+#
+# The wrapper only works in this flattened layout, where it sits next to the
+# real binary and the runtime libraries; in `bazel-bin` and in the runfiles tree
+# those live in separate directories. Bazel's Swift toolchain is hermetic, so
+# this is also how the extractor's tests are run without installing Swift — see
+# `unified/scripts/build-parser.sh`.
+pkg_install(
+    name = "install-parser",
+    srcs = [":swift-syntax-parse-pkg"],
+    target_compatible_with = _SWIFT_SUPPORTED_PLATFORMS,
+)