unified: Make Bazel the only supported build

Nothing builds this extractor with `cargo` any more: the tests, the extractor
pack and the corpus regeneration all go through Bazel. The `cargo` half of the
build is now dead weight, and it is not free -- it is a second, independent way
of compiling the same Swift code, kept in step by hand.

`build.rs` shelled out to `swift build` on the SwiftPM package in `swift/`,
scraped `swiftc -print-target-info` for the runtime directory, and emitted the
resulting link and rpath flags. Bazel does none of that: it compiles
`SwiftSyntaxFFI.swift` directly against `@swift-syntax`, resolved from the Bazel
Central Registry. `Package.swift` and `Package.resolved` existed only for that
`swift build`.

Deleting them collapses three version pins into one. `MODULE.bazel` pinned the
toolchain, `.swift-version` pinned it again for `swiftly` and `build.rs`, and
`Package.swift` pinned the `swift-syntax` release a second time -- with a
comment asking that they be kept in sync and nothing enforcing it. Two Swift
builds that could silently diverge become one that cannot.

`cargo check` still works, since checking does not link, so rust-analyzer keeps
working across the crate -- completion, go-to-definition and inline diagnostics
included. What no longer works is `cargo build`/`cargo test`, and hence the
editor's "run test" lens; use `bazel test //unified/extractor:all_tests`. The
Cargo manifests stay because `misc/bazel/3rdparty` resolves third-party crate
versions from them.

`scripts/create-extractor-pack.sh` becomes a wrapper around the `codeql_pack`
installer that already existed, rather than a parallel cargo-based assembly of
the same pack.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 297ff885-7c13-4202-a9d0-bc0b17f68d8e

Author: tausbn

MODULE.bazel

@@ -228,13 +228,8 @@ use_repo(
 # auto-registers `xcode_swift_toolchain` (host Xcode + OS-provided Swift
 # runtime), which is not hermetic.
 #
-# The version is pinned as a literal rather than read from
-# `unified/swift-syntax-rs/.swift-version` via `swift_version_file`: the latter
-# makes the extension `module_ctx.read` a `//unified/...` label, which fails to
-# resolve when this repo is consumed as a dependency module (`@@ql+`) whose
-# `unified/swift-syntax-rs` package is not loadable in that context. Keep this
-# in sync with `unified/swift-syntax-rs/.swift-version` (used by the `cargo`
-# build) and the `swift-syntax` release in `swift/Package.swift`.
+# This and the `swift-syntax` version above are the only pins: the extractor is
+# built solely by Bazel, so there is no second Swift build to keep in step.
 swift = use_extension("@rules_swift//swift:extensions.bzl", "swift")
 swift.toolchain(
     name = "swift_toolchain",

unified/AGENTS.md

@@ -4,9 +4,10 @@ This is a CodeQL extractor that maps a language's parse tree onto a shared AST
 using the `yeast` desugaring engine. Swift, the only language so far, is parsed
 by Apple's swift-syntax rather than by tree-sitter.
 
-Build and test with Bazel, whose Swift toolchain is hermetic on Linux, so
-nothing needs to be installed locally. The extractor links `swift-syntax`, so a
-`cargo` build additionally needs a local Swift toolchain.
+Everything is built and tested with Bazel, whose Swift toolchain is hermetic on
+Linux, so nothing needs to be installed locally. `cargo build`/`cargo test` do
+not work here: the extractor links a Swift FFI shim that only Bazel builds.
+(`cargo check` still works, so rust-analyzer is unaffected.)
 
 ## Building
 - To build the extractor pack, run `scripts/create-extractor-pack.sh`.

unified/swift-syntax-rs/.gitignore

@@ -1,2 +1 @@
 /target
-/swift/.build

unified/swift-syntax-rs/.swift-version

@@ -1,3 +1,6 @@
+# `BUILD.bazel` is the build. This file feeds `misc/bazel/3rdparty`, which
+# resolves third-party crate versions from it, and `cargo check`; `cargo
+# build`/`test` cannot link the Swift shim.
 [package]
 name = "swift-syntax-rs"
 description = "Rust wrapper around the swift-syntax package for parsing Swift source"

unified/swift-syntax-rs/Cargo.toml

@@ -4,8 +4,11 @@ A Rust wrapper around the [swift-syntax](https://github.com/swiftlang/swift-synt
 package, allowing Swift source code to be parsed from Rust.
 
 Parsing is delegated to a small Swift shim (in [`swift/`](swift/)) that links
-against `SwiftSyntax`/`SwiftParser` and exposes a tiny C ABI. The Rust crate
-builds that shim (via `build.rs`) and provides safe bindings on top of it.
+against `SwiftSyntax`/`SwiftParser` and exposes a tiny C ABI. This crate provides
+safe bindings on top of it.
+
+Bazel builds both halves; there is no `cargo` build (see
+[Building & testing](#building--testing)).
 
 ## Output format
 
@@ -122,54 +125,26 @@ an unparenthesised `a *** b + c` is a single flat sequence whose structure
 cannot be determined without knowing `***`'s precedence, so it is left flat in
 its entirety.
 
-## Prerequisites
-
-The build does not depend on any particular version manager. You need:
-
-- **Rust** — pinned to `1.88` by the repo-root [`rust-toolchain.toml`](../../rust-toolchain.toml),
-  which `rustup` picks up automatically.
-- **Swift** — pinned to the version in [`.swift-version`](.swift-version)
-  (currently `6.3.2`), used to build `swift-syntax` `603.0.2`. Install it any way
-  you like — [swift.org](https://www.swift.org/install/) or
-  [swiftly](https://www.swift.org/swiftly/) (which reads `.swift-version`), or a
-  system package. Just make sure `swift` is on your `PATH` (or point `build.rs`
-  at it with the `SWIFT` environment variable).
-
-On Debian/Ubuntu the Swift runtime also needs `libncurses6` (and related libs)
-available on the system.
-
 ## Building & testing
 
-With `cargo` and `swift` on `PATH`:
-
-```sh
-cargo build
-cargo test
-```
-
-If your `swift`/`swiftc` are not on `PATH`, point the build at them explicitly:
-
-```sh
-SWIFT=/path/to/swift SWIFTC=/path/to/swiftc cargo build
-```
-
-The first build compiles `swift-syntax` and can take several minutes.
-
-## Building with Bazel (CI)
-
-CI builds this crate hermetically with Bazel. A Swift toolchain is downloaded
-from swift.org by the official `rules_swift` standalone toolchain extension
-(wired up in the repo-root `MODULE.bazel`), `swift-syntax` is pulled from the
-Bazel Central Registry, and the FFI shim is compiled as a `swift_library` that
-the Rust targets link against. `build.rs` is not used under Bazel; it only
-builds the Swift shim for the local `cargo` workflow.
+Everything is built by Bazel, which downloads a Swift toolchain from swift.org
+via the official `rules_swift` standalone toolchain extension (wired up in the
+repo-root `MODULE.bazel`) and pulls `swift-syntax` from the Bazel Central
+Registry. Nothing has to be installed locally on Linux:
 
 ```sh
 bazel build //unified/swift-syntax-rs:swift-syntax-parse
 bazel test  //unified/swift-syntax-rs:swift_syntax_rs_test
 bazel run   //unified/swift-syntax-rs:swift-syntax-parse < some.swift
 ```
 
+The first build compiles `swift-syntax` and can take several minutes.
+
+`cargo build`/`cargo test` do **not** work: the Swift shim is compiled by a
+`swift_library` in [`BUILD.bazel`](BUILD.bazel), so a `cargo` link finds no
+`ssr_*` symbols. `cargo check` does work — it does not link — which is all
+rust-analyzer needs.
+
 Requirements:
 
 - **`clang`** must be installed on the runner. `rules_swift` requires the Bazel
@@ -186,20 +161,12 @@ Requirements:
   [`xcode_transition.bzl`](xcode_transition.bzl)), so other targets on macOS
   keep using Bazel's default CC toolchain.
 
-The Swift compiler version is kept in sync across three places: the
-[`.swift-version`](.swift-version) file (read by the local `cargo`/`swift build`
-and by [swiftly](https://www.swift.org/swiftly/)), the literal `swift_version`
-pinned on `swift.toolchain(...)` in the root `MODULE.bazel` (the hermetic
-swift.org **Linux** Bazel toolchain), and the `swift-syntax` release in
-`swift/Package.swift`. On **macOS** the version is *not* pinned by the Bazel
-build: `rules_swift` auto-registers the host `xcode_swift_toolchain`, which uses
-whichever Swift ships with the installed Xcode. So the pin governs Linux (and
-local) builds, while the macOS compiler version depends on the host Xcode.
-
-(The Bazel toolchain pins a literal rather than reading `.swift-version` via
-`swift_version_file`, because the latter makes the module extension read a
-`//unified/...` label, which fails when this repo is consumed as a dependency
-module.)
+Versions are pinned in the root `MODULE.bazel` and nowhere else: the
+`swift_version` literal on `swift.toolchain(...)` selects the hermetic swift.org
+**Linux** toolchain, and `bazel_dep(name = "swift-syntax", ...)` selects the
+`swift-syntax` release. On **macOS** the compiler version is *not* pinned:
+`rules_swift` auto-registers the host `xcode_swift_toolchain`, so it follows
+whichever Swift ships with the installed Xcode.
 
 ## Usage
 
@@ -213,22 +180,20 @@ println!("{json}");
 CLI (reads a file argument or stdin, prints the syntax tree as JSON):
 
 ```sh
-echo 'let x = 1' | cargo run --bin swift-syntax-parse
+echo 'let x = 1' | bazel run //unified/swift-syntax-rs:swift-syntax-parse
 ```
 
 ## Converting to a yeast AST
 
 The JSON tree is consumed by the CodeQL extractor, which converts it into a
 [`yeast::Ast`](../../shared/yeast) — the in-memory format its rewrite rules
 operate on. That adapter is a pure-Rust module living in the extractor
-(`unified/extractor/src/languages/swift/adapter.rs`), so the extractor never
-needs the Swift toolchain: it consumes the JSON produced out-of-process by this
-crate's `parse_to_json` / the `swift-syntax-parse` binary.
+(`unified/extractor/src/languages/swift/adapter.rs`); the extractor links this
+crate and calls `parse_to_json` in-process.
 
 ## Layout
 
-- `swift/` — Swift package exposing the `ssr_parse_json` / `ssr_string_free` C ABI.
-- `build.rs` — builds the Swift package and emits link/rpath flags (local `cargo` only).
-- `BUILD.bazel` — Bazel targets for the hermetic CI build (swift_library + rust targets).
+- `swift/` — Swift sources exposing the `ssr_parse_json` / `ssr_string_free` C ABI.
+- `BUILD.bazel` — the build (swift_library + rust targets).
 - `src/lib.rs` — safe Rust bindings (`parse_to_json`).
 - `src/main.rs` — demo CLI.