Avoid passing -unwindlib on macOS where it isn't needed (#7825)

Removes some warnings from our links on macs when the flag is ignored.

.agents/skills/agent_tools/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: Agent tools
+description:
+    Guidelines and restrictions on shell commands and file manipulation tools
+    for AI assistants.
+---
+
+# Agent tools
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+AI assistants working on the Carbon repository **MUST NOT** use legacy or
+generic UNIX shell search/edit commands when specialized environment tools
+exist.
+
+## Command line tools restrictions
+
+-   **DO NOT USE**: `cat`, `less`, `grep`, `sed`, or other shell utilities for
+    viewing, searching, or modifying files.
+-   **DO NOT USE**: `patch` to write and apply patch files.
+-   **DO NOT USE**: Writing custom scripts in other languages to circumvent this
+    limitation.
+-   **DO USE**: High-fidelity semantic API tools:
+    -   **Viewing**: Use `view_file` instead of `cat` / `less`.
+    -   **Searching**: Use `grep_search` / `find_by_name` instead of `grep` /
+        `find`.
+    -   **Modifying**: Use `replace_file_content`, `multi_replace_file_content`,
+        or `write_to_file` instead of `sed` / `patch` / `python` edits.
+
+You may only write and run temporary programs to modify source code if no
+semantic tool is applicable or when performing complex, systematic transforms
+across many codebase directories simultaneously.
+
+## Temporary files management
+
+Temporary files and scratchpad test scripts created by the assistant during
+analysis, experiments, or debugging:
+
+-   **MUST** reside within the `tmp/` subdirectory under the workspace root.
+-   **MUST** be periodically cleaned out and deleted before ending your turn to
+    preserve a clean git workspace.

.agents/skills/bazel/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: Bazel usage
+description:
+    Instructions that **MUST** be followed when using Bazel or Bazelisk to
+    build, test, and debug in the Carbon repository.
+---
+
+# Bazel usage
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+This skill documents how best to use Bazel when building, testing, or
+manipulating the Carbon repository's Bazel in any way.
+
+## Bazel wrappers
+
+Carbon uses Bazel for its build system. To ensure consistent versions, the
+project uses Bazelisk.
+
+> [!IMPORTANT] Always use `bazelisk` whenever you want to run Bazel. Never run
+> `bazel` directly in the Carbon project. Anything you want to do with `bazel`
+> can be done with the `bazelisk` command instead.
+
+-   **Bazelisk**: Try to use `bazelisk` in your existing `$PATH` if available.
+    -   **`run_bazelisk.py`**: If `bazelisk` isn't available, use
+        `./scripts/run_bazelisk.py` to run bazelisk without it being installed.
+
+## Essential commands
+
+### Building
+
+-   **Build all**: `bazelisk build //...`
+-   **Build toolchain**: `bazelisk build //toolchain/...`
+-   **Build specific target**: `bazelisk build //toolchain:carbon`
+
+### Testing
+
+-   **Test all**: `bazelisk test //...:all`
+-   **Test toolchain**: `bazelisk test //toolchain/...`
+-   **Test examples**: `bazelisk test //examples/...`
+
+> [!TIP] Running all of the tests can be slow, so try to narrowly test the
+> immediately relevant parts of the project first, and only expand coverage as
+> necessary to be confident in the changes.
+
+> [!TIP] For specialized instructions on testing and developing the Carbon
+> toolchain, consult these skills:
+>
+> -   [Toolchain tests](/.agents/skills/toolchain_tests/SKILL.md): For
+>     authoring, structuring, and running `file_test` tests.
+> -   [Toolchain development](/.agents/skills/toolchain_development/SKILL.md):
+>     For architecture, essential commands, and debugging the toolchain.
+
+### Running binaries built by Bazel
+
+> [!IMPORTANT] Always manually run binaries built by Bazel using the
+> `bazelisk run` command. Never run the binary directly from `bazel-bin/`.
+
+You can run the Carbon driver or command line directly via Bazel:
+
+-   `bazelisk run //toolchain -- compile --phase=parse
+    toolchain/parse/testdata/basics/empty.carbon`
+
+## Advanced configurations
+
+### AddressSanitizer (ASan)
+
+To enable ASan for local testing:
+
+-   Pass `--config=asan`: `bazelisk test --config=asan //...`
+
+## Common pitfalls and troubleshooting
+
+### `bazel clean`
+
+Changes to packages installed on your system (like changing LLVM versions or
+installing `libc++`) may not be noticed by Bazel.
+
+-   Run `bazelisk clean` to force cached state to be rebuilt when environment
+    changes occur.

.agents/skills/builtins/SKILL.md

@@ -0,0 +1,276 @@
+---
+name: Builtin functions
+description:
+    Instructions for registering, mapping, constant evaluating, and lowering
+    builtin functions in the Carbon toolchain.
+---
+
+# Builtin Functions in the Carbon Toolchain
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+Builtin functions are compiler-recognized primitives mapping directly from
+Carbon code expressions (via standard prelude bindings) to optimized backend
+execution. This document defines the complete structural workflow, C++ patterns,
+constant evaluation logic, machine lowering mechanics, library bindings, and
+validation strategies required to implement builtin functions in the Carbon
+compiler.
+
+---
+
+## Technical Flow & Lifecycle
+
+```mermaid
+graph TD
+  Src[Carbon Source Code] -->|Prelude Map| Sem[Semantic Analysis / SemIR]
+  Sem -->|Signature Constraint| Sig[builtin_function_kind.cpp]
+  Sem -->|Phase Evaluation| Eval[eval.cpp Constant Interpreter]
+  Sem -->|Machine Codegen| Lower[handle_call.cpp LLVM Lowering]
+  Eval -->|Diagnostics| Diag[diagnostics/kind.def]
+  Lower -->|Native Instructions| LLVM[LLVM IR Generation]
+```
+
+Adding a builtin function involves a 5-step integration:
+
+1.  **Define the Builtin Kind**: Register the enum in
+    [builtin_function_kind.def](../../../toolchain/sem_ir/builtin_function_kind.def).
+2.  **Signature & Compile-Time Registry**: Declare the mapping name, parameter
+    constraints, and compile-time evaluation residency in
+    [builtin_function_kind.cpp](../../../toolchain/sem_ir/builtin_function_kind.cpp).
+3.  **Compile-Time Interpreter Support**: Wire constant evaluation hooks and
+    bounds/exception diagnostics in
+    [eval.cpp](../../../toolchain/check/eval.cpp).
+4.  **LLVM IR Lowering Support**: Connect target machine generation in
+    [handle_call.cpp](../../../toolchain/lower/handle_call.cpp).
+5.  **Prelude Library Mapping**: Bind primitive interfaces to named builtins
+    under [core/prelude/](../../../core/prelude/).
+
+---
+
+## Detailed Step-by-Step Implementation Guide
+
+### Step 1: Kind Definition & Registration
+
+Register your builtin function name using the X-macro in
+[builtin_function_kind.def](../../../toolchain/sem_ir/builtin_function_kind.def):
+
+```cpp
+// toolchain/sem_ir/builtin_function_kind.def
+
+// Converts an integer type to a floating-point type.
+CARBON_SEM_IR_BUILTIN_FUNCTION_KIND(IntConvertFloat)
+```
+
+### Step 2: Signature Validation & Compile-Time Residence
+
+Inside
+[builtin_function_kind.cpp](../../../toolchain/sem_ir/builtin_function_kind.cpp):
+
+1.  **Define Parameter Constraints**: If the parameter requires novel
+    constraints (e.g. "must be a float type"), define a template constraint
+    struct checking the matching `SemIR` type instruction (such as `FloatType`
+    or `FloatLiteralType`). Use pre-established semantic helpers:
+
+    -   `TypeParam<I, T>`: Ensures different parameters resolve to identical
+        type structures (e.g., generic constraint matching).
+    -   `AnyInt`, `AnyFloat`, `AnySizedInt`, `AnySizedFloat`, `CharCompatible`,
+        `StdInitializerList`, `NoReturn`.
+
+2.  **Map Literal Name & Register Constraint Signature**: Declare a
+    `BuiltinInfo` constant inside `namespace BuiltinFunctionInfo` matching the
+    macro-defined name:
+
+    ```cpp
+    // toolchain/sem_ir/builtin_function_kind.cpp
+
+    constexpr BuiltinInfo IntConvertFloat = {
+        "int.convert_float", ValidateSignature<auto(AnyInt)->AnyFloat>};
+    ```
+
+3.  **Establish Compile-Time Residency Status**: Update
+    `BuiltinFunctionKind::IsCompTimeOnly` to determine if a call requires
+    compile-time evaluation:
+    -   **Checked/Diagnostics Primitives**: Return `true` immediately. Runtime
+        lowering of these is illegal (e.g. `IntConvertFloatChecked`).
+    -   **Runtime Primitives**: Return
+        `AnyLiteralTypes(sem_ir, arg_ids, return_type_id)` to enforce that
+        expressions involving unsized literal values (like `IntLiteral` or
+        `FloatLiteral`) are evaluated exclusively at compile-time (as they lack
+        runtime representation).
+
+---
+
+### Step 3: Constant Evaluation Support
+
+Wire the interpreter inside [eval.cpp](../../../toolchain/check/eval.cpp) to
+execute compile-time computations:
+
+1.  **Implement Constant Evaluation Logic**:
+
+    -   Handle the builtin case inside `MakeConstantForBuiltinCall` (which
+        processes the compile-time execution of the call).
+    -   Confirm type validation phase is `Phase::Concrete` to reject incomplete
+        bindings:
+
+        ```cpp
+        case SemIR::BuiltinFunctionKind::IntConvertFloat: {
+          if (phase != Phase::Concrete) {
+            return MakeConstantResult(context, call, phase);
+          }
+          return PerformIntToFloatConvert(context, loc_id, arg_ids[0], call.type_id,
+                                          /*require_exact=*/false);
+        }
+        ```
+
+    -   Extract inputs safely from local value stores (e.g.
+        `context.ints().Get(arg.int_id)` or
+        `context.floats().Get(arg.float_id)`).
+    -   Leverage high-precision LLVM mathematical structures (`llvm::APInt`,
+        `llvm::APFloat`, `llvm::APSInt`) to handle custom bits and signedness
+        safely.
+
+2.  **Diagnose Invalid Parameters or Exceptions**:
+
+    -   Define compile-time diagnostics inside
+        [kind.def](../../../toolchain/diagnostics/kind.def):
+
+        ```cpp
+        // toolchain/diagnostics/kind.def
+        CARBON_DIAGNOSTIC_KIND(IntTooLargeForFloatType)
+        ```
+
+    -   Emplace localized diagnostic formatting messages where they are caught
+        in `eval.cpp`:
+
+        ```cpp
+        CARBON_DIAGNOSTIC(IntTooLargeForFloatType, Error,
+                          "integer value {0} too large for floating-point type {1}",
+                          llvm::APSInt, SemIR::TypeId);
+        context.emitter().Emit(loc_id, IntTooLargeForFloatType, val, dest_type_id);
+        ```
+
+    -   Return `SemIR::ErrorInst::ConstantId` to gracefully abort invalid
+        constant generation rather than crashing the compiler.
+
+3.  **Fast-Path Range Limits**:
+    -   Before evaluating expensive math operations on giant exponents (e.g.
+        `1.0e1000000`), executing range limits check against `dest_width + 64`
+        (sized) or `IntStore::MaxIntWidth` (unsized) is mandatory to prevent
+        out-of-bounds calculations and compile-time memory exhaustion.
+
+---
+
+### Step 4: Machine Code Generation (LLVM Lowering)
+
+Inside [handle_call.cpp](../../../toolchain/lower/handle_call.cpp):
+
+1.  **Map to Native LLVM Instructions**: For runtime-eligible builtins, map the
+    call inside `HandleBuiltinCall` to native LLVM IR builder methods:
+
+    ```cpp
+    case SemIR::BuiltinFunctionKind::IntConvertFloat: {
+      auto* operand = context.GetValue(arg_ids[0]);
+      auto* dest_type = context.GetTypeOfInst(inst_id);
+      bool is_signed = IsSignedInt(context, arg_ids[0]);
+      context.SetLocal(
+          inst_id, is_signed
+                       ? context.builder().CreateSIToFP(operand, dest_type)
+                       : context.builder().CreateUIToFP(operand, dest_type));
+      return;
+    }
+    ```
+
+2.  **Assert on Compile-Time-Only Builtins**: Throw a hard assertion on
+    lowering-cases for checked validator builtins that should never hit code
+    generation:
+
+    ```cpp
+    case SemIR::BuiltinFunctionKind::IntConvertFloatChecked: {
+      CARBON_CHECK(builtin_kind.IsCompTimeOnly(
+          context.sem_ir(), arg_ids,
+          context.sem_ir().insts().Get(inst_id).type_id()));
+      CARBON_FATAL("Missing constant value for call to comptime-only function");
+    }
+    ```
+
+---
+
+### Step 5: Standard Library Prelude Integration
+
+Map the standard library primitive interfaces to your newly minted named
+builtins under [core/prelude/](../../../core/prelude/):
+
+-   **Primitive Mappings**: Bind Carbon methods directly to string-literal
+    builtin equivalents:
+
+    ```carbon
+    fn Convert[self: Self]() -> Float(To) = "int.convert_float";
+    ```
+
+-   **Strict Orphan Rule Compliance**: Carbon's orphan rules prohibit
+    implementing interfaces where neither the type nor the interface is locally
+    defined in the backing source module.
+    -   **Literal Conversions**: Literal types (like `FloatLiteral`,
+        `IntLiteral`) do not have backing Carbon source files. Therefore, an
+        `impl` of `UnsafeAs` (which is defined in `as.carbon`) between two
+        literal types must reside inside `as.carbon` itself.
+    -   **Sized Conversions**: Implementations targeting sized primitives (e.g.
+        `Int(N)`, `Float(N)`) must reside in their respective type source files
+        (such as [int.carbon](../../../core/prelude/types/int.carbon) or
+        [float.carbon](../../../core/prelude/types/float.carbon)) where the
+        backing target type resides to prevent duplicate symbols and structural
+        recursion loops.
+
+---
+
+## High-Fidelity Validation & Test Authoring
+
+Follow the [Toolchain tests](../toolchain_tests/SKILL.md) skill with specialized
+patterns for builtins:
+
+### 1. Checker Builtin File Splits
+
+Create validation splits under
+[toolchain/check/testdata/builtins/](../../../toolchain/check/testdata/builtins/):
+
+-   **Test Naming Convention**: All tests under
+    [toolchain/check/testdata/builtins/](../../../toolchain/check/testdata/builtins/)
+    must be named after the builtin they are testing, replacing `.` characters
+    in the builtin name with `/` (directories). For example, a test for the
+    builtin `"char_literal.convert"` must be located at
+    `toolchain/check/testdata/builtins/char_literal/convert.carbon`.
+-   **Minimal Prelude & Direct Call Isolation**: Builtin tests must **not** test
+    the prelude library or operators. They must use the minimal primitive
+    prelude (`// INCLUDE-FILE:
+    toolchain/testing/testdata/min_prelude/primitives.carbon`) or a smaller
+    prelude, and explicitly declare and call the builtin functions under test
+    directly (e.g., `fn Add(a: f64, b: f64) -> f64 = "float.add";`). This
+    isolates the testing of compiler builtins from the library prelude.
+-   **Min-Prelude Limitations**: Standard operators (like `+`, `-`, `/`, `<`,
+    etc.) are **not** available in minimized preludes because the core operators
+    library isn't imported. To write tests with a minimal footprint, call
+    primitive builtins directly (e.g. `float.negate`, `float.div`) inside your
+    test code to build expressions.
+-   **Canonicalized Float Comparison**: In SemIR, real literal representations
+    with identical mathematical values can result in mismatched `RealId` objects
+    based on spelling variations. Verify compile-time constant conversions using
+    canonicalized comparison functions (e.g. passing converted results through
+    `Expect(X as f64)`) to completely avoid spelling mismatches in expected
+    outputs.
+-   **Locals Bypass**: If validating generic implicit conversions, compile-time
+    arguments cannot take local runtime variable parameters. Validate
+    compile-time conversions by passing literal constants directly, and sized
+    variable implicit conversions at runtime.
+
+### 2. Machine Codegen Lowering Splits
+
+Create testing splits under
+[toolchain/lower/testdata/builtins/](../../../toolchain/lower/testdata/builtins/):
+
+-   Emplace a simple carbon binding to the tested builtin.
+-   Confirm matching LLVM metadata target definitions are mapped precisely
+    (e.g., matching `sitofp i32 %a to float`, `fptosi float %a to i32`).

.agents/skills/code_style/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: Code style
+description:
+    Instructions for code formatting and style guidelines in the Carbon
+    toolchain.
+---
+
+# Code style
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+## License
+
+-   **Licenses**: All Carbon files outside of `third_party/` should have a
+    license following
+    [CONTRIBUTING license instructions](/CONTRIBUTING.md#license).
+
+## Formatting
+
+-   **Bazel**: Use `pre-commit run buildifier --files <file.bzl>` to format
+    Bazel files.
+-   **C++**: Use `pre-commit run clang-format --files <file.cpp>` to format C++
+    files.
+-   **Carbon**: The toolchain's `format` command doesn't work well right now.
+    Instead, try to format Carbon code based on other Carbon files and the C++
+    style.
+-   **Markdown**: Use `pre-commit run prettier --files <file.md>` to format
+    markdown files.
+-   **Python**: Use `pre-commit run black --files <file.py>` to format Python
+    files.
+
+## Comments
+
+-   **Describe the code that is there.** A comment should explain what the
+    current code does or why it is the way it is, not narrate what the code used
+    to be. Do not add a comment to justify a deletion or explain that something
+    is no longer necessary; a reader of the new code has no idea what is being
+    contrasted against, and the comment rots as soon as the old shape is
+    forgotten. Put that reasoning in the commit message instead.
+-   **Do not introduce a local variable just to host a comment.** If a call
+    argument reads clearly on its own, inline it rather than naming it so that a
+    comment has somewhere to attach.
+-   **Lead with a plain summary.** Start a doc comment with a direct statement
+    of what the function does or returns, such as "Returns true if the InstKind
+    is a singleton." Put nuance in a following sentence rather than qualifying
+    the summary into something harder to read.
+-   **Re-read a comment before updating it.** When a symbol is renamed or
+    changes meaning, a comment that mentions it is not automatically stale. Work
+    out what the comment actually asserts first: it may be describing what the
+    code _uses_, which is still true, and rewriting it loses information.
+
+## Documentation
+
+This covers standalone prose: `/docs`, `README.md` files, and the skill files
+under `.agents/skills`.
+
+-   **Be true of the tree it lands in.** Documentation shipping in the same
+    commit as the code it describes should name that code freely. Documentation
+    that lands separately must not: a reader who greps for an identifier from an
+    unlanded change finds nothing, and a claim that only holds after that change
+    is false until it lands. This is easy to get wrong when writing up a lesson
+    while the change that taught it is still in flight.
+-   **Use placeholders for illustrations.** When an example only needs to show a
+    shape, name it `Foo` rather than reaching for a real symbol. Save real
+    identifiers for documenting that identifier, where going stale is at least
+    detectable.
+-   **Make each point stand alone.** A reader has none of the discussion that
+    produced it. State the rule, and enough of the reason to apply it, without
+    assuming knowledge of the change that motivated it.
+
+## Naming
+
+-   **A name is a claim, so keep it true.** When a change invalidates the
+    invariant a name describes, rename it in the same change. A factory called
+    `MakeSingletonFooId` has to be renamed once `Foo` is no longer a singleton,
+    even though nothing forces you to.
+-   **Types in a signature are part of the claim.** A function returning the id
+    of a namespace should return `InstId`, not `TypeInstId`, because a namespace
+    is not a type. Do not let a convenient wider or narrower id type imply
+    something false.
+-   **Delete a predicate whose name stops distinguishing anything.** If a change
+    widens a test so that it no longer says what its name implies, remove it and
+    let callers use the underlying test, rather than keeping a wrapper that
+    sounds meaningful. What callers actually want is often the inverse, and is
+    worth adding under its own name.
+-   **Name a variable for its role, not its representation.** If the role a
+    value plays is unchanged, keep its name even when a change means it is now
+    held or spelled differently.
+
+## Commit descriptions
+
+-   **Say what the change is, not how you made it.** Describe the resulting
+    code. Only describe process when the process is more interesting than the
+    change, as with a large mechanical transformation.
+-   **Do not narrate your own work.** Statements like "each such site was
+    audited" or "we investigated every caller" describe effort, not the change.
+-   **Omit routine mechanical steps.** Do not mention running the testdata
+    autoupdater or the formatter. Every change is expected to include those.
+-   **Do not enumerate each edit.** Describe the change as a whole rather than
+    listing every function or file touched; the diff already lists them.
+-   **Use the project's terms precisely.** Reach for the term of art the
+    codebase uses. Calling something a "type alias" or a "namespace" when it is
+    a named scope misleads, and is worse than a vaguer but accurate word.
+-   **Scope claims to what changed.** Say the specific thing that is now true,
+    rather than a broader statement that happens to contain it.
+
+## Design
+
+-   **Do not distort the data model to improve output.** If printed or golden
+    output is undesirable, change the printer, not the data structures that
+    feed it.
+
+## Style Guides
+
+-   **C++ style**: Follow the
+    [Carbon C++ Project Style Guide](/docs/project/cpp_style_guide.md).
+-   **Markdown style**: Follow the
+    [Google developer documentation style guide](https://developers.google.com/style).
+-   **Python style**: Follow the [PEP 8](https://peps.python.org/pep-0008/)
+    style guide.
+    -   Wrap code and comments to 80 columns.
+    -   Run `pre-commit run flake8 --files <file.py>` to check Python style.

.agents/skills/diagnostics/SKILL.md

@@ -0,0 +1,261 @@
+---
+name: Diagnostics
+description:
+    Instructions for declaring, formatting, emitting, testing, and styling
+    diagnostic messages (errors, warnings, notes) in the Carbon toolchain.
+---
+
+# Diagnostics in the Carbon Toolchain
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+The Carbon compiler features a highly-engineered, context-aware diagnostics
+framework designed to deliver precise, readable, and highly targetable
+diagnostic output (errors, warnings, notes). This document establishes strict
+rules for declaring, formatting, emitting, testing, and styling compiler
+diagnostics.
+
+---
+
+## Architecture Overview
+
+```mermaid
+graph TD
+  Kind[kind.def Registry] -->|Registration| Enum[Kind Enum ID]
+  Enum -->|Build/Emit| Emitter[Emitter LocT]
+  Emitter -->|ConvertLoc| Loc[Converted Physical Loc]
+  Emitter -->|formatv serialization| Formatting[format_providers.h / Custom Types]
+  Emitter -->|Emit Messages| Consumer[Console / Sorting Consumer]
+  Consumer -->|stable sort| StdErr[Compiler Standard Error]
+```
+
+Diagnostics are handled via three decoupled core components:
+
+1.  **Registry**: Globally enumerated kinds inside
+    [kind.def](../../../toolchain/diagnostics/kind.def).
+2.  **Emitters**: Specialized formatting pipelines (parameterized on custom
+    phase location types `LocT` like `Token` or `LocId`) that convert raw tokens
+    to standardized physical source locations (file, line, column, and text
+    snippet).
+3.  **Consumers**: Pipelines that process, track, filter, and sort diagnostics.
+    The default `SortingConsumer` buffers and stable-sorts diagnostics based on
+    their `last_byte_offset` matching compiler traversal order to ensure perfect
+    causal ordering.
+
+---
+
+## 1. Declaring and Registering Diagnostics
+
+All diagnostic types must pass structural uniqueness and coverage verifications.
+
+### The Diagnostic Registry
+
+Every diagnostic kind must be registered globally as an enum option under
+[kind.def](../../../toolchain/diagnostics/kind.def):
+
+```cpp
+// toolchain/diagnostics/kind.def
+CARBON_DIAGNOSTIC_KIND(RealLiteralTooLargeForUnsizedInt)
+```
+
+### The Uniqueness Rule
+
+To ensure optimal compile-time and analysis integrity, every diagnostic kind
+declared in `kind.def` **MUST** be mapped to **one and only one** C++ macro
+declaration (`CARBON_DIAGNOSTIC` or `CARBON_DIAGNOSTIC_ON_SCOPE`).
+
+-   **DO NOT** duplicate diagnostic definitions across different locations.
+-   The C++ representation of the diagnostic is a static/global constant of type
+    `DiagnosticBase<Args...>`.
+-   **Local Scope (Recommended)**: If the diagnostic is unique to a single
+    block/function body, declare it **locally** inside the function body
+    adjacent to its `Emit` trigger:
+
+    ```cpp
+    void ConvertFloatValueToInt(...) {
+      CARBON_DIAGNOSTIC(FloatNaNConvertedToInt, Error,
+                        "cannot convert NaN to integer type {0}", SemIR::TypeId);
+      context.emitter().Emit(loc_id, FloatNaNConvertedToInt, dest_type_id);
+    }
+    ```
+
+-   **File Scope**: If the diagnostic is shared among multiple functions inside
+    the _same_ file, declare it at **file scope** inside the anonymous namespace
+    of the `.cpp` file.
+-   **Global Scope**: If a diagnostic (such as a shared helper note) is reused
+    _across different physical files_, define it in a shared header (e.g.
+    context/check helpers) and mark it `extern` where applicable, ensuring the
+    macro is only invoked once.
+
+---
+
+## 2. Formatting Diagnostic Arguments
+
+Carbon diagnostics leverage LLVM's `formatv` engine. Parameters must be passed
+using strongly-typed arguments to preserve translation capability.
+
+### String Lifetimes & Pitfalls
+
+-   **`llvm::StringRef` is DISALLOWED**: Do not pass `StringRef` as a parameter
+    type to `CARBON_DIAGNOSTIC` due to unsafe lifetime and buffer-allocation
+    boundaries.
+-   **`llvm::StringLiteral` is DISALLOWED**: Do not use literal types as
+    arguments as they prevent future diagnostic localization and translations.
+-   **Use `std::string`**: If string formatting or custom allocations are
+    required, declare the parameter storage type as `std::string`.
+
+### Format Selectors (`format_providers.h`)
+
+Use specialized formatting wrappers under
+[format_providers.h](../../../toolchain/diagnostics/format_providers.h) to
+express clean inline options in format strings:
+
+| Wrapper                    | Target Format Style             | Example Usage                  | Output                                                              |
+| :------------------------- | :------------------------------ | :----------------------------- | :------------------------------------------------------------------ |
+| **`BoolAsSelect`**         | `{Index:true\|false}`           | `"{0:is signed\|is unsigned}"` | Maps bool to selection string.                                      |
+| **`IntAsSelect`**          | `{Index:=Val:String\|:Default}` | `"{0:=1:is\|:are}"`            | Matches exact options.                                              |
+| **`IntAsSelect` (Plural)** | `{Index:s}`                     | `"{0} argument{0:s}"`          | Prints `"s"` if value != 1 (e.g., `"1 argument"`, `"3 arguments"`). |
+
+### Custom Toolchain Type Mappings
+
+Custom structures can define how they serialize inside diagnostics using the
+`DiagnosticType` tag mapping to `Diagnostics::TypeInfo<StorageType>`:
+
+-   **Identifiers & Names** (declared in `check/diagnostic_helpers.h`):
+    -   `NameId`: Formats raw identifier spelling, safely escaping keyword
+        conflicts under backticks automatically.
+    -   `LibraryNameId`: Formats custom library descriptors cleanly (e.g.
+        `default library` or `library "foo"`).
+-   **Sized Primitives**:
+    -   `TypedInt`: Formats an `APInt` constant exactly, extracting target
+        signedness representation automatically from its bound type
+        representation.
+-   **Type Formatter Hierarchy**: When choosing parameter types to print
+    compiler type representations, follow this priority list:
+    1.  **`TypeOfInstId` (Preferred)**: Resolves the backing type of an
+        `InstId`, preserving programmatic aliasing, constraints, and source
+        spelling context. Enclosed under backticks automatically.
+    2.  **`InstIdAsType`**: Converts an `InstId` for a type expression, printing
+        custom type layouts under backticks.
+    3.  **`TypeId` (Fallback)**: Canonical description of the type. **Avoid when
+        possible** because type canonicalization loses intermediate source
+        program spelling and aliasing metadata.
+    4.  **`*AsRawType` (e.g. `InstIdAsRawType`, `TypeIdAsRawType`)**: Formats
+        the type layout exactly like their counter-structures above, but
+        **omits** enclosing backticks (useful when inserting types inside larger
+        code snippets).
+
+---
+
+## 3. Fluent Emission Builders & RAII Scopes
+
+### Fluent Builder Pattern
+
+For compound diagnostics requiring multiple sub-notes, carets, or custom code
+overrides, use `Build` to chain actions fluently:
+
+```cpp
+context.emitter()
+    .Build(second_node, ModifierRepeated, context.token_kind(second_node))
+    .Note(first_node, ModifierPrevious, context.token_kind(first_node))
+    .OverrideSnippet("custom snippet...")
+    .Emit();
+```
+
+> [!SAFETY] Emitter builders are marked `[[nodiscard]]`. To prevent a developer
+> from creating a builder but failing to terminal-chain `.Emit()`, the builder
+> uses an rvalue overload `Emit() &&` that triggers a compile-time
+> `static_assert(false)`. You must save the builder to an lvalue or execute the
+> chain exactly as `emitter.Build(...).Note(...).Emit()`.
+
+### RAII Context & Annotation Scopes
+
+Manage large checking structures requiring blanket note context using RAII block
+scopes:
+
+-   `ContextScope`: Automatically converts any diagnostics emitted within its
+    scope into sub-notes under a high-level operation descriptor:
+
+    ```cpp
+    ContextScope context_scope(&context.emitter(), [&](ContextBuilder& builder) {
+      builder.Context(eval_loc, InCallToEvalFn);
+    });
+    // any checker error emitted here will automatically append the 'InCallToEvalFn' note
+    ```
+
+-   `AnnotationScope`: RAII block scope that automatically attaches blanket note
+    annotations to all scoped diagnostics.
+
+---
+
+## 4. Diagnostics Wording Style Guide
+
+Refer to the official
+[Diagnostic message style guide](../../../toolchain/docs/diagnostics.md#diagnostic-message-style-guide)
+for complete details.
+
+To maintain message consistency and integrate cleanly with Clang diagnostics in
+interoperable code, adhere strictly to these rules:
+
+-   **Start with lowercase and omit periods**: Start diagnostic messages with a
+    lowercase letter or quoted code, and do **not** end them with a period
+    (e.g., `"cannot convert..."` or ``"`self` declared..."``).
+-   **Use backticks for quoted code**: Enclose identifiers, code constructs, and
+    types inside standard backticks (e.g., ``"`{0}` is bad"``).
+-   **Phrase as bullet points without articles**: Phrase diagnostics as
+    descriptive bullet points or sentence fragments rather than full sentences.
+    Leave out standard articles (`a`, `an`, `the`) unless necessary for logical
+    clarity. Semicolons can be used to separate fragments within a message.
+-   **Describe the situation and language rule**: Diagnostics should describe
+    the exact situation the toolchain observed. The language rule violated can
+    be mentioned if it wouldn't otherwise be clear:
+    -   _Situation-only_: `"redeclaration of X"` (implies that redeclaration is
+        not permitted).
+    -   _Rule-inclusion_: ``"`self` declared in invalid context; can only be
+        declared in implicit parameter list"``.
+-   **Wording Choice ("cannot" vs "allowed")**: Explicitly avoid `"allowed"`,
+    `"legal"`, `"permitted"`, `"valid"`, and related passive wording. You may
+    use `"cannot"` if needed, but try to use phrasing that does not require it:
+    -   _Correct_: ``"`export` in `impl` file"`` (Avoids `"allowed"`)
+    -   _Incorrect_: ``"`export` is only allowed in API files"``
+    -   _Correct_: ``"`extern library` specifies current library"`` (Avoids
+        `"cannot"`)
+    -   _Incorrect_: ``"`extern library` cannot specify the current library"``
+-   **Developer Intent Hints**: It is acceptable for a diagnostic to guess at
+    the developer's intent and provide a hint _after_ explaining the situation
+    and the rule, but never as a substitute for that:
+    -   _Correct_: ``"cannot implicitly convert `i32` to `String`; add `as
+        String` for explicit conversion"``
+    -   _Incorrect_: ``"add `as String` to convert `i32` to `String`"`` (Lacks
+        the core violation message).
+-   **Structure for Tooling API**: Try to structure diagnostics such that
+    parameter inputs can be programmatically extracted without string parsing
+    (prefer strongly-typed parameters over format placeholders where possible).
+
+---
+
+## 5. Diagnostics Testing & Coverage Verification
+
+Carbon strictly enforces testing coverage at build-time.
+
+1.  **Tag Verification Requirement**: Every diagnostic kind declared in
+    `kind.def` (which is not blacklisted in the `UntestedKinds` array under
+    [coverage_test.cpp](../../../toolchain/diagnostics/coverage_test.cpp))
+    **MUST** be verified by at least one testcase file inside
+    `toolchain/*/testdata/`.
+2.  **Stderr Checklist Matchers**: The testcase split verifying the diagnostic
+    must catch it using standard CHECK matchers, explicitly tracking the
+    matching enum tag in standard error comments:
+
+    ```carbon
+    // CHECK:STDERR: fail_bounds.carbon:[[@LINE+1]]:15: error: cannot convert NaN to integer type `i32` [FloatNaNConvertedToInt]
+    let a: i32 = Convert(nan_val);
+    ```
+
+3.  **Build Enforcement**: Failing to provide a diagnostic test check matcher
+    triggers a build compilation error on the target test
+    `//toolchain/diagnostics:coverage_test`.

.agents/skills/github_cli/SKILL.md

@@ -0,0 +1,171 @@
+---
+name: GitHub CLI usage
+description:
+    Instructions for using the `gh` command to query and inspect GitHub state
+    safely.
+---
+
+# GitHub CLI usage
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+This skill provides instructions for using the GitHub CLI (`gh`) to query,
+inspect, and search GitHub state (issues, pull requests, repositories) for the
+Carbon project.
+
+## Safety First: Read-Only Usage
+
+> [!IMPORTANT] AI assistants MUST NOT use the `gh` tool to modify any GitHub
+> project state. Do NOT run commands that create, edit, delete, label, comment
+> on, or merge issues, pull requests, releases, or any other resources.
+
+### Allowed Verbs
+
+-   `list`
+-   `view`
+-   `search`
+-   `status`
+-   `api` (Only with `GET` requests)
+
+### Prohibited Verbs
+
+-   `create`
+-   `edit`
+-   `delete`
+-   `merge`
+-   `reopen`
+-   `close`
+-   `comment`
+-   `label`
+
+## Repository Configuration
+
+The `gh` tool interacts with a default repository when run within a local check
+out. For this project, the default repository is expected to be
+`carbon-language/carbon-lang`.
+
+### Verifying Default Repository
+
+To verify the current default repository configuration:
+
+```bash
+gh repo view
+```
+
+The output should indicate the repository is `carbon-language/carbon-lang`.
+
+### Correcting Misconfigurations
+
+If the default repository is misconfigured (for example, pointing to a personal
+fork or a different repository), the human operator must correct it.
+
+> [!IMPORTANT] AI Assistants MUST NOT attempt to mutate `gh` configuration or
+> run commands that change the default repository (such as
+> `gh repository set-default`).
+
+Instruct the human operator to run the following command to select the correct
+default repository:
+
+```bash
+gh repo set-default
+```
+
+The operator will be prompted to select the correct repository (e.g.,
+`carbon-language/carbon-lang`) from the available remotes.
+
+## Common Query Commands
+
+### Issues
+
+-   **List issues**: `gh issue list`
+-   **View specific issue**: `gh issue view <number>`
+-   **Search issues**: `gh issue search "<query>"`
+    -   Example: `gh issue search "crash" --state open`
+
+### Pull Requests
+
+-   **List PRs**: `gh pr list`
+-   **View specific PR**: `gh pr view <number>`
+-   **View PR diff**: `gh pr diff <number>`
+-   **Check PR status**: `gh pr status`
+
+### Search
+
+-   **Search code**: `gh search code "<query>"`
+-   **Search repositories**: `gh search repos "<query>"`
+
+## Advanced Usage: GitHub API
+
+For queries that are not supported by standard `gh` commands, you can use the
+`gh api` command to query the GitHub REST or GraphQL APIs.
+
+### REST API
+
+Query the REST API using paths relative to the API root.
+
+-   **List contributors**:
+
+    ```bash
+    gh api repos/carbon-language/carbon-lang/contributors
+    ```
+
+-   **List issue comments**:
+
+    ```bash
+    gh api repos/carbon-language/carbon-lang/issues/<issue_number>/comments
+    ```
+
+### GraphQL API
+
+For complex queries, use GraphQL to fetch exactly the data needed.
+
+-   **Get repository information**:
+
+    ```bash
+    gh api graphql -f query='
+      query {
+        repository(owner: "carbon-language", name: "carbon-lang") {
+          description
+          stargazerCount
+        }
+      }
+    '
+    ```
+
+### Pagination
+
+Use the `--paginate` flag to automatically fetch all pages of results.
+
+```bash
+gh api --paginate repos/carbon-language/carbon-lang/issues
+```
+
+### Filtering and Formatting
+
+Use `--json` to request JSON output, and `--jq` or `--template` to filter or
+format the results.
+
+-   **List PR titles and authors**:
+
+    ```bash
+    gh pr list --json title,author --jq '.[] | "\(.title) by \(.author.login)"'
+    ```
+
+-   **Format with Go templates**:
+
+    ```bash
+    gh issue list --template '{{range .}}{{.number}} - {{.title}}{{"\n"}}{{end}}'
+    ```
+
+## Documentation References
+
+-   **GitHub CLI Manual**:
+    [cli.github.com/manual](https://cli.github.com/manual/)
+-   **GitHub REST API Documentation**:
+    [docs.github.com/en/rest](https://docs.github.com/en/rest)
+-   **GitHub GraphQL API Documentation**:
+    [docs.github.com/en/graphql](https://docs.github.com/en/graphql)

.agents/skills/github_issues/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: Accessing GitHub issues
+description:
+    Instructions for safely viewing and accessing GitHub issues by way of
+    command line.
+---
+
+# Accessing GitHub issues
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+This skill provides instructions for AI assistants on how to access and view
+GitHub issues. Agents should strongly prefer using the command line `gh` tool to
+access and view the contents of issues rather than viewing their contents by way
+of a web browser.
+
+## Safety First
+
+> [!IMPORTANT] AI assistants MUST NOT modify any GitHub issue state. Only use
+> read-only access commands like `view` or `list`. Do NOT comment, edit, create,
+> close, or delete issues.
+
+## Accessing Issues
+
+Agents must use this skill to access issues regardless of how they are mentioned
+(for example, by URL or by issue number).
+
+### Basic View
+
+To view an issue in the current default repository (expected to be Carbon):
+
+```bash
+gh issue view <issue_number>
+```
+
+### Including Full Context (All Comments)
+
+To ensure the view includes the entire context of the issue, always include the
+`--comments` flag to dump all comments:
+
+```bash
+gh issue view <issue_number> --comments
+```
+
+> [!TIP] If the issue is extremely large and comments are truncated, or you need
+> to process comments programmatically, use the JSON output with `jq`:
+>
+> ```bash
+> gh issue view <issue_number> --json comments --jq '.comments[].body'
+> ```
+
+### Accessing Issues in Other Repositories
+
+To view an issue in another repository (for example, LLVM), use the `-R` or
+`--repo` flag to specify the repository:
+
+```bash
+gh issue view <issue_number> -R <owner>/<repo> --comments
+```
+
+Examples:
+
+-   **LLVM Issue**:
+
+    ```bash
+    gh issue view 5678 -R llvm/llvm-project --comments
+    ```
+
+-   **Carbon Issue (Explicit)**:
+
+    ```bash
+    gh issue view 1234 -R carbon-language/carbon-lang --comments
+    ```
+
+## Mentions via URL
+
+If an issue is mentioned via URL, parse the URL to extract the repository owner,
+repository name, and issue number.
+
+-   **URL pattern**: `https://github.com/<owner>/<repo>/issues/<number>`
+-   **Extraction**:
+    -   Host: `github.com`
+    -   Owner: `<owner>`
+    -   Repo: `<repo>`
+    -   Number: `<number>`
+
+Run the command specifying the repository:
+
+```bash
+gh issue view <number> -R <owner>/<repo> --comments
+```

.agents/skills/jj/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: Jujutsu (jj) usage
+description:
+    Instructions for using Jujutsu (jj) for version control in the Carbon
+    repository.
+---
+
+# Jujutsu (jj) usage
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+[Jujutsu](https://github.com/jj-vcs/jj) is a Git-compatible version control
+system that may be used in Carbon checkouts.
+
+> [!IMPORTANT] You can detect if Jujutsu is in use by checking for a `.jj`
+> directory in the repository root. If present, you **must** use `jj` and **must
+> not** use `git`. If absent, you **must not** use `jj`.
+
+## General usage
+
+Always use the `--no-pager` flag when invoking `jj` to prevent the command from
+blocking or waiting for terminal paging.
+
+## Common commands
+
+### Syncing with remote
+
+-   **Fetch from remote**: `jj --no-pager git fetch`
+-   **Create a new change on top of trunk**: `jj --no-pager new trunk`
+-   **Show repository status**: `jj --no-pager status`
+-   **Show commit history**: `jj --no-pager log`
+
+### Managing changes
+
+-   **View diff of current changes**: `jj --no-pager diff`
+-   **Commit changes**: `jj --no-pager commit`
+    -   _Note_: Prefer using `jj commit` over the combination of `jj describe`
+        and `jj new`.
+-   **Abandon/discard current changes**: `jj --no-pager abandon`
+-   **Rebase current change onto trunk**: `jj --no-pager rebase -o trunk`
+
+### Working with a stack of changes
+
+A change is often built as a stack of commits sent up as a single pull request.
+The stack is not necessarily based on `trunk`; it may be based on another change
+that is itself still in flight.
+
+> [!WARNING] **Never rewrite the history of a change that has been submitted as
+> a pull request.** Reviewers track a PR by its commits, and squashing,
+> reordering, or abandoning them discards review that is already in progress.
+> This cannot be undone from their side.
+>
+> Before rewriting history in any other case, propose the exact command and wait
+> for confirmation. This applies to `squash`, `rebase`, `abandon`, and
+> `describe` on an existing change.
+
+#### Finding the base of the stack
+
+Bookmarks delimit the stack. List the bookmarks that are ancestors of the
+working copy, nearest first:
+
+```bash
+jj --no-pager log -r '::@ & bookmarks()'
+```
+
+Reading the result takes care, because two situations produce similar output:
+
+-   **Editing an existing change.** The nearest bookmark names the change being
+    worked on, and the bookmark below it is the base.
+-   **Starting a new change.** The commits above the nearest bookmark have no
+    bookmark of their own yet, so the nearest bookmark is itself the base.
+
+`trunk` is only ever a base. Finding `trunk` nearest means new work is being
+built on top of it, never that `trunk` itself is being worked on.
+
+The graph does not distinguish the two cases: an unbookmarked or empty commit
+above a bookmark may be the next commit of that change or the start of a new
+one. Ask which it is when it is not clear, and ask before choosing where a fix
+should land rather than after. Guessing wrong means squashing into a change that
+may already be under review.
+
+Once the base is known, use it to scope commands to the current stack:
+
+```bash
+jj --no-pager log -r '<base-bookmark>..@'
+```
+
+#### Managing the stack
+
+-   **Fold a fix into an earlier change**:
+    `jj --no-pager squash --into <change-id> [path]`. Follow-up fixes and
+    formatter reflows belong in the change that introduced the code, not in a
+    trailing "fixes" commit, unless that change has already been submitted.
+    Naming a path squashes only that part of the working copy, leaving unrelated
+    work in place.
+-   **Descriptions**: only one change in the stack needs a long description, the
+    one used as the pull request description. Every other change gets a short
+    one-line summary. Do not repeat the long text across the stack.

.agents/skills/language_server/SKILL.md

@@ -0,0 +1,197 @@
+---
+name: Language server
+description:
+    Instructions for working on Carbon's LSP language server, including its
+    architecture, its file_test-based tests, and the VS Code extension.
+---
+
+# Language server
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+## Introduction
+
+This skill covers [`toolchain/language_server/`](/toolchain/language_server/),
+which implements `carbon language-server`, and
+[`utils/vscode/`](/utils/vscode/), the VS Code extension that launches it.
+
+## Architecture
+
+The server is built on clangd's LSP transport (`clang::clangd`), not on a
+Carbon-specific one. That means clangd's `Protocol.h` types (`Position`,
+`Range`, `Location`, `Hover`, `MarkupContent`) are the interface currency.
+
+-   `server.cpp` / `incoming_messages.cpp`: message dispatch. A handler must be
+    registered in `incoming_messages.cpp` before it can be called.
+-   `handle_*.cpp`: one file per request family, each declaring its entry point
+    in `handle.h`.
+-   `handle_initialize.cpp`: the advertised capabilities. **Adding a capability
+    changes `Content-Length` in every test that calls `initialize`**, so expect
+    a large autoupdate diff.
+-   `context.h` / `context.cpp`: `Context::File` per open document, plus the
+    compile driver. `Context::File::unit()` has a `CARBON_CHECK` on the compile
+    driver, so any handler that reaches for the parse tree must first rule out
+    documents that were never compiled.
+-   `position.h`, `sem_ir_index.h`: mapping source positions to SemIR
+    instructions for real Carbon files.
+-   `sem_ir_text.h`, `handle_sem_ir_text.h`: navigation within the *formatted
+    SemIR* in a test file's `// CHECK:STDOUT:` lines. This is a heuristic text
+    index, deliberately independent of the real SemIR data structures. See
+    [the SemIR text reader](#the-semir-text-reader).
+
+### Document kinds
+
+The server handles two kinds of document, distinguished by the `languageId`
+from `textDocument/didOpen`, with a content sniff as a fallback:
+
+-   `carbon`: a real Carbon file. Compiled; diagnostics published.
+-   `carbon-testdata`: a test file. **Not compiled**, because we lack logic to
+    split it into one file per `// ---` split marker.
+
+> [!IMPORTANT]
+> A handler that assumes every file was compiled will crash on a test file.
+> When adding one, give the test-file path an explicit early return.
+
+## Tests
+
+There is **no language-server-specific test target**.
+`toolchain/language_server/BUILD` only declares
+`filegroup(name = "testdata")`, which is pulled into
+`//toolchain/testing:all_testdata` and run by `//toolchain/testing:file_test`.
+
+```bash
+# Run just the language server tests (or any subset).
+bazelisk test //toolchain/testing:file_test \
+    --test_arg=--file_tests=toolchain/language_server/testdata/position/hover_and_goto.carbon
+
+# See the raw output, which is much easier to read than a test failure.
+bazelisk run //toolchain/testing:file_test -- --dump_output \
+    --file_tests=toolchain/language_server/testdata/position/hover_and_goto.carbon
+
+# Update expectations. Never hand-write CHECK lines.
+./toolchain/autoupdate_testdata.py toolchain/language_server/testdata/...
+```
+
+These tests run serially, because clangd's logging is a global singleton.
+
+### Test file shape
+
+The request stream is a `// --- STDIN` split written with the `[[@LSP-*]]`
+keywords, and the responses land in a trailing `// --- AUTOUPDATE-SPLIT`.
+Documents come from other splits by way of `"text": "FROM_FILE_SPLIT"`, which
+is substituted with the content of the split whose name matches the `uri`.
+
+```carbon
+// --- position.carbon
+fn Abs(n: i32) -> i32 { return n; }
+
+// --- STDIN
+[[@LSP-CALL:initialize:"capabilities": {}]]
+[[@LSP-NOTIFY:textDocument/didOpen:
+  "textDocument": {
+    "uri": "file:/position.carbon",
+    "languageId": "carbon",
+    "text": "FROM_FILE_SPLIT"
+  }
+]]
+[[@LSP-CALL:textDocument/hover:
+  "textDocument": {"uri": "file:/position.carbon"},
+  "position": {"line": 0, "character": 3}
+]]
+[[@LSP-CALL:shutdown]]
+[[@LSP-NOTIFY:exit]]
+
+// --- AUTOUPDATE-SPLIT
+```
+
+Full keyword documentation is in
+[`testing/file_test/README.md`](/testing/file_test/README.md).
+
+### Traps
+
+> [!WARNING]
+> **A blank line inside the `STDIN` split breaks the JSON transport.** It
+> terminates a header block, so clangd logs a timestamped
+> `Warning: Missing Content-Length header, or zero-length message.` The
+> timestamp makes the test unreproducible, so it fails on the next run.
+> Comment lines between messages are fine; blank lines are not. A single blank
+> line immediately before `// --- AUTOUPDATE-SPLIT` is also fine.
+
+Other things worth knowing:
+
+-   **`positionEncoding` is UTF-16.** A `character` is a UTF-16 code unit
+    offset, not a byte offset.
+-   **Line and character numbers in requests are 0-based**, while the `locN_M`
+    suffixes in SemIR output are 1-based. Off-by-ones here are silent: the
+    request succeeds and returns the wrong thing.
+-   **A split can hold a document that itself contains `// CHECK:STDOUT:`
+    lines**, because `CHECK` lines only form expectations inside the
+    `AUTOUPDATE-SPLIT`. Such a document still can't contain a literal `// ---`
+    line, which would split the enclosing test file; write it as
+    `[[@0x2f]]/ --- name.carbon`.
+
+## The SemIR text reader
+
+`sem_ir_text.cpp` indexes the formatted SemIR inside a test file's
+`// CHECK:STDOUT:` lines so that hover and go-to-definition work on operand
+names. It is a heuristic reader, not a parser, and its correctness rests on
+facts about `toolchain/sem_ir/formatter.cpp` and
+`toolchain/sem_ir/inst_namer.cpp`. Re-check these if the formatter changes:
+
+-   There are exactly four scope keywords: `file`, `generated`, `imports`, and
+    `constants` (`InstNamer::GetScopeName`). Everything else is `@entityname`.
+-   A reference is `%name` within its own scope and `scope.%name` otherwise
+    (`InstNamer::GetNameFor`). Names may contain `.` and may _start_ with one,
+    as in `%.Self.frozen`.
+-   **Type annotations are printed in the `constants` scope.**
+    `Formatter::FormatTypeOfInst` does
+    `llvm::SaveAndRestore file_scope(scope_, InstNamer::ScopeId::Constants)`,
+    so in `%x: %foo = ...` a bare `%foo` means `constants.%foo`. This does not
+    apply to ordinary operands or to `[concrete = ...]` annotations.
+-   **`*_decl` braces hold the declared entity's scope.** The braces of
+    `%F.decl: ... = fn_decl @F [...] { ... } { ... }` are lexically inside
+    `file { }`, but their names belong to `@F`.
+-   **`!with Self:` switches scope without a brace**, until `!members:`
+    switches it back. Brace counting alone cannot see this.
+-   A `specific @F(args) { }` block uses `@F`'s scope and defines nothing; each
+    `%name => value` row references an instruction of the generic.
+
+### Validating a change to the reader
+
+The unit tests only cover a handful of cases. To check a change against the
+real corpus, drive the server over a sample of check testdata, hovering on
+every `%name`, and compare the resolved fraction before and after. Roughly 99%
+of names resolve; the residue are names the formatter references but never
+emits a definition line for, such as `%I.WithSelf.F`, which only ever appears
+inside a `[symbolic = ...]` annotation.
+
+Two things to get right in such a harness:
+
+-   Feed the request stream from a **file**, not a pipe. The server reads stdin
+    as a file and reports `error: Input/output error` on a pipe.
+-   Read the output as **bytes**. Python's `text=True` rewrites the `\r\n`
+    framing, and `Content-Length` counts bytes.
+
+## VS Code extension
+
+[`utils/vscode/`](/utils/vscode/) declares three languages in `package.json`:
+
+| Language id      | Applies to                        |
+| ---------------- | --------------------------------- |
+| `carbon`         | `*.carbon`                        |
+| `carbon-testdata`| `**/testdata/**/*.carbon`         |
+| `semir`          | `*.semir`                         |
+
+> [!NOTE]
+> The TextMate _scope_ for SemIR is `source.carbon-semir`, but the
+> _language id_ is `semir`. Markdown code fences in hover text resolve language
+> ids, so a fence must say ` ```semir `.
+
+`extension.ts` launches the server over stdio, using the `carbonPath` setting
+(default `./bazel-bin/toolchain/carbon`). Its `documentSelector` controls which
+files are sent to the server at all; a new document kind has to be added there
+as well as in the server.

.agents/skills/prek/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: Prek
+description:
+    Instructions for running prek, the Carbon pre-submit/style/lint checker,
+    that *MUST* be run before submitting an change.
+---
+
+# Prek
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+`prek` is the Carbon pre-submit, style, and lint checker. Running it is
+mandatory before submitting any changes.
+
+## Running prek
+
+To run `prek` on all files:
+
+```bash
+prek run -a
+```
+
+To validate a specific list of files:
+
+```bash
+prek run --files <files>
+```
+
+## Running prek in a Jujutsu (jj) workspace
+
+If you are working in a Jujutsu workspace, running `prek` directly will fail
+because it expects a standard Git repository structure. Instead, use the helper
+script:
+
+```bash
+./scripts/jj_prek.sh
+```
+
+This script runs `prek` on all files that have changed between `trunk` and your
+current Jujutsu `@` change.
+
+Note that the script always compares against `trunk`. If your change is based on
+another bookmark rather than on `trunk`, the script also checks the files
+changed by that underlying change, so a reported failure may not be in your own
+work.
+
+## Hooks that rewrite files
+
+Some hooks, notably `clang-format` and `rumdl`, fix problems in place rather
+than only reporting them. When they do, `prek` reports a failure and exits
+non-zero even though the tree is now correct.
+
+Re-run `prek` after any failure that modified files, and treat the second, clean
+run as the result. Review what it changed: a reflow is expected, but a content
+change may not be what you intended.
+
+## Prek dependency errors
+
+> [!TIP] If `prek` fails with an error about resolving dependencies or security
+> policy, you may be running in a restricted environment where the
+> special-purpose `gpkg` tool is required. Prefix the command with `gpkg`, for
+> example: `gpkg prek run -a` or `gpkg ./scripts/jj_prek.sh`.

.agents/skills/proposals/SKILL.md

@@ -0,0 +1,135 @@
+---
+name: Proposals
+description:
+    Instructions for writing, submitting, and managing Carbon evolution
+    proposals.
+---
+
+# Proposals
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+## Overview
+
+This skill provides instructions and best practices for working with proposals.
+Only create a proposal when explicitly directed as part of the task.
+
+Make sure to confirm the desired title for the proposal as that will govern the
+filename.
+
+## Create a new proposal
+
+1.  **Use the helper script**: Run `./proposals/scripts/new_proposal.py "Title"`
+    to create a templated file and instructions for setting up the PR.
+2.  **Proposal file**: The file will be named `proposals/p######-title.md`,
+    where `######` is the 6-digit GitHub pull request number and `title` is a
+    slugified version of the proposal title.
+3.  **Template**: Follow the structure in `proposals/scripts/template.md`,
+    noting the specific `TODO` instructions in each section for the content that
+    should be included there.
+4.  **PR description**: Update the pull request description to match the
+    abstract section in the proposal document.
+
+> [!IMPORTANT] Do _not_ mark the PR ready for review. The user must have the
+> opportunity to review the proposal produced before asking for any review.
+
+## Writing style and best practices
+
+-   **Skimmable**: Use
+    [BLUF](<https://en.wikipedia.org/wiki/BLUF_(communication)>) (Bottom Line Up
+    Front) or
+    [Inverted Pyramid](<https://en.wikipedia.org/wiki/Inverted_pyramid_(journalism)>)
+    style. Keep it brief, focused, and technical.
+-   **Match existing proposal style**: Review [existing proposals](/proposals)
+    (preferring more recent ones with higher numbers) to understand the expected
+    style, wording, and nature of content to include.
+-   **Connect to goals**: In the Rationale section, link to specific goals in
+    [`/docs/project/goals.md`](/docs/project/goals.md) and principles in
+    [`/docs/project/principles`](/docs/project/principles) (e.g.,
+    `error_handling.md`, `one_way.md`).
+-   **Living design**: If the proposal updates design documentation, include
+    those changes in the PR if possible. If deferred, add "TODO" comments
+    pointing to the proposal (e.g., `> **TODO:** Document ... adopted in
+    [p######](/proposals/p######-title.md)`). For pervasive changes, file a
+    GitHub issue instead of adding many TODOs.
+
+## Alternatives considered and leads decisions
+
+There are always alternatives to a proposal, and the proposal should carefully
+include sections describing all of them and the rationale for not selecting
+them. Any living design document updates should focus on fully describing the
+end-state design, and the key motivating aspects of that design. The main
+proposal should focus on _what is changing_ and _why it is changing_, and should
+leave detailed description of the resulting design to the living design
+document, and _why not_ rationale to the description of each alternative.
+
+-   **Cover all the alternatives**: Make sure to describe any alternatives
+    considered, even if minor or rejected early.
+-   **Be specific**: Don't be vague about any of the alternatives, or the
+    rationale for not choosing them.
+-   **Connect to goals or principles**: In addition to the rationale section,
+    one of the best rationale structures for rejecting an alternative connects
+    that choice back to the goals or principles relevant.
+-   **Always frame as a tradeoff**: Selecting the proposed direction instead of
+    an alternative is _always_ a tradeoff, with both advantages and
+    disadvantages.
+-   **Where relevant, cite the leads issue** that decides against an
+    alternative, in addition to summarizing the key points, tradeoffs, and
+    rationale for the decision.
+
+> [!IMPORTANT] Don't just list the alternatives, create a sub-section for each
+> alternative and carefully describe the alternative, the advantages,
+> disadvantages and what the core of the decision is to reject each alternative.
+
+> [!IMPORTANT] Carefully research each alternative in the leads issue in order
+> to provide this clear and comprehensive explanation.
+
+## Building from a leads issue
+
+Sometimes a proposal is specifically documenting and formalizing a decided leads
+issue. When this is the case, carefully research that leads issue, reading the
+original issue text and every comment on the issue. Also read any linked Google
+documents, linked issues, examples, gists, or other supplemental information
+cited.
+
+-   **Summarize the leads issue**: Ensure you provide a high level summary of
+    the _decided_ direction of the leads issue as the proposal.
+-   **Capture and document** every key aspect of the decision made and factor
+    that led to the decision. It is important that the proposal stands alone,
+    and the leads issue is merely cited for context and history.
+-   **Stay grounded**: Only include alternatives, rationale, and arguments based
+    on what you find in the issue and related documents. No new information
+    should be in the proposal.
+
+Use the `gh` command line tool to query leads issues in order to carefully
+examine all of the comments. Follow any mentioned links to gather more data.
+Refer to the [GitHub CLI usage skill](/.agents/skills/github_cli/SKILL.md) for
+detailed instructions on using the `gh` tool.
+
+Ask the user to clarify any aspects of the leads issue that are unclear rather
+than continuing to edit the proposal. If there are questions that you don't find
+an answer to in the issue, ask this to the user and let them provide an answer
+that you use as the basis of what to include.
+
+## Examples are golden
+
+Heavily leverage examples to illustrate both the specifics of the design being
+proposed, and the nature of the change being proposed. More examples to
+illustrate more aspects, corner cases, or provide a more complete understanding
+are almost always good. Comments in example code should focus on what that part
+of the example illustrates from the proposal.
+
+## Keep the PR description in sync with the abstract
+
+Whenever you edit the abstract or notice differences from the PR description,
+you should update the PR description to match the abstract. The only exception
+is to retain any "Assisted-by" or other tags at the end of the description that
+are only needed there and not in the abstract.
+
+If you are creating or updating a proposal, make sure the PR description in
+question contains an `Assisted-by:` tag that is appropriate for describing which
+AI tool is being used.

.agents/skills/review_testdata_changes/SKILL.md

@@ -0,0 +1,366 @@
+---
+name: Review testdata changes
+description:
+    Instructions for judging whether changes to file test output
+    (`// CHECK:STDOUT:` and `// CHECK:STDERR:` lines) are correct, which
+    changes are acceptable churn, and which are regressions in disguise.
+---
+
+# Review testdata changes
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+## Introduction
+
+Most toolchain work moves file test output. `./toolchain/autoupdate_testdata.py`
+rewrites the `// CHECK:STDOUT:` and `// CHECK:STDERR:` lines in
+`toolchain/*/testdata/` to match current behavior, so after running it the tests
+pass again whether or not the new behavior is right. Deciding that the new
+output is the output you wanted is a separate, manual step, and it is the step
+this skill covers.
+
+Three skills divide the work:
+
+-   [Toolchain tests](../toolchain_tests/SKILL.md): how to _author_ tests and
+    generate their output.
+-   This skill: how to _judge_ an output diff.
+-   [Summarize testdata changes](../summarize_testdata_changes/SKILL.md): how to
+    _report_ an output diff once you believe it is correct.
+
+> [!IMPORTANT] Never hand-edit `// CHECK:STDOUT:` or `// CHECK:STDERR:` lines.
+> Everything below is about changing the _code_ until the generated output is
+> right, never about editing the output to match the code.
+
+## The rule that generates all the others
+
+**Every line of testdata churn must have a cause you can name.** Not "it is
+similar to the other changes", not "the tests pass now" — an actual sentence
+saying which code change produced it and why that is the intended result.
+
+A diff you cannot narrate is a diff you have not reviewed. Changes you cannot
+explain are where regressions hide, because a regression and an intended change
+look exactly alike once the autoupdater has written them down.
+
+> [!CAUTION] Autoupdating is destructive to your evidence. Once the autoupdater
+> has run, the previous expectations are gone from the working copy. Read the
+> diff after _every_ autoupdate run, and if something changed for a reason you
+> cannot name, fix the code before autoupdating again. Recovering the old
+> expectations later means reverting and re-running.
+
+## STDERR and STDOUT are different kinds of evidence
+
+Treat them separately; they have different standards of proof.
+
+**STDERR is user-visible behavior.** These are the diagnostics a Carbon
+programmer sees. A change here is a change to the language implementation as
+users experience it, so each one needs an individual justification. For a
+refactoring, the expected STDERR diff is empty.
+
+**STDOUT is internal representation.** SemIR dumps, parse trees, LLVM IR. Users
+never see it. Churn here is normal and often unavoidable, so the standard is not
+"no change" but "no change I cannot account for".
+
+For a change that is supposed to preserve behavior, write the list of accepted
+STDERR changes down _before_ you autoupdate, and keep it current. Order matters
+more than form: written first, the list is a prediction the diff can falsify;
+written afterwards, it is a description of whatever happened, and describes a
+regression exactly as well as an intended change.
+
+The list does not have to be a deliverable. Scratch notes you never publish do
+the job, because the work is in committing to the list, not in presenting it.
+What a reader needs is not the list but its exceptions: diagnostics that changed
+without being predicted, and predictions that did not occur. Both are findings.
+The matches are not, and reporting them buries the two entries that matter.
+
+## Judging STDOUT churn
+
+Sort each STDOUT change into mechanical or structural.
+
+### Mechanical churn
+
+Expected, and cheap to accept in bulk once you have confirmed the pattern:
+
+-   **Renaming.** An instruction, type, or scope prints under a new name.
+-   **Positional name renumbering.** Names like `%x.loc18_46.3` embed a line,
+    column, and disambiguating index. Two different events move them:
+    -   Adding or removing an instruction at a location renumbers the rest, so a
+        _single_ removed instruction can show up as many changed lines in the
+        same block. Confirm the cascade is a cascade before accepting it as one.
+    -   Adding or removing a _diagnostic_ moves the source lines themselves, so
+        the line component changes everywhere below it in the file. See
+        [Autoupdate to a fixed point](#autoupdate-to-a-fixed-point).
+-   **Fingerprint-derived names.** Mangled names and some scope names are
+    derived from a hash of their inputs. If you changed a hashed input, these
+    move. Confirm that each such difference is _only_ the fingerprint, and not a
+    fingerprint difference concealing a structural one.
+
+> [!TIP] Mechanical churn is usually wide and shallow: the same substitution,
+> repeated across many files. If a "mechanical" pattern needs a different
+> explanation in each file, it is not mechanical.
+
+### Structural churn
+
+Each of these needs its own explanation:
+
+-   Instructions appearing or disappearing.
+-   Changed `[concrete = ...]`, `[symbolic = ...]`, or other constant-value
+    annotations.
+-   Changed types on existing instructions.
+-   Changed control flow: new or removed blocks, changed branch targets.
+-   Raw instruction ids renumbering in `--dump-raw-sem-ir` output when you did
+    not intend to change the id layout.
+
+## Fewer instructions is not automatically better
+
+A diff that removes instructions looks like an optimization. Whether it is one
+depends on what the changed function owes its caller, and two functions can
+produce the same shrinking diff for opposite reasons:
+
+-   A function that only needs a constant value, but built instructions on the
+    way to it, was doing wasted work. Dropping them and using the constant
+    directly is correct, and the shorter output reflects that.
+-   A function whose caller needs a **non-canonical instruction** can be made
+    shorter the same way, by using the constant instead of creating an
+    instruction of its own — and that is wrong. The instruction carries location
+    information, and symbolic constant substitution operates on it; the constant
+    value alone loses both.
+
+The instruction count is identical evidence in both cases, so it cannot be the
+thing you judge. Decide what the function is required to produce; the count
+follows from that.
+
+The same reasoning runs in reverse: a diff that _adds_ instructions is not
+automatically a regression.
+
+## Judging STDERR churn
+
+### A diagnostic's authority depends on the file's prefix
+
+The `fail_` and `todo_` prefixes (see
+[Toolchain tests](../toolchain_tests/SKILL.md)) say how much the recorded
+diagnostics are worth:
+
+-   **`fail_...`** — the test should and does produce errors. The recorded
+    diagnostic **is the specification**. Changing it is a user-visible behavior
+    change and needs justification on its own merits.
+-   **`fail_todo_...`** — the test produces errors (or crashes) but shouldn't,
+    or produces the wrong errors. The recorded diagnostic is explicitly **not**
+    the specification; the file exists to record that today's behavior is wrong.
+    Changing it replaces one wrong answer with another. That is acceptable when
+    you can say why the new message follows from your change and why it is no
+    further from the intended eventual behavior — which, for many such files, is
+    no diagnostic at all.
+-   **`todo_fail_...`** — the test should produce errors but does not. Gaining a
+    diagnostic here may be _progress_, not a regression. Either way the file
+    must be renamed, since the framework requires a `fail_` prefix on any file
+    that errors: `fail_...` if it now produces the right error, `fail_todo_...`
+    if the error is the wrong one. Both renames make the test pass, so record
+    which case it is instead of letting the rename settle it.
+-   **`todo_...`** — behavior is wrong but produces no errors, and shouldn't.
+    Gaining a diagnostic here is a regression unless you can argue otherwise.
+
+> [!IMPORTANT] This is a reason to look at the _filename_ before judging a
+> diagnostic change, not a license to ignore `todo_` files. "It was already
+> broken" does not excuse making it differently broken for no reason.
+
+### Reclassifying tests
+
+If your change moves a test between the states above, the prefix must move with
+it: when the test is fixed, when it starts failing, and when it starts failing
+differently. The correspondence between the `fail_` prefix and whether
+compilation actually failed is enforced by the test framework, not by the
+autoupdater, so it surfaces when you run `bazelisk test` and not when you
+autoupdate. **Autoupdating is not a substitute for running the tests.**
+
+Only that half of the name is checked. Nothing enforces `todo_`, so a file whose
+behavior you have just fixed can keep its `todo_` prefix indefinitely and still
+pass. A missing `fail_` stops the build; a stale `todo_` is silent, and is yours
+to catch.
+
+When a fix drops a file's prefix, also check that the file still belongs where
+it is and that its comments do not still describe the old broken behavior.
+
+### Vaguer diagnostics are a signal, not a verdict
+
+When a diagnostic becomes less specific — a general "unsupported" message
+replacing one that named the problem — that usually means a code path stopped
+finding information it previously had. Sometimes that is correct: the
+information was misleading, and the old message was confidently wrong.
+
+Do not accept it silently and do not reject it reflexively. Say which direction
+it moved and whether the new message is closer to or further from the eventual
+intended behavior.
+
+## Signals in the shape of the diff
+
+### Zero churn is a result
+
+If you removed something you believed was doing work and _no_ testdata moved,
+that is not a missing test run — it is the proof that the thing was a no-op.
+Say so explicitly; it is one of the strongest pieces of evidence a refactoring
+can produce.
+
+The converse is also informative. If you expected a path to churn and it didn't,
+either your model of the code is wrong or that path is untested. Find out which,
+and consider adding a test before continuing.
+
+### Churn should be proportional to the change
+
+-   **Wide churn from a narrow change** means your model of the code is wrong.
+    Do not autoupdate over it. Find the structural mistake first.
+-   **Narrow churn from a sweeping change** means the affected paths are
+    probably untested.
+
+Set a rough expectation for the size of the diff before you run the autoupdater,
+and treat a large mismatch in either direction as a finding.
+
+### Never make the diff smaller by weakening the test
+
+Editing test _input_ (the Carbon source, not the CHECK lines) to make a diff
+look better is a behavior change in disguise. Deleting a test that now produces
+awkward output is worse. If a test's input has to change, that is a separate,
+explicitly-justified change, not diff cleanup.
+
+## What the autoupdater will not fix for you
+
+-   **`NOAUTOUPDATE` files.** Their expectations are maintained by hand. They
+    fail under `bazelisk test` rather than being silently rewritten.
+-   **Hand-written C++ expectations**, for example golden output asserted in a
+    `_test.cpp`. When several assertions in one of these break together, often
+    only the first failure is reported, so fixing it can reveal another. Re-run
+    until clean rather than assuming one fix was the whole repair.
+-   **Golden files outside `testdata/`**, and documentation that quotes compiler
+    output.
+
+## Review loop
+
+### Run the autoupdater
+
+Autoupdate everything, then read the diff a directory at a time. Passing no
+paths is the default and updates every file test in the toolchain:
+
+```bash
+./toolchain/autoupdate_testdata.py
+```
+
+Narrow the scope only while iterating on one subdirectory you know you are not
+done with, where each round would otherwise regenerate output you have already
+read:
+
+```bash
+./toolchain/autoupdate_testdata.py toolchain/check/testdata/SUBDIR/**/*
+```
+
+The globs are expanded by the shell; the script filters its arguments to
+`.carbon` files under a `testdata/` directory.
+
+> [!TIP] If intermediate states crash on `CARBON_CHECK` failures, pass
+> `--non-fatal-checks` so you can see the full set of downstream damage in one
+> run instead of one crash at a time.
+
+> [!IMPORTANT] Return to the full scope before judging the diff. Whether churn
+> is proportional to the change, and whether a change to one phase moved another
+> phase's testdata, are only visible across everything.
+
+### Autoupdate to a fixed point
+
+One pass is not always enough, because the autoupdater's output is part of its
+own input. `// CHECK:STDERR:` lines sit inline, immediately above the source
+line they describe, and the compiler reads them as comments in the file.
+Gaining or losing a diagnostic therefore moves every source line below it.
+
+Within a single run, the compiler has already read the file as it was, so the
+two kinds of output end up in different states:
+
+-   **STDERR is correct after one pass.** These lines locate themselves
+    relatively, as `[[@LINE+N]]`, and the autoupdater recomputes `N` as it
+    places them.
+-   **STDOUT is stale after one pass.** SemIR names like `%x.loc18_46.3` embed
+    an absolute line and column with no filename attached, and the autoupdater
+    only remaps `file.carbon:18`-style references. Nothing rewrites the `loc`,
+    so it still describes where the instruction was _before_ the diagnostic
+    lines moved it.
+
+Running again compiles the shifted file and the names catch up. The diagnostic
+set does not change this time, so nothing shifts again and a third run is a
+no-op. Keep running the autoupdater until it stops changing files: one pass when
+the diagnostics held still, two when they didn't.
+
+> [!WARNING] The intermediate state is self-inconsistent, not just unfinished:
+> its `loc` names describe a file layout that no longer exists. Keep reading the
+> diff after every run — that rule does not change — but do not chase positional
+> churn to a cause until the file has converged, and do not present the diff
+> until then either.
+
+The converging pass should be positional renumbering and nothing else. If it
+moves an instruction, a type, or a constant value, then something other than a
+`loc` name is sensitive to where lines fall in the file. Find out what before
+accepting it.
+
+The file tests do catch a file left unconverged, since each test re-runs the
+autoupdate in memory and fails with
+`Autoupdate would make changes to the file content` when the result differs. But
+that arrives at `bazelisk test` time, after you have already read a diff that
+was describing a file which had moved out from under it.
+
+### Inspect the diff
+
+Inspect the diagnostics first, since that is the acceptance criterion:
+
+```bash
+# STDERR-only view, with jj.
+jj --no-pager diff --git 'glob:toolchain/*/testdata/**' \
+  | grep -E '^[-+].*CHECK:STDERR'
+
+# The same, with git.
+git diff -- 'toolchain/*/testdata/*' \
+  | grep -E '^[-+].*CHECK:STDERR'
+```
+
+For a structured view separating test input, STDERR, and STDOUT changes, use the
+helper from the
+[Summarize testdata changes](../summarize_testdata_changes/SKILL.md) skill:
+
+```bash
+jj --no-pager diff --git 'glob:toolchain/*/testdata/**' \
+  | python3 .agents/skills/summarize_testdata_changes/scripts/parse_diff.py
+
+git diff -- 'toolchain/*/testdata/*' \
+  | python3 .agents/skills/summarize_testdata_changes/scripts/parse_diff.py
+```
+
+The argument after the tool name is not interchangeable: `glob:...` is a jj
+fileset, `-- ...` is a git pathspec. `--git` and `--no-pager` are jj flags; git
+already emits this format and skips the pager when piped.
+
+### Run the tests
+
+Then run the tests, which is what catches prefix mismatches and non-autoupdated
+expectations:
+
+```bash
+bazelisk test //toolchain/...
+```
+
+See the [Bazel usage](../bazel/SKILL.md) skill.
+
+## Checklist
+
+Before presenting a testdata diff as finished:
+
+-   [ ] The autoupdater was run until it made no further changes, so no `loc`
+        name describes a stale line numbering.
+-   [ ] The list of accepted STDERR changes was written before autoupdating, and
+        every change either matches it or is reported as an exception.
+-   [ ] Every STDOUT change is either an instance of a named mechanical pattern
+        or has its own explanation.
+-   [ ] Instructions that appeared or disappeared are justified by what the
+        changed function owes its caller, not by the instruction count.
+-   [ ] Files whose prefix no longer matches their behavior have been renamed.
+-   [ ] No test input was changed, and no test was deleted, to make the diff
+        smaller.
+-   [ ] The size of the diff is proportional to the size of the change.

.agents/skills/summarize_testdata_changes/SKILL.md

@@ -0,0 +1,209 @@
+---
+name: Summarize testdata changes
+description:
+    Instructions for summarizing changes to Carbon testdata files
+    (`toolchain/*/testdata`).
+---
+
+# Summarize testdata changes
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+This skill provides instructions for creating a comprehensive report summarizing
+changes to Carbon testdata files (`toolchain/*/testdata`) and associating them
+with related code changes.
+
+This skill is about _reporting_ a diff. For deciding whether the diff is correct
+in the first place, see the
+[Review testdata changes](../review_testdata_changes/SKILL.md) skill.
+
+## Goals
+
+Produce a report that:
+
+1.  Summarizes code changes outside of testdata.
+2.  Groups similar testdata changes together, listing all affected files for
+    each group. **Every change to testdata must be represented by at least one
+    group. This includes changes to CHECK lines.**
+3.  Provides detailed breakdowns of test input changes and diagnostic output
+    changes in the corresponding group. **Every single change to inputs or to
+    STDERR checks must be explicitly mentioned in the group, with either an
+    inline diff or a link to the file.**
+
+## Process
+
+### 1. Identify Changes
+
+Use your VCS (Git or Jujutsu) or query Github to identify changes. For large
+changes, it is recommended to use the included helper script to extract test
+input changes.
+
+#### For Git Users:
+
+-   **Summarize code changes**: `git diff --stat -- ':!toolchain/*/testdata/*'`
+    -   To see content of non-testdata changes:
+        `git diff -- ':!toolchain/*/testdata/*'`
+-   **Identify testdata changes**:
+    `git diff --name-only 'toolchain/*/testdata/*'`
+
+#### For Jujutsu (jj) Users:
+
+-   **Summarize code changes**:
+    `jj --no-pager diff --stat '~toolchain/*/testdata'`
+    -   Note: Quoting the fileset `'~toolchain/*/testdata'` is critical if it
+        contains wildcards.
+    -   To see content of non-testdata changes, use `--git` to get standard
+        unified diff format: `jj --no-pager diff --git '~toolchain/*/testdata'`
+-   **Identify testdata changes**:
+    `jj --no-pager diff --name-only 'toolchain/*/testdata'`
+
+#### For Github Pull Requests:
+
+-   **Summarize code changes**: `gh pr diff`
+-   **Identify testdata changes**:
+    `gh pr diff --name-only | grep '^toolchain/.*/testdata'`
+
+#### Handling Specific Revisions:
+
+If you are summarizing changes in a specific revision (for example, `@-`) or
+pull request (for example, #1234), add `-r <rev>` or `<pr_number>` to the
+commands:
+
+-   `git diff <rev>^ <rev> ...` (or use `git show <rev>`)
+-   `jj --no-pager diff -r <rev> ...`
+-   `gh pr diff <pr_number>`
+
+### 2. Extract Test Input Changes (Recommended)
+
+To easily identify changes, use the included Python helper script to extract all
+text additions and removals from the diff, categorized by Input, STDERR, and
+STDOUT changes. This script reads a unified diff from stdin.
+
+```bash
+# For Git:
+git diff -- 'toolchain/*/testdata/*' | python3 .agents/skills/summarize_testdata_changes/scripts/parse_diff.py
+
+# For Jujutsu (jj):
+jj diff --git 'toolchain/*/testdata' | python3 .agents/skills/summarize_testdata_changes/scripts/parse_diff.py
+
+# For a specific revision with jj:
+jj diff -r @- --git 'toolchain/*/testdata' | python3 .agents/skills/summarize_testdata_changes/scripts/parse_diff.py
+
+# For a specific PR with Github:
+gh pr diff 1234 | python3 .agents/skills/summarize_testdata_changes/scripts/parse_diff.py
+```
+
+### 3. Identify Patterns and Produce a List of Groups
+
+-   Read the diff and produce a list of groups of changes that share a common
+    theme or cause (for example, "Updated expected output for integer literals",
+    "Added tests for new keyword").
+-   **CRITICAL**: _Every single change_ in the testdata diff must be represented
+    by at least one group. Do not ignore changes to `CHECK` lines.
+    -   If it's not clear what group a change belongs to, create a new group for
+        it.
+-   For each group:
+    -   Provide a brief description of the group.
+    -   (Optional) Briefly note if the group appears to be an intended or
+        unintended consequence of the code changes.
+-   Divide the groups into sections:
+    -   Test Changes: Changes to test inputs (lines not prefixed with
+        `// CHECK`), along with diagnostic output changes where relevant
+    -   Diagnostic Changes: Changes to diagnostic output (lines prefixed with
+        `// CHECK:STDERR`) with no corresponding changes to test inputs
+    -   [Output Type] Changes: Changes to STDOUT (lines prefixed with `//
+        CHECK:STDOUT`)
+        -   Create one section for each relevant kind of test. For example,
+            parser tests should typically be in a "Parse Tree Changes" section,
+            check tests should typically be in a "SemIR Changes" section, and
+            lower tests should typically be in an "LLVM IR Changes" section.
+
+### 4. Improve Grouping
+
+-   Read the list of groups and check to see if any of them should be combined
+    or split apart. If needed, do so.
+
+### 5. Assign Changes to Groups
+
+-   Read the diff again, and then for _each_ change in the diff:
+    -   Add the change to the appropriate group (or, rarely, groups).
+    -   **CRITICAL**: _Every single change_ in the testdata diff must be
+        represented by at least one group. Do not ignore changes to `CHECK`
+        lines.
+    -   If the change affects _test inputs_ (lines not prefixed with `// CHECK`)
+        or _diagnostic output_ (lines prefixed with `// CHECK:STDERR`):
+        -   List the file within the group. Don't just give one or a few
+            examples. Include every file.
+        -   Provide an inline diff if the change is small.
+        -   Provide a link to the file if the change is large.
+    -   Otherwise, if the change only affects _STDOUT_ (lines prefixed with
+        `// CHECK:STDOUT`):
+        -   Ensure the group contains a representative example that matches the
+            current change.
+        -   The representative example should be an inline diff of the change.
+    -   **CRITICAL**: _Every single change_ to test inputs and diagnostic
+        outputs in the files being summarized must be explicitly listed in at
+        least one group. Do not skip changes, even if they are similar to
+        changes you've already seen, and do not just give examples.
+
+### 6. Validation
+
+As a final validation step:
+
+-   Read through the testdata diff again.
+-   Ensure that every change in the diff is reflected by at least one group in
+    the report.
+
+## Report Template
+
+Use the following template for the generated report:
+
+```markdown
+# `testdata` Change Summary
+
+## Code Changes
+
+[One paragraph summarizing changes outside of testdata.]
+
+## Test Changes
+
+### [Group Name]
+
+[Description of the group.]
+
+[Change 1: diff context OR link]
+
+[Change 2: diff context OR link]
+
+...
+
+## Diagnostic Changes
+
+### [Group Name]
+
+[Description of the group.]
+
+[Change 1: diff context OR link]
+
+[Change 2: diff context OR link]
+
+...
+
+## [Output Type] Changes
+
+### [File Path]
+
+[Description of the group.]
+
+[Example diff context]
+
+Changes of this kind were found in [Number] files. Examples: [List of files]
+
+...
+```
+
+Skip sections that would be empty.

.agents/skills/summarize_testdata_changes/scripts/parse_diff.py

@@ -0,0 +1,65 @@
+__copyright__ = """
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""
+
+import sys
+from collections import defaultdict
+from typing import Dict, List, TextIO
+
+
+def parse_diff(stream: TextIO) -> None:
+    current_file: str = ""
+    file_changes: Dict[str, Dict[str, List[str]]] = defaultdict(
+        lambda: {"input": [], "stderr": [], "stdout": []}
+    )
+
+    for line in stream:
+        if line.startswith("diff --git"):
+            parts = line.split()
+            if len(parts) >= 4:
+                current_file = (
+                    parts[3][2:] if parts[3].startswith("b/") else parts[3]
+                )
+        elif line.startswith("+") or line.startswith("-"):
+            if not line.startswith("+++") and not line.startswith("---"):
+                stripped = line[1:].strip()
+                if stripped.startswith("// CHECK:STDERR"):
+                    file_changes[current_file]["stderr"].append(
+                        line.rstrip("\n")
+                    )
+                elif stripped.startswith("// CHECK:STDOUT"):
+                    file_changes[current_file]["stdout"].append(
+                        line.rstrip("\n")
+                    )
+                elif stripped.startswith("// CHECK"):
+                    file_changes[current_file]["stdout"].append(
+                        line.rstrip("\n")
+                    )
+                else:
+                    file_changes[current_file]["input"].append(
+                        line.rstrip("\n")
+                    )
+
+    for f, c in file_changes.items():
+        if not c["input"] and not c["stderr"] and not c["stdout"]:
+            continue
+        print(f"File: {f}")
+        if c["input"]:
+            print("  --- Input Changes ---")
+            for change in c["input"]:
+                print(f"  {change}")
+        if c["stderr"]:
+            print("  --- STDERR Changes ---")
+            for change in c["stderr"]:
+                print(f"  {change}")
+        if c["stdout"]:
+            print("  --- STDOUT Changes ---")
+            for change in c["stdout"]:
+                print(f"  {change}")
+        print("-" * 40)
+
+
+if __name__ == "__main__":
+    parse_diff(sys.stdin)

.agents/skills/toolchain_development/SKILL.md

@@ -0,0 +1,169 @@
+---
+name: Toolchain development
+description:
+    Instructions for checking, building, debugging, and understanding the Carbon
+    toolchain.
+---
+
+# Toolchain development
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+## Toolchain structure
+
+-   Under [`toolchain/`](/toolchain/):
+    -   [`base/`](/toolchain/base/): Base infrastructure and common utilities.
+    -   [`check/`](/toolchain/check/): Semantic analysis (SemIR generation).
+    -   [`lex/`](/toolchain/lex/): Lexing (Source -> Tokens).
+    -   [`lower/`](/toolchain/lower/): Lowering to LLVM IR.
+    -   [`parse/`](/toolchain/parse/): Parsing (Token -> Parse Tree).
+    -   [`sem_ir/`](/toolchain/sem_ir/): Semantic Intermediate Representation
+        (SemIR) definitions.
+
+## Toolchain architecture
+
+-   **Documentation**: Refer to [`toolchain/docs`](/toolchain/docs) for detailed
+    architecture design and patterns.
+    -   Refer to [Toolchain Idioms](/toolchain/docs/idioms.md) for a
+        comprehensive list of patterns (for example, `ValueStore`, formatting
+        `.def` files, struct reflection) used throughout the implementation.
+-   **Builtin Functions**: Refer to the **Builtin functions** skill
+    ([SKILL.md](../builtins/SKILL.md)) for guidelines on registering, mapping,
+    constant evaluating, and lowering compiler builtin primitives (e.g.
+    `"int.convert_float"`).
+-   **Language server**: Refer to the **Language server** skill
+    ([SKILL.md](../language_server/SKILL.md)) before working on
+    `toolchain/language_server/` or `utils/vscode/`. Neither follows the
+    patterns described here.
+-   **Phases**: Lex -> Parse -> Check -> Lower.
+-   **Definitions**: Many kinds (tokens, parse nodes, SemIR instructions) are
+    defined in `.def` files and expanded by way of macros.
+-   **Handlers**:
+    -   Parser: `Handle<StateName>` in `parse/handle_*.cpp`.
+    -   Checker: `HandleParseNode` in `check/handle_*.cpp`.
+    -   Lowering: `HandleInst` in `lower/handle_*.cpp`.
+-   **Iteration**: Prefer iterative algorithms over recursive ones to prevent
+    stack exhaustion on complex codebases.
+
+### Essential commands
+
+-   **Test everything**: `bazelisk test //...`
+-   **Test specific target**: `bazelisk test //toolchain/testing:file_test`
+-   **Test specific file**: `bazelisk test //toolchain/testing:file_test
+    --test_arg=--file_tests=<path_to_carbon_file>`
+-   **Build toolchain**: `bazelisk build //toolchain/...`
+
+### Updating test data
+
+Carbon tests often use `file_test` (for example,
+`//toolchain/testing/file_test`). For detailed guidelines on authoring tests,
+including file splits, naming conventions (`fail_`, `todo_`), and generating
+minimal output with SemIR dumps, please refer to the **Toolchain tests** skill.
+
+If you change compiler behavior, you likely need to update expected test
+outputs. **Do not manually edit thousands of lines of expected output.** Use the
+script:
+
+```bash
+./toolchain/autoupdate_testdata.py
+# Or for a specific file:
+./toolchain/autoupdate_testdata.py toolchain/check/testdata/my_test.carbon
+```
+
+## Debugging and diagnostics
+
+-   **Compiler Diagnostics**: Refer to the **Diagnostics** skill
+    ([SKILL.md](../diagnostics/SKILL.md)) for strict rules on declaring,
+    formatting, emitting, testing, and styling compiler diagnostic messages
+    (errors, warnings, notes).
+-   **Printing to stderr**: Use `llvm::errs() << "debug info\n";`.
+    -   Avoid `std::cout` (it may interfere with tool output).
+-   **SemIR Stringification**:
+    -   SemIR objects often have a `Print` method or `operator<<`.
+    -   `inst.Print(llvm::errs())`
+-   **Debugging Crashes**:
+    -   Bazel sandboxing can hide artifacts. Use `--sandbox_debug` if needed,
+        but often running the binary directly from `bazel-bin/` is easier for
+        debugging.
+
+## Error handling
+
+-   **No exceptions**: Do not use C++ exceptions.
+-   **`ErrorOr<T>`**: Return `ErrorOr<T>` for fallible operations.
+    -   Check with `if (auto result = Function(); result) { Use(*result); }`
+-   **`llvm::Expected<T>`**: Similar to `ErrorOr`, used when interfacing with
+    LLVM.
+
+### Context-Aware Diagnostics
+
+When declaring and emitting errors, ensure semantic wording matches the exact
+context:
+
+-   **Semantic Precision**: Do not reference "types" when raising errors for
+    unsized expressions like `IntLiteral` or `FloatLiteral`. For example, use
+    `RealLiteralTooLargeForUnsizedInt` instead of a diagnostic referencing an
+    "integer type".
+-   **Wording Consistency**: Before declaring a new diagnostic in
+    [kind.def](../../../toolchain/diagnostics/kind.def), search for existing
+    diagnostics in the targeted implementation files (for example, other uses of
+    `MaxIntWidth`) to align message structures and parameter expectations.
+
+### Casting (LLVM style)
+
+-   Use `llvm::cast<T>(obj)` (checked, asserts on failure).
+-   Use `llvm::dyn_cast<T>(obj)` (returns null on failure).
+-   Use `llvm::isa<T>(obj)` (boolean check).
+-   **Avoid** `dynamic_cast` and standard RTTI.
+
+### Leverage LLVM APIs
+
+Before implementing custom algorithms for mathematical, logical, or bitwise
+operations, inspect target LLVM ADT class APIs:
+
+-   **Builtin APIs**: Verify if LLVM classes (such as `APInt`, `APFloat`, or
+    `APSInt`) already offer native equivalents (for example, `.pow()`,
+    `ilogb()`, `.changeSign()`, `convertFromAPInt()`). Avoid duplicate, naive,
+    or inefficient custom loops.
+
+### Data structures
+
+-   Prefer APIs in `common/` and `toolchain/base/` over LLVM ADTs. For example,
+    use `Map` instead of `llvm::DenseMap`.
+-   If no Carbon API exists, prefer LLVM ADTs over standard library ones (for
+    example `llvm::SmallVector`, `llvm::StringRef`).
+-   `StringRef` is a view; be careful with lifetimes.
+
+## Common pitfalls
+
+1.  **Legacy `explorer` references**: The `explorer` prototype has been moved.
+    Ignore references to it in proposals or old docs; focus on `toolchain`.
+2.  **Manually updating test files**: Always check if `autoupdate_testdata.py`
+    can do it for you.
+3.  **Using `std::string` unnecessarily**: Prefer `llvm::StringRef` for
+    arguments.
+4.  **Header includes**: Use specific include orders (often enforced by
+    `clang-format`).
+5.  **Parse node order**: Semantics processes parse nodes in post-order; ensure
+    your parser transitions support this.
+6.  **Builtin implementation gaps**: If adding a primitive builtin function,
+    make sure you address all phases of the lifecycle: macro definition
+    registration, signature validation, compile-time constant evaluation
+    (interpreter), LLVM IR lowering, and prelude modular implementation bindings
+    (avoiding orphan rules). Refer to the **Builtin functions** skill
+    ([SKILL.md](../builtins/SKILL.md)) for details.
+7.  **Premature helper abstraction**: Avoid extracting tiny helper functions
+    that are called from exactly one place and do not significantly modularize
+    complex code. Prefer inlining directly to keep the implementation compact,
+    readable, and localized.
+8.  **Redundant bounds calculations**: Avoid repeating calculations of complex
+    boundary estimations (such as lower and upper bound estimations). Refactor
+    the logic to calculate unified values once, preserving compactness.
+9.  **Trusting stale `clangd` diagnostics**: In-editor diagnostics are only as
+    good as `compile_commands.json`. If it predates a newly added file, `clangd`
+    falls back to a default command and reports nonsense, such as missing
+    standard headers or "no member named `None`". Regenerate it with
+    `./scripts/create_compdb.py`, which only takes a few seconds.

.agents/skills/toolchain_tests/SKILL.md

@@ -0,0 +1,193 @@
+---
+name: Toolchain tests
+description:
+    Instructions for authoring, structuring, and running toolchain tests using
+    the file_test infrastructure.
+---
+
+# Toolchain tests
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+## Introduction
+
+This skill provides guidelines and patterns for creating and updating tests for
+the Carbon toolchain, especially file tests in `toolchain/*/testdata/` (for
+example, `toolchain/check/testdata/`).
+
+Toolchain tests evaluate Carbon source files through Lexing, Parsing, Checking,
+and optionally Lowering. Output (for example SemIR dumps, Clang errors) is
+captured and validated using inline CHECK records.
+
+Language server tests also use `file_test`, but with quite different
+conventions (an LSP message stream, `AUTOUPDATE-SPLIT`, `FROM_FILE_SPLIT`).
+Refer to the **Language server** skill
+([SKILL.md](../language_server/SKILL.md)) for those.
+
+## Structure and Authoring
+
+### File Layout and Headers
+
+Test files must start with the standard Carbon license, followed by
+configuration comments. Separate sections with blank comment lines (`//`).
+
+```carbon
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// INCLUDE-FILE: toolchain/testing/testdata/min_prelude/...
+//
+// AUTOUPDATE
+```
+
+-   `// AUTOUPDATE` is mandatory for files using CHECK markers.
+-   `// TIP:` lines are automatically generated by the autoupdater. You do not
+    need to hand-write them. It is harmless to add them, but the script will
+    handle it.
+
+### Minimized Preludes
+
+When writing tests entirely unrelated to the Core package, specify a minimal
+prelude file using `// INCLUDE-FILE`. Usually, include
+`toolchain/testing/testdata/min_prelude/` scripts, such as `int.carbon` or
+`primitives.carbon`. This significantly speeds up execution and minimizes STDOUT
+noise.
+
+-   **Builtin Primitive Testing**: Standard operators (such as `+`, `-`, `/`,
+    `<`, etc.) are **not** imported or available inside minimized preludes. To
+    write tests with a minimal prelude footprint, call primitive builtins
+    directly (e.g., `float.negate`, `float.div`) inside your test code to build
+    expressions.
+
+### Split Tests and `[[@TEST_NAME]]`
+
+A single physical file can test multiple scenarios using split constraints:
+
+```carbon
+// --- passing_case.carbon
+library "[[@TEST_NAME]]";
+
+// ...
+
+// --- fail_bad_case.carbon
+library "[[@TEST_NAME]]";
+// ...
+```
+
+-   **Always** use `library "[[@TEST_NAME]]";` in each split rather than
+    hardcoding the library name. This prevents name conflicts, avoids redefining
+    the default library, and keeps the test code clean and templateable.
+-   Exactly `[[@TEST_NAME]]` (including the brackets) must be used. The test
+    infrastructure automatically replaces it with the split's filename minus
+    `todo_` and `fail_` prefixes.
+-   **Do not put code that is expected to pass and code that is expected to fail
+    into the same split.** Validation relies on non-failing splits producing
+    absolutely no errors and failing splits producing the correct compiler
+    errors independently.
+
+### File Prefixing: `fail_` and `todo_`
+
+Expected failures must be differentiated from unexpected failures (and from
+bugs). Include prefixes to name individual split files or the main test:
+
+-   `fail_...`: The test should and does produce compiler errors.
+-   `todo_fail_...`: The test should produce errors but currently does not.
+-   `fail_todo_...`: The test does produce errors or crashes, but it shouldn't
+    (or produces the wrong errors or otherwise misbehaves with errors).
+-   `todo_...`: The test has some incorrect behavior, but doesn't produce errors
+    currently, and shouldn't.
+
+**Main File Naming**: The main test file (and any split-files) must have a
+`fail_` prefix if they have an associated error. **Exception**: The main file
+may omit `fail_` if it contains a least one split that has a `fail_` prefix.
+
+Both the `fail_` and `todo_` prefixes are stripped from filename properties like
+`[[@TEST_NAME]]`.
+
+### Constant Evaluation Validation
+
+When testing constant evaluation in semantic checker tests, follow these
+conventions to ensure diagnostic stability and accuracy:
+
+-   **Literal Spelling Canonicalization**: In Semantic IR, real literals
+    (floating-point constants) with identical mathematical values can be
+    assigned distinct internal representation identifiers based on spelling
+    variations in source code. To completely prevent literal spelling mismatches
+    in expected output checks, validation tests must be performed using
+    canonical comparison methods (for example, passing converted values through
+    an `Expect(X as f64)` function).
+-   **Generic Parameters Validation**: To bypass compile-time constraints where
+    local runtime variables are rejected as generic function arguments, test
+    generic type conversions at runtime, and validate compile-time conversions
+    by passing static literal values directly into primitive builtin calls.
+-   **Exhaustive Edge Case Verification**: For complex mathematical algorithms
+    (such as floating-point to integer truncation and rounding), map and execute
+    test constraints covering every code branch, conditional exit, and fallback
+    evaluation path.
+-   **Rounding Threshold Boundaries**: Test cases that land extremely close to
+    mathematical boundaries (for example, floating-point literals representing a
+    tiny fraction above 1.0, such as $2^{30} \times 2^{-30}$ or
+    $10^{10} \times 10^{-10}$, verifying correct exact truncation down to 1 or
+    0).
+-   **Precise Float Literal Spelling**: Spell floating-point literals in test
+    code with exact mathematical precision targeting target thresholds. For
+    example, if testing the smallest fractional increment above 1.0, use the
+    exact hex fractional representation (e.g. `0x1.0000000000001p0`) or a highly
+    precise decimal fractional spelling (e.g. `1.0000000000000001`) instead of
+    coarse fractions like `1.1` to ensure correct boundary assertions.
+-   **Representation Capacity Boundaries**: Explicitly target edge cases near
+    representation limits of target types. Test combinations of mantissas and
+    exponents that yield values exactly on, just below, or just above the
+    capacity limits of fixed-size destination types (e.g. signed/unsigned
+    targets like `i32` or `u32`).
+-   **Zero-Value Sizing Bounds**: Verify boundary inputs of `0` and `0.0`
+    explicitly. Assert that zero inputs are sized and simplified correctly
+    without triggering calculation underflows, division-by-zero errors, or
+    underestimating required bit allocations.
+
+### Test Code Comments
+
+-   **No agent thinking:** Do not include comments describing your reasoning or
+    "train of thought" (for example, "Wait, but...") inside the test files. Any
+    comments left in tests should be concise and describe what the test _itself_
+    is validating for human readers.
+
+## SemIR Dumps and Minimizing Output
+
+Limit STDOUT checks to the logic under test. Always use `//@dump-sem-ir-begin`
+and `//@dump-sem-ir-end` around the specific declarations/blocks where SemIR
+output is desired. Only use these markers and **not**
+`--dump-sem-ir-ranges=if-present` or similar extra args—new tests use
+`//@dump-sem-ir...` to naturally filter output to the highlighted segments based
+on the default behavior.
+
+```carbon
+//@dump-sem-ir-begin
+fn F(x:? form(ref i32));
+//@dump-sem-ir-end
+```
+
+## Creating/Updating the Output
+
+AI tools should **never** hand-write or manually touch `// CHECK:STDOUT:` or
+`// CHECK:STDERR:` comments.
+
+Write your Carbon test code, headers, and `// AUTOUPDATE` then run the test
+updater:
+
+```bash
+./toolchain/autoupdate_testdata.py toolchain/PATH/TO/YOUR/TEST.carbon
+```
+
+Review the updated test outputs (for example, by way of `git diff`). Ensure
+logic paths are correctly tested rather than producing massive boilerplate
+blocks.
+
+Autoupdating makes the tests pass whether or not the new behavior is correct, so
+deciding that the new output is the output you wanted is a separate step. See
+the [Review testdata changes](../review_testdata_changes/SKILL.md) skill.

.bazelignore

@@ -8,5 +8,5 @@ bazel-carbon-lang
 # See github_tools/MODULE.bazel.
 github_tools
 
-# Used as part of repo patching.
-third_party/boost_unordered
+# Example Bazel project.
+examples/bazel

.bazelrc

@@ -2,12 +2,15 @@
 # Exceptions. See /LICENSE for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-# Ensure all builds have Carbon's workspace status attached. We have carefully
-# factored the stamping done by this to avoid excessive build performance impact
-# and so enable stamping with it by default. CI and systems especially dependent
-# on caching should explicitly use `--nostamp`.
+# Setup stamping with Carbon's workspace status attached but disable it by
+# default.
+#
+# Note that while we have minimized the impact of stamping on build caching, it
+# still has a meaningful impact, especially during development. So we disable
+# stamping by default and builds that need to include the workspace status
+# should explicitly enable it with `--stamp`.
 common --workspace_status_command=./scripts/workspace_status.py
-common --stamp
+common --nostamp
 
 # Provide aliases for configuring the release and pre-release version being
 # built. For documentation of these flags, see //bazel/version/BUILD.
@@ -42,7 +45,11 @@ build --use_target_config_carbon_rules
 # Default to using a disk cache to minimize re-building LLVM and Clang which we
 # try to avoid updating too frequently to minimize rebuild cost. The location
 # here can be overridden in the user configuration where needed.
-common --disk_cache=~/.cache/carbon-lang-build-cache
+#
+# We avoid the disk cache on MacOS because it breaks debugging. When the cache
+# is used, the separate debug symbol files are not perserved.
+common:linux --disk_cache=~/.cache/carbon-lang-build-cache
+common:windows --disk_cache=~/.cache/carbon-lang-build-cache
 # If you'd like a different disk cache size, override it by copying this
 # line to `user.bazelrc` in the repository root and modify the number there.
 common --experimental_disk_cache_gc_max_size=100G
@@ -82,12 +89,12 @@ common --define=absl=1
 # Enable TCMalloc on Linux in optimized builds.
 common --custom_malloc=//bazel/malloc:tcmalloc_if_linux_opt
 
-# Configuration for enabling Address Sanitizer. Note that this is enabled by
-# default for fastbuild. The config is provided to enable ASan even in
-# optimized or other build configurations. Note that ASan and TCMalloc are
+# Configuration for enabling Address Sanitizer. Note that ASan and TCMalloc are
 # incompatible so this explicitly forces the system malloc.
 common:asan --features=asan
 common:asan --custom_malloc=@bazel_tools//tools/cpp:malloc
+# Also double the test timeouts for ASan to improve their consistency.
+test:asan --test_timeout=120,600,1800,-1
 
 # Configuration for enabling LibFuzzer (along with ASan).
 common:fuzzer --features=fuzzer
@@ -118,6 +125,11 @@ common:linux --define=pfm=1
 # Disables `actions.declare_symlink`. Done for cross-environment support.
 common --allow_unresolved_symlinks=false
 
+# Removes the leading `/proc/self/cwd/` from file paths in the debug info. Some
+# tools like VS Code don't understand `/proc/self/cwd` in places like terminal
+# stack dumps, but do understand paths relative to the workspace root.
+common --copt=-fdebug-prefix-map=/proc/self/cwd=
+
 # Allow users to override any of the flags desired by importing a user-specific
 # RC file here if present.
 try-import %workspace%/user.bazelrc
@@ -168,7 +180,6 @@ common --incompatible_disallow_empty_glob
 common --incompatible_disallow_legacy_py_provider
 common --incompatible_disallow_sdk_frameworks_attributes
 common --incompatible_disallow_struct_provider_syntax
-common --incompatible_do_not_split_linking_cmdline
 common --incompatible_dont_enable_host_nonhost_crosstool_features
 common --incompatible_dont_use_javasourceinfoprovider
 common --incompatible_enable_apple_toolchain_resolution

.bazelversion

@@ -1 +1 @@
-8.3.1
+8.6.0

.clang-format

@@ -11,13 +11,24 @@ DerivePointerAlignment: 'false'
 ExperimentalAutoDetectBinPacking: 'false'
 FixNamespaceComments: 'true'
 InsertBraces: 'true'
+InsertTrailingCommas: None
 PointerAlignment: Left
 # We abuse control macros for formatting other kinds of macros.
 SpaceBeforeParens: ControlStatementsExceptControlMacros
 IfMacros:
   [
     'CARBON_DEFINE_RAW_ENUM_CLASS',
-    'CARBON_DEFINE_RAW_ENUM_CLASS_NO_NAMES',
+    'CARBON_DEFINE_ENUM_CLASS_NAMES',
+    'CARBON_DEFINE_RAW_ENUM_MASK',
+    'CARBON_DEFINE_ENUM_MASK_NAMES',
     'CARBON_KIND_SWITCH',
   ]
 StatementMacros: ['ABSTRACT']
+QualifierAlignment: Custom
+QualifierOrder:
+  [inline, static, friend, constexpr, const, volatile, restrict, type]
+Macros:
+  # These macros can contain variable declarations, so clang-format needs to
+  # "see through" them in order to format them correctly.
+  - CARBON_ASSIGN_OR_RETURN(x)=x
+  - CARBON_KIND(x)=x

.clang-tidy

@@ -22,6 +22,7 @@ Checks:
   - '-misc-const-correctness'
   - '-misc-include-cleaner'
   - '-misc-use-anonymous-namespace'
+  - '-modernize-deprecated-headers'
   - '-modernize-return-braced-init-list'
   - '-modernize-use-default-member-init'
   - '-modernize-use-integer-sign-comparison'
@@ -34,22 +35,48 @@ Checks:
   - '-readability-make-member-function-const'
   - '-readability-math-missing-parentheses'
   - '-readability-static-definition-in-anonymous-namespace'
+  - '-readability-trailing-comma'
   - '-readability-use-anyofallof'
 
+  # These are copies of older google- prefixed rules that have been moved
+  # out of that prefix, but the google- prefix names still exist as aliases to
+  # these. We enable the google- prefix rules and use those in our NOLINT
+  # expressions, so we disable the newer aliased rules.
+  #
+  # Alias for google-explicit-constructor.
+  - '-misc-explicit-constructor'
+  # Alias for google-readability-casting.
+  - '-modernize-avoid-c-style-cast'
+
   # Warns when we have multiple empty cases in switches, which we do for comment
   # reasons.
   - '-bugprone-branch-clone'
+  # We use CRTP inheritence widely and across distant areas of the codebase,
+  # which makes maintaining friend lists for the constructors frustrating.
+  - '-bugprone-crtp-constructor-accessibility'
+  # We shadow methods with CRTP, instead of using virtual, such as for Print().
+  - '-bugprone-derived-method-shadowing-base-method'
   # Frequently warns on multiple parameters of the same type.
   - '-bugprone-easily-swappable-parameters'
   # Finds issues like out-of-memory in main(). We don't use exceptions, so it's
   # unlikely to find real issues.
   - '-bugprone-exception-escape'
+  # We have File class types in different namespaces and we forward declare it,
+  # but don't find this to be problematic.
+  - '-bugprone-forward-declaration-namespace'
+  # Doesn't respect `[[clang::enum_extensibility(open)]]`.
+  - '-bugprone-invalid-enum-default-initialization'
   # Has false positives in places such as using an argument to declare a name,
   # which cannot have parentheses. For our limited use of macros, this is a
   # common conflict.
   - '-bugprone-macro-parentheses'
   # Conflicts with integer type C++ style.
   - '-bugprone-narrowing-conversions'
+  # We return const references from value stores.
+  - '-bugprone-return-const-ref-from-parameter'
+  # Complains about reasonable code like `1 << 20` and would push us away from
+  # our integer type C++ style rules.
+  - '-bugprone-signed-bitwise'
   # Has false positives for `enum_base.h`. Clang's built-in switch warnings
   # cover most of our risk of bugs here.
   - '-bugprone-switch-missing-default-case'
@@ -66,6 +93,8 @@ Checks:
   # Extremely slow. TODO: Re-enable once
   # https://github.com/llvm/llvm-project/issues/128797 is fixed.
   - '-misc-confusable-identifiers'
+  # We use multiple inheritence without virtual extensively.
+  - '-misc-multiple-inheritance'
   # Overlaps with `-Wno-missing-prototypes`.
   - '-misc-use-internal-linkage'
   # Suggests `std::array`, which we could migrate to, but conflicts with the
@@ -88,13 +117,32 @@ Checks:
   - '-readability-enum-initial-value'
   # Warns too frequently.
   - '-readability-function-cognitive-complexity'
+  # Allows naming styles we don't use, and has errors on our use of `_1`, `_2`
+  # to have multiple unnamed vars in a destructuring declaration.
+  - '-readability-identifier-naming'
+  # Warns on use of CARBON_KIND() and can't use NOLINT effectively inside a
+  # macro.
+  - '-readability-inconsistent-ifelse-braces'
   # Warns in reasonably documented situations.
   - '-readability-magic-numbers'
   # Warns on `= {}` which is also used to indicate which fields do not need to
   # be explicitly initialized in aggregate initialization.
   - '-readability-redundant-member-init'
+  # We generally do want to collapse if statements, and ask for it in review.
+  # But this check ignores when ifs are nested to place comments above/below
+  # the nested if block. And when the outer if block is also initializing a
+  # variable. There are more than a handful of cases where we want to do this,
+  # especially working with LLVM apis like dyn_cast.
+  - '-readability-redundant-nested-if'
+  # Broken, wants to remove parens from `*(p + 1)` and `("Foo" + s).str()`.
+  # TODO: Re-enable once https://github.com/llvm/llvm-project/issues/192435 and
+  # related bugs are fixed.
+  - '-readability-redundant-parentheses'
   # Warns when callers use similar names as different parameters.
   - '-readability-suspicious-call-argument'
+  # Low value check, and it's a stylistic choice to use `#if defined(...)` when
+  # paired with `#elif defined(...)`.
+  - '-readability-use-concise-preprocessor-directives'
 
 CheckOptions:
   # Don't warn on structs; done by ignoring when there are only public members.
@@ -110,6 +158,10 @@ CheckOptions:
     value: CamelCase
   - key: readability-identifier-naming.NamespaceCase
     value: CamelCase
+  # Headers re-open LLVM and Clang namespaces to forward-declare their types,
+  # which is much cheaper to compile than including their headers.
+  - key: readability-identifier-naming.NamespaceIgnoredRegexp
+    value: '^(clang|llvm)$'
   - key: readability-identifier-naming.StructCase
     value: CamelCase
   - key: readability-identifier-naming.TemplateParameterCase
@@ -142,3 +194,12 @@ CheckOptions:
   # Don't require writing a return type on lambdas.
   - key: modernize-use-trailing-return-type.TransformLambdas
     value: none
+
+  # Use lines rather than statements to measure function size, because
+  # for readability purposes we care about the code as written, before
+  # preprocessing.
+  - key: readability-function-size.StatementThreshold
+    value: none
+  - key: readability-function-size.LineThreshold
+    # Chose 800 to match the default for StatementThreshold.
+    value: 800

.clangd

@@ -6,9 +6,11 @@ CompileFlags:
   # Workaround for https://github.com/clangd/clangd/issues/1582
   Remove: [-march=*]
 Diagnostics:
-  # `unused-includes`: has false positives, reporting includes unused when
-  #   they are used.
-  Suppress: [unused-includes]
+  # `unneeded-internal-declaration`, `unused-function`, `unused-includes`,
+  # `unused-template`: These all have false positives due to not performing
+  # template instantiation. We get a more reliable version of these warnings
+  # from the compiler.
+  Suppress: [unneeded-internal-declaration, unused-function, unused-includes, unused-template]
 
 ---
 
@@ -19,3 +21,12 @@ Diagnostics:
   Suppress:
     # The `#error` requiring a macro definition.
     - pp_hash_error
+
+---
+
+# Suppress diagnostics for template source files.
+If:
+  PathMatch: .*\.tpl\.h
+Diagnostics:
+  Suppress:
+    - undeclared_var_use

.codespell_ignore

@@ -2,6 +2,8 @@
 # Exceptions. See /LICENSE for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+AggregateT
+AnyOther
 ArchType
 atleast
 circularly
@@ -16,6 +18,7 @@ groupt
 indext
 inout
 isELF
+iterm
 parameteras
 pullrequest
 rightt

.github/actions/build-setup-common/action.yml

@@ -11,13 +11,12 @@ inputs:
 runs:
   using: composite
   steps:
-    # Setup Python and related tools.
-    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d # v5.1.0
+    # Setup Python and related tools with uv.
+    - name: Set up uv and Python
+      uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
       with:
-        # Match the min version listed in docs/project/contribution_tools.md
-        # or the oldest version available on the OS.
-        python-version:
-          ${{ inputs.matrix_runner == 'macos-14' && '3.11' || '3.9' }}
+        enable-cache: true
+        version: '0.11.15'
 
     - uses: ./.github/actions/build-setup-macos
       if: startsWith(inputs.matrix_runner, 'macos')
@@ -38,9 +37,10 @@ runs:
         bazelisk --version
         echo '*** run_bazel.py'
         ./scripts/run_bazel.py --version
-        echo '*** python'
-        which python
-        python --version
+        echo '*** uv'
+        which uv
+        uv --version
+        uv python list --only-installed
         echo '*** clang'
         which clang
         clang --version
@@ -70,6 +70,13 @@ runs:
         build --remote_cache=https://storage.googleapis.com/carbon-builds-github-v${CACHE_VERSION}
         build --remote_download_outputs=minimal
 
+        # Allow passing targets that are incompatible so that our explicit
+        # target lists work more like //... wild card patterns in CI. In CI,
+        # we're using explicit target lists to prune to a minimal set of
+        # dependencies, and so skipping incompatible targets is the expected
+        # behavior.
+        build --skip_incompatible_explicit_targets
+
         # We import a special key into every action in order to key the Bazel
         # remote cache in a way that avoids collisions between different
         # runners. Anything that might change the system external to Bazel but

.github/actions/build-setup-macos/action.yml

@@ -23,12 +23,12 @@ runs:
           xcrun simctl delete all
         sudo rm -rf ~/Library/Developer/CoreSimulator/Caches/*
 
-    # Install and cache LLVM 19 from Homebrew. Some runners may have LLVM 19,
+    # Install and cache LLVM 21 from Homebrew. Some runners may have LLVM 21,
     # but this is reliable (including with libc++), and gives us testing at the
     # minimum supported LLVM version.
     - name: Cache Homebrew
       id: cache-homebrew-macos
-      uses: actions/cache@1bd1e32a3bdc45362d1e726936510720a7c30a57 # v4.2.0
+      uses: actions/cache@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
       with:
         # Cover all the critical parts of Homebrew here. Homebrew on Arm macOS
         # uses its own prefix making this easy to cover, but we need a few
@@ -46,7 +46,7 @@ runs:
           }}
         # Note the key needs to include all the packages we're adding.
         key:
-          Homebrew-Cache-${{ inputs.matrix_runner }}-${{ runner.arch }}-llvm@19
+          Homebrew-Cache-${{ inputs.matrix_runner }}-${{ runner.arch }}-llvm@21
 
     - name: Install LLVM and Clang with Homebrew
       if: steps.cache-homebrew-macos.outputs.cache-hit != 'true'
@@ -60,11 +60,11 @@ runs:
         LEAVES=$(brew leaves | egrep -v '^(bazelisk|gh|git|git-lfs|gnu-tar|go@.*|jq|pipx|node@.*|openssl@.*|wget|yq|zlib)$')
         brew uninstall -f --ignore-dependencies $LEAVES
         echo '*** Installing LLVM deps'
-        brew install --force-bottle --only-dependencies llvm@19
+        brew install --force-bottle --only-dependencies llvm@21
         echo '*** Installing LLVM itself'
-        brew install --force-bottle --force --verbose llvm@19
-        echo '*** brew info llvm@19'
-        brew info llvm@19
+        brew install --force-bottle --force --verbose llvm@21
+        echo '*** brew info llvm@21'
+        brew info llvm@21
         echo '*** brew autoremove'
         brew autoremove
         echo '*** brew info'
@@ -77,7 +77,7 @@ runs:
     - name: Setup LLVM and Clang
       shell: bash
       run: |
-        LLVM_PATH="$(brew --prefix llvm@19)"
+        LLVM_PATH="$(brew --prefix llvm@21)"
         echo "Using ${LLVM_PATH}"
         echo "${LLVM_PATH}/bin" >> $GITHUB_PATH
         echo '*** ls "${LLVM_PATH}"'

.github/actions/build-setup-ubuntu/action.yml

@@ -22,23 +22,34 @@ runs:
         # to save time.
         large-packages: false
 
+    # Select the LLVM release - by the cache key and the download.
+    - name: Select LLVM release
+      shell: bash
+      run: |
+        if [[ "${{ runner.arch }}" == "ARM64" ]]; then
+          echo "LLVM_RELEASE=21.1.8" >> "$GITHUB_ENV"
+        else
+          echo "LLVM_RELEASE=21.1.8" >> "$GITHUB_ENV"
+        fi
+
     # Cache and install a recent version of LLVM. This uses the GitHub action
     # cache to avoid directly downloading on each iteration and improve
     # reliability.
     - name: Cache LLVM and Clang installation
       id: cache-llvm-ubuntu
-      uses: actions/cache@1bd1e32a3bdc45362d1e726936510720a7c30a57 # v4.2.0
+      uses: actions/cache@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
       with:
         path: ~/llvm
-        key: LLVM-19.1.7-Cache-ubuntu-${{ runner.arch }}
+        key: LLVM-${{ env.LLVM_RELEASE }}-Cache-ubuntu-${{ runner.arch }}
 
     - name: Download LLVM and Clang installation
       if: steps.cache-llvm-ubuntu.outputs.cache-hit != 'true'
       shell: bash
       run: |
         cd ~
-        LLVM_RELEASE=19.1.7
-        LLVM_TARBALL_NAME=LLVM-$LLVM_RELEASE-Linux-X64
+        # `LLVM_RELEASE` comes from the "Select LLVM release" step; `runner.arch`
+        # (`X64`/`ARM64`) matches the package's arch suffix.
+        LLVM_TARBALL_NAME=LLVM-$LLVM_RELEASE-Linux-${{ runner.arch }}
         LLVM_PATH=~/llvm
         echo "*** Downloading $LLVM_RELEASE"
         wget --show-progress=off "https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_RELEASE/$LLVM_TARBALL_NAME.tar.xz"
@@ -50,10 +61,12 @@ runs:
         echo "*** Testing `clang++ --version`"
         $LLVM_PATH/bin/clang++ --version
         # The installation contains *huge* parts of LLVM we don't need for the
-        # toolchain. Prune them here to keep our cache small.
+        # toolchain. Prune them here to keep our cache small. x86-64 and
+        # AArch64 use different LLVM releases whose tool sets differ, so `-f`
+        # ignores entries that are absent from a given package.
         echo "*** Cleaning the 'llvm' directory"
-        rm $LLVM_PATH/lib/{*.a,*.so,*.so.*}
-        rm $LLVM_PATH/bin/{flang-*,mlir-*,clang-{scan-deps,check,repl},*-test,llvm-{lto*,reduce,bolt*,exegesis,jitlink},bugpoint,opt,llc}
+        rm -f $LLVM_PATH/lib/{*.a,*.so,*.so.*}
+        rm -f $LLVM_PATH/bin/{flang-*,mlir-*,clang-{scan-deps,check,repl},*-test,llvm-{lto*,reduce,bolt*,exegesis,jitlink},bugpoint,opt,llc}
         echo "*** Size of the 'llvm' directory"
         du -hs $LLVM_PATH
 

.github/workflows/README.md

@@ -18,7 +18,8 @@ the "Harden Runner" steps are
 Most jobs only have a few endpoints, but due to tools which do downloads, a few
 have significantly more. These are:
 
--   pre_commit.yaml (Bazel, pre-commit)
+-   clangd_tidy.yaml (Bazel)
+-   prek.yaml (Bazel, prek)
 -   nightly_release.yaml (Bazel)
 -   tests.yaml (Bazel)
 

.github/workflows/auto_assign_prs.yaml

@@ -1,63 +0,0 @@
-# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
-# Exceptions. See /LICENSE for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-name: 'Auto assign PRs'
-on:
-  pull_request_target:
-    types: [opened, ready_for_review]
-
-permissions:
-  pull-requests: write # For gh to edit assignees.
-
-jobs:
-  assign_reviewer:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Harden Runner
-        uses: step-security/harden-runner@17d0e2bd7d51742c71671bd19fa12bdc9d40a3d6 # v2.8.1
-        with:
-          disable-sudo: true
-          egress-policy: block
-          # prettier-ignore
-          allowed-endpoints: >
-            api.github.com:443
-
-      - id: filter
-        uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
-        with:
-          filters: |
-            leads:
-              - '*.md'
-              - 'LICENSE'
-              - 'docs/project/principles/*'
-              - 'docs/project/evolution.md'
-              - 'docs/project/goals.md'
-              - 'docs/project/roadmap.md'
-              - 'proposals/*.md'
-            toolchain:
-              - 'toolchain/**'
-
-      - id: assign-leads
-        if: steps.filter.outputs.leads == 'true'
-        uses: hkusu/review-assign-action@5bee595fdb9765d4a0bd35724b6302fa15569158 # v1.4.0
-        with:
-          reviewers: KateGregory, chandlerc, zygoloid
-          max-num-of-reviewers: 1
-
-      - id: assign-toolchain
-        if: steps.filter.outputs.toolchain == 'true'
-        uses: hkusu/review-assign-action@5bee595fdb9765d4a0bd35724b6302fa15569158 # v1.4.0
-        with:
-          reviewers:
-            chandlerc, danakj, dwblaikie, geoffromer, jonmeow, josh11b, zygoloid
-          max-num-of-reviewers: 1
-
-      - id: assign-fallback
-        if: |
-          steps.filter.outputs.leads != 'true' &&
-          steps.filter.outputs.toolchain != 'true'
-        uses: hkusu/review-assign-action@5bee595fdb9765d4a0bd35724b6302fa15569158 # v1.4.0
-        with:
-          reviewers: chandlerc, danakj, jonmeow, josh11b, zygoloid
-          max-num-of-reviewers: 1

.github/workflows/auto_label_prs.yaml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@17d0e2bd7d51742c71671bd19fa12bdc9d40a3d6 # v2.8.1
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
           disable-sudo: true
           egress-policy: block

.github/workflows/check_dependent_pr.yaml

@@ -0,0 +1,56 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+name: 'Check Dependent PRs'
+on:
+  pull_request_target:
+    types: [opened, synchronize, ready_for_review, closed]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+  pull-requests: write
+  statuses: write
+
+jobs:
+  check_dependent_prs:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            api.github.com:443 github.com:443 pypi.org:443
+            files.pythonhosted.org:443 raw.githubusercontent.com:443
+            releases.astral.sh:443
+
+      # Note: pull_request_target checks out the base branch by default.
+      # This is safe as it avoids running untrusted code from the PR branch.
+      - name: Checkout code
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        with:
+          enable-cache: true
+          version: '0.11.15'
+
+      - name: Check Dependent PR
+        run: |
+          if [ "$EVENT_ACTION" = "closed" ]; then
+            ./github_tools/check_dependent_pr.py --scan
+          else
+            ./github_tools/check_dependent_pr.py --pr-number "${PR_NUMBER}"
+          fi
+        env:
+          GITHUB_ACCESS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          EVENT_ACTION: ${{ github.event.action }}

.github/workflows/clang_tidy.yaml

@@ -1,80 +0,0 @@
-# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
-# Exceptions. See /LICENSE for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-name: 'Clang Tidy'
-
-on:
-  push:
-    branches: [trunk, action-test]
-  pull_request:
-  merge_group:
-
-permissions:
-  contents: read # For actions/checkout.
-  pull-requests: read # For dorny/paths-filter to read pull requests.
-
-# Cancel previous workflows on the PR when there are multiple fast commits.
-# https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#concurrency
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  clang-tidy:
-    runs-on: ubuntu-22.04
-
-    steps:
-      - name: Harden Runner
-        uses: step-security/harden-runner@17d0e2bd7d51742c71671bd19fa12bdc9d40a3d6 # v2.8.1
-        with:
-          egress-policy: block
-          # When adding endpoints, see README.md.
-          # prettier-ignore
-          allowed-endpoints: >
-            *.dl.sourceforge.net:443
-            api.github.com:443
-            bcr.bazel.build:443
-            downloads.sourceforge.net:443
-            github.com:443
-            mirrors.kernel.org:443
-            nodejs.org:443
-            oauth2.googleapis.com:443
-            objects.githubusercontent.com:443
-            pypi.org:443
-            releases.bazel.build:443
-            sourceforge.net:443
-            storage.googleapis.com:443
-
-      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-
-      - id: test-setup
-        uses: ./.github/actions/test-setup
-        with:
-          matrix_runner: 'ubuntu-22.04'
-          base_sha:
-            ${{ github.event_name == 'pull_request' &&
-            github.event.pull_request.base.sha ||
-            github.event.merge_group.base_sha }}
-          remote_cache_key: ${{ secrets.CARBON_BUILDS_GITHUB }}
-          targets_file: ${{ runner.temp }}/targets
-          use_direct_targets: true
-
-      # Run in the clang-tidy config. This is done as part of tests so that we
-      # aren't duplicating bazel/llvm setup.
-      #
-      # The `-k` flag is used to print all clang-tidy errors.
-      - name: clang-tidy
-        if: steps.test-setup.outputs.has_code == 'true'
-        env:
-          TARGETS_FILE: ${{ runner.temp }}/targets
-        run: |
-          ./scripts/run_bazel.py \
-              --attempts=5 \
-              build --config=clang-tidy -k \
-              --target_pattern_file=$TARGETS_FILE
-
-      # See "Disk space before build" in `test-setup`.
-      - name: Disk space after build
-        if: steps.test-setup.outputs.has_code == 'true'
-        run: df -h

.github/workflows/clangd_tidy.yaml

@@ -8,8 +8,7 @@ on:
   push:
     branches: [trunk, action-test]
   pull_request:
-  # TODO: Don't run in merge_group until we're ready to replace clang-tidy.
-  # merge_group:
+  merge_group:
 
 permissions:
   contents: read # For actions/checkout.
@@ -27,34 +26,49 @@ jobs:
 
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@17d0e2bd7d51742c71671bd19fa12bdc9d40a3d6 # v2.8.1
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
           egress-policy: block
           # When adding endpoints, see README.md.
           # prettier-ignore
           allowed-endpoints: >
-            *.dl.sourceforge.net:443
+            *.blob.storage.azure.net:443
+            *.githubapp.com:443
+            *.sourceforge.net:443
             api.github.com:443
+            api.ipify.org:443
             bcr.bazel.build:443
             downloads.sourceforge.net:443
+            files.pythonhosted.org:443
             github.com:443
+            go.dev:443
+            mirror.bazel.build:443
             mirrors.kernel.org:443
             nodejs.org:443
             oauth2.googleapis.com:443
             objects.githubusercontent.com:443
             pypi.org:443
+            raw.githubusercontent.com:443
+            registry.npmjs.org:443
+            release-assets.githubusercontent.com:443
+            releases.astral.sh:443
             releases.bazel.build:443
-            sourceforge.net:443
             storage.googleapis.com:443
+            uploads.github.com:443
+            www.googleapis.com:443
 
-      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - id: filter
         uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
         with:
+          predicate-quantifier: 'every'
           filters: |
             has_cpp:
               - added|modified: '{**/*.cpp,**/*.h}'
+              - '!**/*.tpl.h'
           list-files: 'shell'
 
       - uses: ./.github/actions/build-setup-common
@@ -67,13 +81,9 @@ jobs:
         if: steps.filter.outputs.has_cpp == 'true'
         run: ./scripts/create_compdb.py
 
-      - name: Install clangd-tidy
-        if: steps.filter.outputs.has_cpp == 'true'
-        run: pip install clangd-tidy==1.1.0.post2
-
       - name: Run clangd-tidy
         if: steps.filter.outputs.has_cpp == 'true'
         env:
           FILTER_FILES: ${{ steps.filter.outputs.has_cpp_files }}
         run: |
-          clangd-tidy -p . -j 10 $FILTER_FILES
+          uvx --with clangd-tidy==1.1.0.post2 clangd-tidy -p . -j 10 $FILTER_FILES

.github/workflows/discord_wiki.yaml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@17d0e2bd7d51742c71671bd19fa12bdc9d40a3d6 # v2.8.1
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
           egress-policy: audit
 

.github/workflows/gh_pages_ci.yaml

@@ -22,16 +22,25 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@5c7944e73c4c2a096b17a9cb74d65b6c2bbafbde # v2.9.1
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
           egress-policy: audit
 
       - name: Checkout
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        with:
+          enable-cache: true
+          version: '0.11.15'
+
       - name: Prebuild actions
         run: ./website/prebuild.py
       - name: Setup Ruby
-        uses: ruby/setup-ruby@a6e6f86333f0a2523ece813039b8b4be04560854 # v1.190.0
+        uses: ruby/setup-ruby@6ca151fd1bfcfd6fe0c4eb6837eb0584d0134a0c # v1.290.0
         with:
           # Runs 'bundle install' and caches installed gems automatically.
           bundler-cache: true

.github/workflows/gh_pages_deploy.yaml

@@ -18,29 +18,36 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.ref }}
   cancel-in-progress: true
 
-# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages.
-permissions:
-  contents: read
-  pages: write
-  id-token: write
+permissions: {}
 
 jobs:
   build:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@5c7944e73c4c2a096b17a9cb74d65b6c2bbafbde # v2.9.1
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
           egress-policy: audit
 
       - name: Checkout
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        with:
+          enable-cache: true
+          version: '0.11.15'
+
       - name: Prebuild actions
         run: ./website/prebuild.py
       - name: Setup Pages
         uses: actions/configure-pages@983d7736d9b0ae728b81ab479565c72886d7745b # v5.0.0
       - name: Setup Ruby
-        uses: ruby/setup-ruby@a6e6f86333f0a2523ece813039b8b4be04560854 # v1.190.0
+        uses: ruby/setup-ruby@6ca151fd1bfcfd6fe0c4eb6837eb0584d0134a0c # v1.290.0
         with:
           # Runs 'bundle install' and caches installed gems automatically.
           bundler-cache: true
@@ -49,15 +56,16 @@ jobs:
       - name: Build with Jekyll
         env:
           JEKYLL_ENV: production
+          STEPS_PAGES_OUTPUTS_BASE_PATH: ${{ steps.pages.outputs.base_path }}
         run: |
           bundle exec jekyll build --verbose \
             --source ./ \
             --destination ./_site \
-            --baseurl "${{ steps.pages.outputs.base_path }}"
+            --baseurl "${STEPS_PAGES_OUTPUTS_BASE_PATH}"
       - name: Upload artifact
         # Automatically uploads an artifact from the './_site' directory by
         # default.
-        uses: actions/upload-pages-artifact@56afc609e74202658d3ffba0e8f6dda462b719fa # v3.0.1
+        uses: actions/upload-pages-artifact@7b1f4a764d45c48632c6b24a0339c27f5614fb0b # v4.0.0
 
   deploy:
     environment:
@@ -65,9 +73,13 @@ jobs:
       url: ${{ steps.deployment.outputs.page_url }}
     runs-on: ubuntu-latest
     needs: build
+    # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages.
+    permissions:
+      pages: write
+      id-token: write
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@5c7944e73c4c2a096b17a9cb74d65b6c2bbafbde # v2.9.1
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
           egress-policy: audit
 

.github/workflows/nightly_release.yaml

@@ -37,26 +37,40 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@17d0e2bd7d51742c71671bd19fa12bdc9d40a3d6 # v2.8.1
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
           egress-policy: block
           # When adding endpoints, see README.md.
           # prettier-ignore
           allowed-endpoints: >
-            *.dl.sourceforge.net:443
+            *.blob.storage.azure.net:443
+            *.githubapp.com:443
+            *.sourceforge.net:443
             api.github.com:443
+            api.ipify.org:443
             bcr.bazel.build:443
             downloads.sourceforge.net:443
+            files.pythonhosted.org:443
             github.com:443
+            go.dev:443
+            mirror.bazel.build:443
+            mirrors.kernel.org:443
+            nodejs.org:443
             oauth2.googleapis.com:443
             objects.githubusercontent.com:443
+            pypi.org:443
+            raw.githubusercontent.com:443
+            registry.npmjs.org:443
+            release-assets.githubusercontent.com:443
             releases.bazel.build:443
-            sourceforge.net:443
             storage.googleapis.com:443
             uploads.github.com:443
+            www.googleapis.com:443
 
       - name: Checkout branch
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - name: Set up remote cache access
         env:
@@ -79,10 +93,10 @@ jobs:
         run: |
           ./scripts/run_bazel.py \
             --attempts=5 --jobs-on-last-attempt=4 \
-            test -c opt --remote_download_toplevel \
-            --pre_release=nightly --nightly_date=${{ env.nightly_date }} \
+            test -c opt --stamp --remote_download_toplevel \
+            --pre_release=nightly --nightly_date=${nightly_date} \
             //toolchain \
-            //toolchain/install:carbon_toolchain_tar_gz_rule \
+            //toolchain/install:carbon_toolchain_tar_gz \
             //toolchain/install:carbon_toolchain_tar_gz_test
 
       - name: Extract the release version
@@ -101,8 +115,8 @@ jobs:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           gh release create \
-            --title "Nightly build ${{ env.nightly_date }}" \
+            --title "Nightly build ${nightly_date}" \
             --generate-notes \
             --prerelease \
-            v${{ env.release_version }} \
-            "bazel-bin/toolchain/install/carbon_toolchain-${{ env.release_version }}.tar.gz"
+            v${release_version} \
+            "bazel-bin/toolchain/install/carbon_toolchain-${release_version}.tar.gz"

.github/workflows/prek.yaml

@@ -2,7 +2,7 @@
 # Exceptions. See /LICENSE for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-name: pre-commit
+name: prek
 
 on:
   pull_request:
@@ -14,34 +14,44 @@ permissions:
   contents: read # For actions/checkout.
 
 jobs:
-  pre-commit:
+  prek:
     runs-on: ubuntu-22.04
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@17d0e2bd7d51742c71671bd19fa12bdc9d40a3d6 # v2.8.1
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
-          disable-sudo-and-containers: true
           egress-policy: block
           # When adding endpoints, see README.md.
           # prettier-ignore
           allowed-endpoints: >
-            *.dl.sourceforge.net:443
+            *.blob.storage.azure.net:443
+            *.githubapp.com:443
+            *.sourceforge.net:443
             api.github.com:443
+            api.ipify.org:443
             bcr.bazel.build:443
             downloads.sourceforge.net:443
             files.pythonhosted.org:443
             github.com:443
+            go.dev:443
             mirror.bazel.build:443
+            mirrors.kernel.org:443
             nodejs.org:443
+            oauth2.googleapis.com:443
             objects.githubusercontent.com:443
             pypi.org:443
+            raw.githubusercontent.com:443
             registry.npmjs.org:443
+            release-assets.githubusercontent.com:443
+            releases.astral.sh:443
             releases.bazel.build:443
             storage.googleapis.com:443
-            sourceforge.net:443
+            uploads.github.com:443
+            www.googleapis.com:443
 
-      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d # v5.1.0
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       # Ensure LLVM is set up consistently.
       - uses: ./.github/actions/build-setup-common
@@ -49,22 +59,22 @@ jobs:
           matrix_runner: ubuntu-22.04
           remote_cache_upload: '--remote_upload_local_results=false'
 
-      - uses: pre-commit/action@2c7b3805fd2a0fd8c1884dcaebf91fc102a13ecd # v3.0.1
+      - uses: j178/prek-action@01345c78b7de7d79edf368729212760396ba9345 # v2
 
-      # We want to automatically create github suggestions for pre-commit file
+      # We want to automatically create github suggestions for prek file
       # changes for a pull request. But `pull_request` actions never have write
       # permissions to the repository, so we create the suggestions in a separate
-      # privileged `workflow_run` action in pre_commit_suggestions.yaml. Here,
+      # privileged `workflow_run` action in prek_suggestions.yaml. Here,
       # we upload the diffs and event configuration to an artifact for use by
       # that action.
-      - name: Collect pre-commit output
+      - name: Collect prek output
         if: failure()
         run: |
-          mkdir -p pre-commit-output
-          git diff > pre-commit-output/diff
-          cp $GITHUB_EVENT_PATH pre-commit-output/event
-      - uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # v4.3.1
+          mkdir -p prek-output
+          git diff > prek-output/diff
+          cp $GITHUB_EVENT_PATH prek-output/event
+      - uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         if: failure()
         with:
-          name: pre-commit output
-          path: pre-commit-output/*
+          name: prek output
+          path: prek-output/*

.github/workflows/prek_suggestions.yaml

@@ -2,11 +2,11 @@
 # Exceptions. See /LICENSE for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-# Create PR suggestions based on problems found by pre-commit action.
-name: 'Add pre-commit suggestions'
+# Create PR suggestions based on problems found by prek action.
+name: 'Add prek suggestions'
 
-# This action is run whenever the `pre-commit` action finishes. Because the
-# `pre-commit` action is an unprivileged action running on (for example) the
+# This action is run whenever the `prek` action finishes. Because the
+# `prek` action is an unprivileged action running on (for example) the
 # `pull_request` event, it's run without write permissions to the repository, so
 # we use a separate privileged `workflow_run` action here to pick up its results
 # and convert them into suggestion comments.
@@ -15,7 +15,7 @@ name: 'Add pre-commit suggestions'
 # this file will not take effect until they are merged to trunk.
 on:
   workflow_run:
-    workflows: [pre-commit]
+    workflows: [prek]
     types:
       - completed
 
@@ -25,15 +25,14 @@ permissions:
 
 jobs:
   pull-request-suggestions:
-    # Only generate suggestions if pre-commit for a PR failed.
+    # Only generate suggestions if prek for a PR failed.
     if: |
       github.event.workflow_run.conclusion == 'failure' &&
-      github.event.workflow_run.event == 'pull_request' &&
-      github.actor != 'jonmeow'
+      github.event.workflow_run.event == 'pull_request'
     runs-on: ubuntu-latest
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@17d0e2bd7d51742c71671bd19fa12bdc9d40a3d6 # v2.8.1
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
           disable-sudo: true
           egress-policy: block
@@ -48,17 +47,19 @@ jobs:
         with:
           reviewdog_version: latest
 
-      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-
-      - name: Download pre-commit output
-        uses: actions/download-artifact@c850b930e6ba138125429b7e5c93fc707a7f8427 # v4.1.4
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
-          name: pre-commit output
+          persist-credentials: false
+
+      - name: Download prek output
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+        with:
+          name: prek output
           github-token: ${{ secrets.GITHUB_TOKEN }}
           run-id: ${{ github.event.workflow_run.id }}
 
       # Use https://github.com/reviewdog/reviewdog to create PR suggestions
-      # matching the diff that pre-commit created.
+      # matching the diff that prek created.
       - name: Create suggestions
         env:
           REVIEWDOG_GITHUB_API_TOKEN:

.github/workflows/proposal_labeled.yaml

@@ -31,7 +31,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@17d0e2bd7d51742c71671bd19fa12bdc9d40a3d6 # v2.8.1
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
           disable-sudo: true
           egress-policy: block

.github/workflows/proposal_ready.yaml

@@ -23,7 +23,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@17d0e2bd7d51742c71671bd19fa12bdc9d40a3d6 # v2.8.1
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
           disable-sudo: true
           egress-policy: block

.github/workflows/sync_repos.yaml

@@ -25,13 +25,15 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@17d0e2bd7d51742c71671bd19fa12bdc9d40a3d6 # v2.8.1
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
           egress-policy: audit
 
       # Checkout our main repository.
       - name: Checkout the main repository
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       # Run the sync script.
       - name: Sync to other repositories

.github/workflows/tests.yaml

@@ -22,36 +22,67 @@ concurrency:
 
 jobs:
   test:
+    name:
+      Testing ${{ matrix.config.name != 'Default' && format('({0})',
+      matrix.config.name) || '' }} (${{ matrix.runner }})
     strategy:
       matrix:
-        # Test a recent version of each supported OS.
-        runner: ['ubuntu-22.04', 'macos-14']
-        build_mode: [fastbuild, opt]
+        # Test a recent version of each supported OS, covering both x86-64 and
+        # AArch64: Linux on x86-64 and AArch64, and macOS on AArch64.
+        runner: ['ubuntu-22.04', 'ubuntu-22.04-arm', 'macos-14']
+        # Create a synthetic matrix dimension with the event name for filtering.
+        event: ['${{ github.event_name }}']
+        config:
+          - name: 'Default'
+            flags: ''
+          - name: 'Opt'
+            flags: '-c opt'
+          - name: 'ASan'
+            flags: '--config=asan'
+        exclude:
+          - runner: 'macos-14'
+            config: { name: 'ASan', flags: '--config=asan' }
+          - event: 'pull_request'
+            config: { name: 'ASan', flags: '--config=asan' }
+          - event: 'merge_group'
+            config: { name: 'ASan', flags: '--config=asan' }
     runs-on: ${{ matrix.runner }}
-
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@17d0e2bd7d51742c71671bd19fa12bdc9d40a3d6 # v2.8.1
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
           egress-policy: block
           # When adding endpoints, see README.md.
           # prettier-ignore
           allowed-endpoints: >
-            *.dl.sourceforge.net:443
+            *.blob.storage.azure.net:443
+            *.githubapp.com:443
+            *.sourceforge.net:443
             api.github.com:443
+            api.ipify.org:443
             bcr.bazel.build:443
             downloads.sourceforge.net:443
+            files.pythonhosted.org:443
             github.com:443
+            go.dev:443
+            mirror.bazel.build:443
             mirrors.kernel.org:443
             nodejs.org:443
             oauth2.googleapis.com:443
             objects.githubusercontent.com:443
             pypi.org:443
+            raw.githubusercontent.com:443
+            registry.npmjs.org:443
+            release-assets.githubusercontent.com:443
+            releases.astral.sh:443
             releases.bazel.build:443
-            sourceforge.net:443
             storage.googleapis.com:443
+            uploads.github.com:443
+            www.googleapis.com:443
 
-      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - id: test-setup
         uses: ./.github/actions/test-setup
@@ -65,7 +96,7 @@ jobs:
           targets_file: ${{ runner.temp }}/targets
 
       # Build and run just the tests impacted by the PR or merge group.
-      - name: Test (${{ matrix.build_mode }})
+      - name: Test (${{ matrix.config.name }})
         if: steps.test-setup.outputs.has_code == 'true'
         shell: bash
         env:
@@ -76,10 +107,11 @@ jobs:
         run: |
           # Decrease the jobs sharply if we see repeated failures to try to
           # work around transient network errors even if it makes things
-          # slower.
+          # slower. Note that we allow passing targets that are incompatible and
+          # skip thim as-if we were using `//...` style wild card patterns.
           ./scripts/run_bazel.py \
             --attempts=5 --jobs-on-last-attempt=4 \
-            test -c ${{ matrix.build_mode }} \
+            test ${{ matrix.config.flags }} \
             --target_pattern_file=$TARGETS_FILE
 
       # See "Disk space before build" in `test-setup`.

.github/workflows/triage_inactive.yaml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@17d0e2bd7d51742c71671bd19fa12bdc9d40a3d6 # v2.8.1
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
           disable-sudo: true
           egress-policy: block

.gitignore

@@ -9,7 +9,13 @@
 /github_tools/bazel-*
 /github_tools/MODULE.bazel.lock
 
-# Directories created by python.
+# We also have example Bazel projects that shouldn't have their implementation
+# details committed.
+/examples/**/bazel-*
+/examples/**/MODULE.bazel.lock
+
+# Files and directories created by python.
+uv.lock
 **/__pycache__/
 
 # Ignore the user's VSCode settings and debug setup.
@@ -34,6 +40,7 @@
 
 # vim temporary files
 .*.sw[a-p]
+.swp
 
 # generated by utils/tree_sitter/helix.sh
 /.helix/
@@ -43,3 +50,10 @@
 
 # Ignore the .gdb_history that's created next to the project-specific .gdbinit
 .gdb_history
+
+# Generated by scripts/create_compdb.py
+/external
+
+# Linux perftools output
+perf.data
+perf.data.old

.pre-commit-config.yaml

@@ -11,8 +11,7 @@ default_language_version:
   python: python3 # Defaults to python2, so override it.
 
 repos:
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: cef0300fd0fc4d2a87a85fa2093c6b283ea36f4b # frozen: v5.0.0
+  - repo: builtin
     hooks:
       - id: check-added-large-files
       - id: check-case-conflict
@@ -29,11 +28,34 @@ repos:
         exclude: '^(.*/fuzzer_corpus/.*|.*\.svg)$'
       - id: trailing-whitespace
         exclude: '^(.*/fuzzer_corpus/.*|.*/testdata/.*\.golden|.*\.svg)$'
+
+  # Run markdown linting early so that doc style and table-of-contents see the
+  # linted state.
+  - repo: https://github.com/rvben/rumdl-pre-commit
+    rev: v0.2.58
+    hooks:
+      - id: rumdl
+        args: [--fix]
+
   - repo: https://github.com/google/pre-commit-tool-hooks
     rev: efaea7c61c774c0b1a9805fd999e754a2d19dbd1 # frozen: v1.2.5
     hooks:
       - id: check-google-doc-style
+        exclude: |
+          (?x)^(
+            .*\.agents/.*|
+            .*AGENTS.md
+          )$
       - id: markdown-toc
+
+  # Re-run markdown linting to fix any issues caused by doc style and TOC. This
+  # is very fast, so it shouldn't be problematic to run twice.
+  - repo: https://github.com/rvben/rumdl-pre-commit
+    rev: v0.2.58
+    hooks:
+      - id: rumdl
+        args: [--fix]
+
   - repo: local
     hooks:
       - id: fix-cc-deps
@@ -44,10 +66,29 @@ repos:
         pass_filenames: false
 
   # Formatters should be run late so that they can re-format any prior changes.
-  - repo: https://github.com/psf/black
-    rev: 8a737e727ac5ab2f1d4cf5876720ed276dc8dc4b # frozen: 25.1.0
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: 0c7b6c989466a93942def1f84baf36ddfcd60c83 # frozen: v0.15.14
     hooks:
-      - id: black
+      - id: ruff-check
+        args: [--fix]
+      - id: ruff-format
+
+  - repo: local
+    hooks:
+      - id: ty
+        name: ty
+        entry: ty check --no-progress
+        language: python
+        additional_dependencies:
+          - ty==0.0.46
+          - rich
+          - 'gql>=2.0.0,<3.0.0'
+          - PyGitHub
+          - types-requests
+          - requests
+        types: [python]
+        pass_filenames: false
+
   - repo: local
     hooks:
       - id: prettier
@@ -56,7 +97,7 @@ repos:
         # TODO: Not upgrading to/past 3.4.0 due to list indent changes that may
         # get fixed. See: https://github.com/prettier/prettier/issues/16929
         additional_dependencies: ['prettier@3.3.3']
-        types_or: [html, javascript, json, markdown, yaml]
+        types_or: [html, javascript, json, yaml]
         entry: npx prettier@3.3.3 --write --log-level=warn
   - repo: local
     hooks:
@@ -64,7 +105,7 @@ repos:
         name: Bazel buildifier
         entry: scripts/run_buildifier.py
         # Beyond just formatting, explicitly fix lint warnings.
-        args: ['--lint=fix', '--warnings=all', '-r', '.']
+        args: ['--lint=fix', '--warnings=all']
         language: python
         files: |
           (?x)^(
@@ -90,7 +131,7 @@ repos:
         types_or: [c++, def]
         language: python
         args: ['-i']
-        additional_dependencies: ['clang-format==20.1.8']
+        additional_dependencies: ['clang-format==21.1.8']
 
   - repo: local
     hooks:
@@ -107,6 +148,23 @@ repos:
         entry: scripts/check_sha_filenames.py
         language: python
         files: ^.*/fuzzer_corpus/.*$
+      - id: check-proposal-names
+        name: Check proposal names
+        entry: proposals/scripts/check_proposal_names.py
+        language: python
+        files: ^proposals/p.*\.md$
+        # This edits files other than the ones passed to it, so we need each
+        # chunk of files to be run through the script serially.
+        require_serial: true
+        # This also renames files, invalidating the list of files provided to
+        # subsequent checks so we fail-fast if this makes changes.
+        fail_fast: true
+      - id: build-textmate-grammar
+        name: Build TextMate grammar
+        entry: scripts/update_tm_language.py
+        language: system
+        files: ^utils/vscode/carbon\.tmLanguage\.json$
+        pass_filenames: false
       - id: check-toolchain-diagnostics
         name: Check toolchain diagnostics
         entry: toolchain/diagnostics/check_diagnostics.py
@@ -129,35 +187,8 @@ repos:
         language: python
         files: ^.*/BUILD$
         pass_filenames: false
-  - repo: https://github.com/PyCQA/flake8
-    rev: d93590f5be797aabb60e3b09f2f52dddb02f349f # frozen: 7.3.0
-    hooks:
-      - id: flake8
-  - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: '850d8bf806620ef89a99381c5cf5ea2c1ea826dd' # frozen: v1.17.0
-    hooks:
-      - id: mypy
-        # Use setup.cfg to match the command line.
-        args:
-          - --config-file=setup.cfg
-        # This should match the requirements added in the WORKSPACE pip_install.
-        additional_dependencies:
-          - gql >= 2.0.0, < 3.0.0
-          - PyGitHub
-          - rich
-        # Exclusions are:
-        # - p#### scripts because they're not tested or maintained.
-        # - lit.cfg.py because it has multiple copies, breaking mypy.
-        # - Unit tests because they sometimes violate typing, such as by
-        #   assigning a mock to a function.
-        exclude: |
-          (?x)^(
-              proposals/(?!scripts/).*|
-              .*/lit\.cfg\.py|
-              .*_test\.py
-          )$
   - repo: https://github.com/codespell-project/codespell
-    rev: 63c8f8312b7559622c0d82815639671ae42132ac # frozen: v2.4.1
+    rev: 2ccb47ff45ad361a21071a7eedda4c37e6ae8c5a # frozen: v2.4.2
     hooks:
       - id: codespell
         args: ['-I', '.codespell_ignore', '--uri-ignore-words-list', '*']
@@ -195,7 +226,7 @@ repos:
           - ''
           - '*/'
           - --custom_format
-          - '\.(plist)$'
+          - '\.(plist|tmLanguage)$'
           - '<!--'
           - ''
           - '\-->'
@@ -212,13 +243,14 @@ repos:
           - --custom_format
           - '\.lua$'
           - ''
-          - '-- '
+          - '\-- '
           - ''
         exclude: |
           (?x)^(
               .bazelversion|
               .github/pull_request_template.md|
               .python-version|
+              LICENSE.*|
               compile_flags.txt|
               github_tools/requirements.txt|
               third_party/.*|
@@ -238,6 +270,7 @@ repos:
         name: Check build graph
         entry: scripts/check_build_graph.py
         language: python
+        pass_filenames: false
         files: |
           (?x)^(
             .*BUILD.*|
@@ -249,7 +282,9 @@ repos:
 # This excludes third-party code, and patches to third-party code.
 exclude: |
   (?x)^(
+      \.jj/.*|
       MODULE.bazel.lock|
+      .*package-lock\.json|
       bazel/bazel_clang_tidy/.*\.patch|
       bazel/google_benchmark/.*\.patch|
       bazel/libpfm/.*\.patch|

.python-version

@@ -1 +1 @@
-3.10
+3.12

.rumdl.toml

@@ -0,0 +1,83 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+[global]
+exclude = [
+  ".clang-tidy",
+  ".git",
+  ".jj",
+  "CHANGELOG.md",
+  "LICENSE.md",
+  ".github/pull_request_template.md",
+]
+respect-gitignore = true
+
+# Disable rules that produce the most noise initially. Some of these might make
+# sense to re-enable.
+disable = [
+  "MD033", # Inline HTML - commonly used in real-world markdown
+  "MD036", # Emphasis used instead of heading
+  "MD040", # Code blocks should have a language specified
+  "MD014", # Commands in code blocks should show output
+  "MD034", # Bare URLs
+  "MD059", # Link text should be descriptive
+  "MD028", # Blank line inside blockquote
+]
+
+# Line wrapping
+[MD013]
+reflow = true
+# Note that we might want to use the "normalize" reflow mode to have more
+# consistent line wrapping, however this mode is currently deeply incompatible
+# with inline HTML that we use reasonably often. For now, we go with the default
+# mode that doesn't try to normalize wrapping.
+reflow-mode = "default"
+ignore-link-urls = false
+code-blocks = false
+code-spans = false
+atomic-spans = false
+headings = false
+stern = true
+
+# Heading style
+[MD003]
+style = "atx"
+
+# Narrow restriction on trailing punctuation in headings -- allows ':' and '!'.
+[MD026]
+punctuation = ".,;"
+
+# Unordered list marker style
+[MD004]
+style = "dash"
+
+# Ordered list numbering
+[MD029]
+style = "one-or-ordered"
+
+# Unordered list indentation
+[MD007]
+style = "fixed"
+indent = 4
+
+[MD077]
+style = "aligned"
+
+# Spaces after list markers
+[MD030]
+ul-single = 3
+ul-multi = 3
+ol-align-column = 4
+
+# Code block style
+[MD046]
+style = "fenced"
+
+# Emphasis style
+[MD049]
+style = "underscore"
+
+# Strong style
+[MD050]
+style = "asterisk"

.vscode/extensions.json

@@ -4,8 +4,9 @@
     "bierner.github-markdown-preview",
     "carbon-lang.carbon-vscode",
     "esbenp.prettier-vscode",
+    "rvben.rumdl",
     "llvm-vs-code-extensions.vscode-clangd",
-    "ms-python.black-formatter",
-    "ms-python.python"
+    "charliermarsh.ruff",
+    "astral-sh.ty"
   ]
 }

.vscode/lldb_launch.json

@@ -10,6 +10,25 @@
       "debuggerRoot": "${workspaceFolder}",
       "initCommands": [
         "command script import external/+llvm_project+llvm-project/llvm/utils/lldbDataFormatters.py",
+        "command script import scripts/lldbinit.py",
+        "settings append target.source-map \".\" \"${workspaceFolder}\"",
+        "settings append target.source-map \"/proc/self/cwd\" \"${workspaceFolder}\"",
+        "settings set escape-non-printables false",
+        "settings set target.max-string-summary-length 10000",
+        "env TEST_TARGET=//toolchain/testing:file_test",
+        "env TEST_TMPDIR=/tmp"
+      ]
+    },
+    {
+      "type": "lldb-dap",
+      "request": "launch",
+      "name": "file_test (all files) (lldb)",
+      "program": "bazel-bin/toolchain/testing/file_test",
+      "args": [],
+      "debuggerRoot": "${workspaceFolder}",
+      "initCommands": [
+        "command script import external/+llvm_project+llvm-project/llvm/utils/lldbDataFormatters.py",
+        "command script import scripts/lldbinit.py",
         "settings append target.source-map \".\" \"${workspaceFolder}\"",
         "settings append target.source-map \"/proc/self/cwd\" \"${workspaceFolder}\"",
         "settings set escape-non-printables false",
@@ -33,6 +52,7 @@
       "debuggerRoot": "${workspaceFolder}",
       "initCommands": [
         "command script import external/+llvm_project+llvm-project/llvm/utils/lldbDataFormatters.py",
+        "command script import scripts/lldbinit.py",
         "settings append target.source-map \".\" \"${workspaceFolder}\"",
         "settings append target.source-map \"/proc/self/cwd\" \"${workspaceFolder}\"",
         "settings set escape-non-printables false",

AGENTS.md

@@ -0,0 +1,30 @@
+# Gemini & AI Assistant Guide for Carbon
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+This document provides high-density technical context for AI assistants
+contributing to the Carbon Language project.
+
+## General instructions
+
+-   **Communication**: Be concise, professional, and technical. Use GitHub-style
+    markdown.
+-   **Verification**: Always run relevant tests.
+
+## Bazel usage
+
+> [!IMPORTANT] Always use `bazelisk` instead of `bazel` for all commands in the
+> Carbon project. Refer to the
+> [Bazel usage skill](/.agents/skills/bazel/SKILL.md) for detailed instructions.
+
+## Version control
+
+> [!IMPORTANT] Never rewrite the history of a change that has been submitted as
+> a pull request. Reviewers track a PR by its commits, and rewriting them
+> discards their in-progress review. Ask before rewriting history in any case.
+> Refer to the [Jujutsu (jj) usage skill](/.agents/skills/jj/SKILL.md) for
+> details.

BUILD

@@ -2,8 +2,51 @@
 # Exceptions. See /LICENSE for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+load("@bazel_skylib//rules:common_settings.bzl", "bool_flag", "bool_setting", "int_flag")
+
 filegroup(
     name = "clang_tidy_config",
     srcs = [".clang-tidy"],
     visibility = ["//visibility:public"],
 )
+
+# `bazel run //:generate_compile_commands` to produce `compile_commands.json`.
+alias(
+    name = "generate_compile_commands",
+    actual = "@wolfd_bazel_compile_commands//:generate_compile_commands",
+)
+
+bool_setting(
+    name = "runtimes_build",
+    build_setting_default = False,
+    visibility = ["//visibility:public"],
+)
+
+int_flag(
+    name = "bootstrap_stage",
+    build_setting_default = 0,
+    visibility = ["//visibility:public"],
+)
+
+# A setting that causes bootstrapping to occur using the `exec` config rather
+# than the target config.
+#
+# The exec config is the more technically correct way of doing bootstrapping
+# than the target config. For example it allows bootstrapping with a target that
+# isn't compatible with the current execution host. However, in development
+# builds, it is likely to force building the entire toolchain twice -- once in
+# the target config for running test, and a second time in the exec config for
+# the bootstrap. As a consequence, this is disabled by default.
+#
+# TODO: Add documentation for using the bootstrap flags once stabilized.
+bool_flag(
+    name = "bootstrap_exec_config",
+    build_setting_default = False,
+    visibility = ["//visibility:public"],
+)
+
+config_setting(
+    name = "bootstrap_with_exec_config",
+    flag_values = {"//:bootstrap_exec_config": "True"},
+    visibility = ["//visibility:public"],
+)

CODEOWNERS

@@ -0,0 +1,24 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+# This file is only used for PR autoassignment. Branch protections don't enforce
+# it.
+#
+# Syntax:
+# https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners#codeowners-syntax
+
+# Toolchain reviewers are used as a fallback.
+*                          @carbon-language/toolchain-reviewers
+
+# Key project documents should be reviewed by leads.
+/*.md                      @carbon-language/leads
+/LICENSE                   @carbon-language/leads
+/docs/project/evolution.md @carbon-language/leads
+/docs/project/goals.md     @carbon-language/leads
+/docs/project/principles/* @carbon-language/leads
+/docs/project/roadmap.md   @carbon-language/leads
+/proposals/*.md            @carbon-language/leads
+
+# Toolchain code.
+/toolchain                 @carbon-language/toolchain-reviewers

CONTRIBUTING.md

@@ -33,6 +33,7 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 -   [Style](#style)
     -   [Google Docs and Markdown](#google-docs-and-markdown)
     -   [Other files](#other-files)
+-   [Testing](#testing)
 -   [License](#license)
     -   [Google Docs](#google-docs)
     -   [Markdown](#markdown)
@@ -98,7 +99,7 @@ early, before even writing a proposal, and the process explains how to do that.
 
 Helping with
 [pull requests](https://github.com/carbon-language/carbon-lang/pulls) review is
-a good way to provide feedback, while getting a acquainted with the code base.
+a good way to provide feedback, while getting acquainted with the code base.
 
 #### Implement Carbon's design
 
@@ -226,27 +227,54 @@ trying to write proposals, both types of contributor access will help.
 Please see our [contribution tool](/docs/project/contribution_tools.md)
 documentation for information on setting up a git client for Carbon development,
 as well as helpful tooling that will ease the contribution process. For example,
-[pre-commit](https://pre-commit.com) is used to simplify
+[prek](https://github.com/j178/prek) is used to simplify
 [code review](/docs/project/code_review.md).
 
 #### Using AI-based contribution tools
 
+If you are using an AI assistant to help you contribute, or if you are an AI
+assistant yourself, please consult [AGENTS.md](/AGENTS.md) for high-density
+technical context and tips.
+
 All submissions to Carbon need to follow our
-[Contributor License Agreement (CLA)](#contributor-license-agreements-clas), in
-which contributors agree that their contribution is an original work of
-authorship. This doesn’t prohibit the use of coding assistance tools, but what’s
-submitted does need to be a contributor’s original creation.
+[Contributor License Agreement (CLA)](#contributor-license-agreements-clas),
+which covers any original work of authorship included in the submission. This
+doesn't prohibit the use of coding assistance tools, including tool-, AI-, or
+machine-generated code, as long as these submissions abide by the CLA's
+requirements.
 
-All contributions, regardless of what tools are used, are also still subject to
-normal code review and our
-[guidelines and standards](#contribution-guidelines-and-standards) below.
+All contributions, regardless of what tools are used, are also still the
+responsibility of the operator of these tools and subject to normal code review
+and our [guidelines and standards](#contribution-guidelines-and-standards)
+below. We also emphasize two additional requirements for contributors operating
+or using AI-based tools:
 
-Additionally, we want contributions to Carbon to also be viable as contributions
-to LLVM so that we can move things between these projects where relevant. We
-selected our license in part for this reason, and the same should be true for
-the use of AI-based coding tools. Any contributions to Carbon should also abide
-by the guidance in the
-[LLVM Developer Policy around AI generated code](https://llvm.org/docs/DeveloperPolicy.html#ai-generated-contributions).
+1.  **Contributions should not become extractive of the project and community**:
+    the value added should outweigh the overhead of landing the contribution.
+    The overhead of landing contributions ranges from code review, to
+    discussions, distractions from the current project priorities, or growing
+    maintenance burden without growing maintainers.
+
+2.  **Each PR should be transparent about the tooling used** in proportion to
+    how much of the PR was produced by the tool and whether the tool is a
+    standard one for the project. For example, formatting with the standard
+    tools is reasonable to assume without further comment. But if a PR is
+    largely derived from running a specific Python script, regular expression,
+    or AI-based tool over the codebase, we ask that its commit message is
+    transparent about this and include a description of how the tool was used to
+    formulate the change. For PRs largely derived from AI-based tooling, we
+    suggest following the pattern established by the Fedora Project to mark
+    commits with `Assisted-by: ...`.
+
+Our policies and practices here are inspired by and aim to be roughly compatible
+with several other open source projects:
+
+-   [Fedora Project's policy](https://docs.fedoraproject.org/en-US/council/policy/ai-contribution-policy/)
+-   [LLVM Developer Policy around AI generated code](https://llvm.org/docs/DeveloperPolicy.html#ai-generated-contributions)
+
+As the open source community evolves and learns how best to integrate these
+tools into project and development workflows, we expect to reflect that with
+updates and improvements here.
 
 ### Contribution guidelines and standards
 
@@ -281,7 +309,6 @@ follow the Carbon documentation and coding styles.
         request.
 
 -   For code:
-
     -   New features should have a documented design that has been approved
         through the [evolution process](docs/project/evolution.md). This
         includes modifications to preexisting designs.
@@ -378,9 +405,9 @@ respectful, and don't drown out other discussion.
 Changes to Carbon documentation follow the
 [Google developer documentation style guide](https://developers.google.com/style).
 
-Markdown files should additionally use [Prettier](https://prettier.io) for
-formatting, which we automate with
-[pre-commit](/docs/project/contribution_tools.md#main-tools).
+Markdown files should additionally use [rumdl](https://github.com/rvben/rumdl)
+for formatting, which we automate with
+[prek](/docs/project/contribution_tools.md#running-prek).
 
 Other style points to be aware of are:
 
@@ -400,6 +427,14 @@ Other style points to be aware of are:
 
 If you're not sure what style to use, please ask on Discord or GitHub.
 
+## Testing
+
+Most development in the Carbon project is on the [toolchain](toolchain/). The
+toolchain contains some unit tests, but the majority of testing is done through
+`file_test` tests, which test the output of the different phases of the
+toolchain. The toolchain docs include instructions for
+[building and running tests](toolchain/docs/adding_features.md#tests-and-debugging).
+
 ## License
 
 A license is required at the top of all documents and files.

MODULE.bazel

@@ -19,50 +19,40 @@ of:
     -   Running `bazel mod deps` provides a canonical update to
         `MODULE.bazel.lock`; create a PR with those changes in order to include
         the host platform.
+
+For updates, run `scripts/query_module_versions.py` to list the latest package
+versions.
 """
 
 module(name = "carbon")
 
-http_archive = use_repo_rule(
-    "@bazel_tools//tools/build_defs/repo:http.bzl",
-    "http_archive",
-)
+bazel_dep(name = "abseil-cpp", version = "20260107.1")
+bazel_dep(name = "bazel_skylib", version = "1.9.0")
+bazel_dep(name = "boost.unordered", version = "1.90.0.bcr.1")
+bazel_dep(name = "google_benchmark", version = "1.9.5")
+bazel_dep(name = "googletest", version = "1.17.0.bcr.2")
+bazel_dep(name = "libpfm", version = "4.13.0")
+bazel_dep(name = "re2", version = "2025-11-05.bcr.1")
+bazel_dep(name = "rules_cc", version = "0.2.18")
+bazel_dep(name = "rules_pkg", version = "1.2.0")
+bazel_dep(name = "rules_shell", version = "0.8.0")
+bazel_dep(name = "tcmalloc", version = "0.0.0-20250927-12f2552")
+bazel_dep(name = "tree-sitter-bazel", version = "0.26.5")
 
-bazel_dep(name = "abseil-cpp", version = "20250512.1")
-bazel_dep(name = "bazel_skylib", version = "1.8.1")
-bazel_dep(name = "google_benchmark", version = "1.9.4")
-bazel_dep(name = "googletest", version = "1.17.0")
-bazel_dep(name = "re2", version = "2024-07-02.bcr.1")
-bazel_dep(name = "rules_cc", version = "0.1.4")
-bazel_dep(name = "rules_pkg", version = "1.1.0")
-bazel_dep(name = "rules_shell", version = "0.5.0")
-bazel_dep(name = "tcmalloc", version = "0.0.0-20250331-43fcf6e")
-bazel_dep(name = "tree-sitter-bazel", version = "0.24.4")
-
-# The registry only has an old version. We use that here to avoid a miss but
-# override it with a newer version.
-bazel_dep(name = "libpfm", version = "4.11.0")
-
-libpfm_version = "4.13.0"
-
-# The official site is https://perfmon2.sourceforge.net/, but SourceForge makes
-# it difficult to download from bazel. On GitHub action runners,
-# https://git.code.sf.net/p/perfmon2/libpfm4 seems to be blocked. As a
-# consequence, use a mirror.
-archive_override(
-    module_name = "libpfm",
-    integrity = "sha256-sGBx1+UoQCplBCc+pwA1Tr/PS2L/4jnLZHH82wSuPz0=",
-    patch_strip = 1,
-    patches = ["@//bazel/libpfm:0001-Introduce-a-simple-native-Bazel-build.patch"],
-    strip_prefix = "libpfm4-{0}".format(libpfm_version),
-    urls = ["https://github.com/wcohen/libpfm4/archive/v{0}.tar.gz".format(libpfm_version)],
+bazel_dep(name = "wolfd_bazel_compile_commands", version = "0.5.2", dev_dependency = True)
+git_override(
+    module_name = "wolfd_bazel_compile_commands",
+    # This is https://github.com/wolfd/bazel-compile-commands/pull/3 which is
+    # needed to correctly select target configurations in our compile commands.
+    commit = "7c673ac868cd237f262bb37a7819b1a279566a66",
+    remote = "https://github.com/chandlerc/bazel-compile-commands.git",
 )
 
 bazel_dep(name = "bazel_clang_tidy", dev_dependency = True)
 git_override(
     module_name = "bazel_clang_tidy",
-    # HEAD as of 2025-01-09.
-    commit = "db677011c7363509a288a9fb3bf0a50830bbf791",
+    # HEAD as of 2026-01-28.
+    commit = "c4d35e0d0b838309358e57a2efed831780f85cd0",
     remote = "https://github.com/erenon/bazel_clang_tidy.git",
 )
 
@@ -74,52 +64,38 @@ use_repo(bazel_cc_toolchain, "bazel_cc_toolchain")
 
 register_toolchains("@bazel_cc_toolchain//:all")
 
-bazel_dep(name = "hedron_compile_commands", dev_dependency = True)
-git_override(
-    module_name = "hedron_compile_commands",
-    # HEAD as of 2025-01-09.
-    commit = "4f28899228fb3ad0126897876f147ca15026151e",
-    remote = "https://github.com/hedronvision/bazel-compile-commands-extractor.git",
-)
-
-boost_unordered_version = "1.85.0"
-
-http_archive(
-    name = "boost_unordered",
-    build_file = "@//:third_party/boost_unordered/BUILD.bazel",
-    integrity = "sha256-2dQ4IQH/xFiK1iWCkrMYLeR8zsSQqGchKOdTuf1u0zI=",
-    strip_prefix = "boost_unordered-{0}".format(boost_unordered_version),
-    urls = ["https://github.com/MikePopoloski/boost_unordered/archive/v{0}.tar.gz".format(boost_unordered_version)],
-)
+register_toolchains("//toolchain/install:all")
 
 # Required for llvm-project.
 bazel_dep(name = "platforms", version = "1.0.0")
-bazel_dep(name = "zlib", version = "1.3.1.bcr.6", repo_name = "llvm_zlib")
-bazel_dep(name = "zstd", version = "1.5.7", repo_name = "llvm_zstd")
+bazel_dep(name = "protobuf", version = "34.0.bcr.1", repo_name = "com_google_protobuf")
+bazel_dep(name = "zlib-ng", version = "2.3.3", repo_name = "llvm_zlib")
+bazel_dep(name = "zstd", version = "1.5.7.bcr.1", repo_name = "llvm_zstd")
 
 ###############################################################################
 # llvm-project
 ###############################################################################
 
-# We pin to specific upstream commits and try to track top-of-tree reasonably
-# closely rather than pinning to a specific release.
-# HEAD as of 2025-08-09.
-llvm_project_version = "fc44a4fcd3c54be927c15ddd9211aca1501633e7"
-
 # Load a repository for the raw llvm-project, pre-overlay.
-http_archive(
-    name = "llvm-raw",
+bazel_dep(name = "llvm-raw")
+git_override(
+    module_name = "llvm-raw",
     build_file_content = "# empty",
-    integrity = "sha256-0iiuvlWDxpxOSP16jhSePSLuba+urpQAlGcUPTLZv8Q=",
-    patch_args = ["-p1"],
+    # We pin to specific upstream commits and try to track top-of-tree
+    # reasonably closely rather than pinning to a specific release.
+    # HEAD as of 2026-09-08.
+    commit = "7024b9e1b423b3c3c6ac76ab6a73cb2c9e4ef842",
+    patch_cmds = ["echo \"module(name='llvm-raw')\" > MODULE.bazel"],
+    patch_strip = 1,
     patches = [
-        "@carbon//bazel/llvm_project:0001_Patch_for_mallinfo2_when_using_Bazel_build_system.patch",
-        "@carbon//bazel/llvm_project:0002_Added_Bazel_build_for_compiler_rt_fuzzer.patch",
-        "@carbon//bazel/llvm_project:0003_Comment_out_unloaded_proto_library_dependencies.patch",
-        "@carbon//bazel/llvm_project:0004_Introduce_filegroups_for_compiler_rt_builtins_runtime.patch",
+        "//bazel/llvm_project:0001_Patch_for_mallinfo2_when_using_Bazel_build_system.patch",
+        "//bazel/llvm_project:0002_Added_Bazel_build_for_compiler_rt_fuzzer.patch",
+        "//bazel/llvm_project:0004_Introduce_basic_sources_exporting_for_libunwind.patch",
+        "//bazel/llvm_project:0005_Introduce_basic_sources_exporting_for_libcxx_and_libcxxabi.patch",
+        "//bazel/llvm_project:0006_Add_more_libc_math_excludes.patch",
+        "//bazel/llvm_project:0011_Temporarily_remove_reference_to_hermetic_toolchain.patch",
     ],
-    strip_prefix = "llvm-project-{0}".format(llvm_project_version),
-    urls = ["https://github.com/llvm/llvm-project/archive/{0}.tar.gz".format(llvm_project_version)],
+    remote = "https://github.com/llvm/llvm-project.git",
 )
 
 # Apply the overlay to produce llvm-project.
@@ -133,10 +109,39 @@ use_repo(llvm_project, "llvm-project")
 # Python
 ###############################################################################
 
-bazel_dep(name = "rules_python", version = "1.5.1")
+bazel_dep(name = "rules_python", version = "1.9.0")
 
 python = use_extension("@rules_python//python/extensions:python.bzl", "python")
 python.toolchain(
-    python_version = "3.11",
+    python_version = "3.12",
 )
 use_repo(python, "python_versions")
+
+###############################################################################
+# Bazel integration testing
+###############################################################################
+
+bazel_dep(
+    name = "rules_bazel_integration_test",
+    version = "0.37.1",
+    dev_dependency = True,
+)
+
+# We test against our current Bazel version, the latest release, and the latest
+# release candidate.
+bazel_binaries = use_extension(
+    "@rules_bazel_integration_test//:extensions.bzl",
+    "bazel_binaries",
+    dev_dependency = True,
+)
+bazel_binaries.download(version_file = "//:.bazelversion")
+bazel_binaries.download(version = "latest")
+bazel_binaries.download(version = "last_rc")
+use_repo(
+    bazel_binaries,
+    "bazel_binaries",
+    "bazel_binaries_bazelisk",
+    "build_bazel_bazel_.bazelversion",
+    "build_bazel_bazel_last_rc",
+    "build_bazel_bazel_latest",
+)

README.md

@@ -169,6 +169,9 @@ If you're already a C++ developer, Carbon should have a gentle learning curve.
 It is built out of a consistent set of language constructs that should feel
 familiar and be easy to read and understand.
 
+The Carbon code here is hypothetical and meant to show the look and feel of the
+language.
+
 C++ code like this:
 
 <a href="docs/images/snippets.md#c">
@@ -248,10 +251,10 @@ challenge for C++ and something a successor language needs to address.
 
 We plan to support a two step migration process:
 
-1. Highly automated, minimal supervision migration from C++ to a dialect of
-   Carbon designed for C++ interop and migration.
-2. Incremental refactoring of the Carbon code to adopt memory-safe designs,
-   patterns, and APIs.
+1.  Highly automated, minimal supervision migration from C++ to a dialect of
+    Carbon designed for C++ interop and migration.
+2.  Incremental refactoring of the Carbon code to adopt memory-safe designs,
+    patterns, and APIs.
 
 We also want to address important, low-hanging fruit in the safety space
 immediately when migrating into Carbon:
@@ -362,6 +365,27 @@ Learn more about the Carbon project:
 
 Carbon focused talks from the community:
 
+### 2026
+
+-   Carbon memory safety: a first deep dive (July 10,
+    [video](https://drive.google.com/file/d/1tQlzpnbWZfn2WtTFMoJgF93QteByBBwm/view?usp=sharing),
+    [transcript](https://docs.google.com/document/d/1JB9H3KzVixAPC5WIytS4AMyrvjwzC7TXqp596veLT34/edit?usp=sharing),
+    [slides](https://chandlerc.blog/slides/2026-memory-safety-deep-3/))
+-   Benchmarking and optimizing the Carbon compiler, NDC {Toronto} (May 5-8)
+    ([video](https://www.youtube.com/watch?v=hN6KcAKfTN0),
+    [slides](https://chandlerc.blog/slides/2026-ndc-toronto-carbon-benchmarking))
+-   Carbon: graduating from the experiment, NDC {Toronto} (May 5-8)
+    ([video](https://www.youtube.com/watch?v=WJl4ftb5Fxg),
+    [slides](https://chandlerc.blog/slides/2026-ndc-toronto-carbon-update/))
+
+### 2025
+
+-   Carbon: from C++ to Memory Safety, REBASE - ICFP/SPLASH
+    ([slides](https://chandlerc.blog/slides/2025-rebase-carbon))
+-   Memory safety everywhere with both Carbon and Rust, RustConf
+    ([video](https://youtu.be/FYLuom6gg_s),
+    [slides](https://chandlerc.blog/slides/2025-rustconf-memory-safety-everywhere))
+
 ### 2024
 
 -   Generic implementation strategies in Carbon and Clang, LLVM Developers'

SECURITY.md

@@ -27,7 +27,6 @@ If you haven't received a response, a couple steps to take are (in order):
 1.  Contact individuals directly:
     -   [Chandler Carruth](mailto:chandlerc@gmail.com)
     -   [Richard Smith](mailto:richard@metafoo.co.uk)
-    -   [Jon Ross-Perkins](mailto:jperkins@google.com)
 2.  Reach out on
     [#infra](https://discord.com/channels/655572317891461132/707150492370862090)
     on Discord ([invite](https://discord.gg/ZjVdShJDAs))

bazel-execroot

@@ -1 +0,0 @@
-bazel-out/../../_main

bazel/carbon_rules/defs.bzl

@@ -4,22 +4,61 @@
 
 """Provides rules for building Carbon files using the toolchain."""
 
+load("@rules_cc//cc:action_names.bzl", "ACTION_NAMES")
+load("@rules_cc//cc/common:cc_common.bzl", "cc_common")
+load("@rules_cc//cc/common:cc_info.bzl", "CcInfo")
+
 def _carbon_binary_impl(ctx):
     toolchain_driver = ctx.executable.internal_exec_toolchain_driver
     toolchain_data = ctx.files.internal_exec_toolchain_data
+    prebuilt_runtimes = ctx.files.internal_exec_prebuilt_runtimes
 
     # If the exec driver isn't provided, that means we're trying to use a target
     # config toolchain, likely to avoid build overhead of two configs.
     if toolchain_driver == None:
         toolchain_driver = ctx.executable.internal_target_toolchain_driver
         toolchain_data = ctx.files.internal_target_toolchain_data
+        prebuilt_runtimes = ctx.files.internal_target_prebuilt_runtimes
+
+    # The extra link flags needed.
+    link_flags = []
+
+    # Pass any C++ flags from our dependencies onto Carbon.
+    dep_flags = []
+    dep_hdrs = []
+    dep_api_files = []
+    dep_link_inputs = []
+    deps = ctx.attr.deps + ctx.attr._default_deps
+    for dep in deps:
+        if CcInfo in dep:
+            cc_info = dep[CcInfo]
+
+            # TODO: We should reuse the feature-based flag generation in
+            # bazel/cc_toolchains here.
+            dep_flags += ["--clang-arg=-D{0}".format(define) for define in cc_info.compilation_context.defines.to_list()]
+            dep_flags += ["--clang-arg=-I{0}".format(path) for path in cc_info.compilation_context.includes.to_list()]
+            dep_flags += ["--clang-arg=-iquote{0}".format(path) for path in cc_info.compilation_context.quote_includes.to_list()]
+            dep_flags += ["--clang-arg=-isystem{0}".format(path) for path in cc_info.compilation_context.system_includes.to_list()]
+            dep_hdrs.append(cc_info.compilation_context.headers)
+            for link_input in cc_info.linking_context.linker_inputs.to_list():
+                link_flags += link_input.user_link_flags
+                dep_link_inputs += link_input.additional_inputs
+                for lib in link_input.libraries:
+                    dep_link_inputs += [dep for dep in [lib.dynamic_library, lib.static_library] if dep]
+                    dep_link_inputs += lib.objects
+        if DefaultInfo in dep:
+            dep_link_inputs += dep[DefaultInfo].files.to_list()
+        if CarbonLibraryInfo in dep:
+            carbon_info = dep[CarbonLibraryInfo]
+            dep_link_inputs += carbon_info.objs.to_list()
+            dep_api_files += carbon_info.apis
+
+    # Add the dependencies' link flags and inputs to the link flags.
+    link_flags += [dep.path for dep in dep_link_inputs]
 
     # Build object files for the prelude and for the binary itself.
-    # TODO: Eventually the prelude should be build as a separate `carbon_library`.
-    srcs_and_flags = [
-        (ctx.files.prelude_srcs, ["--no-prelude-import"]),
-        (ctx.files.srcs, []),
-    ]
+    srcs_and_flags = [(ctx.files.srcs, dep_flags)]
+
     objs = []
     for (srcs, extra_flags) in srcs_and_flags:
         for src in srcs:
@@ -32,44 +71,189 @@ def _carbon_binary_impl(ctx):
             # TODO: This is a hack; replace with something better once the toolchain
             # supports doing so.
             #
-            # TODO: Switch to the `prefix_root` based rule similar to linking when
+            # TODO: Switch to the `prefix` based rule similar to linking when
             # the prelude moves there.
             out = ctx.actions.declare_file("_objs/{0}/{1}o".format(
                 ctx.label.name,
                 src.short_path.removeprefix(ctx.label.package).removesuffix(src.extension),
             ))
             objs.append(out)
-            srcs_reordered = [s for s in srcs if s != src] + [src]
+            srcs_reordered = dep_api_files + [s for s in srcs if s != src] + [src]
             ctx.actions.run(
                 outputs = [out],
-                inputs = srcs_reordered,
+                inputs = depset(direct = srcs_reordered, transitive = dep_hdrs),
                 executable = toolchain_driver,
                 tools = depset(toolchain_data),
-                arguments = ["compile", "--output=" + out.path] + [s.path for s in srcs_reordered] + extra_flags,
+                arguments = ["compile", "--output=" + out.path, "--output-last-input-only"] +
+                            ["--no-include-carbon-core"] +
+                            [s.path for s in srcs_reordered] + extra_flags + ctx.attr.flags,
                 mnemonic = "CarbonCompile",
                 progress_message = "Compiling " + src.short_path,
             )
 
+    # Add the Carbon object files to the link flags.
+    link_flags += [o.path for o in objs]
+
     bin = ctx.actions.declare_file(ctx.label.name)
+
+    # Get all link options from the toolchain and dependencies using standard pattern.
+    cc_toolchain = ctx.attr._cc_toolchain[cc_common.CcToolchainInfo]
+    feature_configuration = cc_common.configure_features(
+        ctx = ctx,
+        cc_toolchain = cc_toolchain,
+        requested_features = ctx.features,
+        unsupported_features = ctx.disabled_features,
+    )
+    variables = cc_common.create_link_variables(
+        feature_configuration = feature_configuration,
+        cc_toolchain = cc_toolchain,
+        is_using_linker = True,
+        user_link_flags = link_flags + [
+            # TODO: Remove once the sanitizer runtimes are available.
+            "-fno-sanitize=all",
+        ],
+        output_file = bin.path,
+    )
+    full_link_flags = cc_common.get_memory_inefficient_command_line(
+        feature_configuration = feature_configuration,
+        action_name = ACTION_NAMES.cpp_link_executable,
+        variables = variables,
+    )
+
     ctx.actions.run(
         outputs = [bin],
-        inputs = objs,
+        inputs = depset(direct = objs + dep_link_inputs),
         executable = toolchain_driver,
-        tools = depset(toolchain_data),
-        arguments = ["link", "--output=" + bin.path] + [o.path for o in objs],
+        tools = depset(direct = toolchain_data + prebuilt_runtimes),
+        arguments = full_link_flags,
         mnemonic = "CarbonLink",
         progress_message = "Linking " + bin.short_path,
     )
     return [DefaultInfo(files = depset([bin]), executable = bin)]
 
+CarbonLibraryInfo = provider(
+    doc = "Contains information about a linkage unit of one or more compiled Carbon libraries.",
+    fields = {
+        "apis": "The api source files to provide to library consumers.",
+        "objs": "A depset of one or more compiled library files, including impl and api.",
+    },
+)
+
+def _carbon_library_impl(ctx):
+    toolchain_driver = ctx.executable.internal_exec_toolchain_driver
+    toolchain_data = ctx.files.internal_exec_toolchain_data
+
+    # If the exec driver isn't provided, that means we're trying to use a target
+    # config toolchain, likely to avoid build overhead of two configs.
+    if toolchain_driver == None:
+        toolchain_driver = ctx.executable.internal_target_toolchain_driver
+        toolchain_data = ctx.files.internal_target_toolchain_data
+
+    # Pass any C++ flags from our dependencies onto Carbon.
+    dep_flags = []
+    dep_hdrs = []
+    dep_api_srcs = []
+    for dep in ctx.attr.deps:
+        if CcInfo in dep:
+            cc_info = dep[CcInfo]
+
+            # TODO: We should reuse the feature-based flag generation in
+            # bazel/cc_toolchains here.
+            dep_flags += ["--clang-arg=-D{0}".format(define) for define in cc_info.compilation_context.defines.to_list()]
+            dep_flags += ["--clang-arg=-I{0}".format(path) for path in cc_info.compilation_context.includes.to_list()]
+            dep_flags += ["--clang-arg=-iquote{0}".format(path) for path in cc_info.compilation_context.quote_includes.to_list()]
+            dep_flags += ["--clang-arg=-isystem{0}".format(path) for path in cc_info.compilation_context.system_includes.to_list()]
+            dep_hdrs.append(cc_info.compilation_context.headers)
+        if CarbonLibraryInfo in dep:
+            carbon_info = dep[CarbonLibraryInfo]
+            dep_api_srcs += carbon_info.apis.to_list()
+
+    # Build object files for the library impls and api file
+    srcs_and_flags = [(ctx.files.srcs + ctx.files.hdrs, dep_flags)]
+
+    objs = []
+    for (srcs, extra_flags) in srcs_and_flags:
+        for src in srcs:
+            # Build each source file. For now, we pass all sources to each compile
+            # because we don't have visibility into dependencies and have no way to
+            # specify multiple output files. Object code for each input is written
+            # into the output file in turn, so the final carbon source file
+            # specified ends up determining the contents of the object file.
+            #
+            # TODO: This is a hack; replace with something better once the toolchain
+            # supports doing so.
+            #
+            # TODO: Switch to the `prefix` based rule similar to linking when
+            # the prelude moves there.
+            out = ctx.actions.declare_file("_objs/{0}/{1}o".format(
+                ctx.label.name,
+                src.short_path.removeprefix(ctx.label.package).removesuffix(src.extension),
+            ))
+            objs.append(out)
+            srcs_reordered = dep_api_srcs + [s for s in srcs if s != src] + [src]
+            ctx.actions.run(
+                outputs = [out],
+                inputs = depset(direct = srcs_reordered, transitive = dep_hdrs),
+                executable = toolchain_driver,
+                tools = depset(toolchain_data),
+                arguments = ["compile", "--output=" + out.path, "--output-last-input-only"] +
+                            ["--no-include-carbon-core"] +
+                            extra_flags + ctx.attr.flags + [s.path for s in srcs_reordered],
+                mnemonic = "CarbonCompile",
+                progress_message = "Compiling " + src.short_path,
+            )
+
+    return [CarbonLibraryInfo(apis = ctx.files.hdrs, objs = depset(objs))]
+
+# We synthesize two sets of attributes from mirrored `select`s here
+# because we want to select on an internal property of these attributes
+# but that isn't `select`-able. Instead, we have both attributes and
+# `select` which one we use.
+_select_internal_exec_toolchain_driver = select({
+    Label("//bazel/carbon_rules:use_target_config_carbon_rules_config"): None,
+    "//conditions:default": Label("//toolchain/install:carbon-busybox"),
+})
+_select_internal_exec_toolchain_data = select({
+    Label("//bazel/carbon_rules:use_target_config_carbon_rules_config"): None,
+    "//conditions:default": Label("//toolchain/install:install_data"),
+})
+_select_internal_exec_prebuilt_runtimes = select({
+    Label("//bazel/carbon_rules:use_target_config_carbon_rules_config"): None,
+    "//conditions:default": Label("//toolchain/install:built_runtimes"),
+})
+_select_internal_target_toolchain_driver = select({
+    Label(
+        "//bazel/carbon_rules:use_target_config_carbon_rules_config",
+    ): Label("//toolchain/install:carbon-busybox"),
+    "//conditions:default": None,
+})
+_select_internal_target_toolchain_data = select({
+    Label(
+        "//bazel/carbon_rules:use_target_config_carbon_rules_config",
+    ): Label("//toolchain/install:install_data"),
+    "//conditions:default": None,
+})
+_select_internal_target_prebuilt_runtimes = select({
+    Label(
+        "//bazel/carbon_rules:use_target_config_carbon_rules_config",
+    ): Label("//toolchain/install:built_runtimes"),
+    "//conditions:default": None,
+})
+
 _carbon_binary_internal = rule(
     implementation = _carbon_binary_impl,
     attrs = {
-        # The exec config toolchain driver and data. These will be `None` when
-        # using the target config and populated when using the exec config. We
-        # have to use duplicate attributes here and below to have different
-        # `cfg` settings, as that isn't `select`-able, and we'll use `select`s
-        # when populating these.
+        "deps": attr.label_list(allow_files = True, providers = [[CcInfo], [CarbonLibraryInfo]]),
+        "flags": attr.string_list(),
+
+        # The exec config toolchain attributes. These will be `None` when using
+        # the target config and populated when using the exec config. We have to
+        # use duplicate attributes here and below to have different `cfg`
+        # settings, as that isn't `select`-able, and we'll use `select`s when
+        # populating these.
+        "internal_exec_prebuilt_runtimes": attr.label(
+            cfg = "exec",
+        ),
         "internal_exec_toolchain_data": attr.label(
             cfg = "exec",
         ),
@@ -79,11 +263,14 @@ _carbon_binary_internal = rule(
             cfg = "exec",
         ),
 
-        # The target config toolchain driver and data. These will be 'None' when
+        # The target config toolchain attributes. These will be 'None' when
         # using the exec config and populated when using the target config. We
         # have to use duplicate attributes here and below to have different
         # `cfg` settings, as that isn't `select`-able, and we'll use `select`s
         # when populating these.
+        "internal_target_prebuilt_runtimes": attr.label(
+            cfg = "target",
+        ),
         "internal_target_toolchain_data": attr.label(
             cfg = "target",
         ),
@@ -92,42 +279,117 @@ _carbon_binary_internal = rule(
             executable = True,
             cfg = "target",
         ),
-        "prelude_srcs": attr.label_list(allow_files = [".carbon"]),
         "srcs": attr.label_list(allow_files = [".carbon"]),
+        "_cc_toolchain": attr.label(default = "//toolchain/install:carbon_stage1_cc_toolchain"),
+        "_default_deps": attr.label_list(default = [Label("//core:io")]),
     },
     executable = True,
+    fragments = ["cpp"],
 )
 
-def carbon_binary(name, srcs):
+_carbon_library_internal = rule(
+    implementation = _carbon_library_impl,
+    attrs = {
+        "deps": attr.label_list(allow_files = True),
+        "flags": attr.string_list(),
+        "hdrs": attr.label_list(allow_files = [".carbon"]),
+
+        # The exec config toolchain attributes. These will be `None` when using
+        # the target config and populated when using the exec config. We have to
+        # use duplicate attributes here and below to have different `cfg`
+        # settings, as that isn't `select`-able, and we'll use `select`s when
+        # populating these.
+        "internal_exec_prebuilt_runtimes": attr.label(
+            cfg = "exec",
+        ),
+        "internal_exec_toolchain_data": attr.label(
+            cfg = "exec",
+        ),
+        "internal_exec_toolchain_driver": attr.label(
+            allow_single_file = True,
+            executable = True,
+            cfg = "exec",
+        ),
+
+        # The target config toolchain attributes. These will be 'None' when
+        # using the exec config and populated when using the target config. We
+        # have to use duplicate attributes here and below to have different
+        # `cfg` settings, as that isn't `select`-able, and we'll use `select`s
+        # when populating these.
+        "internal_target_prebuilt_runtimes": attr.label(
+            cfg = "target",
+        ),
+        "internal_target_toolchain_data": attr.label(
+            cfg = "target",
+        ),
+        "internal_target_toolchain_driver": attr.label(
+            allow_single_file = True,
+            executable = True,
+            cfg = "target",
+        ),
+        "srcs": attr.label_list(allow_files = [".carbon"]),
+        "_cc_toolchain": attr.label(default = "//toolchain/install:carbon_stage1_cc_toolchain"),
+    },
+    executable = False,
+    fragments = ["cpp"],
+)
+
+def carbon_binary(name, srcs, deps = [], flags = [], tags = []):
     """Compiles a Carbon binary.
 
     Args:
       name: The name of the build target.
       srcs: List of Carbon source files to compile.
+      deps: List of dependencies.
+      flags: Extra flags to pass to the Carbon compile command.
+      tags: Tags to apply to the rule.
     """
     _carbon_binary_internal(
         name = name,
         srcs = srcs,
-        prelude_srcs = ["//core:prelude_files"],
+        deps = deps,
+        flags = flags,
+        tags = tags,
+        internal_exec_toolchain_driver = _select_internal_exec_toolchain_driver,
+        internal_exec_toolchain_data = _select_internal_exec_toolchain_data,
+        internal_exec_prebuilt_runtimes = _select_internal_exec_prebuilt_runtimes,
+        internal_target_toolchain_driver = _select_internal_target_toolchain_driver,
+        internal_target_toolchain_data = _select_internal_target_toolchain_data,
+        internal_target_prebuilt_runtimes = _select_internal_target_prebuilt_runtimes,
+    )
 
-        # We synthesize two sets of attributes from mirrored `select`s here
-        # because we want to select on an internal property of these attributes
-        # but that isn't `select`-able. Instead, we have both attributes and
-        # `select` which one we use.
-        internal_exec_toolchain_driver = select({
-            "//bazel/carbon_rules:use_target_config_carbon_rules_config": None,
-            "//conditions:default": "//toolchain/install:prefix_root/bin/carbon",
-        }),
-        internal_exec_toolchain_data = select({
-            "//bazel/carbon_rules:use_target_config_carbon_rules_config": None,
-            "//conditions:default": "//toolchain/install:install_data",
-        }),
-        internal_target_toolchain_driver = select({
-            "//bazel/carbon_rules:use_target_config_carbon_rules_config": "//toolchain/install:prefix_root/bin/carbon",
-            "//conditions:default": None,
-        }),
-        internal_target_toolchain_data = select({
-            "//bazel/carbon_rules:use_target_config_carbon_rules_config": "//toolchain/install:install_data",
-            "//conditions:default": None,
-        }),
+def carbon_library(name, hdrs = [], srcs = [], deps = [], flags = [], tags = [], visibility = []):
+    """Compiles a Carbon library.
+
+    Note: This carbon_library is designed as a _linkage_unit_, and does not necessarily
+    have to correlate the Carbon language library concept. As such it is designed to
+    accommodate more than one api file.
+
+    The arguments `hdrs` and `srcs` are kept for reasons of convention and compatibility
+    with C++ toolchains, particularly build aspects that folks might want to reuse on
+    mixed projects.
+
+    Args:
+      name: The name of the build target.
+      hdrs: List of one or more api files.
+      srcs: List of zero or more implementation files.
+      deps: List of dependencies.
+      flags: Extra flags to pass to the Carbon compile command.
+      tags: Tags to apply to the rule.
+      visibility: Visibility rules for the library.
+    """
+    _carbon_library_internal(
+        name = name,
+        hdrs = hdrs,
+        srcs = srcs,
+        deps = deps,
+        flags = flags,
+        tags = tags,
+        visibility = visibility,
+        internal_exec_toolchain_driver = _select_internal_exec_toolchain_driver,
+        internal_exec_toolchain_data = _select_internal_exec_toolchain_data,
+        internal_exec_prebuilt_runtimes = _select_internal_exec_prebuilt_runtimes,
+        internal_target_toolchain_driver = _select_internal_target_toolchain_driver,
+        internal_target_toolchain_data = _select_internal_target_toolchain_data,
+        internal_target_prebuilt_runtimes = _select_internal_target_prebuilt_runtimes,
     )

bazel/cc_toolchains/BUILD

@@ -3,9 +3,13 @@
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 load("@bazel_skylib//lib:selects.bzl", "selects")
+load("@rules_python//python:defs.bzl", "py_library", "py_test")
+load(":carbon_bootstrapping.bzl", "gen_cc_toolchain_paths_with_stage")
 
 package(default_visibility = ["//visibility:public"])
 
+exports_files(["carbon_cc_toolchain_config.bzl"])
+
 # For use by defs.bzl.
 # Matches when asan is enabled on a macOS platform.
 selects.config_setting_group(
@@ -46,3 +50,46 @@ config_setting(
     name = "fastbuild",
     values = {"compilation_mode": "fastbuild"},
 )
+
+filegroup(
+    name = "installed_cc_toolchain_starlark",
+    srcs = [
+        "cc_toolchain_actions.bzl",
+        "cc_toolchain_base_features.bzl",
+        "cc_toolchain_config_features.bzl",
+        "cc_toolchain_cpp_features.bzl",
+        "cc_toolchain_debugging.bzl",
+        "cc_toolchain_features.bzl",
+        "cc_toolchain_linking.bzl",
+        "cc_toolchain_modules.bzl",
+        "cc_toolchain_optimization.bzl",
+        "cc_toolchain_sanitizer_features.bzl",
+        "cc_toolchain_tools.bzl",
+
+        # TODO: Remove this once we can remove the use of it from Carbon
+        # toolchain rules.
+        "cc_toolchain_carbon_project_features.bzl",
+    ],
+)
+
+gen_cc_toolchain_paths_with_stage(
+    name = "gen_cc_tools_paths",
+    stage = 0,
+)
+
+# Test that the default toolchain's Make variables expand correctly.
+py_test(
+    name = "cc_tools_test",
+    srcs = ["cc_tools_test.py"],
+    args = ["$(location :gen_cc_tools_paths)"],
+    data = [":gen_cc_tools_paths"],
+    deps = [":cc_tools_test_lib"],
+)
+
+# Library containing the test logic, used by tests in other packages.
+py_library(
+    name = "cc_tools_test_lib",
+    srcs = ["cc_tools_test.py"],
+    visibility = ["//visibility:public"],
+    deps = ["@bazel_tools//tools/python/runfiles"],
+)

bazel/cc_toolchains/carbon_bootstrapping.bzl

@@ -0,0 +1,219 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""Starlark rules for bootstrapping the Carbon toolchain."""
+
+load("@bazel_tools//tools/cpp:toolchain_utils.bzl", "find_cpp_toolchain")
+load("//toolchain/runtimes:carbon_runtimes.bzl", "carbon_runtimes_build")
+load(
+    ":carbon_cc_toolchain_config.bzl",
+    "carbon_cc_toolchain",
+)
+
+def _bootstrap_transition_impl(_, attr):
+    return {
+        "//:bootstrap_stage": attr.stage,
+
+        # Note that we need to either set or clear the runtimes build flag each
+        # time we transition to a different bootstarp stage or we can
+        # incorrectly inherit an unexpected state.
+        "//:runtimes_build": attr.enable_runtimes_build,
+    }
+
+_bootstrap_transition = transition(
+    inputs = [],
+    outputs = [
+        "//:bootstrap_stage",
+        "//:runtimes_build",
+    ],
+    implementation = _bootstrap_transition_impl,
+)
+
+def _filegroup_with_stage_impl(ctx):
+    return [DefaultInfo(files = depset(ctx.files.srcs))]
+
+filegroup_with_stage = rule(
+    implementation = _filegroup_with_stage_impl,
+    attrs = {
+        "enable_runtimes_build": attr.bool(default = False),
+        "srcs": attr.label_list(mandatory = True, cfg = _bootstrap_transition),
+        "stage": attr.int(mandatory = True),
+        "_allowlist_function_transition": attr.label(
+            default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
+        ),
+    },
+    doc = "A filegroup whose sources are built using a specific toolchain stage.",
+)
+
+def _exec_filegroup_impl(ctx):
+    return [DefaultInfo(files = depset(ctx.files.srcs))]
+
+_exec_filegroup = rule(
+    implementation = _exec_filegroup_impl,
+    attrs = {
+        "srcs": attr.label_list(cfg = "exec"),
+    },
+)
+
+def filegroup_with_stage_and_exec(name, srcs, stage, tags = []):
+    """Wraps `filegroup_with_stage` with a conditional `exec` config transition.
+
+    When `//:bootstrap_exec_config` is disabled, this works exactly like
+    `filegroup_with_stage`. But when it is _enabled_, it also adds an `exec`
+    config transition.
+    """
+    impl_tags = tags if "manual" in tags else tags + ["manual"]
+
+    filegroup_with_stage(
+        name = name + "_stage_only",
+        srcs = srcs,
+        stage = stage,
+        tags = impl_tags,
+    )
+
+    _exec_filegroup(
+        name = name + "_with_exec",
+        srcs = [":" + name + "_stage_only"],
+        tags = impl_tags,
+    )
+
+    native.alias(
+        name = name,
+        actual = select({
+            "//:bootstrap_with_exec_config": ":" + name + "_with_exec",
+            "//conditions:default": ":" + name + "_stage_only",
+        }),
+        tags = tags,
+    )
+
+def _gen_cc_toolchain_paths_impl(ctx):
+    cc_toolchain = find_cpp_toolchain(ctx)
+
+    expanded_vars = [
+        ctx.expand_make_variables("vars", v, {})
+        for v in ctx.attr.vars
+    ]
+
+    out = ctx.actions.declare_file(ctx.attr.name + ".txt")
+    ctx.actions.write(out, "\n".join(expanded_vars) + "\n")
+
+    # Include all toolchain files in runfiles.
+    runfiles = ctx.runfiles(files = [out]).merge(
+        ctx.runfiles(transitive_files = cc_toolchain.all_files),
+    )
+
+    return [DefaultInfo(files = depset([out]), runfiles = runfiles)]
+
+gen_cc_toolchain_paths_with_stage = rule(
+    implementation = _gen_cc_toolchain_paths_impl,
+    attrs = {
+        "enable_runtimes_build": attr.bool(default = False),
+        "stage": attr.int(mandatory = True),
+        "vars": attr.string_list(
+            default = ["$(CC)", "$(AR)", "$(NM)", "$(OBJCOPY)", "$(STRIP)"],
+        ),
+        "_allowlist_function_transition": attr.label(
+            default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
+        ),
+        "_cc_toolchain": attr.label(
+            default = Label("@bazel_tools//tools/cpp:current_cc_toolchain"),
+        ),
+    },
+    toolchains = ["@bazel_tools//tools/cpp:toolchain_type"],
+    cfg = _bootstrap_transition,
+)
+
+def carbon_bootstrapped_cc_toolchain(
+        name,
+        all_hdrs,
+        base_files,
+        clang_hdrs,
+        platforms,
+        runtimes_cfg,
+        build_stage = 1,
+        base_stage = 0,
+        tags = []):
+    """Create a bootstrapped Carbon `cc_toolchain` for the current target.
+
+    This builds on `carbon_cc_toolchain`, but enables bootstrapping the produced
+    toolchain from a base stage's toolchain.
+
+    Args:
+        name:
+            The name of the toolchain suite to produce, used as the base of the
+            names of each component of the toolchain suite.
+        all_hdrs: A list of header files to include in the toolchain.
+        base_files: A list of files to include in the toolchain.
+        build_stage: The stage to use for the build files.
+        base_stage: The stage to use for the base files.
+        clang_hdrs: A list of header files to include in the toolchain.
+        platforms: An array of (os, cpu) pairs to support in the toolchain.
+        runtimes_cfg: The runtimes configuration to use in the toolchain.
+        tags: Tags to apply to the toolchain.
+    """
+    impl_tags = tags if "manual" in tags else tags + ["manual"]
+
+    filegroup_with_stage_and_exec(
+        name = "{}_clang_hdrs".format(name),
+        srcs = clang_hdrs,
+        stage = base_stage,
+        tags = impl_tags,
+    )
+
+    filegroup_with_stage_and_exec(
+        name = "{}_base_files".format(name),
+        srcs = base_files,
+        stage = base_stage,
+        tags = impl_tags,
+    )
+
+    filegroup_with_stage_and_exec(
+        name = "{}_runtimes_compile_files".format(name),
+        srcs = [
+            ":{}_base_files".format(name),
+            ":{}_clang_hdrs".format(name),
+        ],
+        stage = base_stage,
+        tags = impl_tags,
+    )
+
+    filegroup_with_stage_and_exec(
+        name = "{}_compile_files".format(name),
+        srcs = [":{}_base_files".format(name)] + all_hdrs,
+        stage = base_stage,
+        tags = impl_tags,
+    )
+
+    # The runtimes build for this stage of the bootstrap is only compatible with
+    # both the build stage and the runtimes build. We'll induce those below, and
+    # constrain them here to avoid any other usage.
+    carbon_runtimes_build(
+        name = "{}_runtimes_build".format(name),
+        config = runtimes_cfg,
+        clang_hdrs = ["{}_clang_hdrs".format(name)],
+        tags = impl_tags,
+    )
+
+    # Wrap the runtimes build in a filegroup that both sets the stage to the
+    # build stage as well as enabling runtimes building. Note that this is _not_
+    # the base stage -- runtimes should be built by the same stage, simply using
+    # the runtimes build setting.
+    filegroup_with_stage(
+        name = "{}_runtimes".format(name),
+        srcs = [":{}_runtimes_build".format(name)],
+        stage = build_stage,
+        enable_runtimes_build = True,
+        tags = impl_tags,
+    )
+
+    carbon_cc_toolchain(
+        name = name,
+        platforms = platforms,
+        base_files_target = ":{}_base_files".format(name),
+        runtimes_compile_files_target = ":{}_runtimes_compile_files".format(name),
+        compile_files_target = ":{}_compile_files".format(name),
+        runtimes_target = ":{}_runtimes".format(name),
+        extra_toolchain_settings = [":is_bootstrap_stage_{}".format(build_stage)],
+        tags = tags,
+    )

bazel/cc_toolchains/carbon_cc_toolchain_config.bzl

@@ -0,0 +1,380 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""Starlark cc_toolchain configuration rules for using the Carbon toolchain"""
+
+load("@rules_cc//cc:action_names.bzl", "ACTION_NAMES", "ACTION_NAME_GROUPS")
+load(
+    "@rules_cc//cc:cc_toolchain_config_lib.bzl",
+    "action_config",
+    "flag_group",
+    "flag_set",
+    "tool",
+    "tool_path",
+)
+load(
+    "@rules_cc//cc:defs.bzl",
+    "CcToolchainConfigInfo",
+    "cc_toolchain",
+)
+load("@rules_cc//cc/common:cc_common.bzl", "cc_common")
+load(
+    "carbon_clang_variables.bzl",
+    "clang_include_dirs",
+    "clang_resource_dir",
+    "clang_sysroot",
+)
+load(
+    "cc_toolchain_actions.bzl",
+    "all_c_compile_actions",
+)
+load("cc_toolchain_carbon_project_features.bzl", "carbon_project_features")
+load("cc_toolchain_features.bzl", "clang_cc_toolchain_features")
+load(
+    ":cc_toolchain_tools.bzl",
+    "llvm_tool_paths",
+)
+
+def _make_action_configs(tools, runtimes_path = None):
+    runtimes_flag = "--no-build-runtimes"
+    if runtimes_path:
+        runtimes_flag = "--prebuilt-runtimes={0}".format(runtimes_path)
+
+    return [
+        action_config(
+            action_name = name,
+            enabled = True,
+            tools = [tools.clang],
+        )
+        for name in all_c_compile_actions
+    ] + [
+        action_config(
+            action_name = name,
+            enabled = True,
+            tools = [tools.clangpp],
+        )
+        for name in ACTION_NAME_GROUPS.all_cpp_compile_actions
+    ] + [
+        action_config(
+            action_name = name,
+            enabled = True,
+            tools = [tools.carbon_busybox],
+            flag_sets = [flag_set(flag_groups = [flag_group(flags = [
+                runtimes_flag,
+                "link",
+                # We want to allow Bazel to intermingle linked object files and
+                # Clang-spelled link flags. The first `--` starts the list of
+                # initial object files by ending flags to the `link` subcommand,
+                # and the second `--` switches to Clang-spelled flags.
+                "--",
+                "--",
+            ])])],
+        )
+        for name in ACTION_NAME_GROUPS.all_cc_link_actions
+    ] + [
+        action_config(
+            action_name = name,
+            enabled = True,
+            tools = [tools.llvm_ar],
+        )
+        for name in [ACTION_NAMES.cpp_link_static_library]
+    ] + [
+        action_config(
+            action_name = name,
+            enabled = True,
+            tools = [tools.llvm_strip],
+        )
+        for name in [ACTION_NAMES.strip]
+    ]
+
+def _compute_clang_system_include_dirs():
+    system_include_dirs_start_index = None
+    for index, dir in enumerate(clang_include_dirs):
+        # Skip over the include search directories until we find the resource
+        # directory. The system include directories are everything after that.
+        if dir.startswith(clang_resource_dir):
+            system_include_dirs_start_index = index + 1
+            break
+    if not system_include_dirs_start_index:
+        fail("Could not find the resource directory in the clang include " +
+             "directories: {}".format(clang_include_dirs))
+    return clang_include_dirs[system_include_dirs_start_index:]
+
+def _carbon_cc_toolchain_config_impl(ctx):
+    llvm_bindir = "llvm/bin"
+    clang_bindir = llvm_bindir
+    tools = struct(
+        carbon_busybox = tool(path = "carbon-busybox"),
+        clang = tool(path = clang_bindir + "/clang"),
+        clangpp = tool(path = clang_bindir + "/clang++"),
+        llvm_ar = tool(path = llvm_bindir + "/llvm-ar"),
+        llvm_strip = tool(path = llvm_bindir + "/llvm-strip"),
+    )
+    if ctx.attr.bins:
+        carbon_busybox = None
+        clang = None
+        clangpp = None
+        llvm_ar = None
+        llvm_strip = None
+        for f in ctx.files.bins:
+            if f.basename == "carbon-busybox":
+                carbon_busybox = f
+            elif f.basename == "clang":
+                clang = f
+            elif f.basename == "clang++":
+                clangpp = f
+            elif f.basename == "llvm-ar":
+                llvm_ar = f
+            elif f.basename == "llvm-strip":
+                llvm_strip = f
+        if not all([carbon_busybox, clang, clangpp, llvm_ar, llvm_strip]):
+            fail("Missing required tool in bins: {0}".format(ctx.attr.bins))
+        llvm_bindir = llvm_ar.dirname
+        clang_bindir = clang.dirname
+        tools = struct(
+            carbon_busybox = tool(tool = carbon_busybox),
+            clang = tool(tool = clang),
+            clangpp = tool(tool = clangpp),
+            llvm_ar = tool(tool = llvm_ar),
+            llvm_strip = tool(tool = llvm_strip),
+        )
+
+    # Only use a sysroot if a non-trivial one is set in Carbon's config.
+    builtin_sysroot = None
+    sysroot_include_search = []
+    sdk_settings = []
+    if clang_sysroot != "None" and clang_sysroot != "/":
+        builtin_sysroot = clang_sysroot
+        sysroot_include_search = ["%sysroot%/usr/include"]
+
+        # On MacOS, the compiler depends on this file at the root of the SDK,
+        # and it ends up in the `.d` files.
+        sdk_settings = ["%sysroot%/SDKSettings.json"]
+
+    runtimes_path = None
+    if ctx.attr.runtimes:
+        for f in ctx.files.runtimes:
+            if f.basename == "runtimes_root":
+                runtimes_path = f.dirname
+                break
+        if not runtimes_path:
+            fail("Unable to compute the runtimes path for: {0}".format(
+                ctx.attr.runtimes,
+            ))
+
+    identifier = "{0}_toolchain_{1}_{2}".format(
+        ctx.attr.identifier_prefix,
+        ctx.attr.target_cpu,
+        ctx.attr.target_os,
+    )
+
+    return cc_common.create_cc_toolchain_config_info(
+        ctx = ctx,
+        features = clang_cc_toolchain_features(
+            target_os = ctx.attr.target_os,
+            target_cpu = ctx.attr.target_cpu,
+
+            # TODO: This should be configured externally rather than here so
+            # that the install Carbon toolchain doesn't automatically include
+            # Carbon-project-specific flags. However, that is especially awkward
+            # to do until we fully migrate to a rules-based toolchain, and the
+            # project-specific flags are largely harmless at the moment. We also
+            # omit a meaningful cache key as when using the Carbon toolchain we
+            # don't need it as it is a hermetic part of Bazel.
+            project_features = carbon_project_features(cache_key = ""),
+        ),
+        action_configs = _make_action_configs(tools, runtimes_path),
+        cxx_builtin_include_directories = [
+            "runtimes/libunwind/include",
+            "runtimes/libcxx/include",
+            "runtimes/libcxxabi/include",
+            "{}/include".format(clang_resource_dir),
+            "runtimes/clang_resource_dir/include",
+        ] + _compute_clang_system_include_dirs() + sysroot_include_search + sdk_settings,
+        builtin_sysroot = builtin_sysroot,
+
+        # This configuration only supports local non-cross builds so derive
+        # everything from the target CPU selected.
+        toolchain_identifier = identifier,
+
+        # This is used to expose a "flag" that `config_setting` rules can use to
+        # determine if the compiler is Clang.
+        compiler = "clang",
+
+        # Pass in our tool paths to expose Make variables like $(NM) and
+        # $(OBJCOPY).
+        tool_paths = llvm_tool_paths(llvm_bindir, clang_bindir) + [tool_path(name = "carbon-busybox", path = "carbon-busybox")],
+    )
+
+carbon_cc_toolchain_config = rule(
+    implementation = _carbon_cc_toolchain_config_impl,
+    attrs = {
+        "bins": attr.label(mandatory = False),
+        "identifier_prefix": attr.string(mandatory = True),
+        "runtimes": attr.label(mandatory = False),
+        "target_cpu": attr.string(mandatory = True),
+        "target_os": attr.string(mandatory = True),
+    },
+    provides = [CcToolchainConfigInfo],
+)
+
+def _runtimes_transition_impl(_, attr):
+    return {
+        "//:runtimes_build": True,
+    }
+
+_runtimes_transition = transition(
+    inputs = [],
+    outputs = [
+        "//:runtimes_build",
+    ],
+    implementation = _runtimes_transition_impl,
+)
+
+def _filegroup_with_runtimes_build_impl(ctx):
+    return [DefaultInfo(files = depset(ctx.files.srcs))]
+
+filegroup_with_runtimes_build = rule(
+    implementation = _filegroup_with_runtimes_build_impl,
+    attrs = {
+        "srcs": attr.label_list(mandatory = True, cfg = _runtimes_transition),
+        "_allowlist_function_transition": attr.label(
+            default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
+        ),
+    },
+    doc = "A filegroup whose sources are built with or without runtimes building enabled.",
+)
+
+def carbon_cc_toolchain(
+        name,
+        platforms,
+        base_files_target,
+        runtimes_compile_files_target,
+        compile_files_target,
+        runtimes_target,
+        extra_toolchain_settings = [],
+        tags = []):
+    """Create a Carbon `cc_toolchain` for the current target.
+
+    This macro constructs the configuration and toolchain rules for a baseline
+    Carbon toolchain, including building its own runtimes on demand.
+
+    Args:
+        name: The base name for the toolchain targets.
+        platforms: Supported platforms.
+        base_files_target: Target for base files.
+        runtimes_compile_files_target: Target for runtimes compile files.
+        compile_files_target: Target for compile files.
+        runtimes_target: Target for runtimes.
+        extra_toolchain_settings: Extra toolchain settings.
+        tags: Tags to apply to the toolchain.
+    """
+    impl_tags = tags if "manual" in tags else tags + ["manual"]
+
+    carbon_cc_toolchain_config(
+        name = "{}_runtimes_toolchain_config".format(name),
+        identifier_prefix = "{}_runtimes".format(name),
+        target_cpu = select({
+            ":is_{}_{}".format(os, cpu): cpu
+            for os, cpus in platforms.items()
+            for cpu in cpus
+        }),
+        target_os = select({
+            "@platforms//os:{}".format(os): os
+            for os in platforms.keys()
+        }),
+        bins = base_files_target,
+        tags = impl_tags,
+    )
+
+    cc_toolchain(
+        name = "{}_runtimes_cc_toolchain".format(name),
+        all_files = runtimes_compile_files_target,
+        ar_files = base_files_target,
+        as_files = runtimes_compile_files_target,
+        compiler_files = runtimes_compile_files_target,
+        dwp_files = base_files_target,
+        linker_files = base_files_target,
+        objcopy_files = base_files_target,
+        strip_files = base_files_target,
+        toolchain_config = ":{}_runtimes_toolchain_config".format(name),
+        toolchain_identifier = select({
+            ":is_{}_{}".format(os, cpu): "{}_{}_{}_runtimes_toolchain".format(name, os, cpu)
+            for os, cpus in platforms.items()
+            for cpu in cpus
+        }),
+        tags = impl_tags,
+    )
+
+    native.toolchain(
+        name = "{}_runtimes_toolchain".format(name),
+        target_settings = [":is_runtimes_build"] + extra_toolchain_settings,
+        use_target_platform_constraints = True,
+        toolchain = ":{}_runtimes_cc_toolchain".format(name),
+        toolchain_type = "@bazel_tools//tools/cpp:toolchain_type",
+        tags = tags,
+    )
+
+    carbon_cc_toolchain_config(
+        name = "{}_toolchain_config".format(name),
+        identifier_prefix = name,
+        target_cpu = select({
+            ":is_{}_{}".format(os, cpu): cpu
+            for os, cpus in platforms.items()
+            for cpu in cpus
+        }),
+        target_os = select({
+            "@platforms//os:{}".format(os): os
+            for os in platforms.keys()
+        }),
+        runtimes = runtimes_target,
+        bins = base_files_target,
+        tags = impl_tags,
+    )
+
+    native.filegroup(
+        name = "{}_linker_files".format(name),
+        srcs = [
+            base_files_target,
+            runtimes_target,
+        ],
+        tags = impl_tags,
+    )
+
+    native.filegroup(
+        name = "{}_all_files".format(name),
+        srcs = [
+            compile_files_target,
+            ":{}_linker_files".format(name),
+        ],
+        tags = impl_tags,
+    )
+
+    cc_toolchain(
+        name = "{}_cc_toolchain".format(name),
+        all_files = ":{}_all_files".format(name),
+        ar_files = base_files_target,
+        as_files = compile_files_target,
+        compiler_files = compile_files_target,
+        dwp_files = ":{}_linker_files".format(name),
+        linker_files = ":{}_linker_files".format(name),
+        objcopy_files = base_files_target,
+        strip_files = base_files_target,
+        toolchain_config = ":" + name + "_toolchain_config",
+        toolchain_identifier = select({
+            ":is_{}_{}".format(os, cpu): "{}_{}_{}_toolchain".format(name, os, cpu)
+            for os, cpus in platforms.items()
+            for cpu in cpus
+        }),
+        tags = impl_tags,
+    )
+
+    native.toolchain(
+        name = name + "_toolchain",
+        target_settings = [":not_runtimes_build"] + extra_toolchain_settings,
+        use_target_platform_constraints = True,
+        toolchain = ":" + name + "_cc_toolchain",
+        toolchain_type = "@bazel_tools//tools/cpp:toolchain_type",
+        tags = tags,
+    )

bazel/cc_toolchains/carbon_clang_variables.bzl

@@ -0,0 +1,20 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""A Starlark file exporting detected Carbon toolchain configuration variables.
+
+This file gets processed by a repository rule, substituting the `VARIABLE`s with
+values, for example using an invocation of `carbon config`.
+"""
+
+load(
+    "@bazel_cc_toolchain//:clang_detected_variables.bzl",
+    _clang_include_dirs = "clang_include_dirs",
+    _clang_resource_dir = "clang_resource_dir",
+    _sysroot_dir = "sysroot_dir",
+)
+
+clang_include_dirs = _clang_include_dirs
+clang_resource_dir = _clang_resource_dir
+clang_sysroot = _sysroot_dir

bazel/cc_toolchains/cc_toolchain_actions.bzl

@@ -0,0 +1,21 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""Useful sets of actions for defining `cc_toolchain_config` features."""
+
+load("@rules_cc//cc:action_names.bzl", "ACTION_NAMES", "ACTION_NAME_GROUPS")
+
+# all_c_compile_actions includes actions that compile C or assembly.
+all_c_compile_actions = [
+    x
+    for x in ACTION_NAME_GROUPS.all_cc_compile_actions
+    if x not in ACTION_NAME_GROUPS.all_cpp_compile_actions
+]
+
+# preprocessor_compile_actions includes actions that run the preprocessor.
+preprocessor_compile_actions = [
+    x
+    for x in ACTION_NAME_GROUPS.all_cc_compile_actions
+    if x not in [ACTION_NAMES.assemble, ACTION_NAMES.cpp_module_codegen]
+]

bazel/cc_toolchains/cc_toolchain_base_features.bzl

@@ -0,0 +1,129 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""Definitions used for the base features of a `cc_toolchain_config`."""
+
+load("@rules_cc//cc:action_names.bzl", "ACTION_NAMES", "ACTION_NAME_GROUPS")
+load(
+    "@rules_cc//cc:cc_toolchain_config_lib.bzl",
+    "feature",
+    "feature_set",
+    "flag_group",
+    "flag_set",
+)
+
+# Declare features that are used by Bazel to model specific build modes.
+dbg_feature = feature(name = "dbg")
+fastbuild_feature = feature(name = "fastbuild")
+host_feature = feature(name = "host")
+opt_feature = feature(name = "opt")
+
+# Declare features that control enabling and disabling Bazel logic.
+no_legacy_features_feature = feature(name = "no_legacy_features")
+supports_pic_feature = feature(name = "supports_pic", enabled = True)
+
+supports_dynamic_linker_feature = feature(
+    name = "supports_dynamic_linker",
+    enabled = True,
+    requires = [feature_set(["linux_target"])],
+)
+supports_start_end_lib_feature = feature(
+    name = "supports_start_end_lib",
+    enabled = True,
+    requires = [feature_set(["linux_target"])],
+)
+
+user_flags_feature = feature(
+    name = "user_flags",
+    enabled = True,
+    flag_sets = [
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_compile_actions,
+            flag_groups = [flag_group(
+                expand_if_available = "user_compile_flags",
+                flags = ["%{user_compile_flags}"],
+                iterate_over = "user_compile_flags",
+            )],
+        ),
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_link_actions,
+            flag_groups = [flag_group(
+                expand_if_available = "user_link_flags",
+                flags = ["%{user_link_flags}"],
+                iterate_over = "user_link_flags",
+            )],
+        ),
+    ],
+)
+
+# TODO: It's not clear this is the right location for these flags, and it is a
+# little awkward.
+output_flags_feature = feature(
+    name = "output_flags",
+    enabled = True,
+    flag_sets = [
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_compile_actions,
+            flag_groups = [
+                # For compile actions we have a single source and so put it at
+                # the end next to the output.
+                flag_group(
+                    expand_if_available = "source_file",
+                    flags = ["%{source_file}"],
+                ),
+                flag_group(
+                    expand_if_available = "output_file",
+                    flags = ["-o", "%{output_file}"],
+                ),
+            ],
+        ),
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_link_actions,
+            flag_groups = [flag_group(
+                expand_if_available = "output_execpath",
+                flags = ["-o", "%{output_execpath}"],
+            )],
+        ),
+    ],
+)
+
+strip_feature = feature(
+    name = "strip_flags",
+    enabled = True,
+    flag_sets = [flag_set(
+        actions = [ACTION_NAMES.strip],
+        flag_groups = [
+            flag_group(
+                flags = ["-S"],
+            ),
+            flag_group(
+                flags = ["-p"],
+            ),
+            flag_group(
+                expand_if_available = "output_file",
+                flags = ["-o", "%{output_file}"],
+            ),
+            flag_group(
+                iterate_over = "stripopts",
+                flags = ["%{stripopts}"],
+            ),
+            flag_group(
+                expand_if_available = "input_file",
+                flags = ["%{input_file}"],
+            ),
+        ],
+    )],
+)
+
+base_features = [
+    dbg_feature,
+    fastbuild_feature,
+    host_feature,
+    no_legacy_features_feature,
+    opt_feature,
+    strip_feature,
+    supports_pic_feature,
+    supports_dynamic_linker_feature,
+    supports_start_end_lib_feature,
+]

bazel/cc_toolchains/cc_toolchain_carbon_project_features.bzl

@@ -0,0 +1,82 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""Defines `cc_toolchain_config` features specific to the Carbon project."""
+
+load("@rules_cc//cc:action_names.bzl", "ACTION_NAMES", "ACTION_NAME_GROUPS")
+load(
+    "@rules_cc//cc:cc_toolchain_config_lib.bzl",
+    "feature",
+    "feature_set",
+    "flag_group",
+    "flag_set",
+    "with_feature_set",
+)
+load(
+    ":cc_toolchain_actions.bzl",
+    "preprocessor_compile_actions",
+)
+
+# An enabled feature that requires the `fastbuild` compilation. This is used
+# to toggle general features on by default, while allowing them to be
+# directly enabled and disabled more generally as desired.
+carbon_project_fastbuild_feature = feature(
+    name = "enable_in_fastbuild",
+    enabled = True,
+    requires = [feature_set(["fastbuild"])],
+    implies = [
+        "minimal_optimization_flags",
+        "minimal_debug_info_flags",
+        "preserve_call_stacks",
+    ],
+)
+
+def carbon_project_features(cache_key):
+    return [carbon_project_fastbuild_feature, feature(
+        name = "project_flags",
+        enabled = True,
+        flag_sets = [
+            flag_set(
+                actions = ACTION_NAME_GROUPS.all_cc_compile_actions,
+                flag_groups = [flag_group(flags = [
+                    # Don't warn on external code as we can't
+                    # necessarily patch it easily. Note that these have
+                    # to be initial directories in the `#include` line.
+                    "--system-header-prefix=absl/",
+                    "--system-header-prefix=benchmark/",
+                    "--system-header-prefix=boost/",
+                    "--system-header-prefix=clang-tools-extra/",
+                    "--system-header-prefix=clang/",
+                    "--system-header-prefix=gmock/",
+                    "--system-header-prefix=gtest/",
+                    "--system-header-prefix=libfuzzer/",
+                    "--system-header-prefix=llvm/",
+                    "--system-header-prefix=re2/",
+                    "--system-header-prefix=tools/cpp/",
+                    "--system-header-prefix=tree_sitter/",
+                ])],
+            ),
+            flag_set(
+                actions = preprocessor_compile_actions,
+                flag_groups = [flag_group(flags = [
+                    # Pass a cache key as a `-D` flag to avoid unintended Bazel
+                    # cache hits when the underlying toolchain changes.
+                    # TODO: We should consider replacing this by causing changes
+                    # to the installed toolchain to more reliably end up as part
+                    # of the action digest.
+                    "-DBAZEL_COMPILE_CACHE_KEY=\"%s\"" % cache_key,
+                ])],
+            ),
+            flag_set(
+                actions = [
+                    ACTION_NAMES.c_compile,
+                    ACTION_NAMES.cpp_compile,
+                    ACTION_NAMES.cpp_header_parsing,
+                    ACTION_NAMES.cpp_module_compile,
+                ],
+                flag_groups = [flag_group(flags = ["-DHAVE_MALLCTL"])],
+                with_features = [with_feature_set(["freebsd_target"])],
+            ),
+        ],
+    )]

bazel/cc_toolchains/cc_toolchain_config_features.bzl

@@ -0,0 +1,54 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""Configuration features for other features in a `cc_toolchain_config`.
+
+These features are designed to be used by other features in a
+`cc_toolchain_config` that need to configure their behavior in some way. This
+can be configuration based on either the target or host of the build, and along
+multiple dimensions of each.
+"""
+
+load(
+    "@rules_cc//cc:cc_toolchain_config_lib.bzl",
+    "feature",
+)
+
+os_names = [
+    "freebsd",
+    "linux",
+    "macos",
+    "windows",
+]
+
+def target_os_features(target_os):
+    if target_os not in os_names:
+        fail("Unsupported target OS: %s" % target_os)
+    return [
+        feature(name = os_name + "_target", enabled = os_name == target_os)
+        for os_name in os_names
+    ]
+
+cpu_names = [
+    "aarch64",
+    "x86_64",
+]
+
+# Also support canonicalizing different spellings of CPUs to one of the above
+# names.
+cpu_canonical_name_map = {
+    "aarch64": "aarch64",
+    "arm64": "aarch64",
+    "x86_64": "x86_64",
+}
+
+def target_cpu_features(target_cpu):
+    if target_cpu not in cpu_canonical_name_map:
+        fail("Unsupported target CPU: %s" % target_cpu)
+    target_cpu = cpu_canonical_name_map[target_cpu]
+
+    return [
+        feature(name = cpu_name + "_target", enabled = cpu_name == target_cpu)
+        for cpu_name in cpu_names
+    ]

bazel/cc_toolchains/cc_toolchain_cpp_features.bzl

@@ -0,0 +1,344 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""Definitions of general C++ `cc_toolchain_config` features."""
+
+load("@rules_cc//cc:action_names.bzl", "ACTION_NAMES", "ACTION_NAME_GROUPS")
+load(
+    "@rules_cc//cc:cc_toolchain_config_lib.bzl",
+    "feature",
+    "flag_group",
+    "flag_set",
+    "with_feature_set",
+)
+load(
+    ":cc_toolchain_actions.bzl",
+    "preprocessor_compile_actions",
+)
+
+# Sysroots and MacOS are complicated:
+#
+# On Darwin/MacOS, the `-isysroot` flag is used for includes *and* libraries,
+# and if specified it wins over `--sysroot` which would be used for libraries
+# on other platforms.
+# https://discourse.llvm.org/t/silly-what-is-the-difference-between-sysroot-and-isysroot/55788/2
+#
+# Additionally, on a MacOS build of clang, the sysroot defaults to `/`, which
+# is incorrect and it needs to be pointed to the SDK root. However, as a
+# convenience, homebrew builds of clang automatically add `-isysroot` to the
+# command line, so that the user doesn't have to. But the SDK it chooses does
+# not always match the one returned from `xcrun --show-sdk-path`, which is the
+# SDK that we want to use. So we need to override homebrew's choice and specify
+# `-isysroot`. This will also supersede anything given to `--sysroot` (on
+# Darwin) so we don't need to specify both. For non-homebrew clang builds on
+# MacOS, specifying `-isysroot` will also work to point the compiler to the
+# correct SDK instead of `--sysroot`.
+_sysroot_flag_sets = [
+    flag_set(
+        actions = ACTION_NAME_GROUPS.all_cc_compile_actions + ACTION_NAME_GROUPS.all_cc_link_actions,
+        flag_groups = [
+            flag_group(
+                expand_if_available = "sysroot",
+                flags = ["--sysroot=%{sysroot}"],
+            ),
+        ],
+        with_features = [with_feature_set(not_features = ["macos_target"])],
+    ),
+    flag_set(
+        actions = ACTION_NAME_GROUPS.all_cc_compile_actions + ACTION_NAME_GROUPS.all_cc_link_actions,
+        flag_groups = [
+            flag_group(
+                flags = ["-isysroot", "%{sysroot}"],
+            ),
+        ],
+        with_features = [with_feature_set(["macos_target"])],
+    ),
+]
+
+clang_feature = feature(
+    name = "clang",
+    enabled = True,
+    flag_sets = _sysroot_flag_sets + [
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_compile_actions + ACTION_NAME_GROUPS.all_cc_link_actions,
+            flag_groups = [
+                flag_group(flags = [
+                    "-no-canonical-prefixes",
+                    "-fcolor-diagnostics",
+                ]),
+            ],
+        ),
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_compile_actions,
+            flag_groups = [
+                flag_group(flags = [
+                    # Compile actions shouldn't link anything.
+                    "-c",
+                ]),
+
+                # Flags controlling the production of specific outputs from
+                # compile actions.
+                flag_group(
+                    expand_if_available = "output_assembly_file",
+                    flags = ["-S"],
+                ),
+                flag_group(
+                    expand_if_available = "output_preprocess_file",
+                    flags = ["-E"],
+                ),
+                flag_group(
+                    expand_if_available = "dependency_file",
+                    flags = ["-MD", "-MF", "%{dependency_file}"],
+                ),
+                flag_group(
+                    expand_if_available = "output_file",
+                    flags = ["-frandom-seed=%{output_file}"],
+                ),
+            ],
+        ),
+        flag_set(
+            # Flags specific to compiling C++ sources.
+            actions = ACTION_NAME_GROUPS.all_cpp_compile_actions,
+            flag_groups = [flag_group(flags = [
+                "-fno-exceptions",
+                "-fno-rtti",
+                "-std=c++20",
+            ])],
+        ),
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_compile_actions,
+            flag_groups = [flag_group(flags = [
+                "-ffunction-sections",
+                "-fdata-sections",
+            ])],
+        ),
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_compile_actions,
+            flag_groups = [flag_group(
+                expand_if_available = "pic",
+                flags = ["-fPIC"],
+            )],
+        ),
+        flag_set(
+            actions = preprocessor_compile_actions,
+            flag_groups = [
+                flag_group(flags = [
+                    # Disable a warning and override builtin macros to
+                    # ensure a hermetic build.
+                    "-Wno-builtin-macro-redefined",
+                    "-D__DATE__=\"redacted\"",
+                    "-D__TIMESTAMP__=\"redacted\"",
+                    "-D__TIME__=\"redacted\"",
+                ]),
+                flag_group(
+                    flags = ["-D%{preprocessor_defines}"],
+                    iterate_over = "preprocessor_defines",
+                ),
+                flag_group(
+                    expand_if_available = "includes",
+                    flags = ["-include", "%{includes}"],
+                    iterate_over = "includes",
+                ),
+                flag_group(
+                    flags = ["-iquote", "%{quote_include_paths}"],
+                    iterate_over = "quote_include_paths",
+                ),
+                flag_group(
+                    flags = ["-I%{include_paths}"],
+                    iterate_over = "include_paths",
+                ),
+                flag_group(
+                    flags = ["-isystem", "%{system_include_paths}"],
+                    iterate_over = "system_include_paths",
+                ),
+            ],
+        ),
+        flag_set(
+            actions = [
+                ACTION_NAMES.cpp_link_dynamic_library,
+                ACTION_NAMES.cpp_link_nodeps_dynamic_library,
+            ],
+            flag_groups = [flag_group(flags = ["-shared"])],
+        ),
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_link_actions,
+            flag_groups = [
+                flag_group(
+                    expand_if_available = "strip_debug_symbols",
+                    flags = ["-Wl,-S"],
+                ),
+                flag_group(
+                    expand_if_available = "library_search_directories",
+                    flags = ["-L%{library_search_directories}"],
+                    iterate_over = "library_search_directories",
+                ),
+                flag_group(
+                    expand_if_available =
+                        "runtime_library_search_directories",
+                    iterate_over = "runtime_library_search_directories",
+                    flags = [
+                        "-Wl,-rpath,$ORIGIN/%{runtime_library_search_directories}",
+                    ],
+                ),
+            ],
+        ),
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_link_actions,
+            flag_groups = [
+                flag_group(
+                    flags = [
+                        "-fuse-ld=lld",
+                        # Force the C++ standard library and runtime libraries
+                        # to be statically linked. This works even with libc++
+                        # and libunwind despite the names, provided libc++ is
+                        # built with the CMake option:
+                        # - `-DCMAKE_POSITION_INDEPENDENT_CODE=ON`
+                        "-static-libstdc++",
+                        "-static-libgcc",
+                        # Link with Clang's runtime library. This is always
+                        # linked statically.
+                        "-rtlib=compiler-rt",
+                        # Link with pthread.
+                        "-lpthread",
+                    ],
+                ),
+            ],
+            with_features = [with_feature_set(["linux_target"])],
+        ),
+        flag_set(
+            actions = [ACTION_NAMES.cpp_link_executable],
+            flag_groups = [flag_group(
+                expand_if_available = "force_pic",
+                flags = ["-pie"],
+            )],
+            with_features = [with_feature_set([
+                "linux_target",
+                "freebsd_target",
+            ])],
+        ),
+        flag_set(
+            actions = [ACTION_NAMES.cpp_link_executable],
+            flag_groups = [flag_group(
+                expand_if_available = "force_pic",
+                flags = ["-fpie"],
+            )],
+            with_features = [with_feature_set(["macos_target"])],
+        ),
+    ],
+)
+
+clang_warnings_feature = feature(
+    name = "clang_warnings",
+    enabled = True,
+    flag_sets = [flag_set(
+        actions = ACTION_NAME_GROUPS.all_cc_compile_actions,
+        flag_groups = [flag_group(flags = [
+            "-Werror",
+            "-Wall",
+            "-Wextra",
+            "-Wthread-safety",
+            "-Wself-assign",
+            "-Wimplicit-fallthrough",
+            "-Wctad-maybe-unsupported",
+            "-Wextra-semi",
+            "-Wmissing-prototypes",
+            "-Wzero-as-null-pointer-constant",
+            "-Wdelete-non-virtual-dtor",
+
+            # TODO: Regression that warns on anonymous unions; remove depending
+            # on fix.
+            "-Wno-missing-designated-field-initializers",
+        ])],
+    )],
+)
+
+# Libc++ HARDENING_MODE has 4 possible values:
+# https://libcxx.llvm.org/Hardening.html#notes-for-users
+#
+# Do not enable DEBUG hardening mode, even for -c dbg, because its performance
+# impact on llvm-symbolizer is too severe -- this flag results in symbolization
+# becoming quadratic in the number of debug symbols, in practice meaning it
+# never completes.
+_libcpp_debug_flags = [
+    "-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_EXTENSIVE",
+]
+_libcpp_release_flags = [
+    "-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_FAST",
+]
+
+def libcxx_feature(llvm_bindir = None, clang_bindir = None):
+    """Builds a libc++ feature.
+
+    Returns:
+        The feature for use with `cc_toolchain_config`.
+
+    Args:
+        llvm_bindir: Optional LLVM installation `bin` directory, causes the
+            feature to look for adjacent installed libraries.
+        clang_bindir: Optional Clang installation `bin` directory, causes the
+            feature to look for adjacent installed libraries if different from
+            `llvm_bindir`.
+    """
+
+    # Explicitly add LLVM libs to the search path to preempt the
+    # detected GCC installation's library paths. Those might have a
+    # system installed libc++ and we want to find the one next to
+    # our Clang.
+    extra_link_flags = []
+    if llvm_bindir:
+        extra_link_flags.append("-L" + llvm_bindir + "/../lib")
+    if clang_bindir and clang_bindir != llvm_bindir:
+        extra_link_flags.append("-L" + clang_bindir + "/../lib")
+
+    return feature(
+        name = "libcxx",
+        enabled = True,
+        flag_sets = [
+            flag_set(
+                actions = ACTION_NAME_GROUPS.all_cpp_compile_actions + ACTION_NAME_GROUPS.all_cc_link_actions,
+                flag_groups = [flag_group(flags = [
+                    "-stdlib=libc++",
+                ])],
+                with_features = [
+                    # libc++ is only used on non-Windows platforms.
+                    with_feature_set(not_features = ["windows_target"]),
+                ],
+            ),
+            flag_set(
+                actions = ACTION_NAME_GROUPS.all_cpp_compile_actions,
+                flag_groups = [flag_group(flags = _libcpp_debug_flags)],
+                with_features = [with_feature_set(not_features = ["opt"])],
+            ),
+            flag_set(
+                actions = ACTION_NAME_GROUPS.all_cpp_compile_actions,
+                flag_groups = [flag_group(flags = _libcpp_release_flags)],
+                with_features = [with_feature_set(features = ["opt"])],
+            ),
+            flag_set(
+                actions = ACTION_NAME_GROUPS.all_cc_link_actions,
+                flag_groups = [flag_group(flags = [
+                    "-unwindlib=libunwind",
+                ])],
+                with_features = [
+                    # libc++ is only used on non-Windows platforms, and macOS
+                    # doesn't support a custom unwinding library (or need one)
+                    # even when using libc++.
+                    with_feature_set(not_features = [
+                        "macos_target",
+                        "windows_target",
+                    ]),
+                ],
+            ),
+            flag_set(
+                actions = ACTION_NAME_GROUPS.all_cc_link_actions,
+                flag_groups = [flag_group(flags = extra_link_flags + [
+                    # Force linking the static libc++abi archive here. This
+                    # *should* be linked automatically, but not every release of
+                    # LLVM correctly sets the CMake flags to do so.
+                    "-l:libc++abi.a",
+                ])],
+                with_features = [with_feature_set(["linux_target"])],
+            ),
+        ],
+    )

bazel/cc_toolchains/cc_toolchain_debugging.bzl

@@ -0,0 +1,135 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""Definitions of debugging related features used in a `cc_toolchain_config`."""
+
+load("@rules_cc//cc:action_names.bzl", "ACTION_NAME_GROUPS")
+load(
+    "@rules_cc//cc:cc_toolchain_config_lib.bzl",
+    "feature",
+    "feature_set",
+    "flag_group",
+    "flag_set",
+)
+
+# Handle different levels and forms of debug info emission with individual
+# features so that they can be ordered and the defaults can override the
+# minimal settings if both are enabled.
+minimal_debug_info_flags = feature(
+    name = "minimal_debug_info_flags",
+    implies = ["debug_info_compression_flags"],
+    flag_sets = [flag_set(
+        actions = ACTION_NAME_GROUPS.all_cc_compile_actions,
+        flag_groups = [flag_group(flags = ["-gmlt"])],
+    )],
+)
+debug_info_flags = feature(
+    name = "debug_info_flags",
+    implies = ["debug_info_compression_flags"],
+    flag_sets = [flag_set(
+        actions = ACTION_NAME_GROUPS.all_cc_compile_actions,
+        flag_groups = [
+            flag_group(flags = ["-g"]),
+            flag_group(
+                expand_if_available = "per_object_debug_info_file",
+                flags = ["-gsplit-dwarf"],
+            ),
+        ],
+    )],
+)
+debug_info_compression_flags = feature(
+    name = "debug_info_compression_flags",
+    flag_sets = [flag_set(
+        actions = ACTION_NAME_GROUPS.all_cc_compile_actions + ACTION_NAME_GROUPS.all_cc_link_actions,
+        flag_groups = [flag_group(flags = ["-gz"])],
+    )],
+)
+
+# Define a set of mutually exclusive debugger flags.
+debugger_flags = feature(name = "debugger_flags")
+lldb_flags = feature(
+    # Use a convenient name for users to select if needed.
+    name = "lldb_flags",
+    # Default enable LLDB-optimized flags whenever debugging.
+    enabled = True,
+    requires = [feature_set(features = ["debug_info_flags"])],
+    provides = ["debugger_flags"],
+    flag_sets = [flag_set(
+        actions = ACTION_NAME_GROUPS.all_cc_compile_actions,
+        flag_groups = [flag_group(flags = [
+            "-glldb",
+            "-gpubnames",
+            "-gsimple-template-names",
+        ])],
+    )],
+)
+gdb_flags = feature(
+    # Use a convenient name for users to select if needed.
+    name = "gdb_flags",
+    requires = [feature_set(features = ["debug_info_flags"])],
+    provides = ["debugger_flags"],
+    flag_sets = [
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_compile_actions,
+            flag_groups = [flag_group(flags = [
+                "-ggdb",
+                "-ggnu-pubnames",
+            ])],
+        ),
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_link_actions,
+            flag_groups = [flag_group(flags = ["-Wl,--gdb-index"])],
+        ),
+    ],
+)
+
+# This feature can be enabled in conjunction with any optimizations to
+# ensure accurate call stacks and backtraces for profilers or errors.
+preserve_call_stacks = feature(
+    name = "preserve_call_stacks",
+    flag_sets = [flag_set(
+        actions = ACTION_NAME_GROUPS.all_cc_compile_actions,
+        flag_groups = [flag_group(flags = [
+            # Ensure good backtraces by preserving frame pointers and
+            # disabling tail call elimination.
+            "-fno-omit-frame-pointer",
+            "-mno-omit-leaf-frame-pointer",
+            "-fno-optimize-sibling-calls",
+        ])],
+    )],
+)
+
+# Enable split debug info whenever debug info is requested.
+enable_split_debug_info = feature(
+    name = "per_object_debug_info",
+    enabled = True,
+    # This has to be directly conditioned on requesting debug info at
+    # all, otherwise Bazel will look for an extra output file and not
+    # find one.
+    requires = [feature_set(features = ["debug_info_flags"])],
+)
+
+# Enable debug info whenever in the `dbg` build mode. We do this separately from
+# the `debug_info_flags` feature itself as other things may want to enable that
+# feature as well.
+enable_debug_info_in_dbg = feature(
+    name = "enable_debug_info_in_dbg",
+    enabled = True,
+    requires = [feature_set(["dbg"])],
+    implies = ["debug_info_flags"],
+)
+
+# Note that the order of features is significant in this list and determines the
+# relative order of flags from the features listed.
+debugging_features = [
+    minimal_debug_info_flags,
+    debug_info_flags,
+    debug_info_compression_flags,
+    debugger_flags,
+    lldb_flags,
+    gdb_flags,
+    preserve_call_stacks,
+    enable_split_debug_info,
+    enable_debug_info_in_dbg,
+]

bazel/cc_toolchains/cc_toolchain_features.bzl

@@ -0,0 +1,75 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""Helpers to construct ordered sequences of `cc_toolchain` features."""
+
+load(
+    ":cc_toolchain_base_features.bzl",
+    "base_features",
+    "output_flags_feature",
+    "user_flags_feature",
+)
+load(
+    ":cc_toolchain_config_features.bzl",
+    "target_cpu_features",
+    "target_os_features",
+)
+load(
+    ":cc_toolchain_cpp_features.bzl",
+    "clang_feature",
+    "clang_warnings_feature",
+)
+load(":cc_toolchain_debugging.bzl", "debugging_features")
+load(":cc_toolchain_linking.bzl", "linking_features")
+load(":cc_toolchain_modules.bzl", "modules_features")
+load(":cc_toolchain_optimization.bzl", "optimization_features")
+load(":cc_toolchain_sanitizer_features.bzl", "sanitizer_features")
+
+def clang_cc_toolchain_features(
+        target_os,
+        target_cpu,
+        project_features = [],
+        extra_cpp_features = []):
+    """Builds a sequence of Clang-oriented `cc_toolchain_config` features.
+
+    Returns:
+        The list of features for calling `create_cc_toolchain_config_info`.
+
+    Args:
+        target_os: Used to select OS-specific features to include.
+        target_cpu: Used to select CPU-specific features to include.
+        project_features: Optional list of project-specific features to include.
+        extra_cpp_features: Optional list of extra C++ features to include, for
+            example `libcxx_feature` can be passed here to enable using libc++.
+    """
+
+    # The order of the features determines the relative order of flags used.
+    features = []
+    features += target_os_features(target_os)
+    features += target_cpu_features(target_cpu)
+    features += base_features
+    features += [
+        # We always use Clang in the toolchain and enable all of its warnings.
+        clang_feature,
+        clang_warnings_feature,
+    ]
+
+    # Enable any extra baseline C++ features here where others can override
+    # their flags if needed.
+    features += extra_cpp_features
+
+    features += sanitizer_features
+    features += optimization_features
+    features += modules_features
+    features += debugging_features
+    features += linking_features
+
+    # Lastly, we add project features and the user flags so they can override
+    # anything above, and the output flags last of all for ease of debugging.
+    features += project_features
+    features += [
+        user_flags_feature,
+        output_flags_feature,
+    ]
+    return features

bazel/cc_toolchains/cc_toolchain_linking.bzl

@@ -0,0 +1,284 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""Definitions of linking related features used in a `cc_toolchain_config`."""
+
+load("@rules_cc//cc:action_names.bzl", "ACTION_NAMES", "ACTION_NAME_GROUPS")
+load(
+    "@rules_cc//cc:cc_toolchain_config_lib.bzl",
+    "feature",
+    "flag_group",
+    "flag_set",
+    "variable_with_value",
+    "with_feature_set",
+)
+
+link_libraries_feature = feature(
+    name = "link_libraries",
+    enabled = True,
+    flag_sets = [
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_link_actions,
+            flag_groups = [
+                flag_group(
+                    expand_if_available = "linkstamp_paths",
+                    flags = ["%{linkstamp_paths}"],
+                    iterate_over = "linkstamp_paths",
+                ),
+                flag_group(
+                    expand_if_available = "libraries_to_link",
+                    flag_groups = [
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "object_file_group",
+                            ),
+                            flags = ["-Wl,--start-lib"],
+                        ),
+                        flag_group(
+                            expand_if_true = "libraries_to_link.is_whole_archive",
+                            flags = ["-Wl,-whole-archive"],
+                        ),
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "object_file_group",
+                            ),
+                            flags = ["%{libraries_to_link.object_files}"],
+                            iterate_over = "libraries_to_link.object_files",
+                        ),
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "object_file",
+                            ),
+                            flags = ["%{libraries_to_link.name}"],
+                        ),
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "interface_library",
+                            ),
+                            flags = ["%{libraries_to_link.name}"],
+                        ),
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "static_library",
+                            ),
+                            flags = ["%{libraries_to_link.name}"],
+                        ),
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "dynamic_library",
+                            ),
+                            flags = ["-l%{libraries_to_link.name}"],
+                        ),
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "versioned_dynamic_library",
+                            ),
+                            flags = ["-l:%{libraries_to_link.name}"],
+                        ),
+                        flag_group(
+                            expand_if_true = "libraries_to_link.is_whole_archive",
+                            flags = ["-Wl,-no-whole-archive"],
+                        ),
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "object_file_group",
+                            ),
+                            flags = ["-Wl,--end-lib"],
+                        ),
+                    ],
+                    iterate_over = "libraries_to_link",
+                ),
+                # Note that the params file comes at the end, after the
+                # libraries to link above.
+                flag_group(
+                    expand_if_available = "linker_param_file",
+                    flags = ["@%{linker_param_file}"],
+                ),
+            ],
+            with_features = [with_feature_set(not_features = ["macos_target"])],
+        ),
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_link_actions,
+            flag_groups = [
+                flag_group(
+                    expand_if_available = "linkstamp_paths",
+                    flags = ["%{linkstamp_paths}"],
+                    iterate_over = "linkstamp_paths",
+                ),
+                flag_group(
+                    expand_if_available = "libraries_to_link",
+                    flag_groups = [
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "object_file_group",
+                            ),
+                            flags = ["-Wl,--start-lib"],
+                        ),
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "object_file_group",
+                            ),
+                            flag_groups = [
+                                flag_group(
+                                    expand_if_false = "libraries_to_link.is_whole_archive",
+                                    flags = ["%{libraries_to_link.object_files}"],
+                                ),
+                                flag_group(
+                                    expand_if_true = "libraries_to_link.is_whole_archive",
+                                    flags = ["-Wl,-force_load,%{libraries_to_link.object_files}"],
+                                ),
+                            ],
+                            iterate_over = "libraries_to_link.object_files",
+                        ),
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "object_file",
+                            ),
+                            flag_groups = [
+                                flag_group(
+                                    expand_if_false = "libraries_to_link.is_whole_archive",
+                                    flags = ["%{libraries_to_link.name}"],
+                                ),
+                                flag_group(
+                                    expand_if_true = "libraries_to_link.is_whole_archive",
+                                    flags = ["-Wl,-force_load,%{libraries_to_link.name}"],
+                                ),
+                            ],
+                        ),
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "interface_library",
+                            ),
+                            flag_groups = [
+                                flag_group(
+                                    expand_if_false = "libraries_to_link.is_whole_archive",
+                                    flags = ["%{libraries_to_link.name}"],
+                                ),
+                                flag_group(
+                                    expand_if_true = "libraries_to_link.is_whole_archive",
+                                    flags = ["-Wl,-force_load,%{libraries_to_link.name}"],
+                                ),
+                            ],
+                        ),
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "static_library",
+                            ),
+                            flag_groups = [
+                                flag_group(
+                                    expand_if_false = "libraries_to_link.is_whole_archive",
+                                    flags = ["%{libraries_to_link.name}"],
+                                ),
+                                flag_group(
+                                    expand_if_true = "libraries_to_link.is_whole_archive",
+                                    flags = ["-Wl,-force_load,%{libraries_to_link.name}"],
+                                ),
+                            ],
+                        ),
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "dynamic_library",
+                            ),
+                            flags = ["-l%{libraries_to_link.name}"],
+                        ),
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "versioned_dynamic_library",
+                            ),
+                            flags = ["-l:%{libraries_to_link.name}"],
+                        ),
+                        flag_group(
+                            expand_if_true = "libraries_to_link.is_whole_archive",
+                            flag_groups = [
+                                flag_group(
+                                    expand_if_false = "macos_flags",
+                                    flags = ["-Wl,-no-whole-archive"],
+                                ),
+                            ],
+                        ),
+                        flag_group(
+                            expand_if_equal = variable_with_value(
+                                name = "libraries_to_link.type",
+                                value = "object_file_group",
+                            ),
+                            flags = ["-Wl,--end-lib"],
+                        ),
+                    ],
+                    iterate_over = "libraries_to_link",
+                ),
+                # Note that the params file comes at the end, after the
+                # libraries to link above.
+                flag_group(
+                    expand_if_available = "linker_param_file",
+                    flags = ["@%{linker_param_file}"],
+                ),
+            ],
+            with_features = [with_feature_set(["macos_target"])],
+        ),
+    ],
+)
+
+# Archive actions have an entirely independent set of flags and don't
+# interact with either compiler or link actions.
+archiving_feature = feature(
+    name = "archiving",
+    enabled = True,
+    flag_sets = [flag_set(
+        actions = [ACTION_NAMES.cpp_link_static_library],
+        flag_groups = [
+            flag_group(flags = ["rcsD"]),
+            flag_group(
+                expand_if_available = "output_execpath",
+                flags = ["%{output_execpath}"],
+            ),
+            flag_group(
+                expand_if_available = "libraries_to_link",
+                flag_groups = [
+                    flag_group(
+                        expand_if_equal = variable_with_value(
+                            name = "libraries_to_link.type",
+                            value = "object_file",
+                        ),
+                        flags = ["%{libraries_to_link.name}"],
+                    ),
+                    flag_group(
+                        expand_if_equal = variable_with_value(
+                            name = "libraries_to_link.type",
+                            value = "object_file_group",
+                        ),
+                        flags = ["%{libraries_to_link.object_files}"],
+                        iterate_over = "libraries_to_link.object_files",
+                    ),
+                ],
+                iterate_over = "libraries_to_link",
+            ),
+            flag_group(
+                expand_if_available = "linker_param_file",
+                flags = ["@%{linker_param_file}"],
+            ),
+        ],
+    )],
+)
+
+# Note that the order of features is significant in this list and determines the
+# relative order of flags from the features listed.
+linking_features = [
+    link_libraries_feature,
+    archiving_feature,
+]

bazel/cc_toolchains/cc_toolchain_modules.bzl

@@ -0,0 +1,82 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""Definitions of C++ and Clang header modules toolchain features."""
+
+load("@rules_cc//cc:action_names.bzl", "ACTION_NAMES")
+load(
+    "@rules_cc//cc:cc_toolchain_config_lib.bzl",
+    "feature",
+    "feature_set",
+    "flag_group",
+    "flag_set",
+)
+
+use_module_maps = feature(
+    name = "use_module_maps",
+    requires = [feature_set(features = ["module_maps"])],
+    flag_sets = [
+        flag_set(
+            actions = [
+                ACTION_NAMES.c_compile,
+                ACTION_NAMES.cpp_compile,
+                ACTION_NAMES.cpp_header_parsing,
+                ACTION_NAMES.cpp_module_compile,
+            ],
+            flag_groups = [
+                # These flag groups are separate so they do not expand to
+                # the cross product of the variables.
+                flag_group(flags = ["-fmodule-name=%{module_name}"]),
+                flag_group(
+                    flags = ["-fmodule-map-file=%{module_map_file}"],
+                ),
+            ],
+        ),
+    ],
+)
+
+# Tell bazel we support module maps in general, so they will be generated
+# for all c/c++ rules.
+# Note: not all C++ rules support module maps; thus, do not imply this
+# feature from other features - instead, require it.
+module_maps = feature(
+    name = "module_maps",
+    enabled = True,
+    implies = [
+        # "module_map_home_cwd",
+        # "module_map_without_extern_module",
+        # "generate_submodules",
+    ],
+)
+
+layering_check = feature(
+    name = "layering_check",
+    implies = ["use_module_maps"],
+    flag_sets = [flag_set(
+        actions = [
+            ACTION_NAMES.c_compile,
+            ACTION_NAMES.cpp_compile,
+            ACTION_NAMES.cpp_header_parsing,
+            ACTION_NAMES.cpp_module_compile,
+        ],
+        flag_groups = [
+            flag_group(flags = [
+                "-fmodules-strict-decluse",
+                "-Wprivate-header",
+            ]),
+            flag_group(
+                iterate_over = "dependent_module_map_files",
+                flags = ["-fmodule-map-file=%{dependent_module_map_files}"],
+            ),
+        ],
+    )],
+)
+
+# Note that the order of features is significant in this list and determines the
+# relative order of flags from the features listed.
+modules_features = [
+    layering_check,
+    module_maps,
+    use_module_maps,
+]

bazel/cc_toolchains/cc_toolchain_optimization.bzl

@@ -0,0 +1,66 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""Definitions of optimization `cc_toolchain_config` features."""
+
+load("@rules_cc//cc:action_names.bzl", "ACTION_NAME_GROUPS")
+load(
+    "@rules_cc//cc:cc_toolchain_config_lib.bzl",
+    "feature",
+    "feature_set",
+    "flag_group",
+    "flag_set",
+    "with_feature_set",
+)
+
+# Handle different levels of optimization with individual features so that
+# they can be ordered and the defaults can override the minimal settings if
+# both are enabled.
+minimal_optimization_flags = feature(
+    name = "minimal_optimization_flags",
+    flag_sets = [flag_set(
+        actions = ACTION_NAME_GROUPS.all_cc_compile_actions,
+        flag_groups = [flag_group(flags = ["-Og"])],
+    )],
+)
+default_optimization_flags = feature(
+    name = "default_optimization_flags",
+    enabled = True,
+    requires = [feature_set(["opt"])],
+    flag_sets = [
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_compile_actions,
+            flag_groups = [flag_group(flags = ["-DNDEBUG"])],
+        ),
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_compile_actions,
+            flag_groups = [flag_group(flags = ["-O3"])],
+        ),
+    ],
+)
+
+cpu_flags = feature(
+    name = "aarch64_cpu_flags",
+    enabled = True,
+    flag_sets = [
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_compile_actions + ACTION_NAME_GROUPS.all_cc_link_actions,
+            flag_groups = [flag_group(flags = ["-march=armv8.2-a"])],
+            with_features = [with_feature_set(["aarch64_target"])],
+        ),
+        flag_set(
+            actions = ACTION_NAME_GROUPS.all_cc_compile_actions + ACTION_NAME_GROUPS.all_cc_link_actions,
+            flag_groups = [flag_group(flags = ["-march=x86-64-v2"])],
+            with_features = [with_feature_set(["x86_64_target"])],
+        ),
+    ],
+)
+
+# Note that the order of features is significant in this list and determines the
+# relative order of flags from the features listed.
+optimization_features = [
+    minimal_optimization_flags,
+    default_optimization_flags,
+    cpu_flags,
+]

bazel/cc_toolchains/cc_toolchain_sanitizer_features.bzl

@@ -0,0 +1,109 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""Definitions of sanitizer-related `cc_toolchain_config` features."""
+
+load("@rules_cc//cc:action_names.bzl", "ACTION_NAME_GROUPS")
+load(
+    "@rules_cc//cc:cc_toolchain_config_lib.bzl",
+    "feature",
+    "feature_set",
+    "flag_group",
+    "flag_set",
+    "with_feature_set",
+)
+
+sanitizer_common_flags = feature(
+    name = "sanitizer_common_flags",
+    implies = ["minimal_debug_info_flags", "preserve_call_stacks"],
+    flag_sets = [flag_set(
+        actions = ACTION_NAME_GROUPS.all_cc_link_actions,
+        flag_groups = [flag_group(flags = ["-static-libsan"])],
+        with_features = [
+            with_feature_set(["linux_target"]),
+            with_feature_set(["freebsd_target"]),
+        ],
+    )],
+)
+
+asan = feature(
+    name = "asan",
+    implies = ["sanitizer_common_flags"],
+    flag_sets = [flag_set(
+        actions = ACTION_NAME_GROUPS.all_cc_compile_actions + ACTION_NAME_GROUPS.all_cc_link_actions,
+        flag_groups = [flag_group(flags = [
+            "-fsanitize=address,undefined,nullability",
+            "-fsanitize-address-use-after-scope",
+            # Outlining is almost always the right tradeoff for our
+            # sanitizer usage where we're more pressured on generated code
+            # size than runtime performance.
+            "-fsanitize-address-outline-instrumentation",
+            # We don't need the recovery behavior of UBSan as we expect
+            # builds to be clean. Not recovering is a bit cheaper.
+            "-fno-sanitize-recover=undefined,nullability",
+            # Don't embed the full path name for files. This limits the size
+            # and combined with line numbers is unlikely to result in many
+            # ambiguities.
+            "-fsanitize-undefined-strip-path-components=-1",
+            # Needed due to clang AST issues, such as in
+            # clang/AST/Redeclarable.h line 199.
+            "-fno-sanitize=vptr",
+        ])],
+    )],
+)
+
+# A feature that further reduces the generated code size of our the ASan
+# feature, but at the cost of lower quality diagnostics. This is enabled
+# along with ASan in our fastbuild configuration, but can be disabled
+# explicitly to get better error messages.
+asan_min_size = feature(
+    name = "asan_min_size",
+    requires = [feature_set(["asan"])],
+    flag_sets = [flag_set(
+        actions = ACTION_NAME_GROUPS.all_cc_compile_actions + ACTION_NAME_GROUPS.all_cc_link_actions,
+        flag_groups = [flag_group(flags = [
+            # Force two UBSan checks that have especially large code size
+            # cost to use the minimal branch to a trapping instruction model
+            # instead of the full diagnostic.
+            "-fsanitize-trap=alignment,null",
+        ])],
+    )],
+)
+
+fuzzer = feature(
+    name = "fuzzer",
+    flag_sets = [flag_set(
+        actions = ACTION_NAME_GROUPS.all_cc_compile_actions + ACTION_NAME_GROUPS.all_cc_link_actions,
+        flag_groups = [flag_group(flags = [
+            "-fsanitize=fuzzer-no-link",
+        ])],
+    )],
+)
+
+sanitizer_workarounds = feature(
+    name = "sanitizer_workarounds",
+    enabled = True,
+    requires = [feature_set(["asan"])],
+    flag_sets = [flag_set(
+        actions = ACTION_NAME_GROUPS.all_cc_compile_actions + ACTION_NAME_GROUPS.all_cc_link_actions,
+        flag_groups = [flag_group(flags = [
+            # Likely due to being unable to use the static-linked and up-to-date
+            # sanitizer runtimes, we have to disable this sanitizer on macOS.
+            "-fno-sanitize=function",
+        ])],
+        with_features = [with_feature_set(["macos_target"])],
+    )],
+)
+
+# Note that the order of features is significant in this list and determines the
+# relative order of flags from the features listed.
+sanitizer_features = [
+    sanitizer_common_flags,
+    asan,
+    asan_min_size,
+    fuzzer,
+
+    # Note that the workarounds must come last here to override earlier flags.
+    sanitizer_workarounds,
+]

bazel/cc_toolchains/cc_toolchain_tools.bzl

@@ -0,0 +1,79 @@
+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+# Exceptions. See /LICENSE for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""Macros to produce tool-related parts of a `cc_toolchain_config`.
+
+These macros cover both the `actions_config` array and the `tool_paths` array.
+
+They presume an LLVM and Clang toolchain's tools, but support both a single
+installation and installations that split the LLVM tools and Clang tools apart.
+"""
+
+load("@rules_cc//cc:action_names.bzl", "ACTION_NAMES", "ACTION_NAME_GROUPS")
+load(
+    "@rules_cc//cc:cc_toolchain_config_lib.bzl",
+    "action_config",
+    "tool",
+    "tool_path",
+)
+load(
+    ":cc_toolchain_actions.bzl",
+    "all_c_compile_actions",
+)
+
+def llvm_tool_paths(llvm_bindir, clang_bindir = None):
+    if not clang_bindir:
+        clang_bindir = llvm_bindir
+    return [
+        tool_path(name = "ar", path = llvm_bindir + "/llvm-ar"),
+        tool_path(name = "ld", path = clang_bindir + "/ld.lld"),
+        tool_path(name = "cpp", path = clang_bindir + "/clang-cpp"),
+        tool_path(name = "gcc", path = clang_bindir + "/clang++"),
+        tool_path(name = "dwp", path = llvm_bindir + "/llvm-dwp"),
+        tool_path(name = "gcov", path = llvm_bindir + "/llvm-cov"),
+        tool_path(name = "nm", path = llvm_bindir + "/llvm-nm"),
+        tool_path(name = "objcopy", path = llvm_bindir + "/llvm-objcopy"),
+        tool_path(name = "objdump", path = llvm_bindir + "/llvm-objdump"),
+        tool_path(name = "strip", path = llvm_bindir + "/llvm-strip"),
+    ]
+
+def llvm_action_configs(llvm_bindir, clang_bindir = None):
+    if not clang_bindir:
+        clang_bindir = llvm_bindir
+    return [
+        action_config(
+            action_name = name,
+            enabled = True,
+            tools = [tool(path = clang_bindir + "/clang")],
+        )
+        for name in all_c_compile_actions
+    ] + [
+        action_config(
+            action_name = name,
+            enabled = True,
+            tools = [tool(path = clang_bindir + "/clang++")],
+        )
+        for name in ACTION_NAME_GROUPS.all_cpp_compile_actions
+    ] + [
+        action_config(
+            action_name = name,
+            enabled = True,
+            tools = [tool(path = clang_bindir + "/clang++")],
+        )
+        for name in ACTION_NAME_GROUPS.all_cc_link_actions
+    ] + [
+        action_config(
+            action_name = name,
+            enabled = True,
+            tools = [tool(path = llvm_bindir + "/llvm-ar")],
+        )
+        for name in [ACTION_NAMES.cpp_link_static_library]
+    ] + [
+        action_config(
+            action_name = name,
+            enabled = True,
+            tools = [tool(path = llvm_bindir + "/llvm-strip")],
+        )
+        for name in [ACTION_NAMES.strip]
+    ]

bazel/cc_toolchains/cc_tools_test.py

@@ -0,0 +1,60 @@
+"""Tests that the C++ toolchain tools can be executed.
+
+This script reads a file containing paths to C++ tools (like clang++, llvm-ar)
+and attempts to run each with `--version` to verify they are functional.
+"""
+
+__copyright__ = """
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""
+
+import os
+import subprocess
+import sys
+
+from bazel_tools.tools.python.runfiles import runfiles
+
+
+def test_tools() -> None:
+    """Reads paths from file and runs each tool with --version."""
+    if len(sys.argv) < 2:
+        print("Usage: cc_tools_test.py <paths_file>")
+        sys.exit(1)
+
+    paths_file = sys.argv[1]
+    print(f"Reading tools from: {paths_file}")
+    with open(paths_file, "r") as f:
+        tools = [line.strip() for line in f if line.strip()]
+
+    print(f"Testing tools: {tools}")
+    r = runfiles.Create()
+    repo_name = os.environ.get("TEST_WORKSPACE") or "_main"
+
+    for tool in tools:
+        if "bazel-out/" in tool:
+            _, _, rest = tool.partition("bazel-out/")
+            _, sep, after = rest.partition("bin/")
+            if sep:
+                tool = after
+
+        rlocation_path = os.path.join(repo_name, tool)
+        tool = r.Rlocation(rlocation_path)
+
+        print(f"Running {tool} --version")
+        try:
+            res = subprocess.run(
+                [tool, "--version"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            print(res.stdout)
+        except Exception as e:
+            print(f"Failed to run {tool}: {e}")
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    test_tools()

bazel/cc_toolchains/clang_configuration.bzl

@@ -83,7 +83,11 @@ def _compute_clang_resource_dir(repository_ctx, clang):
     ).stdout
 
     # The only line printed is this path.
-    return output.splitlines()[0]
+    dir_path = repository_ctx.path(output.splitlines()[0])
+
+    # Canonicalize the path to help ensure string matching succeeds
+    # even with clang installs returning a non-canonical path.
+    return str(dir_path.realpath)
 
 def _compute_mac_os_sysroot(repository_ctx):
     """Runs `xcrun` to extract the correct sysroot."""
@@ -148,7 +152,7 @@ def _compute_clang_cpp_include_search_paths(repository_ctx, clang, sysroot):
     if repository_ctx.os.name.lower().startswith("mac os"):
         if not sysroot:
             fail("Must provide a sysroot on macOS!")
-        cmd.append("--sysroot=" + sysroot)
+        cmd += ["-isysroot", sysroot]
 
     # Note that verbose output is on stderr, not stdout!
     output = _run(repository_ctx, cmd).stderr.splitlines()
@@ -174,6 +178,8 @@ def _configure_clang_toolchain_impl(repository_ctx):
         repository_ctx.attr._clang_cc_toolchain_config,
         "cc_toolchain_config.bzl",
     )
+    for file_label in repository_ctx.attr._clang_toolchain_files:
+        repository_ctx.symlink(file_label, file_label.name)
 
     # Find a Clang C++ compiler, and where it lives. We need to walk symlinks
     # here as the other LLVM tools may not be symlinked into the PATH even if
@@ -182,9 +188,9 @@ def _configure_clang_toolchain_impl(repository_ctx):
     (clang, clang_version, clang_version_for_cache) = _detect_system_clang(
         repository_ctx,
     )
-    if clang_version and clang_version < 19:
+    if clang_version and clang_version < 21:
         fail("Found clang {0}. ".format(clang_version) +
-             "Carbon requires clang >=19. See " +
+             "Carbon requires clang >=21. See " +
              "https://github.com/carbon-language/carbon-lang/blob/trunk/docs/project/contribution_tools.md#old-llvm-versions")
 
     clang_cpp = clang.dirname.get_child("clang++")
@@ -224,7 +230,7 @@ def _configure_clang_toolchain_impl(repository_ctx):
         repository_ctx.attr._clang_detected_variables_template,
         substitutions = {
             "{CLANG_BINDIR}": str(clang.dirname),
-            "{CLANG_INCLUDE_DIRS_LIST}": str(
+            "{CLANG_INCLUDE_DIRS}": str(
                 [str(path) for path in include_dirs],
             ),
             "{CLANG_RESOURCE_DIR}": resource_dir,
@@ -258,6 +264,22 @@ configure_clang_toolchain = repository_rule(
             default = Label("//bazel/cc_toolchains:clang_toolchain.BUILD"),
             allow_single_file = True,
         ),
+        "_clang_toolchain_files": attr.label_list(
+            default = [
+                Label("//bazel/cc_toolchains:cc_toolchain_actions.bzl"),
+                Label("//bazel/cc_toolchains:cc_toolchain_base_features.bzl"),
+                Label("//bazel/cc_toolchains:cc_toolchain_carbon_project_features.bzl"),
+                Label("//bazel/cc_toolchains:cc_toolchain_config_features.bzl"),
+                Label("//bazel/cc_toolchains:cc_toolchain_cpp_features.bzl"),
+                Label("//bazel/cc_toolchains:cc_toolchain_debugging.bzl"),
+                Label("//bazel/cc_toolchains:cc_toolchain_features.bzl"),
+                Label("//bazel/cc_toolchains:cc_toolchain_linking.bzl"),
+                Label("//bazel/cc_toolchains:cc_toolchain_modules.bzl"),
+                Label("//bazel/cc_toolchains:cc_toolchain_optimization.bzl"),
+                Label("//bazel/cc_toolchains:cc_toolchain_sanitizer_features.bzl"),
+                Label("//bazel/cc_toolchains:cc_toolchain_tools.bzl"),
+            ],
+        ),
     },
     environ = ["CC"],
 )

bazel/cc_toolchains/clang_detected_variables.tpl.bzl

@@ -14,5 +14,5 @@ clang_bindir = "{CLANG_BINDIR}"
 clang_version = {CLANG_VERSION}
 clang_version_for_cache = "{CLANG_VERSION_FOR_CACHE}"
 clang_resource_dir = "{CLANG_RESOURCE_DIR}"
-clang_include_dirs_list = {CLANG_INCLUDE_DIRS_LIST}
+clang_include_dirs = {CLANG_INCLUDE_DIRS}
 sysroot_dir = "{SYSROOT}"

bazel/cc_toolchains/defs.bzl

@@ -41,6 +41,6 @@ def cc_env():
     macos_env = {"MallocNanoZone": "0"}
 
     return common_env | select({
-        "//bazel/cc_toolchains:macos_asan": macos_env,
+        Label("//bazel/cc_toolchains:macos_asan"): macos_env,
         "//conditions:default": {},
     })

bazel/check_deps/BUILD

@@ -13,8 +13,8 @@ load("@rules_python//python:defs.bzl", "py_test")
 filegroup(
     name = "non_test_cc_rules",
     data = [
-        "//toolchain/install:carbon_toolchain_tar_gz_rule",
-        "//toolchain/install:carbon_toolchain_tar_rule",
+        "//toolchain/install:carbon_toolchain_tar",
+        "//toolchain/install:carbon_toolchain_tar_gz",
     ],
     tags = ["manual"],
 )

bazel/check_deps/check_non_test_cc_deps.py

@@ -41,14 +41,25 @@ for dep in deps:
         # Other packages in the LLVM project shouldn't be accidentally used
         # in Carbon. We can expand the above list if use cases emerge.
         if package not in (
-            "llvm",
-            "lld",
             "clang",
             "clang-tools-extra/clangd",
+            "libc",
+            "libcxx",
+            "libcxxabi",
             "libunwind",
+            "lld",
+            "llvm",
             # While this is in a `third_party` directory, its code is documented
             # as part of LLVM and for use in compiler-rt.
             "third-party/siphash",
+        ) and (
+            package == "third-party"
+            and rule
+            not in (
+                # LLVM wrappers for zlib-ng and zstd, which are fine as linked.
+                "zlib",
+                "zstd",
+            )
         ):
             sys.exit(
                 "ERROR: unexpected dependency into the LLVM project: %s" % dep
@@ -68,14 +79,18 @@ for dep in deps:
     if repo == "" and not rule.startswith("third_party"):
         continue
 
+    # LLVM code managed in the Carbon repository is still LLVM code and OK.
+    if repo == "" and rule.startswith("third_party/llvm:"):
+        continue
+
     # Utility libraries provided by Bazel that are under a compatible license.
     if repo in ("@@rules_cc+", "@@bazel_tools"):
         continue
 
-    # These are stubs wrapping system libraries for LLVM. They aren't
-    # distributed and so should be fine.
+    # These libraries have compatible licenses and are linked in without copying
+    # source, so fine for our binaries.
     if repo in (
-        "@@zlib+",
+        "@@zlib-ng+",
         "@@zstd+",
     ):
         continue

bazel/check_deps/update_roots.py

@@ -1,4 +1,9 @@
-#!/usr/bin/env python3
+#!/usr/bin/env -S uv run --script
+
+# /// script
+# requires-python = ">=3.12"
+# ///
+
 
 """Update the roots of the Carbon build used for dependency checking.
 

bazel/libpfm/0001-Introduce-a-simple-native-Bazel-build.patch

@@ -1,133 +0,0 @@
-From 04fb28b5673d29a8c38519845c87f4c00c76e9cf Mon Sep 17 00:00:00 2001
-From: Chandler Carruth <chandlerc@gmail.com>
-Date: Sat, 13 Jan 2024 02:15:19 -0800
-Subject: [PATCH] Introduce a simple native Bazel build.
-
----
- BUILD.bazel     | 84 +++++++++++++++++++++++++++++++++++++++++++++++++
- MODULE.bazel    | 10 ++++++
- WORKSPACE.bazel |  5 +++
- 3 files changed, 99 insertions(+)
- create mode 100644 BUILD.bazel
- create mode 100644 MODULE.bazel
- create mode 100644 WORKSPACE.bazel
-
-diff --git a/BUILD.bazel b/BUILD.bazel
-new file mode 100644
-index 0000000..427c854
---- /dev/null
-+++ b/BUILD.bazel
-@@ -0,0 +1,84 @@
-+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
-+# Exceptions. See /LICENSE for license information.
-+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-+
-+load("@rules_cc//cc:defs.bzl", "cc_library")
-+
-+package(default_visibility = ["//visibility:public"])
-+
-+aarch64_srcs = [
-+    "lib/pfmlib_arm_perf_event.c",
-+    "lib/pfmlib_arm.c",
-+    "lib/pfmlib_arm_armv8.c",
-+    "lib/pfmlib_arm_armv9.c",
-+    "lib/pfmlib_tx2_unc_perf_event.c",
-+    "lib/pfmlib_kunpeng_unc_perf_event.c",
-+    "lib/pfmlib_arm_priv.h",
-+    "lib/events/arm_cortex_a57_events.h",
-+    "lib/events/arm_cortex_a53_events.h",
-+    "lib/events/arm_xgene_events.h",
-+    "lib/events/arm_cavium_tx2_events.h",
-+    "lib/events/arm_marvell_tx2_unc_events.h",
-+    "lib/events/arm_fujitsu_a64fx_events.h",
-+    "lib/events/arm_neoverse_n1_events.h",
-+    "lib/events/arm_neoverse_n2_events.h",
-+    "lib/events/arm_neoverse_v1_events.h",
-+    "lib/events/arm_neoverse_v2_events.h",
-+    "lib/events/arm_hisilicon_kunpeng_events.h",
-+    "lib/events/arm_hisilicon_kunpeng_unc_events.h",
-+]
-+
-+x86_64_srcs = [
-+    "lib/pfmlib_amd64_priv.h",
-+] + glob(
-+    [
-+        "lib/pfmlib_amd64*.c",
-+        "lib/pfmlib_intel*.c",
-+        "lib/pfmlib_intel*_priv.h",
-+        "lib/events/amd64_events_*.h",
-+        "lib/events/intel_*_events.h",
-+    ],
-+    exclude = [
-+        # 32-bit CPUs
-+        "lib/pfmlib_intel_coreduo.c",
-+        "lib/pfmlib_intel_p6.c",
-+    ],
-+)
-+
-+cc_library(
-+    name = "libpfm",
-+    srcs = [
-+        "lib/events/perf_events.h",
-+        "lib/pfmlib_common.c",
-+        "lib/pfmlib_perf_event.c",
-+        "lib/pfmlib_perf_event_pmu.c",
-+        "lib/pfmlib_perf_event_priv.h",
-+        "lib/pfmlib_perf_event_raw.c",
-+        "lib/pfmlib_priv.h",
-+    ] + select({
-+        "@platforms//cpu:aarch64": aarch64_srcs,
-+        "@platforms//cpu:x86_64": x86_64_srcs,
-+    }),
-+    hdrs = glob(["include/perfmon/*.h"]),
-+    copts = [
-+        "-DHAS_OPENAT",
-+        "-D_REENTRANT",
-+        "-I.",
-+        "-fvisibility=hidden",
-+    ] + select({
-+        "@platforms//cpu:x86_64": [
-+            "-DCONFIG_PFMLIB_ARCH_X86",
-+            "-DCONFIG_PFMLIB_ARCH_X86_64",
-+        ],
-+        "//conditions:default": [],
-+    }),
-+    strip_include_prefix = "include",
-+    target_compatible_with = select({
-+        # This library only makes sense on Linux, and we only include support
-+        # for building on AArch64 and x86-64. Other CPUs can be added to this
-+        # list if build support is added for them.
-+        "@platforms//cpu:aarch64": ["@platforms//os:linux"],
-+        "@platforms//cpu:x86_64": ["@platforms//os:linux"],
-+        "//conditions:default": ["@platforms//:incompatible"],
-+    }),
-+)
-diff --git a/MODULE.bazel b/MODULE.bazel
-new file mode 100644
-index 0000000..c901cbe
---- /dev/null
-+++ b/MODULE.bazel
-@@ -0,0 +1,10 @@
-+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
-+# Exceptions. See /LICENSE for license information.
-+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-+
-+"""Bazel modules."""
-+
-+module(name = "libpfm")
-+
-+bazel_dep(name = "rules_cc", version = "0.0.9")
-+bazel_dep(name = "platforms", version = "0.0.8")
-diff --git a/WORKSPACE.bazel b/WORKSPACE.bazel
-new file mode 100644
-index 0000000..9aad57c
---- /dev/null
-+++ b/WORKSPACE.bazel
-@@ -0,0 +1,5 @@
-+# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
-+# Exceptions. See /LICENSE for license information.
-+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-+
-+# See `MODULE.bazel` for details.
---
-2.43.0

bazel/libpfm/BUILD

@@ -1,9 +0,0 @@
-# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
-# Exceptions. See /LICENSE for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-package(default_visibility = ["//visibility:public"])
-
-exports_files(glob([
-    "*.patch",
-]))

bazel/llvm_project/0002_Added_Bazel_build_for_compiler_rt_fuzzer.patch

@@ -8,14 +8,13 @@ Subject: [PATCH] Add libfuzzer target to compiler-rt.
  1 file changed, 17 insertions(+)
 
 diff --git a/utils/bazel/llvm-project-overlay/compiler-rt/BUILD.bazel b/utils/bazel/llvm-project-overlay/compiler-rt/BUILD.bazel
-index 9bdd454e1e36..0f30c21f63dc 100644
+index 90264449de76..115da4cb77f6 100644
 --- a/utils/bazel/llvm-project-overlay/compiler-rt/BUILD.bazel
 +++ b/utils/bazel/llvm-project-overlay/compiler-rt/BUILD.bazel
-@@ -50,3 +50,20 @@ cc_library(
-         ":config",
+@@ -57,6 +57,23 @@ cc_library(
      ],
  )
-+
+
 +cc_library(
 +    name = "FuzzerMain",
 +    srcs = glob(
@@ -32,5 +31,9 @@ index 9bdd454e1e36..0f30c21f63dc 100644
 +    ],
 +    includes = ["lib/fuzzer"],
 +)
++
+ cc_library(
+     name = "orc_rt_common_headers",
+     hdrs = [
 --
-2.42.0
+2.42.0

bazel/llvm_project/0003_Comment_out_unloaded_proto_library_dependencies.patch

@@ -1,69 +0,0 @@
-From 01f35f954121def682097d8e697ac524b2c8acc6 Mon Sep 17 00:00:00 2001
-From: jonmeow <jperkins@google.com>
-Date: Mon, 3 Feb 2025 11:18:25 -0800
-Subject: [PATCH] Comment out unloaded proto_library dependencies
-
----
- .../llvm-project-overlay/clang/BUILD.bazel    | 46 +++++++++----------
- 1 file changed, 23 insertions(+), 23 deletions(-)
-
-diff --git a/utils/bazel/llvm-project-overlay/clang/BUILD.bazel b/utils/bazel/llvm-project-overlay/clang/BUILD.bazel
-index e3b20e43dd22..8b26e322a0ed 100644
---- a/utils/bazel/llvm-project-overlay/clang/BUILD.bazel
-+++ b/utils/bazel/llvm-project-overlay/clang/BUILD.bazel
-@@ -2603,29 +2603,29 @@ cc_library(
-     ],
- )
- 
--proto_library(
--    name = "cxx-proto",
--    srcs = ["tools/clang-fuzzer/cxx_proto.proto"],
--)
--
--cc_proto_library(
--    name = "cxx_cc_proto",
--    deps = [":cxx-proto"],
--)
--
--cc_library(
--    name = "proto-to-cxx-lib",
--    srcs = ["tools/clang-fuzzer/proto-to-cxx/proto_to_cxx.cpp"],
--    hdrs = ["tools/clang-fuzzer/proto-to-cxx/proto_to_cxx.h"],
--    includes = ["tools/clang-fuzzer"],
--    deps = [":cxx_cc_proto"],
--)
--
--cc_binary(
--    name = "clang-proto-to-cxx",
--    srcs = ["tools/clang-fuzzer/proto-to-cxx/proto_to_cxx_main.cpp"],
--    deps = [":proto-to-cxx-lib"],
--)
-+# proto_library(
-+#     name = "cxx-proto",
-+#     srcs = ["tools/clang-fuzzer/cxx_proto.proto"],
-+# )
-+#
-+# cc_proto_library(
-+#     name = "cxx_cc_proto",
-+#     deps = [":cxx-proto"],
-+# )
-+#
-+# cc_library(
-+#     name = "proto-to-cxx-lib",
-+#     srcs = ["tools/clang-fuzzer/proto-to-cxx/proto_to_cxx.cpp"],
-+#     hdrs = ["tools/clang-fuzzer/proto-to-cxx/proto_to_cxx.h"],
-+#     includes = ["tools/clang-fuzzer"],
-+#     deps = [":cxx_cc_proto"],
-+# )
-+#
-+# cc_binary(
-+#     name = "clang-proto-to-cxx",
-+#     srcs = ["tools/clang-fuzzer/proto-to-cxx/proto_to_cxx_main.cpp"],
-+#     deps = [":proto-to-cxx-lib"],
-+# )
- 
- cc_library(
-     name = "clang-fuzzer-initialize",
--- 
-2.48.1
-

bazel/llvm_project/0004_Introduce_basic_sources_exporting_for_libunwind.patch

@@ -0,0 +1,64 @@
+Commit ID: 354e38c89f28e2cc284e655a9cde707f457dc02c
+Change ID: sxspxmonsuvqzuvxvrvorlumwpwromsv
+Author   : Chandler Carruth <chandlerc@gmail.com> (2025-09-25 22:55:26)
+Committer: Chandler Carruth <chandlerc@gmail.com> (2026-02-14 03:46:06)
+
+    Introduce basic sources exporting for libunwind
+
+    This exports the source files directly so that they can be used to build
+    this runtime library on demand.
+
+diff --git a/utils/bazel/llvm-project-overlay/libunwind/BUILD.bazel b/utils/bazel/llvm-project-overlay/libunwind/BUILD.bazel
+index c9fdc819c0..7d734c5a06 100644
+--- a/utils/bazel/llvm-project-overlay/libunwind/BUILD.bazel
++++ b/utils/bazel/llvm-project-overlay/libunwind/BUILD.bazel
+@@ -21,3 +21,19 @@
+     ],
+     strip_include_prefix = "include",
+ )
++
++filegroup(
++    name = "libunwind_hdrs",
++    srcs = glob(["include/**/*.h"]),
++)
++
++filegroup(
++    name = "libunwind_srcs",
++    srcs = glob([
++        "src/*.cpp",
++        "src/*.hpp",
++        "src/*.c",
++        "src/*.h",
++        "src/*.S",
++    ]),
++)
+diff --git a/utils/bazel/llvm-project-overlay/libunwind/libunwind_library.bzl b/utils/bazel/llvm-project-overlay/libunwind/libunwind_library.bzl
+new file mode 100644
+index 0000000000..25675d3070
+--- /dev/null
++++ b/utils/bazel/llvm-project-overlay/libunwind/libunwind_library.bzl
+@@ -0,0 +1,24 @@
++# This file is licensed under the Apache License v2.0 with LLVM Exceptions.
++# See https://llvm.org/LICENSE.txt for license information.
++# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
++
++"""Starlark variables and macros for building libunwind.
++
++Variables provide base line information for how to build libunwind source files.
++These can be used to generate non-Bazel builds of the library.
++
++Macros provide a convenient way to construct Bazel `cc_library` rules for
++libunwind.
++"""
++
++# TODO: Should libunwind use `-fvisibility-inlines-hidden` and
++# `-fvisibility=hidden`, similar to libc++?
++libunwind_copts = [
++    "-D_LIBUNWIND_IS_NATIVE_ONLY",
++    "-O3",
++    "-fPIC",
++    "-fno-exceptions",
++    "-fno-rtti",
++    "-funwind-tables",
++    "-nostdinc++",
++]

bazel/llvm_project/0004_Introduce_filegroups_for_compiler_rt_builtins_runtime.patch

@@ -1,194 +0,0 @@
-From 19d5d9913778ca95da272f41c5916907154a5e73 Mon Sep 17 00:00:00 2001
-From: Chandler Carruth <chandlerc@gmail.com>
-Date: Thu, 24 Apr 2025 05:03:43 +0000
-Subject: [PATCH] Introduce filegroups for compiler-rt builtins runtimes
-
-These filegroups allow downstream projects to package and build
-customized runtime libraries.
-
-The filegroups work hard to use globs and a careful structuring to
-create the structured breakdown of sources needed to target different
-architectures and platforms without having to maintain a complete
-parallel list of sources from CMake.
----
- .../compiler-rt/BUILD.bazel                   | 167 ++++++++++++++++++
- 1 file changed, 167 insertions(+)
-
-diff --git a/utils/bazel/llvm-project-overlay/compiler-rt/BUILD.bazel b/utils/bazel/llvm-project-overlay/compiler-rt/BUILD.bazel
-index 6a5a89fdee40..7d158f0c13f2 100644
---- a/utils/bazel/llvm-project-overlay/compiler-rt/BUILD.bazel
-+++ b/utils/bazel/llvm-project-overlay/compiler-rt/BUILD.bazel
-@@ -128,3 +128,170 @@ cc_library(
-     ],
-     includes = ["lib/fuzzer"],
- )
-+
-+BUILTINS_CRTBEGIN_SRCS = ["lib/builtins/crtbegin.c"]
-+
-+filegroup(
-+    name = "builtins_crtbegin_src",
-+    srcs = BUILTINS_CRTBEGIN_SRCS,
-+)
-+
-+BUILTINS_CRTEND_SRCS = ["lib/builtins/crtend.c"]
-+
-+filegroup(
-+    name = "builtins_crtend_src",
-+    srcs = BUILTINS_CRTEND_SRCS,
-+)
-+
-+# Note that while LLVM's CompilerRT provides a few hosted sources, we don't
-+# currently build them:
-+#
-+# - `emutls.c`: Unclear we need to support targets with software emulated
-+#   TLS rather than hardware support.
-+# - `enable_execute_stack.c`: Used to implement support for a builtin that
-+#   marks part of the stack as *executable* to support the GCC extension of
-+#   nested functions. This extension was never implemented in Clang, and is
-+#   generally considered a security issue to include. We expect to be able
-+#   to avoid even linking the support code for this into binaries at this
-+#   point.
-+# - `eprintf.c`: This provided a legacy `__eprintf` builtin used by old
-+#   versions of `assert.h` in its macros, but does not appear to be needed
-+#   when building with modern versions of this header.
-+BUILTINS_HOSTED_SRCS = [
-+    "lib/builtins/emutls.c",
-+    "lib/builtins/enable_execute_stack.c",
-+    "lib/builtins/eprintf.c",
-+]
-+
-+filegroup(
-+    name = "builtins_hosted_srcs",
-+    srcs = BUILTINS_HOSTED_SRCS,
-+)
-+
-+BUILTINS_BF16_SRCS_PATTERNS = [
-+    # `bf` marks 16-bit Brain floating-point number builtins.
-+    "lib/builtins/*bf*.c",
-+]
-+
-+filegroup(
-+    name = "builtins_bf16_srcs",
-+    srcs = glob(BUILTINS_BF16_SRCS_PATTERNS),
-+)
-+
-+BUILTINS_X86_FP80_SRCS_PATTERNS = [
-+    # `xc` marks 80-bit complex number builtins.
-+    "lib/builtins/*xc*.c",
-+
-+    # `xf` marks 80-bit floating-point builtins.
-+    "lib/builtins/*xf*.c",
-+]
-+
-+filegroup(
-+    name = "builtins_x86_fp80_srcs",
-+    srcs = glob(
-+        BUILTINS_X86_FP80_SRCS_PATTERNS,
-+        exclude = BUILTINS_BF16_SRCS_PATTERNS,
-+    ),
-+)
-+
-+BUILTINS_TF_SRCS_PATTERNS = [
-+    # `tc` marks 128-bit complex number builtins.
-+    "lib/builtins/*tc*.c",
-+
-+    # `tf` marks 128-bit floating-point builtins.
-+    "lib/builtins/*tf*.c",
-+]
-+
-+BUILTINS_TF_EXCLUDES = (
-+    BUILTINS_HOSTED_SRCS +
-+    BUILTINS_BF16_SRCS_PATTERNS +
-+    BUILTINS_X86_FP80_SRCS_PATTERNS
-+)
-+
-+filegroup(
-+    name = "builtins_tf_srcs",
-+    srcs = glob(
-+        BUILTINS_TF_SRCS_PATTERNS,
-+        exclude = BUILTINS_TF_EXCLUDES,
-+    ),
-+)
-+
-+BUILTINS_MACOS_ATOMIC_SRCS_PATTERNS = [
-+    "lib/builtins/atomic_*.c",
-+]
-+
-+filegroup(
-+    name = "builtins_macos_atomic_srcs",
-+    srcs = glob(BUILTINS_MACOS_ATOMIC_SRCS_PATTERNS),
-+)
-+
-+filegroup(
-+    name = "builtins_aarch64_srcs",
-+    srcs = [
-+        "lib/builtins/cpu_model/aarch64.c",
-+        "lib/builtins/cpu_model/aarch64.h",
-+    ] + glob(
-+        [
-+            "lib/builtins/cpu_model/AArch64*.inc",
-+            "lib/builtins/cpu_model/aarch64/**/*.inc",
-+            "lib/builtins/aarch64/*.S",
-+            "lib/builtins/aarch64/*.c",
-+        ],
-+        exclude = [
-+            # This file isn't intended to directly compile, but to be used to
-+            # generate a collection of outline atomic helpers.
-+            # TODO: Add support for generating the sources for these helpers if
-+            # there are users that need this functionality from the builtins
-+            # library.
-+            "lib/builtins/aarch64/lse.S",
-+        ],
-+    ),
-+)
-+
-+filegroup(
-+    name = "builtins_x86_arch_srcs",
-+    srcs = [
-+        "lib/builtins/cpu_model/x86.c",
-+        "lib/builtins/i386/fp_mode.c",
-+    ],
-+)
-+
-+filegroup(
-+    name = "builtins_x86_64_srcs",
-+    srcs = glob([
-+        "lib/builtins/x86_64/*.c",
-+        "lib/builtins/x86_64/*.S",
-+    ]),
-+)
-+
-+filegroup(
-+    name = "builtins_i386_srcs",
-+    srcs = glob(
-+        [
-+            "lib/builtins/i386/*.c",
-+            "lib/builtins/i386/*.S",
-+        ],
-+        exclude = [
-+            # This file is used for both i386 and x86_64.
-+            "lib/builtins/i386/fp_mode.c",
-+        ],
-+    ),
-+)
-+
-+filegroup(
-+    name = "builtins_generic_srcs",
-+    srcs = ["lib/builtins/cpu_model/cpu_model.h"] + glob(
-+        [
-+            "lib/builtins/*.c",
-+            "lib/builtins/*.h",
-+            "lib/builtins/*.inc",
-+        ],
-+        exclude = (
-+            BUILTINS_CRTBEGIN_SRCS +
-+            BUILTINS_CRTEND_SRCS +
-+            BUILTINS_TF_EXCLUDES +
-+            BUILTINS_TF_SRCS_PATTERNS +
-+            BUILTINS_MACOS_ATOMIC_SRCS_PATTERNS
-+        ),
-+    ),
-+)
--- 
-2.49.0.850.g28803427d3-goog
-

bazel/llvm_project/0005_Introduce_basic_sources_exporting_for_libcxx_and_libcxxabi.patch

@@ -0,0 +1,236 @@
+Commit ID: 1fd710ed69a0f47f454c386d39302ddb756a88b3
+Change ID: mstnwoqruyypnoouksnyqssllrsozpos
+Bookmarks: bz-libcxx* bz-libcxx@git
+Author   : Chandler Carruth <chandlerc@gmail.com> (2025-09-25 22:55:26)
+Committer: Chandler Carruth <chandlerc@gmail.com> (2026-03-08 07:41:54)
+
+    Introduce basic sources exporting for libcxx and libcxxabi
+
+    This exports the source files directly so that they can be used to build
+    a libcxx runtime library on demand. It also differentiates between
+    normal sources and textual sources.
+
+diff --git a/utils/bazel/llvm-project-overlay/libcxx/BUILD.bazel b/utils/bazel/llvm-project-overlay/libcxx/BUILD.bazel
+new file mode 100644
+index 0000000000..c8b517ab56
+--- /dev/null
++++ b/utils/bazel/llvm-project-overlay/libcxx/BUILD.bazel
+@@ -0,0 +1,139 @@
++# This file is licensed under the Apache License v2.0 with LLVM Exceptions.
++# See https://llvm.org/LICENSE.txt for license information.
++# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
++
++licenses(["notice"])
++
++package(
++    default_visibility = ["//visibility:public"],
++)
++
++exports_files([
++    "include/__config_site.in",
++    "include/module.modulemap.in",
++    "vendor/llvm/default_assertion_handler.in",
++])
++
++filegroup(
++    name = "libcxx_hdrs",
++    srcs = glob(
++        [
++            # Top level includes and those in `experimental` and `ext` sometimes
++            # have no extension.
++            "include/*",
++            "include/experimental/*",
++            "include/ext/*",
++
++            # Implementation detail headers all use `.h` extensions
++            "include/**/*.h",
++        ],
++        exclude = [
++            # Omit CMake and CMake-configured files that get caught by the
++            # extension-less patterns.
++            "**/*.in",
++            "**/CMakeLists.txt",
++
++            # Omit C++03 compatibility headers as current users don't need them.
++            "include/__cxx03/**",
++        ],
++    ),
++)
++
++LIBCXX_SRCS_PSTL_LIBDISPATCH = [
++    "src/pstl/libdispatch.cpp",
++]
++
++filegroup(
++    name = "libcxx_srcs_pstl_libdispatch",
++    srcs = LIBCXX_SRCS_PSTL_LIBDISPATCH,
++)
++
++LIBCXX_SRCS_SUPPORT_IBM_PATTERNS = [
++    "src/support/ibm/**/*.cpp",
++]
++
++filegroup(
++    name = "libcxx_srcs_support_ibm",
++    srcs = glob(LIBCXX_SRCS_SUPPORT_IBM_PATTERNS),
++)
++
++LIBCXX_SRCS_SUPPORT_WIN32_PATTERNS = [
++    "src/support/win32/**/*.cpp",
++]
++
++filegroup(
++    name = "libcxx_srcs_support_win32",
++    srcs = glob(LIBCXX_SRCS_SUPPORT_WIN32_PATTERNS),
++)
++
++LIBCXX_SRCS_TZDB = [
++    "src/experimental/chrono_exception.cpp",
++    "src/experimental/time_zone.cpp",
++    "src/experimental/tzdb.cpp",
++    "src/experimental/tzdb_list.cpp",
++]
++
++filegroup(
++    name = "libcxx_srcs_tzdb",
++    srcs = LIBCXX_SRCS_TZDB,
++)
++
++# Exclude platform-dependent patterns that are provided by per-target filegroups
++# above.
++LIBCXX_SRCS_TARGET_EXCLUDES = (
++    LIBCXX_SRCS_PSTL_LIBDISPATCH +
++    LIBCXX_SRCS_SUPPORT_IBM_PATTERNS +
++    LIBCXX_SRCS_SUPPORT_WIN32_PATTERNS +
++    LIBCXX_SRCS_TZDB
++)
++
++filegroup(
++    name = "libcxx_srcs_generic",
++    srcs = glob(
++        [
++            "src/**/*.cpp",
++            "src/**/*.h",
++            "src/**/*.ipp",
++        ],
++        exclude = [
++            # Build is for use with libc++abi and so don't need 'new.cpp'.
++            "src/new.cpp",
++
++            # Build is for compiler-rt platforms so we have its int128 support.
++            "src/filesystem/int128_builtins.cpp",
++        ] + LIBCXX_SRCS_TARGET_EXCLUDES,
++    ),
++)
++
++filegroup(
++    name = "libcxx_linux_srcs",
++    srcs = [
++        ":libcxx_srcs_generic",
++        ":libcxx_srcs_tzdb",
++    ],
++)
++
++filegroup(
++    name = "libcxx_macos_srcs",
++    srcs = [
++        ":libcxx_srcs_generic",
++        # TODO: Include libdispatch sources here to enable that pstl backend.
++    ],
++)
++
++filegroup(
++    name = "libcxx_win32_srcs",
++    srcs = [
++        ":libcxx_srcs_generic",
++        ":libcxx_srcs_support_win32",
++    ],
++)
++
++filegroup(
++    name = "libcxx_all_srcs",
++    srcs = [
++        ":libcxx_linux_srcs",
++        ":libcxx_macos_srcs",
++        ":libcxx_win32_srcs",
++    ],
++)
+diff --git a/utils/bazel/llvm-project-overlay/libcxx/libcxx_library.bzl b/utils/bazel/llvm-project-overlay/libcxx/libcxx_library.bzl
+new file mode 100644
+index 0000000000..66f64f3610
+--- /dev/null
++++ b/utils/bazel/llvm-project-overlay/libcxx/libcxx_library.bzl
+@@ -0,0 +1,37 @@
++# This file is licensed under the Apache License v2.0 with LLVM Exceptions.
++# See https://llvm.org/LICENSE.txt for license information.
++# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
++
++"""Starlark variables and macros for building libc++ and libc++abi.
++
++Variables provide base line information for how to build libc++ and libc++abi
++source files. These can be used to generate non-Bazel builds of the library.
++
++TODO: Add macros that provide a convenient way to construct Bazel `cc_library`
++rules for libc++ and libc++abi.
++
++TODO: Add either sufficient usage in the macros, or add a how-to example here in
++the documentation so the use of these variables is more clear.
++"""
++
++_libcxx_base_copts = [
++    "-std=c++26",
++    "-O3",
++    "-fPIC",
++    "-fvisibility-inlines-hidden",
++    "-fvisibility=hidden",
++    "-nostdinc++",
++]
++
++_libcxx_defines = [
++    "-D_LIBCPP_BUILDING_LIBRARY",
++    "-D_LIBCPP_REMOVE_TRANSITIVE_INCLUDES",
++]
++
++_libcxxabi_defines = [
++    "-DLIBCXX_BUILDING_LIBCXXABI",
++]
++
++libcxx_copts = _libcxx_base_copts + _libcxx_defines
++libcxxabi_copts = _libcxx_base_copts + _libcxxabi_defines
++libcxx_and_abi_copts = _libcxx_base_copts + _libcxx_defines + _libcxxabi_defines
+diff --git a/utils/bazel/llvm-project-overlay/libcxxabi/BUILD.bazel b/utils/bazel/llvm-project-overlay/libcxxabi/BUILD.bazel
+new file mode 100644
+index 0000000000..2db70b54e2
+--- /dev/null
++++ b/utils/bazel/llvm-project-overlay/libcxxabi/BUILD.bazel
+@@ -0,0 +1,30 @@
++# This file is licensed under the Apache License v2.0 with LLVM Exceptions.
++# See https://llvm.org/LICENSE.txt for license information.
++# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
++
++licenses(["notice"])
++
++package(
++    default_visibility = ["//visibility:public"],
++)
++
++filegroup(
++    name = "libcxxabi_hdrs",
++    srcs = glob(["include/*.h"]),
++)
++
++filegroup(
++    name = "libcxxabi_srcs",
++    srcs = glob([
++        "src/**/*.cpp",
++        "src/**/*.h",
++    ]),
++)
++
++filegroup(
++    name = "libcxxabi_textual_srcs",
++    srcs = glob([
++        "src/**/*.def",
++        "src/**/*.inc",
++    ]),
++)

bazel/llvm_project/0006_Add_more_libc_math_excludes.patch

@@ -0,0 +1,37 @@
+Removes additional libc-backed arithmetic builtins added
+by https://github.com/llvm/llvm-project/pull/207092
+and https://github.com/llvm/llvm-project/pull/209984
+---
+--- a/utils/bazel/llvm-project-overlay/compiler-rt/BUILD.bazel
++++ b/utils/bazel/llvm-project-overlay/compiler-rt/BUILD.bazel
+@@ -303,6 +303,30 @@
+     "lib/builtins/extendsfdf2.cpp",
+     "lib/builtins/extendsftf2.cpp",
+     "lib/builtins/extendxftf2.cpp",
++    "lib/builtins/fixdfdi.cpp",
++    "lib/builtins/fixdfsi.cpp",
++    "lib/builtins/fixdfti.cpp",
++    "lib/builtins/fixsfdi.cpp",
++    "lib/builtins/fixsfsi.cpp",
++    "lib/builtins/fixsfti.cpp",
++    "lib/builtins/fixunsdfdi.cpp",
++    "lib/builtins/fixunsdfsi.cpp",
++    "lib/builtins/fixunsdfti.cpp",
++    "lib/builtins/fixunssfdi.cpp",
++    "lib/builtins/fixunssfsi.cpp",
++    "lib/builtins/fixunssfti.cpp",
++    "lib/builtins/floatdidf.cpp",
++    "lib/builtins/floatdisf.cpp",
++    "lib/builtins/floatsidf.cpp",
++    "lib/builtins/floatsisf.cpp",
++    "lib/builtins/floattidf.cpp",
++    "lib/builtins/floattisf.cpp",
++    "lib/builtins/floatundidf.cpp",
++    "lib/builtins/floatundisf.cpp",
++    "lib/builtins/floatunsidf.cpp",
++    "lib/builtins/floatunsisf.cpp",
++    "lib/builtins/floatuntidf.cpp",
++    "lib/builtins/floatuntisf.cpp",
+     "lib/builtins/muldf3.cpp",
+     "lib/builtins/mulsf3.cpp",
+     "lib/builtins/multf3.cpp",

bazel/llvm_project/0011_Temporarily_remove_reference_to_hermetic_toolchain.patch

@@ -0,0 +1,24 @@
+Temporarily undo
+https://github.com/llvm/llvm-project/pull/207295
+Which introduces a dependency on the hermetic llvm
+toolchain. A fix-forward is in progress, at which
+point we can remove this patch.
+---
+--- a/utils/bazel/llvm-project-overlay/llvm/config.bzl
++++ b/utils/bazel/llvm-project-overlay/llvm/config.bzl
+@@ -72,7 +72,6 @@
+ backtrace_defines = select({
+     "@platforms//os:emscripten": [],
+     "@platforms//os:windows": [],
+-    "@llvm//platforms/config:musl": [],
+     "//conditions:default": [
+         "HAVE_BACKTRACE=1",
+         "BACKTRACE_HEADER=<execinfo.h>",
+@@ -80,7 +79,6 @@
+ })
+ 
+ mallinfo_defines = select({
+-    "@llvm//platforms/config:gnu": ["HAVE_MALLINFO=1"],
+     "//conditions:default": [],
+ })
+ 

bazel/manifest/defs.bzl

@@ -8,17 +8,21 @@ def _get_files(ctx):
     files = []
     for src in ctx.attr.srcs:
         files.extend([f.path for f in src[DefaultInfo].files.to_list()])
-        files.extend([
-            f.path
-            for f in src[DefaultInfo].default_runfiles.files.to_list()
-        ])
 
     if ctx.attr.strip_package_dir:
         # Files may or may not be prefixed with the bin directory, and then
         # may or may not be prefixed with the package directory. Strip both.
         bin_dir = ctx.bin_dir.path + "/"
+        workspace_root = (
+            ctx.label.workspace_root + "/" if ctx.label.workspace_root else ""
+        )
         package_dir = ctx.label.package + "/"
-        files_stripped = [f.removeprefix(bin_dir).removeprefix(package_dir) for f in files]
+        files_stripped = [
+            f.removeprefix(bin_dir)
+                .removeprefix(workspace_root)
+                .removeprefix(package_dir)
+            for f in files
+        ]
     else:
         files_stripped = files
 

bazel/version/gen_tmpl.py

@@ -1,4 +1,13 @@
-#!/usr/bin/env python3
+#!/usr/bin/env -S uv run --script
+
+# /// script
+# requires-python = ">=3.12"
+# ///
+
+# NOTE: The `uv` shebang and inline metadata above are only used for direct
+# execution of this script outside of Bazel. When executed by Bazel (e.g., as a
+# tool in a rule or as a test), Bazel uses its own hermetic Python toolchain
+# and ignores this metadata.
 
 """Generate a file from a template, substituting the provided key/value pairs.
 
@@ -88,7 +97,7 @@ def main() -> None:
             # Remove line endings.
             line = line.rstrip("\r\n")
             # Exactly matches our pattern
-            (key, value) = line.split(" ", 1)
+            key, value = line.split(" ", 1)
             key = key.removeprefix("STABLE_")
             if key in substitutions:
                 if args.verbose:

bazel/version/rules.bzl

@@ -134,8 +134,8 @@ expand_version_build_info_internal = rule(
 def expand_version_build_info(name, **kwargs):
     expand_version_build_info_internal(
         name = name,
-        internal_stamp_flag_detect = select({
-            "//bazel/version:internal_stamp_flag_detect": True,
+        internal_stamp_flag_detect = False if kwargs.get("stamp") == 0 else select({
+            Label("//bazel/version:internal_stamp_flag_detect"): True,
             "//conditions:default": False,
         }),
         **kwargs

common/BUILD

@@ -32,6 +32,8 @@ cc_library(
     name = "bazel_working_dir",
     hdrs = ["bazel_working_dir.h"],
     deps = [
+        ":check",
+        ":filesystem",
         "@llvm-project//llvm:Support",
     ],
 )
@@ -159,6 +161,27 @@ cc_test(
     ],
 )
 
+cc_library(
+    name = "enum_mask_base",
+    hdrs = ["enum_mask_base.h"],
+    deps = [
+        ":enum_base",
+        "@llvm-project//llvm:Support",
+    ],
+)
+
+cc_test(
+    name = "enum_mask_base_test",
+    size = "small",
+    srcs = ["enum_mask_base_test.cpp"],
+    deps = [
+        ":enum_mask_base",
+        ":raw_string_ostream",
+        "//testing/base:gtest_main",
+        "@googletest//:gtest",
+    ],
+)
+
 cc_library(
     name = "error",
     hdrs = ["error.h"],
@@ -176,6 +199,7 @@ cc_library(
     hdrs = ["error_test_helpers.h"],
     deps = [
         ":error",
+        ":ostream",
         "@googletest//:gtest",
     ],
 )
@@ -262,10 +286,10 @@ sh_test(
     size = "small",
     srcs = [":filesystem_benchmark"],
     args = [
-        "--benchmark_min_time=1x",
-        # Restrict the sizes to 4-digit ones or smaller to keep test times low.
+        "--benchmark_dry_run",
+        # Restrict the sizes to 2-digit ones or smaller to keep test times low.
         # The `$$` is repeated for Bazel escaping of `$`.
-        "--benchmark_filter=^[^/]+(/[0-9]{1,4}(/[0-9]+)?)?/real_time$$",
+        "--benchmark_filter=^[^/]+(/[0-9]{1,2}(/[0-9]+)?)?/real_time$$",
     ],
 )
 
@@ -318,12 +342,22 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "hashing_llvm",
+    hdrs = ["hashing_llvm.h"],
+    deps = [
+        ":hashing",
+        "@llvm-project//llvm:Support",
+    ],
+)
+
 cc_test(
     name = "hashing_test",
     size = "small",
     srcs = ["hashing_test.cpp"],
     deps = [
         ":hashing",
+        ":hashing_llvm",
         ":raw_string_ostream",
         "//testing/base:gtest_main",
         "@googletest//:gtest",
@@ -360,6 +394,7 @@ cc_test(
     size = "small",
     srcs = ["hashtable_key_context_test.cpp"],
     deps = [
+        ":hashing_llvm",
         ":hashtable_key_context",
         "//testing/base:gtest_main",
         "@googletest//:gtest",
@@ -393,6 +428,28 @@ cc_library(
     alwayslink = 1,
 )
 
+cc_library(
+    name = "latch",
+    srcs = ["latch.cpp"],
+    hdrs = ["latch.h"],
+    deps = [
+        ":check",
+        "@llvm-project//llvm:Support",
+    ],
+)
+
+cc_test(
+    name = "latch_test",
+    size = "small",
+    srcs = ["latch_test.cpp"],
+    deps = [
+        ":latch",
+        "//testing/base:gtest_main",
+        "@googletest//:gtest",
+        "@llvm-project//llvm:Support",
+    ],
+)
+
 cc_library(
     name = "map",
     hdrs = ["map.h"],
@@ -414,6 +471,7 @@ cc_test(
         ":raw_hashtable_test_helpers",
         "//testing/base:gtest_main",
         "@googletest//:gtest",
+        "@llvm-project//llvm:Support",
     ],
 )
 
@@ -427,7 +485,7 @@ cc_binary(
         "//testing/base:benchmark_main",
         "@abseil-cpp//absl/container:flat_hash_map",
         "@abseil-cpp//absl/random",
-        "@boost_unordered",
+        "@boost.unordered",
         "@google_benchmark//:benchmark",
         "@llvm-project//llvm:Support",
     ],
@@ -441,9 +499,9 @@ sh_test(
     timeout = "moderate",
     srcs = [":map_benchmark"],
     args = [
-        "--benchmark_min_time=1x",
+        "--benchmark_dry_run",
         # The `$$` is repeated for Bazel escaping of `$`.
-        "--benchmark_filter=^[^/]*/[1-9][0-9]{0,3}(/[0-9]+)?$$",
+        "--benchmark_filter=^[^/]*/[1-9][0-9]{0,2}(/[0-9]+)?$$",
     ],
 )
 
@@ -460,6 +518,19 @@ cc_library(
     ],
 )
 
+cc_test(
+    name = "ostream_test",
+    size = "small",
+    srcs = ["ostream_test.cpp"],
+    deps = [
+        ":ostream",
+        ":raw_string_ostream",
+        "//testing/base:gtest_main",
+        "@googletest//:gtest",
+        "@llvm-project//llvm:Support",
+    ],
+)
+
 cc_library(
     name = "pretty_stack_trace_function",
     hdrs = ["pretty_stack_trace_function.h"],
@@ -511,7 +582,7 @@ sh_test(
     size = "small",
     srcs = ["raw_hashtable_metadata_group_benchmark"],
     args = [
-        "--benchmark_min_time=1x",
+        "--benchmark_dry_run",
     ],
 )
 
@@ -531,7 +602,7 @@ cc_library(
         "@abseil-cpp//absl/base:no_destructor",
         "@abseil-cpp//absl/hash",
         "@abseil-cpp//absl/random",
-        "@boost_unordered",
+        "@boost.unordered",
         "@google_benchmark//:benchmark",
         "@llvm-project//llvm:Support",
     ],
@@ -589,6 +660,7 @@ cc_test(
         ":set",
         "//testing/base:gtest_main",
         "@googletest//:gtest",
+        "@llvm-project//llvm:Support",
     ],
 )
 
@@ -614,9 +686,9 @@ sh_test(
     timeout = "moderate",
     srcs = [":set_benchmark"],
     args = [
-        "--benchmark_min_time=1x",
+        "--benchmark_dry_run",
         # The `$$` is repeated for Bazel escaping of `$`.
-        "--benchmark_filter=^[^/]*/[1-9][0-9]{0,3}(/[0-9]+)?$$",
+        "--benchmark_filter=^[^/]*/[1-9][0-9]{0,2}(/[0-9]+)?$$",
     ],
 )
 

common/array_stack.h

@@ -82,7 +82,7 @@ class ArrayStack {
   // Adds multiple values to the top array on the stack.
   auto AppendToTop(llvm::ArrayRef<ValueT> values) -> void {
     CARBON_CHECK(!array_offsets_.empty(),
-                 "Must call PushArray before PushValues.");
+                 "Must call PushArray before AppendToTop.");
     llvm::append_range(values_, values);
   }
 

common/bazel_working_dir.h

@@ -5,25 +5,45 @@
 #ifndef CARBON_COMMON_BAZEL_WORKING_DIR_H_
 #define CARBON_COMMON_BAZEL_WORKING_DIR_H_
 
-#include "llvm/Support/FileSystem.h"
+#include <stdlib.h>
+
+#include <filesystem>
+#include <system_error>
+
+#include "common/check.h"
+#include "common/filesystem.h"
 
 namespace Carbon {
 
-// Behave as if the working directory is where `bazel run` was invoked.
-// This should only be used in development binaries, not release.
-inline auto SetWorkingDirForBazel() -> bool {
+// Change working directory to behave as if it is where `bazel run` was invoked.
+//
+// Accepts an optional `exe_path` argument that will be adjusted to continue to
+// be valid after this adjustment.
+//
+// There is no reasonable recovery we can do if either we can't make the path
+// absolute or we can't change directory. As a consequence, this aborts if
+// either of those fail rather than propagating any error.
+inline auto SetWorkingDirForBazelRun(std::filesystem::path exe_path = {})
+    -> std::filesystem::path {
   char* build_working_dir = getenv("BUILD_WORKING_DIRECTORY");
   if (build_working_dir == nullptr) {
-    return true;
+    return exe_path;
   }
 
-  if (std::error_code err =
-          llvm::sys::fs::set_current_path(build_working_dir)) {
-    llvm::errs() << "Failed to set working directory: " << err.message();
-    return false;
+  // Adjust `exe_path` before changing directory.
+  if (!exe_path.empty()) {
+    std::error_code err;
+    exe_path = std::filesystem::absolute(exe_path, err);
+    CARBON_CHECK(!err, "Unable to make an absolute path for `{0}`: {1}",
+                 exe_path, err.message());
   }
 
-  return true;
+  auto chdir_result = Filesystem::Cwd().Chdir(build_working_dir);
+  CARBON_CHECK(chdir_result.ok(),
+               "Unable to change working directory to `{0}`: {1}",
+               build_working_dir, chdir_result.error());
+
+  return exe_path;
 }
 
 }  // namespace Carbon

common/check_internal.cpp

@@ -8,18 +8,61 @@
 #include <string>
 
 #include "common/ostream.h"
+#include "llvm/Support/FormatCommon.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Signals.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace Carbon::Internal {
 
-auto CheckFailImpl(const char* kind, const char* file, int line,
-                   const char* condition_str, llvm::StringRef extra_message)
+namespace {
+// Renders `fmt` over the externally-built, type-erased `adapters` into `out`,
+// with the same semantics as `llvm::formatv` (including runtime format-string
+// validation).
+//
+// TODO: We should add a type-erased helper to upstream LLVM instead of rolling
+// our own type-erased version of `format` here.
+auto FormatvInto(
+    llvm::raw_ostream& out, llvm::StringRef format_str,
+    llvm::ArrayRef<llvm::support::detail::FormatFunctorRef> adapters) -> void {
+  for (const llvm::ReplacementItem& replacement :
+       llvm::formatv_object_base::parseFormatString(format_str, adapters.size(),
+                                                    /*Validate=*/true)) {
+    if (replacement.Type == llvm::ReplacementType::Literal ||
+        replacement.Index >= adapters.size()) {
+      out << replacement.Spec;
+      continue;
+    }
+    llvm::FmtAlign(adapters[replacement.Index], replacement.Where,
+                   replacement.Width, replacement.Pad)
+        .format(out, replacement.Options);
+  }
+}
+}  // namespace
+
+auto CheckFailImpl(
+    const char* kind, const char* file, int line, const char* condition_str,
+    const char* extra_format,
+    llvm::ArrayRef<llvm::support::detail::FormatFunctorRef> extra_adapters)
     -> void {
-  // Render the final check string here.
-  std::string message = llvm::formatv(
-      "{0} failure at {1}:{2}{3}{4}{5}{6}\n", kind, file, line,
-      llvm::StringRef(condition_str).empty() ? "" : ": ", condition_str,
-      extra_message.empty() ? "" : ": ", extra_message);
+  // Render the final check string directly into one stream. The extra message
+  // is rendered in place from its format string and type-erased adapters, so
+  // we never materialize a separate string just for it.
+  //
+  // `llvm::raw_string_ostream` (rather than `common/raw_string_ostream.h`) is
+  // used to avoid a dependency cycle: `RawStringOstream` itself uses
+  // `CARBON_CHECK`. It is unbuffered, so `message` is populated directly.
+  std::string message;
+  llvm::raw_string_ostream message_stream(message);
+  message_stream << kind << " failure at " << file << ":" << line;
+  if (*condition_str != '\0') {
+    message_stream << ": " << condition_str;
+  }
+  if (*extra_format != '\0') {
+    message_stream << ": ";
+    FormatvInto(message_stream, extra_format, extra_adapters);
+  }
+  message_stream << "\n";
 
   // This macro is defined by `--config=non-fatal-checks`.
 #ifdef CARBON_NON_FATAL_CHECKS

common/check_internal.h

@@ -31,25 +31,29 @@ CheckCondition(bool condition)
 // Implements the check failure message printing.
 //
 // This is out-of-line and will arrange to stop the program, print any debugging
-// information and this string. In `!NDEBUG` mode (`dbg` and `fastbuild`), check
-// failures can be made non-fatal by a build flag, so this is not `[[noreturn]]`
-// in that case.
+// information and the failure message. In `!NDEBUG` mode (`dbg` and
+// `fastbuild`), check failures can be made non-fatal by a build flag, so this
+// is not `[[noreturn]]` in that case.
 //
 // This API uses `const char*` C string arguments rather than `llvm::StringRef`
 // because we know that these are available as C strings and passing them that
 // way lets the code size of calling it be smaller: it only needs to materialize
 // a single pointer argument for each. The runtime cost of re-computing the size
-// should be minimal. The extra message however might not be compile-time
-// guaranteed to be a C string so we use a normal `StringRef` there.
+// should be minimal.
+//
+// The user can provide an extra format string along with an array of
+// type-erased format adapters. This will be rendered into the final message.
 #ifdef NDEBUG
 [[noreturn]]
 #endif
-auto CheckFailImpl(const char* kind, const char* file, int line,
-                   const char* condition_str, llvm::StringRef extra_message)
+auto CheckFailImpl(
+    const char* kind, const char* file, int line, const char* condition_str,
+    const char* extra_format,
+    llvm::ArrayRef<llvm::support::detail::FormatFunctorRef> extra_adapters)
     -> void;
 
-// Allow converting format values; the default behaviour is to just pass them
-// through.
+// Allow custom conversion of format values; the default behaviour is to just
+// pass them through.
 template <typename T>
 auto ConvertFormatValue(T&& t) -> T&& {
   return std::forward<T>(t);
@@ -70,37 +74,53 @@ auto ConvertFormatValue(T&& t) -> auto {
   }
 }
 
+// Builds one type-erased format functor per value -- forwarding each value
+// through the conversion machinery. References to each of these functors are
+// then collected into an init list that can be accessed with an `ArrayRef`. All
+// of this is then passed to the out-of-line rendering function `CheckFailImpl`.
+//
+// This is templated only on the value types, not on the per-check-site
+// metadata (file, line, etc., which are passed as ordinary arguments), so the
+// adapter-building is instantiated once per distinct sequence of value types in
+// the TU.
+template <typename... Ts>
+#ifdef NDEBUG
+[[noreturn]]
+#endif
+auto CheckFailFormat(const char* kind, const char* file, int line,
+                     const char* condition_str, const char* extra_format,
+                     Ts&&... values) -> void {
+  CheckFailImpl(kind, file, line, condition_str, extra_format,
+                {llvm::support::detail::FormatFunctor(
+                    ConvertFormatValue(std::forward<Ts>(values)))...});
+}
+
 // Prints a check failure, including rendering any user-provided message using
 // a format string.
 //
-// Most of the parameters are passed as compile-time template strings to avoid
-// runtime cost of parameter setup in optimized builds. Each of these are passed
-// along to the underlying implementation to include in the final printed
-// message.
-//
-// Any user-provided format string and values are directly passed to
-// `llvm::formatv` which handles all of the formatting of output.
+// The check-site metadata is passed as compile-time template strings to avoid
+// runtime cost of parameter setup in optimized builds. This function is
+// instantiated once per check site (its template arguments are unique to the
+// site), so it is kept trivial: it just lowers those template strings to
+// ordinary arguments and forwards everything to `CheckFailFormat`, where the
+// adapter-building is shared across sites with the same value types.
 template <TemplateString Kind, TemplateString File, int Line,
           TemplateString ConditionStr, TemplateString FormatStr, typename... Ts>
 #ifdef NDEBUG
 [[noreturn]]
 #endif
-[[gnu::cold, clang::noinline]] auto
-CheckFail(Ts&&... values) -> void {
-  if constexpr (llvm::StringRef(FormatStr).empty()) {
-    // Skip the format string rendering if empty. Note that we don't skip it
-    // even if there are no values as we want to have consistent handling of
-    // `{}`s in the format string. This case is about when there is no message
-    // at all, just the condition.
-    CheckFailImpl(Kind.c_str(), File.c_str(), Line, ConditionStr.c_str(), "");
-  } else {
-    CheckFailImpl(Kind.c_str(), File.c_str(), Line, ConditionStr.c_str(),
-                  llvm::formatv(FormatStr.c_str(),
-                                ConvertFormatValue(std::forward<Ts>(values))...)
-                      .str());
-  }
+[[gnu::cold, clang::noinline]] auto CheckFail(Ts&&... values) -> void {
+  CheckFailFormat(Kind.c_str(), File.c_str(), Line, ConditionStr.c_str(),
+                  FormatStr.c_str(), std::forward<Ts>(values)...);
 }
 
+// Type-checks the arguments of a `DCHECK` in optimized builds, where the check
+// itself is dead code, without instantiating any formatting machinery for them
+// and without provoking unused-variable warnings. It is only ever named from
+// dead code, so it is never actually called.
+template <typename... Ts>
+auto IgnoreDeadCheckArgs(Ts&&... /*values*/) -> void {}
+
 }  // namespace Carbon::Internal
 
 // Evaluates the condition of a CHECK as a boolean value.
@@ -149,21 +169,23 @@ CheckFail(Ts&&... values) -> void {
    CARBON_INTERNAL_FATAL_NORETURN_SUFFIX())
 
 #ifdef NDEBUG
-// For `DCHECK` in optimized builds we have a dead check that we want to
-// potentially "use" arguments, but otherwise have the minimal overhead. We
-// avoid forming interesting format strings here so that we don't have to
-// repeatedly instantiate the `Check` function above. This format string would
-// be an error if actually used.
+// For `DCHECK` in optimized builds the check is dead code, but we still want to
+// type-check its arguments so they can't bitrot. We route them through
+// `IgnoreDeadCheckArgs`, which uses the arguments (avoiding unused-variable
+// warnings) but builds no format adapters, so the dead check doesn't pull in
+// the formatting machinery -- in particular not the per-value-type adapters
+// that the live `CheckFail` path would. The format string is a literal, so it
+// needs no type-checking and is dropped.
 #define CARBON_INTERNAL_DEAD_DCHECK(condition, ...) \
   CARBON_INTERNAL_DEAD_DCHECK_IMPL##__VA_OPT__(_FORMAT)(__VA_ARGS__)
 
 #define CARBON_INTERNAL_DEAD_DCHECK_IMPL() \
-  Carbon::Internal::CheckFail<"", "", 0, "", "">()
+  Carbon::Internal::IgnoreDeadCheckArgs()
 
 #define CARBON_INTERNAL_DEAD_DCHECK_IMPL_FORMAT(format_str, ...) \
-  Carbon::Internal::CheckFail<"", "", 0, "", "">(__VA_ARGS__)
+  Carbon::Internal::IgnoreDeadCheckArgs(__VA_ARGS__)
 
-// The CheckFail function itself is noreturn in NDEBUG.
+// The `CheckFail` function itself is noreturn in NDEBUG.
 #define CARBON_INTERNAL_FATAL_NORETURN_SUFFIX() void()
 #else
 #define CARBON_INTERNAL_FATAL_NORETURN_SUFFIX() std::abort()