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

@@ -7,3 +7,6 @@ bazel-carbon-lang
 
 # See github_tools/MODULE.bazel.
 github_tools
+
+# Example Bazel project.
+examples/bazel

.bazeliskrc

@@ -1,7 +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
-
-# Keep pinned to a recent release, listed at
-# https://github.com/bazelbuild/bazel.
-USE_BAZEL_VERSION=7.2.0

.bazelrc

@@ -2,104 +2,226 @@
 # 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`.
-build --workspace_status_command=./scripts/workspace_status.py
-build --stamp
+# 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 --nostamp
 
 # Provide aliases for configuring the release and pre-release version being
 # built. For documentation of these flags, see //bazel/version/BUILD.
-build --flag_alias=release=//bazel/version:release
-build --flag_alias=pre_release=//bazel/version:pre_release
-build --flag_alias=rc_number=//bazel/version:rc_number
-build --flag_alias=beta_number=//bazel/version:beta_number
-build --flag_alias=alpha_number=//bazel/version:alpha_number
-build --flag_alias=nightly_date=//bazel/version:nightly_date
+common --flag_alias=release=//bazel/version:release
+common --flag_alias=pre_release=//bazel/version:pre_release
+common --flag_alias=rc_number=//bazel/version:rc_number
+common --flag_alias=nightly_date=//bazel/version:nightly_date
 
 # Support running clang-tidy with:
 #   bazel build --config=clang-tidy -k //...
 # See: https://github.com/erenon/bazel_clang_tidy
-build:clang-tidy --aspects @bazel_clang_tidy//clang_tidy:clang_tidy.bzl%clang_tidy_aspect
-build:clang-tidy --output_groups=report
-build:clang-tidy --@bazel_clang_tidy//:clang_tidy_config=//:clang_tidy_config
+common:clang-tidy --aspects @bazel_clang_tidy//clang_tidy:clang_tidy.bzl%clang_tidy_aspect
+common:clang-tidy --output_groups=report
+common:clang-tidy --@bazel_clang_tidy//:clang_tidy_config=//:clang_tidy_config
+common:clang-tidy --action_env=PATH --host_action_env=PATH
 
 # This warning seems to incorrectly fire in this build configuration, despite
 # not firing in our normal builds.
-build:clang-tidy --copt=-Wno-unknown-pragmas
+common:clang-tidy --copt=-Wno-unknown-pragmas
+
+# --config=non-fatal-checks makes CHECK failures not terminate compilation.
+common:non-fatal-checks --per_file_copt=common/check_internal.cpp@-DCARBON_NON_FATAL_CHECKS
+
+# Provide an alias for controlling the `carbon_*` Bazel rules' configuration. We
+# enable use of the target config here to make our build and tests more
+# efficient, see the documentation in //bazel/carbon_rules/BUILD for details.
+common --flag_alias=use_target_config_carbon_rules=//bazel/carbon_rules:use_target_config_carbon_rules
+# Bazel doesn't track what commands the flag_alias is valid for, so we can't use
+# common here.
+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.
 #
-# Note that this cache will grow without bound currently. You should
-# periodically run the `scripts/clean_disk_cache.sh` script or some equivalent.
-# https://github.com/bazelbuild/bazel/issues/5139 tracks fixing this in Bazel.
-build --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
 
-# Enable some safety when using the build cache, likely to be defaulted in
-# future Bazel releases.
-build --experimental_guard_against_concurrent_changes
+# Enable some safety when using the build cache. Defaults to `lite`.
+common --guard_against_concurrent_changes=full
+
+# Used by clang_configuration.bzl.
+common --action_env=CC --host_action_env=CC
+common --action_env=CMAKE_SYSROOT --host_action_env=CMAKE_SYSROOT
 
 # Disable warnings for all external compilations. These involve code that isn't
 # developed as part of Carbon and may be difficult or impossible to patch, so
 # warnings aren't likely to be actionable.
-build --per_file_copt=external/.*\.(c|cc|cpp|cxx)$@-w
-build --host_per_file_copt=external/.*\.(c|cc|cpp|cxx)$@-w
-
-# The `rules_treesitter` synthesized libraries don't allow us to inject flags,
-# and compile generated code where we can't fix warnings.
-build --per_file_copt=utils/treesitter/_treesitter.tree_sitter/.*\.c$@-w
-build --host_per_file_copt=utils/treesitter/_treesitter.tree_sitter/.*\.c$@-w
-
-# The `cc_proto_library` rule doesn't allow providing `copts`:
-# https://github.com/bazelbuild/bazel/issues/22610
-#
-# We unfortunately need to work around issues with `-Wmissing-prototypes` in
-# generated protobuf code, so pass the `copt` manually here. The warning issue
-# is likely part of:
-# https://github.com/llvm/llvm-project/issues/94138
-build --per_file_copt=.*\.pb\.cc$@-Wno-missing-prototypes
-build --host_per_file_copt=.*\.pb\.cc$@-Wno-missing-prototypes
+common --per_file_copt=external/.*\.(c|cc|cpp|cxx)$@-w
+common --host_per_file_copt=external/.*\.(c|cc|cpp|cxx)$@-w
 
 # Default dynamic linking to off. While this can help build performance in some
 # edge cases with very large linked executables and a slow linker, between using
 # fast linkers on all platforms (LLD and the Apple linker), as well as having
 # relatively few such executables, shared objects simply waste too much space in
 # our builds.
-build --dynamic_mode=off
+common --dynamic_mode=off
 
 # Always compile PIC code. There are few if any disadvantages on the platforms
 # and architectures we care about and it avoids the need to compile files twice.
-build --force_pic
+common --force_pic
 
 # Completely disable Bazel's automatic stripping of debug information. Removing
 # that information causes unhelpful backtraces from unittest failures and other
 # crashes. Optimized builds already avoid using debug information by default.
-build --strip=never
+common --strip=never
 
 # Enable Abseil for GoogleTest.
-build --define=absl=1
+common --define=absl=1
 
-# 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.
-build:asan --features=asan
+# Enable TCMalloc on Linux in optimized builds.
+common --custom_malloc=//bazel/malloc:tcmalloc_if_linux_opt
+
+# 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).
-build:fuzzer --features=fuzzer
-
-# Always allow tests to symbolize themselves with whatever `llvm-symbolize` is
-# in the users environment.
-build --test_env=ASAN_SYMBOLIZER_PATH
+common:fuzzer --features=fuzzer
 
 # Force actions to have a UTF-8 language encoding.
 # TODO: Need to investigate what this should be on Windows, but at least for
 # Linux and macOS this seems strictly better than the Bazel default of just
 # `en_US`.
-build --action_env=LANG=en_US.UTF-8
+common --action_env=LANG=en_US.UTF-8
+
+# Allow per-platform configuration.
+common --enable_platform_specific_config
+
+# Enable libpfm for google_benchmark on Linux only.
+common:linux --define=pfm=1
+
+# Enable split debug info on Linux, which is significantly more space efficient
+# and should work well with modern debuggers. Note that this is Linux specific
+# as macOS has its own approach that is always partially but not completely
+# split.
+#
+# Note: if using GDB, see documentation to get that working:
+# https://docs.carbon-lang.dev/docs/project/contribution_tools.html#debugging-with-gdb-instead-of-lldb
+#
+# TODO: Bazel has a bug where it doesn't manage dwo files in the cache correctly.
+# common:linux --fission=yes
+
+# 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
+
+# Query error in `@bazel_tools`. This reproduces with
+# `bazel query 'deps(//...)'`.
+# TODO: Enable the flag once compatibility issues are fixed.
+# common --incompatible_disable_non_executable_java_binary
+
+# Incompatible with the clang-tidy build mode.
+# TODO: Enable the flag once compatibility issues are fixed.
+# common --incompatible_auto_exec_groups
+
+# Incompatible with `rules_cc`.
+# TODO: Enable the flag once compatibility issues are fixed.
+# common --incompatible_no_rule_outputs_param
+# common --incompatible_stop_exporting_language_modules
+
+# Incompatible with `rules_pkg`.
+# TODO: Enable the flag once compatibility issues are fixed.
+# common --incompatible_disable_target_default_provider_fields
+
+# Incompatible with `rules_shell`.
+# TODO: Enable the flag once compatibility issues are fixed.
+# common --incompatible_check_visibility_for_toolchains
+
+# Enable as many incompatible flags as we can, per
+# https://bazel.build/release/backward-compatibility. To get the latest list,
+# using `bazelisk --migrate build //...` will help.
+common --incompatible_allow_tags_propagation
+common --incompatible_always_check_depset_elements
+common --incompatible_always_include_files_in_data
+common --incompatible_bazel_test_exec_run_under
+common --incompatible_check_sharding_support
+common --incompatible_check_testonly_for_output_files
+common --incompatible_config_setting_private_default_visibility
+common --incompatible_default_to_explicit_init_py
+common --incompatible_depset_for_java_output_source_jars
+common --incompatible_depset_for_libraries_to_link_getter
+common --incompatible_disable_autoloads_in_main_repo
+common --incompatible_disable_native_android_rules
+common --incompatible_disable_native_repo_rules
+common --incompatible_disable_objc_library_transition
+common --incompatible_disable_starlark_host_transitions
+common --incompatible_disable_target_provider_fields
+common --incompatible_disallow_ctx_resolve_tools
+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_dont_enable_host_nonhost_crosstool_features
+common --incompatible_dont_use_javasourceinfoprovider
+common --incompatible_enable_apple_toolchain_resolution
+common --incompatible_enable_deprecated_label_apis
+common --incompatible_enable_proto_toolchain_resolution
+common --incompatible_enforce_config_setting_visibility
+common --incompatible_enforce_starlark_utf8
+common --incompatible_exclusive_test_sandboxed
+common --incompatible_fail_on_unknown_attributes
+common --incompatible_fix_package_group_reporoot_syntax
+common --incompatible_java_common_parameters
+common --incompatible_legacy_local_fallback
+common --incompatible_locations_prefers_executable
+common --incompatible_make_thinlto_command_lines_standalone
+common --incompatible_merge_fixed_and_default_shell_env
+common --incompatible_merge_genfiles_directory
+common --incompatible_modify_execution_info_additive
+common --incompatible_new_actions_api
+common --incompatible_no_attr_license
+common --incompatible_no_implicit_file_export
+common --incompatible_no_implicit_watch_label
+common --incompatible_objc_alwayslink_by_default
+common --incompatible_package_group_has_public_syntax
+common --incompatible_py2_outputs_are_suffixed
+common --incompatible_py3_is_default
+common --incompatible_python_disable_py2
+common --incompatible_python_disallow_native_rules
+common --incompatible_remote_use_new_exit_code_for_lost_inputs
+common --incompatible_remove_legacy_whole_archive
+common --incompatible_require_ctx_in_configure_features
+common --incompatible_require_linker_input_cc_api
+common --incompatible_run_shell_command_string
+common --incompatible_sandbox_hermetic_tmp
+common --incompatible_simplify_unconditional_selects_in_rule_attrs
+common --incompatible_stop_exporting_build_file_path
+common --incompatible_strict_action_env
+common --incompatible_strip_executable_safely
+common --incompatible_top_level_aspects_require_providers
+common --incompatible_unambiguous_label_stringification
+common --incompatible_use_cc_configure_from_rules_cc
+common --incompatible_use_new_cgroup_implementation
+common --incompatible_use_plus_in_repo_names
+common --incompatible_use_python_toolchains
+common --incompatible_validate_top_level_header_inclusions
+common --incompatible_visibility_private_attributes_at_definition

.bazelversion

@@ -0,0 +1 @@
+8.6.0

.clang-format

@@ -11,9 +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_RAW_ENUM_CLASS',
+    '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

@@ -8,72 +8,198 @@ UseColor: true
 # This is necessary for `--config=clang-tidy` to catch errors.
 WarningsAsErrors: '*'
 
-# - bugprone-exception-escape finds issues like out-of-memory in main(). We
-#   don't use exceptions, so it's unlikely to find real issues.
-# - bugprone-macro-parentheses 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-switch-missing-default-case has false positives for `enum_base.h`.
-#   Clang's built-in switch warnings cover most of our risk of bugs here.
-# - bugprone-unchecked-optional-access in clang-tidy 16 has false positives on
-#   code like:
-#     while (auto name_ref = insts().Get(inst_id).TryAs<SemIR::NameRef>()) {
-#       inst_id = name_ref->value_id;
-#                 ^ unchecked access to optional value
-#     }
-# - google-readability-function-size overlaps with readability-function-size.
-# - modernize-use-designated-initializers is disabled because it fires on
-#   creation of SemIR typed insts, for which we do not currently want to use
-#   designated initialization.
-# - modernize-use-nodiscard is disabled because it only fixes const methods,
-#   not non-const, which yields distracting results on accessors.
-# - performance-unnecessary-value-param is disabled because it duplicate
-#   modernize-pass-by-value.
 Checks:
-  -*, bugprone-*, -bugprone-branch-clone, -bugprone-easily-swappable-parameters,
-  -bugprone-exception-escape, -bugprone-macro-parentheses,
-  -bugprone-narrowing-conversions, -bugprone-switch-missing-default-case,
-  -bugprone-unchecked-optional-access, google-*,
-  -google-readability-function-size, -google-readability-todo,
-  misc-definitions-in-headers, misc-misplaced-const, misc-redundant-expression,
-  misc-static-assert, misc-unconventional-assign-operator,
-  misc-uniqueptr-reset-release, misc-unused-*, modernize-*,
-  -modernize-avoid-c-arrays, -modernize-return-braced-init-list,
-  -modernize-use-default-member-init, -modernize-use-designated-initializers,
-  -modernize-use-emplace, -modernize-use-nodiscard, performance-*,
-  -performance-unnecessary-value-param, readability-*,
-  -readability-convert-member-functions-to-static,
-  -readability-function-cognitive-complexity, -readability-else-after-return,
-  -readability-identifier-length, -readability-implicit-bool-conversion,
-  -readability-magic-numbers, -readability-make-member-function-const,
-  -readability-static-definition-in-anonymous-namespace,
-  -readability-suspicious-call-argument, -readability-use-anyofallof
+  # We turn on all of a few categories by default.
+  - '-*'
+  - 'bugprone-*'
+  - 'google-*'
+  - 'misc-*'
+  - 'modernize-*'
+  - 'performance-*'
+  - 'readability-*'
+
+  # Disabled due to the implied style choices.
+  - '-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'
+  - '-modernize-use-emplace'
+  - '-readability-avoid-nested-conditional-operator'
+  - '-readability-convert-member-functions-to-static'
+  - '-readability-else-after-return'
+  - '-readability-identifier-length'
+  - '-readability-implicit-bool-conversion'
+  - '-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'
+  # In clang-tidy 16, has false positives on code like:
+  #     while (auto name_ref = insts().Get(inst_id).TryAs<SemIR::NameRef>()) {
+  #       inst_id = name_ref->value_id;
+  #                 ^ unchecked access to optional value
+  #     }
+  - '-bugprone-unchecked-optional-access'
+  # Overlaps with `readability-function-size`.
+  - '-google-readability-function-size'
+  # Suggests usernames on TODOs, which we don't want.
+  - '-google-readability-todo'
+  # 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
+  # status quo.
+  - '-modernize-avoid-c-arrays'
+  # Warns on creation of SemIR typed insts, for which we do not currently want
+  # to use designated initialization.
+  - '-modernize-use-designated-initializers'
+  # Only fixes const methods, not non-const, which yields distracting results on
+  # accessors.
+  - '-modernize-use-nodiscard'
+  # We aren't using the ranges library due to performance concerns.
+  - '-modernize-use-ranges'
+  # Low value compared to the engineering cost.
+  - '-performance-enum-size'
+  # Duplicates `modernize-pass-by-value`.
+  - '-performance-unnecessary-value-param'
+  # Warns on enums which use the `LastValue = Value` pattern if all the other
+  # discriminants aren't given an explicit value.
+  - '-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:
-  - { key: readability-identifier-naming.ClassCase, value: CamelCase }
-  - { key: readability-identifier-naming.ClassConstantCase, value: CamelCase }
-  - {
-      key: readability-identifier-naming.ConstexprVariableCase,
-      value: CamelCase,
-    }
-  - { key: readability-identifier-naming.NamespaceCase, value: CamelCase }
-  - { key: readability-identifier-naming.StructCase, value: CamelCase }
-  - {
-      key: readability-identifier-naming.TemplateParameterCase,
-      value: CamelCase,
-    }
-  - { key: readability-identifier-naming.TypeAliasCase, value: CamelCase }
-  - { key: readability-identifier-naming.TypedefCase, value: CamelCase }
-  - { key: readability-identifier-naming.UnionCase, value: CamelCase }
-  - { key: readability-identifier-naming.VariableCase, value: lower_case }
-  - { key: readability-identifier-naming.ParameterCase, value: lower_case }
-  - { key: readability-identifier-naming.ClassMemberCase, value: lower_case }
-  - {
-      key: readability-identifier-naming.MethodIgnoredRegexp,
-      value: '^classof$',
-    }
-  - {
-      # This erroneously fires in C++20 mode with LLVM 16 clang-tidy, due to:
-      # https://github.com/llvm/llvm-project/issues/46097
-      key: readability-identifier-naming.TemplateParameterIgnoredRegexp,
-      value: '^expr-type$',
-    }
+  # Don't warn on structs; done by ignoring when there are only public members.
+  - key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
+    value: true
+
+  # CamelCase names.
+  - key: readability-identifier-naming.ClassCase
+    value: CamelCase
+  - key: readability-identifier-naming.ClassConstantCase
+    value: CamelCase
+  - key: readability-identifier-naming.ConstexprVariableCase
+    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
+    value: CamelCase
+  - key: readability-identifier-naming.TypeAliasCase
+    value: CamelCase
+  - key: readability-identifier-naming.TypedefCase
+    value: CamelCase
+  - key: readability-identifier-naming.UnionCase
+    value: CamelCase
+
+  # lower_case names.
+  - key: readability-identifier-naming.ClassMemberCase
+    value: lower_case
+  - key: readability-identifier-naming.ParameterCase
+    value: lower_case
+  - key: readability-identifier-naming.VariableCase
+    value: lower_case
+
+  # TODO: This is for explorer's use of LLVM casting support, so we should be
+  # able to remove it once explorer is deleted.
+  - key: readability-identifier-naming.MethodIgnoredRegexp
+    value: '^classof$'
+
+  # This erroneously fires in C++20 mode with LLVM 16 clang-tidy, due to:
+  # https://github.com/llvm/llvm-project/issues/46097
+  - key: readability-identifier-naming.TemplateParameterIgnoredRegexp
+    value: '^expr-type$'
+
+  # 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

@@ -0,0 +1,32 @@
+# 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
+
+CompileFlags:
+  # Workaround for https://github.com/clangd/clangd/issues/1582
+  Remove: [-march=*]
+Diagnostics:
+  # `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]
+
+---
+
+# Suppress common diagnostics for x-macro files.
+If:
+  PathMatch: .*\.def
+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,9 @@
 # Exceptions. See /LICENSE for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+AggregateT
+AnyOther
+ArchType
 atleast
 circularly
 compiletime
@@ -12,7 +15,13 @@ crossreference
 falsy
 forin
 groupt
+indext
 inout
+isELF
+iterm
 parameteras
 pullrequest
+rightt
+rouge
 statics
+switcht

.devcontainer/devcontainer.json

@@ -1,22 +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": "carbon-lang",
-  "build": {
-    "dockerfile": "../docker/ubuntu2204/base/Dockerfile"
-  },
-  "customizations": {
-    "vscode": {
-      "extensions": [
-        "bazelbuild.vscode-bazel",
-        "bierner.github-markdown-preview",
-        "daohong-emilio.yash",
-        "esbenp.prettier-vscode",
-        "llvm-vs-code-extensions.vscode-clangd",
-        "ms-python.python"
-      ]
-    }
-  }
-}

.gdbinit

@@ -2,5 +2,6 @@
 # Exceptions. See /LICENSE for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-source third_party/llvm-project/libcxx/utils/gdb/libcxx/printers.py
+source external/+llvm_project+llvm-project/llvm/utils/gdb-scripts/prettyprinters.py
+source external/+llvm_project+llvm-project/libcxx/utils/gdb/libcxx/printers.py
 python register_libcxx_printer_loader()

.gitattributes

@@ -0,0 +1,7 @@
+# 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 tells Github to detect files having the extension `.def` as `C++` files, which
+# ensures that these files get syntax highlighted properly.
+*.def linguist-language=C++

.github/ISSUE_TEMPLATE/01_explorer_bug.yml

@@ -1,44 +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: Carbon Explorer bug
-description: >
-  Report a bug with the Carbon Explorer interpreter. This is what's provided at
-  [Compiler Explorer](https://carbon.compiler-explorer.com).
-labels: [explorer]
-body:
-  - type: markdown
-    attributes:
-      value: >
-        **Attention:** If this is a _question_, please use either [GitHub
-        Discussions](https://github.com/carbon-language/carbon-lang/discussions)
-        or [Discord](https://discord.gg/ZjVdShJDAs).
-  - type: textarea
-    id: desc
-    attributes:
-      label: >
-        Description of the bug:
-  - type: textarea
-    id: repro
-    attributes:
-      label: >
-        What did you do, or what's a simple way to reproduce the bug?
-      description: >
-        Please provide example code and errors; a shortlink to the execution on
-        [Compiler Explorer](https://carbon.compiler-explorer.com) can also help.
-  - type: textarea
-    id: expected
-    attributes:
-      label: >
-        What did you expect to happen?
-  - type: textarea
-    id: actual
-    attributes:
-      label: >
-        What actually happened?
-  - type: textarea
-    id: extras
-    attributes:
-      label: >
-        Any other information, logs, or outputs that you want to share?

.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,15 +37,19 @@ 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
         echo '*** clang++'
         which clang++
         clang++ --version
+        echo '*** clang-tidy'
+        which clang-tidy
+        clang-tidy --version
 
     # Add our bazel configuration and print basic info to ease debugging.
     - name: Configure Bazel and print info
@@ -57,9 +60,22 @@ runs:
       shell: bash
       run: |
         cat >user.bazelrc <<EOF
+        # Disable the local disk cache as we use a remote cache and don't want
+        # two copies of every output taking up disk space. The only way to
+        # disable the disk cache is with an empty string:
+        # https://github.com/bazelbuild/bazel/issues/5308
+        build --disk_cache=
+
         # Enable remote cache for our CI but minimize downloads.
         build --remote_cache=https://storage.googleapis.com/carbon-builds-github-v${CACHE_VERSION}
-        build --remote_download_minimal
+        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
@@ -105,3 +121,22 @@ runs:
         test --test_output=errors
         EOF
         ./scripts/run_bazel.py info
+
+    - name: Run bazel to sync deps with retry
+      shell: bash
+      run: |
+        # GitHub sometimes has a high failure rate for Bazel's downloads (even
+        # from GitHub URLs). Bazel exits with `1` on HTTP errors, which is hard
+        # to distinguish from a normal, permanent error.
+        #
+        # This workaround runs fast commands that should always pass (although
+        # they may be broken by an invalid PR). All errors are retried. The hope
+        # is that this caches necessary downloads, allowing later commands to
+        # more reliably succeed without retrying "permanent" errors.
+        #
+        # Disable lockfile updates, because some actions want to see
+        # differences.
+        ./scripts/run_bazel.py --attempts=5 --retry-all-errors \
+          mod --lockfile_mode=off deps
+        ./scripts/run_bazel.py --attempts=5 --retry-all-errors \
+          cquery --lockfile_mode=off //... | wc -l

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

@@ -9,15 +9,26 @@ inputs:
 runs:
   using: composite
   steps:
-    # Install and cache LLVM 16 from Homebrew.
-    # TODO: We can potentially remove this and simplify things when the
-    # Homebrew version of LLVM updates to 16 here:
-    # https://github.com/actions/runner-images/blob/main/images/macos/macos-12-Readme.md
+    # Free up disk space as the macOS runners end up using most for Xcode
+    # versions we don't need and iOS simulators.
+    - name: Free up disk space
+      shell: bash
+      run: |
+        # The xcrun occasionally fails (maybe a race condition?), so retry a few
+        # times. Example failure:
+        #   "data" couldn't be moved to "Deleting-<ID>"
+        echo '*** Delete iOS simulators'
+        xcrun simctl delete all || \
+          xcrun simctl delete all || \
+          xcrun simctl delete all
+        sudo rm -rf ~/Library/Developer/CoreSimulator/Caches/*
+
+    # 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@0c45773b623bea8c8e75f6c82b208c3cf94ea4f9 # v4.0.2
-      env:
-        cache-name: cache-homebrew
+      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
@@ -34,7 +45,8 @@ runs:
             '
           }}
         # Note the key needs to include all the packages we're adding.
-        key: Homebrew-Cache-${{ inputs.matrix_runner }}-${{ runner.arch }}
+        key:
+          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'
@@ -48,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@16
+        brew install --force-bottle --only-dependencies llvm@21
         echo '*** Installing LLVM itself'
-        brew install --force-bottle --force --verbose llvm@16
-        echo '*** brew info llvm@16'
-        brew info llvm@16
+        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'
@@ -65,7 +77,7 @@ runs:
     - name: Setup LLVM and Clang
       shell: bash
       run: |
-        LLVM_PATH="$(brew --prefix llvm@16)"
+        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

@@ -6,8 +6,8 @@ name: Setup build environment (Ubuntu)
 runs:
   using: composite
   steps:
-    # Ubuntu images start with 23GB available, and this adds 14GB more. For
-    # comparison, MacOS images have >100GB free.
+    # Ubuntu images start with ~23GB available; this takes a few seconds to add
+    # ~22GB more.
     #
     # Although we could delete more, if we run into a limit, not deleting
     # everything provides a little flexibility to get space while trying
@@ -18,41 +18,57 @@ runs:
         android: true
         dotnet: true
         haskell: true
+        # Enabling large-packages adds ~3 minutes to save ~4GB, so turn it off
+        # 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@0c45773b623bea8c8e75f6c82b208c3cf94ea4f9 # v4.0.2
-      env:
-        cache-name: cache-llvm
+      uses: actions/cache@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
       with:
         path: ~/llvm
-        key: LLVM-16-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=clang+llvm-16.0.4-x86_64-linux-gnu-ubuntu-22.04
+        # `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-16.0.4/$LLVM_RELEASE.tar.xz"
-        echo "*** Extracting $LLVM_RELEASE"
-        tar -xJf "$LLVM_RELEASE.tar.xz"
-        echo "*** Moving to 'llvm'"
-        mv "$LLVM_RELEASE" llvm
+        wget --show-progress=off "https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_RELEASE/$LLVM_TARBALL_NAME.tar.xz"
+        echo "*** Extracting $LLVM_TARBALL_NAME.tar.xz"
+        mkdir $LLVM_PATH
+        tar -xJf $LLVM_TARBALL_NAME.tar.xz --strip-components=1 -C $LLVM_PATH
+        echo "*** Deleting $LLVM_TARBALL_NAME.tar.xz"
+        rm $LLVM_TARBALL_NAME.tar.xz
         echo "*** Testing `clang++ --version`"
-        ~/llvm/bin/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/lib/{*.a,*.so,*.so.*,*.bc}
-        rm llvm/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
+        du -hs $LLVM_PATH
 
     - name: Setup LLVM and Clang paths
       shell: bash

.github/actions/test-setup/action.yml

@@ -0,0 +1,172 @@
+# 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: Test setup
+
+inputs:
+  matrix_runner:
+    required: true
+  base_sha:
+    required: true
+  remote_cache_key:
+    required: true
+  targets_file:
+    required: true
+  use_direct_targets:
+    default: 'false'
+
+outputs:
+  has_code:
+    value: ${{ steps.filter.outputs.has_code}}
+  has_cpp_files:
+    value: ${{ steps.filter.outputs.has_cpp_files}}
+
+runs:
+  using: composite
+  steps:
+    # Tests should only run on applicable paths, but we still need to have an
+    # action run for the merge queue. We filter steps based on the paths here,
+    # and condition steps on the output.
+    - id: filter
+      uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
+      with:
+        filters: |
+          has_code:
+            - '!{**/*.md,LICENSE,CODEOWNERS,.git*}'
+          has_cpp_files:
+            - '{**/*.cpp,**/*.h}'
+
+    # Disable uploads when the remote cache is read-only.
+    - name: Set up remote cache access (read-only)
+      if:
+        steps.filter.outputs.has_code == 'true' && github.event_name ==
+        'pull_request'
+      shell: bash
+      run: |
+        echo "remote_cache_upload=--remote_upload_local_results=false" \
+            >> $GITHUB_ENV
+
+    # Provide a cache key when the remote cache is read-write.
+    - name: Set up remote cache access (read-write)
+      if:
+        steps.filter.outputs.has_code == 'true' && github.event_name !=
+        'pull_request'
+      shell: bash
+      env:
+        REMOTE_CACHE_KEY: ${{ inputs.remote_cache_key }}
+      run: |
+        echo "$REMOTE_CACHE_KEY" | base64 -d > $HOME/remote_cache_key.json
+        echo "remote_cache_upload=--google_credentials=$HOME/remote_cache_key.json" \
+            >> $GITHUB_ENV
+
+    - uses: ./.github/actions/build-setup-common
+      if: steps.filter.outputs.has_code == 'true'
+      with:
+        matrix_runner: ${{ inputs.matrix_runner }}
+        remote_cache_upload: ${{ env.remote_cache_upload }}
+
+    # Just for visibility, print space before and after the build.
+    - name: Disk space before build
+      if: steps.filter.outputs.has_code == 'true'
+      shell: bash
+      run: df -h
+
+    - name: Verify MODULE.bazel.lock
+      if: steps.filter.outputs.has_code == 'true'
+      shell: bash
+      run: |
+        exit_code=0
+        ./scripts/run_bazel.py \
+          --attempts=5 \
+          mod deps --lockfile_mode=error || exit_code=$?
+        if (( $exit_code != 0 )); then
+          ./scripts/run_bazel.py \
+            --attempts=5 \
+            mod deps --lockfile_mode=update
+          echo "MODULE.bazel.lock is out of date! Use below file for update."
+          echo "Platforms may require merging output, for example by applying"
+          echo "an update, re-running triggers, and applying the next update."
+          echo "============================================================"
+          cat MODULE.bazel.lock
+          echo "============================================================"
+          exit 1
+        fi
+
+    # Build and run all targets on branch pushes to ensure we always have a
+    # clean tree. We don't expect this to be an interactive path and so don't
+    # optimize the latency of this step.
+    - name: Using all targets for push
+      if: steps.filter.outputs.has_code == 'true' && github.event_name == 'push'
+      shell: bash
+      env:
+        TARGETS_FILE: ${{ inputs.targets_file }}
+      run: |
+        echo "//..." >$TARGETS_FILE
+
+    # Compute the set of possible rules impacted by this change using
+    # Bazel-based diffing. This lets PRs and the merge queue have a much more
+    # efficient test CI action by avoiding even enumerating (and downloading)
+    # all of the unaffected Bazel targets.
+    - name: Compute indirect pull request targets
+      if:
+        steps.filter.outputs.has_code == 'true' && github.event_name != 'push'
+        && inputs.use_direct_targets != 'true'
+      shell: bash
+      env:
+        # Compute the base SHA from the different event structures.
+        GIT_BASE_SHA: ${{ inputs.base_sha }}
+        TARGETS_FILE: ${{ inputs.targets_file }}
+      run: |
+        # First fetch the relevant base into the git repository.
+        git fetch --depth=1 origin $GIT_BASE_SHA
+
+        # Do a retried query to try to download things for target-determinator.
+        ./scripts/run_bazel.py --attempts=5 cquery //... > /dev/null
+
+        # Then use `target-determinator` as wrapped by our script.
+        ./scripts/target_determinator.py $GIT_BASE_SHA >$TARGETS_FILE
+
+        # Bazel requires a test target to run the test command. There may be
+        # no targets or there may only be non-test targets that we want to
+        # build, so simply inject an explicit no-op test target.
+        echo "//scripts:no_op_test" >> $TARGETS_FILE
+
+    # Run the query to generate the targets file.
+    - name: Compute direct pull request targets
+      if:
+        steps.filter.outputs.has_code == 'true' && github.event_name != 'push'
+        && inputs.use_direct_targets == 'true'
+      shell: bash
+      env:
+        GIT_BASE_SHA: ${{ inputs.base_sha }}
+        QUERY_FILE: ${{ inputs.targets_file }}.query
+        TARGETS_FILE: ${{ inputs.targets_file }}
+      run: |
+        # First fetch the relevant base into the git repository.
+        git fetch --depth=1 origin $GIT_BASE_SHA
+
+        # Generate the query file. `same_pkg_direct_rdeps` is used to try to
+        # only get targets that contain modified files as srcs or hdrs (or
+        # similar artifacts).
+        echo 'same_pkg_direct_rdeps(' > $QUERY_FILE
+
+        # Start with an uninteresting file so that we can `union` below.
+        echo '  scripts/no_op_test.py' >> $QUERY_FILE
+
+        # Use `union` to join the list of files. Add quotes to defend against
+        # spaces. Note we can filter to the intersection of Carbon extensions
+        # and the supported list at:
+        # https://github.com/erenon/bazel_clang_tidy/blob/master/clang_tidy/clang_tidy.bzl#L65
+        for f in $(git diff --name-only --diff-filter=d \
+                     $GIT_BASE_SHA -- '**/*.h' '**/*.cpp'); do
+          echo "  union '$f'" >> $QUERY_FILE
+        done
+
+        echo ')' >> $QUERY_FILE
+
+        # Use query because cquery doesn't support `same_pkg_direct_rdeps`.
+        ./scripts/run_bazel.py \
+          --attempts=5 \
+          query --query_file=$QUERY_FILE \
+          > $TARGETS_FILE

.github/release.yaml

@@ -0,0 +1,43 @@
+# 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
+#
+# Provide the configuration and categorization for generated release notes.
+
+changelog:
+  exclude:
+    labels:
+      - ignore-for-release
+
+  categories:
+    - title: 'Proposals accepted and merged :scroll:'
+      labels:
+        - proposal
+      exclude.labels:
+        - bot
+    - title: 'Toolchain and implementation changes :hammer_and_wrench:'
+      labels:
+        - toolchain
+      exclude.labels:
+        - bot
+    - title: 'Documentation changes :memo:'
+      labels:
+        - documentation
+      exclude.labels:
+        - bot
+    - title: 'Utilities :triangular_ruler:'
+      labels:
+        - utilities
+      exclude.labels:
+        - bot
+    - title: 'Infrastructure changes :building_construction:'
+      labels:
+        - infrastructure
+      exclude.labels:
+        - bot
+    - title: 'Automated robot PRs :robot:'
+      labels:
+        - bot
+    - title: 'Other changes'
+      labels:
+        - '*'

.github/workflows/README.md

@@ -1,4 +1,4 @@
-# Testing workflows
+# Workflows
 
 <!--
 Part of the Carbon Language project, under the Apache License v2.0 with LLVM
@@ -6,6 +6,30 @@ Exceptions. See /LICENSE for license information.
 SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 -->
 
+## Hardening
+
+Workflows are hardened using
+[Step Security tool](https://app.stepsecurity.io/secureworkflow). Findings for
+the "Harden Runner" steps are
+[available online](https://app.stepsecurity.io/github/carbon-language/carbon-lang/actions/runs).
+
+### Allowed endpoints
+
+Most jobs only have a few endpoints, but due to tools which do downloads, a few
+have significantly more. These are:
+
+-   clangd_tidy.yaml (Bazel)
+-   prek.yaml (Bazel, prek)
+-   nightly_release.yaml (Bazel)
+-   tests.yaml (Bazel)
+
+When updating one of these, consider updating all of them.
+
+We try to keep `allowed-endpoints` with one per line. Prettier wants to wrap
+them, which we fix this with `prettier-ignore`.
+
+## Testing
+
 We keep around an `action-test` branch in carbon-lang, which can be used to test
 triggers with `push:` configurations. For example:
 

.github/workflows/assign_prs.yaml

@@ -1,68 +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'
-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@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
-        with:
-          egress-policy: audit
-
-      - 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'
-            explorer:
-              - 'explorer/**'
-            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-explorer
-        if: steps.filter.outputs.explorer == 'true'
-        uses: hkusu/review-assign-action@5bee595fdb9765d4a0bd35724b6302fa15569158 # v1.4.0
-        with:
-          reviewers: geoffromer, jonmeow, 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, geoffromer, jonmeow, josh11b, zygoloid
-          max-num-of-reviewers: 1
-
-      - id: assign-fallback
-        if: |
-          steps.filter.outputs.leads != 'true' &&
-          steps.filter.outputs.explorer != 'true' &&
-          steps.filter.outputs.toolchain != 'true'
-        uses: hkusu/review-assign-action@5bee595fdb9765d4a0bd35724b6302fa15569158 # v1.4.0
-        with:
-          reviewers: chandlerc, jonmeow, josh11b, zygoloid
-          max-num-of-reviewers: 1

.github/workflows/auto_label_prs.yaml

@@ -0,0 +1,122 @@
+# 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 label PRs'
+on:
+  pull_request_target:
+    types: [opened, ready_for_review]
+
+permissions:
+  pull-requests: write # For gh to edit labels.
+
+# TODO: `--repo carbon-language/carbon-lang` is a temporary workaround for:
+# https://github.com/cli/cli/issues/11055
+# Once a later version is released on runners, maybe August 2025, we should be
+# able to remove the extra flag.
+jobs:
+  set_labels:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.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: |
+            documentation:
+              - '*.md'
+              - 'docs/**'
+              - 'examples/**'
+              - 'third_party/examples/**'
+
+            infrastructure:
+              - '*.bzl'
+              - '*.cfg'
+              - '*.toml'
+              - '.*'
+              - '.*/**'
+              - 'BUILD'
+              - 'MODULE.*'
+              - 'WORKSPACE'
+              - 'bazel/**'
+              - 'github_tools/**'
+              - 'proposal/scripts/**'
+              - 'scripts/**'
+
+            # Here we only want the `proposal` label when a *new* file is added
+            # directly in this directory. We use `added` and a single level glob
+            # to achieve that.
+            proposal:
+              - added: 'proposals/*'
+
+            # We include common, shared code into the toolchain label for
+            # convenience. Essentially, this is everything we intend to ship as
+            # part of the reference implementation of the language.
+            toolchain:
+              - 'common/**'
+              - 'core/**'
+              - 'testing/**'
+              - 'toolchain/**'
+
+            utilities:
+              - 'utils/**'
+
+      - id: documentation
+        if: steps.filter.outputs.documentation == 'true'
+        run: |
+          gh pr edit "${PR}" --add-label "documentation" --repo carbon-language/carbon-lang
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR: ${{ github.event.pull_request.html_url }}
+
+      - id: infrastructure
+        if: steps.filter.outputs.infrastructure == 'true'
+        run: |
+          gh pr edit "${PR}" --add-label "infrastructure" --repo carbon-language/carbon-lang
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR: ${{ github.event.pull_request.html_url }}
+
+      - id: proposal
+        if: steps.filter.outputs.proposal == 'true'
+        run: |
+          gh pr edit "${PR}" --add-label "proposal" --repo carbon-language/carbon-lang
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR: ${{ github.event.pull_request.html_url }}
+
+      - id: toolchain
+        if: steps.filter.outputs.toolchain == 'true'
+        run: |
+          gh pr edit "${PR}" --add-label "toolchain" --repo carbon-language/carbon-lang
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR: ${{ github.event.pull_request.html_url }}
+
+      - id: utilities
+        if: steps.filter.outputs.utilities == 'true'
+        run: |
+          gh pr edit "${PR}" --add-label "utilities" --repo carbon-language/carbon-lang
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR: ${{ github.event.pull_request.html_url }}
+
+      # Note that this is not a path-based label, but an *author* based label,
+      # and it applies orthogonally to the others.
+      - id: automated
+        if:
+          contains(fromJSON('["CarbonInfraBot", "dependabot"]'),
+          github.event.pull_request.user.login)
+        run: |
+          gh pr edit "${PR}" --add-label "automated" --repo carbon-language/carbon-lang
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR: ${{ github.event.pull_request.html_url }}

.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/clangd_tidy.yaml

@@ -0,0 +1,89 @@
+# 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 (clangd)'
+
+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:
+  clangd-tidy:
+    runs-on: ubuntu-22.04
+
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
+        with:
+          egress-policy: block
+          # When adding endpoints, see README.md.
+          # prettier-ignore
+          allowed-endpoints: >
+            *.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
+            uploads.github.com:443
+            www.googleapis.com:443
+
+      - 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
+        if: steps.filter.outputs.has_cpp == 'true'
+        with:
+          matrix_runner: 'ubuntu-22.04'
+          remote_cache_upload: '--remote_upload_local_results=false'
+
+      - name: Create compile commands
+        if: steps.filter.outputs.has_cpp == 'true'
+        run: ./scripts/create_compdb.py
+
+      - name: Run clangd-tidy
+        if: steps.filter.outputs.has_cpp == 'true'
+        env:
+          FILTER_FILES: ${{ steps.filter.outputs.has_cpp_files }}
+        run: |
+          uvx --with clangd-tidy==1.1.0.post2 clangd-tidy -p . -j 10 $FILTER_FILES

.github/workflows/discord_wiki.yaml

@@ -2,23 +2,23 @@
 # Exceptions. See /LICENSE for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-name: Wiki Changed Discord Notification
+name: Discord Wiki Change Notifications
 
 on: gollum
 
-permissions: none
+# Minimum permissions.
+permissions:
+  contents: read
 
 jobs:
   notify:
     runs-on: ubuntu-latest
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
           egress-policy: audit
 
-      - uses:
-          'oznu/gh-wiki-edit-discord-notification@1f5b688c27310fba606368b20469c81f5ffd9a2f
-          # v1.0.0'
+      - uses: oznu/gh-wiki-edit-discord-notification@1f5b688c27310fba606368b20469c81f5ffd9a2f # v1.0.0
         with:
           discord-webhook-url: ${{ secrets.DISCORD_WEBHOOK_WIKI_EDIT }}

.github/workflows/gh_pages_ci.yaml

@@ -0,0 +1,50 @@
+# 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: GitHub Pages CI
+
+on:
+  pull_request:
+
+# 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
+
+permissions:
+  contents: read
+
+jobs:
+  # Build job
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
+        with:
+          egress-policy: audit
+
+      - name: Checkout
+        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@6ca151fd1bfcfd6fe0c4eb6837eb0584d0134a0c # v1.290.0
+        with:
+          # Runs 'bundle install' and caches installed gems automatically.
+          bundler-cache: true
+          # Increment this number if you need to re-download cached gems.
+          cache-version: 0
+      - name: Build with Jekyll
+        run: bundle exec jekyll build

.github/workflows/gh_pages_deploy.yaml

@@ -0,0 +1,88 @@
+# 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: GitHub Pages deploy
+
+on:
+  # Runs on pushes targeting the default branch.
+  push:
+    branches: ['trunk']
+
+  # Allows you to run this workflow manually from the Actions tab.
+  workflow_dispatch:
+
+# 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
+
+permissions: {}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
+        with:
+          egress-policy: audit
+
+      - name: Checkout
+        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@6ca151fd1bfcfd6fe0c4eb6837eb0584d0134a0c # v1.290.0
+        with:
+          # Runs 'bundle install' and caches installed gems automatically.
+          bundler-cache: true
+          # Increment this number if you need to re-download cached gems.
+          cache-version: 0
+      - 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}"
+      - name: Upload artifact
+        # Automatically uploads an artifact from the './_site' directory by
+        # default.
+        uses: actions/upload-pages-artifact@7b1f4a764d45c48632c6b24a0339c27f5614fb0b # v4.0.0
+
+  deploy:
+    environment:
+      name: github-pages
+      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@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
+        with:
+          egress-policy: audit
+
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e # v4.0.5

.github/workflows/label_prs.yaml

@@ -1,71 +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 label PRs'
-on:
-  pull_request_target:
-    types: [opened, ready_for_review]
-
-permissions:
-  pull-requests: write # For gh to edit labels.
-
-jobs:
-  assign_reviewer:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Harden Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
-        with:
-          egress-policy: audit
-
-      - id: filter
-        uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
-        with:
-          filters: |
-            documentation:
-              - '*.md'
-              - 'docs/**'
-            explorer:
-              - 'explorer/**'
-            infrastructure:
-              - 'BUILD'
-              - 'WORKSPACE'
-              - '.*'
-              - '.*/**'
-              - 'bazel/**'
-              - 'scripts/**'
-            toolchain:
-              - 'toolchain/**'
-
-      - id: documentation
-        if: steps.filter.outputs.docs == 'true'
-        run: |
-          gh pr edit "${PR}" --add-label "documentation"
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PR: ${{ github.event.pull_request.html_url }}
-
-      - id: explorer
-        if: steps.filter.outputs.explorer == 'true'
-        run: |
-          gh pr edit "${PR}" --add-label "explorer"
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PR: ${{ github.event.pull_request.html_url }}
-
-      - id: infrastructure
-        if: steps.filter.outputs.docs == 'true'
-        run: |
-          gh pr edit "${PR}" --add-label "infrastructure"
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PR: ${{ github.event.pull_request.html_url }}
-
-      - id: toolchain
-        if: steps.filter.outputs.toolchain == 'true'
-        run: |
-          gh pr edit "${PR}" --add-label "toolchain"
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PR: ${{ github.event.pull_request.html_url }}

.github/workflows/nightly-release.yaml

@@ -1,94 +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
-#
-# This workflow creates a GitHub "release" of a nightly build of the project.
-#
-# Note: This is just an initial rough attempt, there is a lot of future work
-# needed here. A brief summary of TODOs:
-#
-# - Configure a nice release notes template and switch to generating the title
-#   and notes instead of hard coding them.
-#
-# - Do some amount of testing prior to building and uploading the release.
-#   - Tempting to try to examine existing testing workflow, but maybe better to
-#     allow re-using any complex parts and do our own testing. That would, for
-#     example, allow us to narrow or expand the set of tests uses for
-#     pre-release testing to potentially be different from continuous testing.
-#   - Some questions around what to do in the event of a failure... error? Where
-#     does the error go? Create a draft, unpublished release instead?
-#
-# - Build artifacts for all the different OSes we have GitHub runners for rather
-#   than just x86 Linux.
-
-name: Nightly Release
-
-on:
-  schedule:
-    - cron: '0 2 * * *'
-  # Enable manual runs for testing or manually (re-)creating a nightly release.
-  workflow_dispatch:
-
-permissions:
-  contents: write # For creating and uploading to releases.
-
-jobs:
-  release:
-    runs-on: ubuntu-22.04
-    steps:
-      - name: Harden Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
-        with:
-          egress-policy: audit
-
-      - name: Checkout branch
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-
-      - name: Set up remote cache access
-        env:
-          REMOTE_CACHE_KEY: ${{ secrets.CARBON_BUILDS_GITHUB }}
-        run: |
-          echo "$REMOTE_CACHE_KEY" | base64 -d > $HOME/remote_cache_key.json
-          echo "remote_cache_upload=--google_credentials=$HOME/remote_cache_key.json" \
-              >> $GITHUB_ENV
-
-      - uses: ./.github/actions/build-setup-common
-        with:
-          matrix_runner: ubuntu-22.04
-          remote_cache_upload: ${{ env.remote_cache_upload }}
-
-      - name: Get nightly date
-        run: |
-          echo "nightly_date=$(date '+%Y.%m.%d')" >> $GITHUB_ENV
-
-      - name: Build release
-        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 }} \
-            //toolchain/install:prefix_root/bin/carbon \
-            //toolchain/install:carbon_toolchain_tar_gz_rule \
-            //toolchain/install:carbon_toolchain_tar_gz_test
-
-      - name: Extract the release version
-        run: |
-          # Make sure we can run the toolchain to get the version.
-          ./bazel-bin/toolchain/install/prefix_root/bin/carbon version
-
-          # Now stash it in a variable and export it.
-          VERSION=$( \
-            ./bazel-bin/toolchain/install/prefix_root/bin/carbon version \
-            | cut -d' ' -f5 | cut -d'+' -f1)
-          echo "release_version=$VERSION" >> $GITHUB_ENV
-
-      - name: Create the release
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          gh release create \
-            --title "Nightly build ${{ env.nightly_date }}" \
-            --notes 'A nightly development build of Carbon.' \
-            --prerelease \
-            v${{ env.release_version }} \
-            "bazel-bin/toolchain/install/carbon_toolchain-${{ env.release_version }}.tar.gz"

.github/workflows/nightly_release.yaml

@@ -0,0 +1,122 @@
+# 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 workflow creates a GitHub "release" of a nightly build of the project.
+#
+# Note: This is just an initial rough attempt, there is a lot of future work
+# needed here. A brief summary of TODOs:
+#
+# - Configure a nice release notes template and switch to generating the title
+#   and notes instead of hard coding them.
+#
+# - Do some amount of testing prior to building and uploading the release.
+#   - Tempting to try to examine existing testing workflow, but maybe better to
+#     allow reusing any complex parts and do our own testing. That would, for
+#     example, allow us to narrow or expand the set of tests uses for
+#     pre-release testing to potentially be different from continuous testing.
+#   - Some questions around what to do in the event of a failure... error? Where
+#     does the error go? Create a draft, unpublished release instead?
+#
+# - Build artifacts for all the different OSes we have GitHub runners for rather
+#   than just x86 Linux.
+
+name: Nightly Release
+
+on:
+  schedule:
+    - cron: '0 2 * * *'
+  # Enable manual runs for testing or manually (re-)creating a nightly release.
+  workflow_dispatch:
+
+permissions:
+  contents: write # For creating and uploading to releases.
+
+jobs:
+  release:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
+        with:
+          egress-policy: block
+          # When adding endpoints, see README.md.
+          # prettier-ignore
+          allowed-endpoints: >
+            *.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
+            storage.googleapis.com:443
+            uploads.github.com:443
+            www.googleapis.com:443
+
+      - name: Checkout branch
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Set up remote cache access
+        env:
+          REMOTE_CACHE_KEY: ${{ secrets.CARBON_BUILDS_GITHUB }}
+        run: |
+          echo "$REMOTE_CACHE_KEY" | base64 -d > $HOME/remote_cache_key.json
+          echo "remote_cache_upload=--google_credentials=$HOME/remote_cache_key.json" \
+              >> $GITHUB_ENV
+
+      - uses: ./.github/actions/build-setup-common
+        with:
+          matrix_runner: ubuntu-22.04
+          remote_cache_upload: ${{ env.remote_cache_upload }}
+
+      - name: Get nightly date
+        run: |
+          echo "nightly_date=$(date '+%Y.%m.%d')" >> $GITHUB_ENV
+
+      - name: Build release
+        run: |
+          ./scripts/run_bazel.py \
+            --attempts=5 --jobs-on-last-attempt=4 \
+            test -c opt --stamp --remote_download_toplevel \
+            --pre_release=nightly --nightly_date=${nightly_date} \
+            //toolchain \
+            //toolchain/install:carbon_toolchain_tar_gz \
+            //toolchain/install:carbon_toolchain_tar_gz_test
+
+      - name: Extract the release version
+        run: |
+          # Make sure we can run the toolchain to get the version.
+          ./bazel-bin/toolchain/carbon version
+
+          # Now stash it in a variable and export it.
+          VERSION=$( \
+            ./bazel-bin/toolchain/carbon version \
+            | cut -d' ' -f5 | cut -d'+' -f1)
+          echo "release_version=$VERSION" >> $GITHUB_ENV
+
+      - name: Create the release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release create \
+            --title "Nightly build ${nightly_date}" \
+            --generate-notes \
+            --prerelease \
+            v${release_version} \
+            "bazel-bin/toolchain/install/carbon_toolchain-${release_version}.tar.gz"

.github/workflows/pre_commit.yaml

@@ -1,45 +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: pre-commit
-
-on:
-  pull_request:
-  merge_group:
-  push:
-    branches: [trunk]
-
-permissions:
-  contents: read # For actions/checkout.
-
-jobs:
-  pre-commit:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Harden Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
-        with:
-          egress-policy: audit
-
-      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d # v5.1.0
-      - uses: pre-commit/action@2c7b3805fd2a0fd8c1884dcaebf91fc102a13ecd # v3.0.1
-
-      # We want to automatically create github suggestions for pre-commit 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,
-      # we upload the diffs and event configuration to an artifact for use by
-      # that action.
-      - name: Collect pre-commit 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
-        if: failure()
-        with:
-          name: pre-commit output
-          path: pre-commit-output/*

.github/workflows/pre_commit_suggestions.yaml

@@ -1,62 +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
-
-# Create PR suggestions based on problems found by pre-commit action.
-name: 'Add pre-commit 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
-# `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.
-#
-# This action is only run from the workflow file on the trunk branch. Changes to
-# this file will not take effect until they are merged to trunk.
-on:
-  workflow_run:
-    workflows: [pre-commit]
-    types:
-      - completed
-
-# Note reviewdog/reviewdog has its own token.
-permissions:
-  contents: read # For actions/checkout.
-
-jobs:
-  pull-request-suggestions:
-    # Only generate suggestions if pre-commit for a PR failed.
-    if: |
-      github.event.workflow_run.conclusion == 'failure' &&
-      github.event.workflow_run.event == 'pull_request' &&
-      github.actor != 'jonmeow'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Harden Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
-        with:
-          egress-policy: audit
-
-      - uses: reviewdog/action-setup@3f401fe1d58fe77e10d665ab713057375e39b887 # v1.3.0
-        with:
-          reviewdog_version: latest
-
-      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-
-      - name: Download pre-commit output
-        uses: actions/download-artifact@c850b930e6ba138125429b7e5c93fc707a7f8427 # v4.1.4
-        with:
-          name: pre-commit 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.
-      - name: Create suggestions
-        env:
-          REVIEWDOG_GITHUB_API_TOKEN:
-            ${{ secrets.CARBON_INFRA_BOT_FOR_REVIEWDOG }}
-        run: |
-          cat ./diff | \
-          GITHUB_EVENT_PATH=./event \
-            reviewdog -f=diff -f.diff.strip=1 -reporter=github-pr-review

.github/workflows/prek.yaml

@@ -0,0 +1,80 @@
+# 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: prek
+
+on:
+  pull_request:
+  merge_group:
+  push:
+    branches: [trunk]
+
+permissions:
+  contents: read # For actions/checkout.
+
+jobs:
+  prek:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
+        with:
+          egress-policy: block
+          # When adding endpoints, see README.md.
+          # prettier-ignore
+          allowed-endpoints: >
+            *.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
+            uploads.github.com:443
+            www.googleapis.com:443
+
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      # Ensure LLVM is set up consistently.
+      - uses: ./.github/actions/build-setup-common
+        with:
+          matrix_runner: ubuntu-22.04
+          remote_cache_upload: '--remote_upload_local_results=false'
+
+      - uses: j178/prek-action@01345c78b7de7d79edf368729212760396ba9345 # v2
+
+      # 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 prek_suggestions.yaml. Here,
+      # we upload the diffs and event configuration to an artifact for use by
+      # that action.
+      - name: Collect prek output
+        if: failure()
+        run: |
+          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: prek output
+          path: prek-output/*

.github/workflows/prek_suggestions.yaml

@@ -0,0 +1,70 @@
+# 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
+
+# Create PR suggestions based on problems found by prek action.
+name: 'Add prek suggestions'
+
+# 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.
+#
+# This action is only run from the workflow file on the trunk branch. Changes to
+# this file will not take effect until they are merged to trunk.
+on:
+  workflow_run:
+    workflows: [prek]
+    types:
+      - completed
+
+# Note reviewdog/reviewdog has its own token.
+permissions:
+  contents: read # For actions/checkout.
+
+jobs:
+  pull-request-suggestions:
+    # Only generate suggestions if prek for a PR failed.
+    if: |
+      github.event.workflow_run.conclusion == 'failure' &&
+      github.event.workflow_run.event == 'pull_request'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
+        with:
+          disable-sudo: true
+          egress-policy: block
+          # prettier-ignore
+          allowed-endpoints: >
+            api.github.com:443
+            github.com:443
+            objects.githubusercontent.com:443
+            raw.githubusercontent.com:443
+
+      - uses: reviewdog/action-setup@3f401fe1d58fe77e10d665ab713057375e39b887 # v1.3.0
+        with:
+          reviewdog_version: latest
+
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          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 prek created.
+      - name: Create suggestions
+        env:
+          REVIEWDOG_GITHUB_API_TOKEN:
+            ${{ secrets.CARBON_INFRA_BOT_FOR_REVIEWDOG }}
+        run: |
+          cat ./diff | \
+          GITHUB_EVENT_PATH=./event \
+            reviewdog -f=diff -f.diff.strip=1 -reporter=github-pr-review

.github/workflows/proposal_labeled.yaml

@@ -22,14 +22,22 @@ on:
 permissions:
   pull-requests: write # For gh to edit labels.
 
+# TODO: `--repo carbon-language/carbon-lang` is a temporary workaround for:
+# https://github.com/cli/cli/issues/11055
+# Once a later version is released on runners, maybe August 2025, we should be
+# able to remove the extra flag.
 jobs:
   proposal_labeled:
     runs-on: ubuntu-latest
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
-          egress-policy: audit
+          disable-sudo: true
+          egress-policy: block
+          # prettier-ignore
+          allowed-endpoints: >
+            api.github.com:443
 
       - name: draft
         if: |
@@ -40,7 +48,8 @@ jobs:
             --remove-label "proposal accepted" \
             --remove-label "proposal declined" \
             --remove-label "proposal deferred" \
-            --add-label "proposal"
+            --add-label "proposal" \
+            --repo carbon-language/carbon-lang
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           PR: ${{ github.event.pull_request.html_url }}
@@ -54,7 +63,8 @@ jobs:
             --remove-label "proposal accepted" \
             --remove-label "proposal declined" \
             --remove-label "proposal deferred" \
-            --add-label "proposal"
+            --add-label "proposal" \
+            --repo carbon-language/carbon-lang
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           PR: ${{ github.event.pull_request.html_url }}
@@ -68,7 +78,8 @@ jobs:
             --remove-label "proposal rfc" \
             --remove-label "proposal declined" \
             --remove-label "proposal deferred" \
-            --add-label "proposal"
+            --add-label "proposal" \
+            --repo carbon-language/carbon-lang
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           PR: ${{ github.event.pull_request.html_url }}
@@ -82,7 +93,8 @@ jobs:
             --remove-label "proposal rfc" \
             --remove-label "proposal accepted" \
             --remove-label "proposal deferred" \
-            --add-label "proposal"
+            --add-label "proposal" \
+            --repo carbon-language/carbon-lang
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           PR: ${{ github.event.pull_request.html_url }}
@@ -96,7 +108,8 @@ jobs:
             --remove-label "proposal rfc" \
             --remove-label "proposal accepted" \
             --remove-label "proposal declined" \
-            --add-label "proposal"
+            --add-label "proposal" \
+            --repo carbon-language/carbon-lang
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           PR: ${{ github.event.pull_request.html_url }}

.github/workflows/proposal_ready.yaml

@@ -13,15 +13,23 @@ on:
 permissions:
   pull-requests: write # For gh to edit labels.
 
+# TODO: `--repo carbon-language/carbon-lang` is a temporary workaround for:
+# https://github.com/cli/cli/issues/11055
+# Once a later version is released on runners, maybe August 2025, we should be
+# able to remove the extra flag.
 jobs:
   proposal_ready:
     if: contains(github.event.pull_request.labels.*.name, 'proposal')
     runs-on: ubuntu-latest
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
-          egress-policy: audit
+          disable-sudo: true
+          egress-policy: block
+          # prettier-ignore
+          allowed-endpoints: >
+            api.github.com:443
 
       - name: rfc
         run: |
@@ -30,7 +38,8 @@ jobs:
             --remove-label "proposal accepted" \
             --remove-label "proposal declined" \
             --remove-label "proposal deferred" \
-            --add-label "proposal rfc"
+            --add-label "proposal rfc" \
+            --repo carbon-language/carbon-lang
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           PR: ${{ github.event.pull_request.html_url }}

.github/workflows/stale.yaml

@@ -1,59 +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: 'Triage inactive issues and PRs'
-on:
-  schedule:
-    - cron: '30 1 * * *'
-
-permissions:
-  issues: write # For actions/stale to close stale issues.
-  pull-requests: write # For actions/stale to close stale PRs.
-
-jobs:
-  stale:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Harden Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
-        with:
-          egress-policy: audit
-
-      - uses: actions/stale@28ca1036281a5e5922ead5184a1bbf96e5fc984e # v9.0.0
-        with:
-          stale-issue-message: >
-            We triage inactive PRs and issues in order to make it easier to find
-            active work. If this issue should remain active or becomes active
-            again, please comment or remove the `inactive` label. The `long
-            term` label can also be added for issues which are expected to take
-            time.
-
-
-            This issue is labeled `inactive` because the last activity was over
-            90 days ago.
-          stale-pr-message: >
-            We triage inactive PRs and issues in order to make it easier to find
-            active work. If this PR should remain active, please comment or
-            remove the `inactive` label.
-
-
-            This PR is labeled `inactive` because the last activity was over 90
-            days ago. This PR will be closed and archived after 14 additional
-            days without activity.
-          close-pr-message: >
-            We triage inactive PRs and issues in order to make it easier to find
-            active work. If this PR should remain active or becomes active
-            again, please reopen it.
-
-
-            This PR was closed and archived because there has been no new
-            activity in the 14 days since the `inactive` label was added.
-          stale-issue-label: 'inactive'
-          stale-pr-label: 'inactive'
-          exempt-issue-labels:
-            'long term,design idea,design update,good first issue,leads question'
-          days-before-stale: 90
-          days-before-close: 14
-          days-before-issue-close: -1
-          operations-per-run: 100

.github/workflows/sync_repos.yaml

@@ -2,7 +2,7 @@
 # Exceptions. See /LICENSE for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-name: sync-repos
+name: Sync repos
 
 on:
   push:
@@ -25,13 +25,15 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        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

@@ -2,7 +2,7 @@
 # Exceptions. See /LICENSE for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-name: test
+name: Tests
 
 on:
   push:
@@ -22,142 +22,83 @@ concurrency:
 
 jobs:
   test:
+    name:
+      Testing ${{ matrix.config.name != 'Default' && format('({0})',
+      matrix.config.name) || '' }} (${{ matrix.runner }})
     strategy:
       matrix:
-        # On PRs and in the merge queue test a recent version of each supported
-        # OS. On push (post-submit), also run on `macos-12` to get Intel macOS
-        # coverage.
-        runner:
-          ${{ fromJSON(github.event_name != 'push' && '["ubuntu-22.04",
-          "macos-14"]' || '["ubuntu-22.04", "macos-14", "macos-12"]') }}
-        build_mode: [fastbuild, opt]
-        include:
-          # The clang-tidy config doesn't work on macos (missing `truncate`).
-          - runner: ubuntu-22.04
-            build_mode: clang-tidy
+        # 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@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
         with:
-          egress-policy: audit
+          egress-policy: block
+          # When adding endpoints, see README.md.
+          # prettier-ignore
+          allowed-endpoints: >
+            *.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
+            uploads.github.com:443
+            www.googleapis.com:443
 
-      # Checkout the pull request head or the branch.
-      - name: Checkout pull request
-        if: github.event_name == 'pull_request'
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
-          ref: ${{ github.event.pull_request.head.sha }}
+          persist-credentials: false
 
-      - name: Checkout branch
-        if: github.event_name != 'pull_request'
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-
-      # Tests should only run on applicable paths, but we still need to have an
-      # action run for the merge queue. We filter steps based on the paths here,
-      # and condition steps on the output.
-      - id: filter
-        uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
-        with:
-          filters: |
-            has_code:
-              - '!{**/*.md,LICENSE,CODEOWNERS,.git*}'
-
-      # Disable uploads when the remote cache is read-only.
-      - name: Set up remote cache access (read-only)
-        if:
-          steps.filter.outputs.has_code == 'true' && github.event_name ==
-          'pull_request'
-        run: |
-          echo "remote_cache_upload=--remote_upload_local_results=false" \
-              >> $GITHUB_ENV
-
-      # Provide a cache key when the remote cache is read-write.
-      - name: Set up remote cache access (read-write)
-        if:
-          steps.filter.outputs.has_code == 'true' && github.event_name !=
-          'pull_request'
-        env:
-          REMOTE_CACHE_KEY: ${{ secrets.CARBON_BUILDS_GITHUB }}
-        run: |
-          echo "$REMOTE_CACHE_KEY" | base64 -d > $HOME/remote_cache_key.json
-          echo "remote_cache_upload=--google_credentials=$HOME/remote_cache_key.json" \
-              >> $GITHUB_ENV
-
-      - uses: ./.github/actions/build-setup-common
-        if: steps.filter.outputs.has_code == 'true'
+      - id: test-setup
+        uses: ./.github/actions/test-setup
         with:
           matrix_runner: ${{ matrix.runner }}
-          remote_cache_upload: ${{ env.remote_cache_upload }}
-
-      # Just for visibility, print space before and after the build.
-      - name: Disk space before build
-        if: steps.filter.outputs.has_code == 'true'
-        run: df -h
-
-      - name: Verify MODULE.bazel.lock
-        if: steps.filter.outputs.has_code == 'true'
-        run: |
-          exit_code=0
-          ./scripts/run_bazel.py \
-            --attempts=5 \
-            mod deps --lockfile_mode=error || exit_code=$?
-          if (( $exit_code != 0 )); then
-            ./scripts/run_bazel.py \
-              --attempts=5 \
-              mod deps --lockfile_mode=update
-            echo "MODULE.bazel.lock is out of date! Use below file for update."
-            echo "Platforms may require merging output, for example by applying"
-            echo "an update, re-running triggers, and applying the next update."
-            echo "============================================================"
-            cat MODULE.bazel.lock
-            echo "============================================================"
-            exit 1
-          fi
-
-      # Build and run all targets on branch pushes to ensure we always have a
-      # clean tree. We don't expect this to be an interactive path and so don't
-      # optimize the latency of this step.
-      - name: Compute impacted pull request targets (for push)
-        if:
-          steps.filter.outputs.has_code == 'true' && github.event_name == 'push'
-        env:
-          TARGETS_FILE: ${{ runner.temp }}/targets
-        run: |
-          echo "//..." >$TARGETS_FILE
-
-      # Compute the set of possible rules impacted by this change using
-      # Bazel-based diffing. This lets PRs and the merge queue have a much more
-      # efficient test CI action by avoiding even enumerating (and downloading)
-      # all of the unaffected Bazel targets.
-      - name: Compute impacted pull request targets
-        if:
-          steps.filter.outputs.has_code == 'true' && github.event_name != 'push'
-        env:
-          # Compute the base SHA from the different event structures.
-          GIT_BASE_SHA:
+          base_sha:
             ${{ github.event_name == 'pull_request' &&
             github.event.pull_request.base.sha ||
             github.event.merge_group.base_sha }}
-          TARGETS_FILE: ${{ runner.temp }}/targets
-        run: |
-          # First fetch the relevant base into the git repository.
-          git fetch --depth=1 origin $GIT_BASE_SHA
-
-          # Then use `target-determinator` as wrapped by our script.
-          ./scripts/target_determinator.py $GIT_BASE_SHA >$TARGETS_FILE
-
-          # Bazel requires a test target to run the test command. There may be
-          # no targets or there may only be non-test targets that we want to
-          # build, so simply inject an explicit no-op test target.
-          echo "//scripts:no_op_test" >> $TARGETS_FILE
+          remote_cache_key: ${{ secrets.CARBON_BUILDS_GITHUB }}
+          targets_file: ${{ runner.temp }}/targets
 
       # Build and run just the tests impacted by the PR or merge group.
-      - name: Test (${{ matrix.build_mode }})
-        if:
-          steps.filter.outputs.has_code == 'true' && matrix.build_mode !=
-          'clang-tidy'
+      - name: Test (${{ matrix.config.name }})
+        if: steps.test-setup.outputs.has_code == 'true'
+        shell: bash
         env:
           # 'libtool_check_unique failed to generate' workaround.
           # https://github.com/bazelbuild/bazel/issues/14113#issuecomment-999794586
@@ -166,29 +107,14 @@ 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
 
-      # 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.filter.outputs.has_code == 'true' && matrix.build_mode ==
-          'clang-tidy'
-        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".
+      # See "Disk space before build" in `test-setup`.
       - name: Disk space after build
-        if: steps.filter.outputs.has_code == 'true'
+        if: steps.test-setup.outputs.has_code == 'true'
         run: df -h

.github/workflows/triage_inactive.yaml

@@ -0,0 +1,64 @@
+# 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: 'Triage inactive issues and PRs'
+on:
+  schedule:
+    - cron: '30 1 * * *'
+
+permissions:
+  issues: write # For actions/stale to close stale issues.
+  pull-requests: write # For actions/stale to close stale PRs.
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@58077d3c7e43986b6b15fba718e8ea69e387dfcc # v2.15.1
+        with:
+          disable-sudo: true
+          egress-policy: block
+          # prettier-ignore
+          allowed-endpoints: >
+            api.github.com:443
+
+      - uses: actions/stale@28ca1036281a5e5922ead5184a1bbf96e5fc984e # v9.0.0
+        with:
+          stale-issue-message: >
+            We triage inactive PRs and issues in order to make it easier to find
+            active work. If this issue should remain active or becomes active
+            again, please comment or remove the `inactive` label. The `long term
+            issue` label can also be added for issues which are expected to take
+            time.
+
+
+            This issue is labeled `inactive` because the last activity was over
+            90 days ago.
+          stale-pr-message: >
+            We triage inactive PRs and issues in order to make it easier to find
+            active work. If this PR should remain active, please comment or
+            remove the `inactive` label.
+
+
+            This PR is labeled `inactive` because the last activity was over 90
+            days ago. This PR will be closed and archived after 14 additional
+            days without activity.
+          close-pr-message: >
+            We triage inactive PRs and issues in order to make it easier to find
+            active work. If this PR should remain active or becomes active
+            again, please reopen it.
+
+
+            This PR was closed and archived because there has been no new
+            activity in the 14 days since the `inactive` label was added.
+          stale-issue-label: 'inactive'
+          stale-pr-label: 'inactive'
+          exempt-issue-labels:
+            'long term issue,design idea,design update,good first issue,leads
+            question'
+          days-before-stale: 90
+          days-before-close: 14
+          days-before-issue-close: -1
+          operations-per-run: 100

.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.
@@ -33,10 +39,21 @@
 \#*\#
 
 # vim temporary files
-.*.swp
+.*.sw[a-p]
+.swp
 
-# generated by utils/treesitter/helix.sh
+# generated by utils/tree_sitter/helix.sh
 /.helix/
 
 # Ignore .DS_Store files
 .DS_Store
+
+# 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

.lldbinit

@@ -0,0 +1,8 @@
+# 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
+
+command script import external/+llvm_project+llvm-project/llvm/utils/lldbDataFormatters.py
+command script import scripts/lldbinit.py
+settings set escape-non-printables false
+settings set target.max-string-summary-length 10000

.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: 2c9f875913ee60ca25ce70243dc24d5b6415598c # frozen: v4.6.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,21 +66,46 @@ 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: 3702ba224ecffbcec30af640c149f231d90aebdb # frozen: 24.4.2
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: 0c7b6c989466a93942def1f84baf36ddfcd60c83 # frozen: v0.15.14
     hooks:
-      - id: black
-  - repo: https://github.com/pre-commit/mirrors-prettier
-    rev: ffb6a759a979008c0e6dff86e39f4745a2d9eac4 # frozen: v3.1.0
+      - 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
+        name: prettier
+        language: node
+        # 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, yaml]
+        entry: npx prettier@3.3.3 --write --log-level=warn
   - repo: local
     hooks:
       - id: buildifier
         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)^(
@@ -81,17 +128,10 @@ repos:
       - id: clang-format
         name: clang-format
         entry: clang-format
-        types_or: [c++, proto, def]
+        types_or: [c++, def]
         language: python
         args: ['-i']
-        additional_dependencies: ['clang-format==17.0.1']
-      - id: explorer-format-grammar
-        name: Format the explorer grammar file
-        entry: explorer/syntax/format_grammar.py
-        language: python
-        files: ^explorer/syntax/(lexer.lpp|parser.ypp)$
-        pass_filenames: false
-        additional_dependencies: ['clang-format==17.0.1']
+        additional_dependencies: ['clang-format==21.1.8']
 
   - repo: local
     hooks:
@@ -108,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
@@ -130,34 +187,8 @@ repos:
         language: python
         files: ^.*/BUILD$
         pass_filenames: false
-  - repo: https://github.com/PyCQA/flake8
-    rev: 7d37d9032d0d161634be4554273c30efd4dea0b3 # frozen: 7.0.0
-    hooks:
-      - id: flake8
-  - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: 'e5ea6670624c24f8321f6328ef3176dbba76db46' # frozen: v1.10.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
-        # 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: 6e41aba91fb32e9feb741a6258eefeb9c6e4a482 # frozen: v2.2.6
+    rev: 2ccb47ff45ad361a21071a7eedda4c37e6ae8c5a # frozen: v2.4.2
     hooks:
       - id: codespell
         args: ['-I', '.codespell_ignore', '--uri-ignore-words-list', '*']
@@ -180,17 +211,22 @@ repos:
             Exceptions. See /LICENSE for license information.
             SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
           - --custom_format
-          - '\.(carbon|c|json|proto|ypp)(\.tmpl)?$'
+          - '\.(carbon|c|json|scss|ypp)(\.tmpl)?$'
           - ''
           - '// '
           - ''
           - --custom_format
+          - '\.(js|ts|mjs)$'
+          - '/*'
+          - ' * '
+          - ' */'
+          - --custom_format
           - '\.(l|lpp|y)$'
           - '/*'
           - ''
           - '*/'
           - --custom_format
-          - '\.(plist)$'
+          - '\.(plist|tmLanguage)$'
           - '<!--'
           - ''
           - '\-->'
@@ -207,26 +243,48 @@ repos:
           - --custom_format
           - '\.lua$'
           - ''
-          - '-- '
+          - '\-- '
           - ''
         exclude: |
           (?x)^(
               .bazelversion|
               .github/pull_request_template.md|
+              .python-version|
+              LICENSE.*|
               compile_flags.txt|
               github_tools/requirements.txt|
               third_party/.*|
+              utils/vscode/esbuild.js|
+              website/.ruby-version|
+              website/Gemfile.lock|
               .*\.def|
+              .*\.png|
               .*\.svg|
               .*/fuzzer_corpus/.*|
               .*/testdata/.*\.golden
           )$
       - id: check-links
+  - repo: local
+    hooks:
+      - id: check-build-graph
+        name: Check build graph
+        entry: scripts/check_build_graph.py
+        language: python
+        pass_filenames: false
+        files: |
+          (?x)^(
+            .*BUILD.*|
+            .*MODULE.bazel.*|
+            .*WORKSPACE.*|
+            .*\.bzl
+          )$
 
 # 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|

.prettierrc.yaml

@@ -9,6 +9,6 @@ tabWidth: 2
 trailingComma: 'es5'
 useTabs: false
 overrides:
-  - files: '*.md'
+  - files: '**/*.md'
     options:
       tabWidth: 4

.python-version

@@ -0,0 +1 @@
+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

@@ -2,9 +2,11 @@
   "recommendations": [
     "bazelbuild.vscode-bazel",
     "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/extensions/carbon-lang

@@ -1 +0,0 @@
-../../utils/vscode/

.vscode/gdb_launch.json

@@ -0,0 +1,25 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "by-gdb",
+      "request": "launch",
+      "name": "file_test (gdb)",
+      "program": "bazel-bin/toolchain/testing/file_test",
+      "programArgs": "--file_tests=${relativeFile}",
+      "cwd": "${workspaceFolder}",
+      "env": {
+        "TEST_TARGET": "//toolchain/testing:file_test",
+        "TEST_TMPDIR": "/tmp"
+      }
+    },
+    {
+      "type": "by-gdb",
+      "request": "launch",
+      "name": "carbon compile (gdb)",
+      "program": "bazel-bin/toolchain/carbon",
+      "programArgs": "compile --phase=lower --dump-sem-ir --stream-errors ${relativeFile}",
+      "cwd": "${workspaceFolder}"
+    }
+  ]
+}

.vscode/lldb_launch.json

@@ -0,0 +1,63 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "lldb-dap",
+      "request": "launch",
+      "name": "file_test (lldb)",
+      "program": "bazel-bin/toolchain/testing/file_test",
+      "args": ["--file_tests=${relativeFile}"],
+      "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",
+        "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": "carbon compile (lldb)",
+      "program": "bazel-bin/toolchain/carbon",
+      "args": [
+        "compile",
+        "--phase=lower",
+        "--dump-sem-ir",
+        "--stream-errors",
+        "${relativeFile}"
+      ],
+      "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"
+      ]
+    }
+  ]
+}

.vscode/tasks.json

@@ -0,0 +1,38 @@
+{
+  // See https://go.microsoft.com/fwlink/?LinkId=733558
+  // for the documentation about the tasks.json format
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "saveAll",
+      "command": "${command:workbench.action.files.saveAll}"
+    },
+    {
+      "label": "autoupdate: toolchain tests",
+      "type": "process",
+      "command": "toolchain/autoupdate_testdata.py",
+      "group": "build",
+      "dependsOn": ["saveAll"],
+      "dependsOrder": "sequence",
+      "presentation": {
+        "echo": false,
+        "panel": "dedicated",
+        "showReuseMessage": false,
+        "clear": true
+      },
+      "problemMatcher": {
+        "owner": "cpp",
+        "fileLocation": ["relative", "${workspaceFolder}"],
+        "source": "autoupdate",
+        "pattern": {
+          "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "severity": 4,
+          "message": 5
+        }
+      }
+    }
+  ]
+}

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

CODE_OF_CONDUCT.md

@@ -145,16 +145,9 @@ any member of the conduct team directly.
 
 ## Conduct team
 
-The conduct team can be emailed at conduct@carbon-lang.dev, and currently has
-the following members:
+The conduct team can be emailed at conduct@carbon-lang.dev.
 
--   Allison Poppe (@acpoppe on Discord and GitHub)
--   Céline Dedaj (@celineausberlin on Discord and GitHub)
--   Christopher Di Bella (@cjdb.work on Discord, @cjdb on GitHub)
--   Lexi Bromfield (@lexinadia on Discord and @lexi-nadia on GitHub)
--   flysand (@flysand on Discord and @flysand7 on GitHub)
-
-More details about the team and its management are on the
+More details about the team, its current members and its management are on the
 [conduct team page](/docs/project/teams/conduct_team.md).
 
 ### Reporting conduct

CONTRIBUTING.md

@@ -25,6 +25,7 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     -   [Collaboration systems](#collaboration-systems)
         -   [Getting access](#getting-access)
     -   [Contribution tools](#contribution-tools)
+        -   [Using AI-based contribution tools](#using-ai-based-contribution-tools)
     -   [Contribution guidelines and standards](#contribution-guidelines-and-standards)
         -   [Guidelines and philosophy for contributions](#guidelines-and-philosophy-for-contributions)
         -   [How to say things](#how-to-say-things)
@@ -32,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)
@@ -97,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
 
@@ -177,14 +179,13 @@ the Code of Conduct.
 -   [Google Calendar](https://calendar.google.com/calendar/embed?src=c_07td7k4qjq0ssb4gdl6bmbnkik%40group.calendar.google.com)
     is used for meeting invites and project reminders. Contributors may add
     calendar entries for meetings added to discuss details. Standard entries
-    are:
-
-    -   The
-        [weekly sync](https://docs.google.com/document/d/1dwS2sJ8tsN3LwxqmZSv9OvqutYhP71dK9Dmr1IXQFTs/edit?resourcekey=0-NxBWgL9h05yD2GOR3wUisg),
-        where contributors are welcome.
-    -   [Open discussions](https://docs.google.com/document/d/1tEt4iM6vfcY0O0DG0uOEMIbaXcZXlNREc2ChNiEtn_w/edit),
-        which are unstructured meeting slots used for discussing proposals,
-        tooling, and other Carbon topics based on who attends.
+    have
+    [minutes](https://drive.google.com/drive/folders/1VssO6kn9-HeKfzPDqBDR0Sy5CUE0OnSs)
+    and include:
+    -   The weekly sync, where contributors are welcome.
+    -   Open discussions, which are unstructured meeting slots used for
+        discussing proposals, tooling, and other Carbon topics based on who
+        attends.
 
 #### Getting access
 
@@ -226,9 +227,55 @@ 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),
+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 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:
+
+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
 
 All documents and pull requests must be consistent with the guidelines and
@@ -262,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.
@@ -359,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:
 
@@ -381,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

@@ -4,78 +4,55 @@
 
 """Bazel modules.
 
-If `MODULE.bazel.lock` changes locally, it means the host platform hasn't yet
-been added to the lock file. 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.
+`MODULE.bazel.lock` may change locally when `bazel` is executed. This means one
+of:
 
-Platforms tested with GitHub actions are kept up-to-date. Other platforms may
-fall out of sync on dependency changes, and should be updated with a PR the same
-way a platform is added.
+1.  An input is changing, typically `MODULE.bazel` or `.bazelversion`.
+    -   Running `bazel mod deps` provides a canonical update to
+        `MODULE.bazel.lock`; include the changes.
+    -   GitHub test actions may also identify platform-specific lockfile
+        updates.
+2.  The host platform hasn't yet been added to the lock file.
+    -   Platforms tested with GitHub actions are kept up-to-date. Other
+        platforms may fall out of sync due to `bazel` or dependency changes,
+        and should be updated with a PR the same way a platform is added.
+    -   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 = "bazel_skylib", version = "1.7.1")
-bazel_dep(name = "rules_pkg", version = "0.10.1")
-bazel_dep(name = "abseil-cpp", version = "20240116.2")
-bazel_dep(name = "re2", version = "2024-06-01")
-bazel_dep(name = "googletest", version = "1.14.0.bcr.1")
-
-google_benchmark_version = "1.8.3"
-
-bazel_dep(name = "google_benchmark", version = google_benchmark_version)
-archive_override(
-    module_name = "google_benchmark",
-    integrity = "sha256-a8GApX0j1NlRVRn5KwyD1hsFtbqxiJYfNqx7BrDZ6c4=",
-    patch_strip = 1,
-    patches = ["@//bazel/google_benchmark:0001-Use-libpfm-by-default-on-supported-platforms.patch"],
-    strip_prefix = "benchmark-{0}".format(google_benchmark_version),
-    urls = ["https://github.com/google/benchmark/archive/refs/tags/v{0}.tar.gz".format(google_benchmark_version)],
-)
-
-# 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"
-
-archive_override(
-    module_name = "libpfm",
-    integrity = "sha256-0YuXdkx1VSjBBR03bjNUXQ62DG6/hWgENoE/pbBMw9E=",
-    patch_strip = 1,
-    patches = ["@//bazel/libpfm:0001-Introduce-a-simple-native-Bazel-build.patch"],
-    strip_prefix = "libpfm-{0}".format(libpfm_version),
-    urls = ["https://sourceforge.net/projects/perfmon2/files/libpfm4/libpfm-{0}.tar.gz".format(libpfm_version)],
-)
-
-bazel_dep(name = "rules_bison", version = "0.2.2")
-bazel_dep(name = "rules_flex", version = "0.2.1")
-bazel_dep(name = "rules_m4", version = "0.2.3")
-bazel_dep(name = "rules_cc", version = "0.0.9")
-bazel_dep(name = "rules_proto", version = "6.0.2")
-bazel_dep(name = "protobuf", version = "27.1")
-
-libprotobuf_mutator_version = "1.3"
-
-http_archive(
-    name = "com_google_libprotobuf_mutator",
-    build_file = "@//:third_party/libprotobuf_mutator/BUILD.txt",
-    sha256 = "1ee3473a6b0274494fce599539605bb19305c0efadc62b58d645812132c31baa",
-    strip_prefix = "libprotobuf-mutator-{0}".format(libprotobuf_mutator_version),
-    urls = ["https://github.com/google/libprotobuf-mutator/archive/v{0}.tar.gz".format(libprotobuf_mutator_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 2024-03-12.
-    commit = "bff5c59c843221b05ef0e37cef089ecc9d24e7da",
+    # HEAD as of 2026-01-28.
+    commit = "c4d35e0d0b838309358e57a2efed831780f85cd0",
     remote = "https://github.com/erenon/bazel_clang_tidy.git",
 )
 
@@ -87,50 +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 2024-03-12.
-    commit = "204aa593e002cbd177d30f11f54cff3559110bb9",
-    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 = "0.0.10")
-bazel_dep(name = "zlib", version = "1.3.1.bcr.1", repo_name = "llvm_zlib")
-bazel_dep(name = "zstd", version = "1.5.6", repo_name = "llvm_zstd")
+bazel_dep(name = "platforms", version = "1.0.0")
+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 2024-05-17.
-llvm_project_version = "a68d20e986053ec571223a9f3ead3e146a27dc82"
-
 # 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",
-    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",
+        "//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",
     ],
-    sha256 = "4c53512522cfd625a75aa7f201e6932f18ebf3fbe8ee89e05883c3d30ca935ac",
-    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.
@@ -144,10 +109,39 @@ use_repo(llvm_project, "llvm-project")
 # Python
 ###############################################################################
 
-bazel_dep(name = "rules_python", version = "0.33.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

@@ -29,10 +29,9 @@ https://drive.google.com/drive/folders/1QrBXiy_X74YsOueeC0IYlgyolWIhvusB
 
 <!--
 Don't let the text wrap too narrowly to the left of the above image.
-The `div` reduces the vertical height.
-GitHub will autolink `img`, but won't produce a link when `href="#"`.
+The `div` reduces the vertical height. The `picture` prevents autolinking.
 -->
-<div><a href="#"><img src="docs/images/bumper.png"></a></div>
+<div><picture><img src="docs/images/bumper.png" alt=""></picture></div>
 
 **Fast and works with C++**
 
@@ -124,9 +123,9 @@ and provides a deeper view into our goals for the Carbon project and language.
 
 ## Project status
 
-Carbon Language is currently an experimental project. There is no working
-compiler or toolchain. You can see the demo interpreter for Carbon on
-[compiler-explorer.com](http://carbon.compiler-explorer.com/).
+Carbon Language is currently an experimental project. We are hard at work on a
+toolchain implementation with compiler and linker. You can try out the current
+state at [compiler-explorer.com](http://carbon.compiler-explorer.com/).
 
 We want to better understand whether we can build a language that meets our
 successor language criteria, and whether the resulting language can gather a
@@ -146,15 +145,17 @@ and the language:
     -   Operator overloading
     -   Lexical and syntactic structure
     -   Code organization and modular structure
--   A prototype interpreter demo that can both run isolated examples and gives a
-    detailed analysis of the specific semantic model and abstract machine of
-    Carbon. We call this the [Carbon Explorer](/explorer/).
 -   An under-development [compiler and toolchain](/toolchain/) that will compile
     Carbon (and eventually C++ code as well) into standard executable code. This
     is where most of our current implementation efforts are directed.
+    -   Historically, there was also a prototype
+        [explorer](https://github.com/carbon-language/explorer) interpreter that
+        implemented an older version of the Carbon language design, but is no
+        longer under development and has been archived.
 
-If you're interested in contributing, we're currently focused on
-[developing the Carbon toolchain until it can support Carbon ↔ C++ interop](/docs/project/roadmap.md#objective-for-2024-a-working-toolchain-that-supports-c-interop).
+If you're interested in contributing, we're currently focused on developing the
+Carbon toolchain until it can
+[support Carbon ↔ C++ interop](/docs/project/roadmap.md#access-most-non-template-c-apis-in-carbon).
 Beyond that, we plan to continue developing the design and toolchain until we
 can ship the
 [0.1 language](/docs/project/milestones.md#milestone-01-a-minimum-viable-product-mvp-for-evaluation)
@@ -168,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">
@@ -243,44 +247,84 @@ and with a smooth evolutionary path.
 
 Safety, and especially
 [memory safety](https://en.wikipedia.org/wiki/Memory_safety), remains a key
-challenge for C++ and something a successor language needs to address. Our
-initial priority and focus is on immediately addressing important, low-hanging
-fruit in the safety space:
+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.
+
+We also want to address important, low-hanging fruit in the safety space
+immediately when migrating into Carbon:
 
 -   Tracking uninitialized states better, increased enforcement of
-    initialization, and systematically providing hardening against
-    initialization bugs when desired.
--   Designing fundamental APIs and idioms to support dynamic bounds checks in
-    debug and hardened builds.
--   Having a default debug build mode that is both cheaper and more
-    comprehensive than existing C++ build modes even when combined with
+    initialization, and hardening against initialization bugs when needed.
+-   Designing fundamental APIs and idioms to support dynamic bounds checking.
+-   Switching from undefined behavior to erroneous behavior wherever possible,
+    and marking the remaining undefined behavior with visible `unsafe` syntax.
+-   Having a default debug build mode that has less runtime overhead while being
+    more comprehensive than existing C++ debug build modes combined with
     [Address Sanitizer](https://github.com/google/sanitizers/wiki/AddressSanitizer).
 
-Once we can migrate code into Carbon, we will have a simplified language with
-room in the design space to add any necessary annotations or features, and
-infrastructure like [generics](#generics) to support safer design patterns.
-Longer term, we will build on this to introduce **a safe Carbon subset**. This
-will be a large and complex undertaking, and won't be in the 0.1 design.
-Meanwhile, we are closely watching and learning from efforts to add memory safe
-semantics onto C++ such as Rust-inspired
-[lifetime annotations](https://discourse.llvm.org/t/rfc-lifetime-annotations-for-c/61377).
+For more details, see our [safety design](/docs/design/safety).
 
 ## Getting started
 
-To try out Carbon, you can use the Carbon explorer to interpret Carbon code and
-print its output. You can try it out immediately at
-[compiler-explorer.com](http://carbon.compiler-explorer.com/).
+To try out Carbon immediately in your browser, you can use the toolchain at:
+[carbon.compiler-explorer.com](http://carbon.compiler-explorer.com/).
 
-Because Carbon is an early, experimental project we don't yet have releases you
-can download and try out locally, you'll instead need to build any tools
-yourself from source. We expect to have packaged releases you can try out when
-we reach our
+We are developing a traditional toolchain for Carbon that can compile and link
+programs. However, Carbon is still an early, experimental project, and so we
+only have very experimental nightly releases of the Carbon toolchain available
+to download, and only on limited platforms. If you are using a recent Ubuntu
+Linux or similar (Debian, WSL, etc.), you can try these out by going to our
+[releases](https://github.com/carbon-language/carbon-lang/releases) page and
+download the latest nightly toolchain tar file:
+`carbon_toolchain-0.0.0-0.nightly.YYYY.MM.DD.tar.gz`. Then you can try it out:
+
+```shell
+# A variable with the nightly version from yesterday:
+VERSION="$(date -d yesterday +0.0.0-0.nightly.%Y.%m.%d)"
+
+# Get the release
+wget https://github.com/carbon-language/carbon-lang/releases/download/v${VERSION}/carbon_toolchain-${VERSION}.tar.gz
+
+# Unpack the toolchain:
+tar -xvf carbon_toolchain-${VERSION}.tar.gz
+
+# Create a simple Carbon source file:
+echo "import Core library \"io\"; fn Run() { Core.Print(42); }" > forty_two.carbon
+
+# Compile to an object file:
+./carbon_toolchain-${VERSION}/bin/carbon compile \
+  --output=forty_two.o forty_two.carbon
+
+# Install minimal system libraries used for linking. Note that installing `gcc`
+# or `g++` for compiling C/C++ code with GCC will also be sufficient, these are
+# just the specific system libraries Carbon linking still uses.
+sudo apt install libgcc-11-dev
+
+# Link to an executable:
+./carbon_toolchain-${VERSION}/bin/carbon link \
+  --output=forty_two forty_two.o
+
+# Run it:
+./forty_two
+```
+
+As a reminder, the toolchain is still very early and many things don't yet work.
+Please hold off on filing lots of bugs: we know many parts of this don't work
+yet or may not work on all systems. We expect to have releases that are much
+more robust and reliable that you can try out when we reach our
 [0.1 milestone](/docs/project/milestones.md#milestone-01-a-minimum-viable-product-mvp-for-evaluation).
 
-If you do want to try out Carbon locally, you'll need to install our
-[build dependencies](/docs/project/contribution_tools.md#setup-commands) (Bazel,
-Clang, LLD, libc++) and check out the Carbon repository, for example on Debian
-or Ubuntu:
+If you want to build Carbon's toolchain yourself or are thinking about
+contributing fixes or improvements to Carbon, you'll need to install our
+[build dependencies](/docs/project/contribution_tools.md#setup-commands) (Clang,
+LLD, libc++) and check out the Carbon repository. For example, on Debian or
+Ubuntu:
 
 ```shell
 # Update apt.
@@ -288,7 +332,6 @@ sudo apt update
 
 # Install tools.
 sudo apt install \
-  bazel \
   clang \
   libc++-dev \
   libc++abi-dev \
@@ -299,19 +342,12 @@ $ git clone https://github.com/carbon-language/carbon-lang
 $ cd carbon-lang
 ```
 
-Then you can build and run the explorer:
-
-```shell
-# Build and run the explorer.
-$ bazel run //explorer -- ./explorer/testdata/print/format_only.carbon
-```
-
-And you can try out our toolchain which has a very early-stage compiler for
+Then you can try out our toolchain which has a very early-stage compiler for
 Carbon:
 
 ```shell
 # Build and run the toolchain's help to get documentation on the command line.
-$ bazel run //toolchain/driver:carbon -- help
+$ ./scripts/run_bazelisk.py run //toolchain -- help
 ```
 
 For complete instructions, including installing dependencies on various
@@ -322,45 +358,81 @@ Learn more about the Carbon project:
 
 -   [Project goals](/docs/project/goals.md)
 -   [Language design overview](/docs/design)
--   [Carbon Explorer](/explorer)
 -   [Carbon Toolchain](/toolchain)
 -   [FAQ](/docs/project/faq.md)
 
 ## Conference talks
 
-Past Carbon focused talks from the community:
+Carbon focused talks from the community:
 
-### 2022
+### 2026
 
--   [Carbon Language: An experimental successor to C++](https://www.youtube.com/watch?v=omrY53kbVoA),
-    CppNorth
--   [Carbon Language: Syntax and trade-offs](https://www.youtube.com/watch?v=9Y2ivB8VaIs),
-    Core C++
+-   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/))
 
-### 2023
+### 2025
 
--   [Carbon’s Successor Strategy: From C++ interop to memory safety](https://www.youtube.com/watch?v=1ZTJ9omXOQ0),
-    C++Now
--   Definition-Checked Generics
-    ([Part 1](https://www.youtube.com/watch?v=FKC8WACSMP0),
-    [Part 2](https://www.youtube.com/watch?v=VxQ3PwxiSzk)), C++Now
--   [Modernizing Compiler Design for Carbon’s Toolchain](https://www.youtube.com/watch?v=ZI198eFghJk),
-    C++Now
+-   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
 
--   [Carbon: An experiment in different tradeoffs](https://llvm.swoogo.com/2024eurollvm/session/2086974/carbon-an-experiment-in-different-tradeoffs),
-    panel session at EuroLLVM 2024
+-   Generic implementation strategies in Carbon and Clang, LLVM Developers'
+    Meeting ([video](https://youtu.be/j0BL52NdjAU),
+    [slides](https://chandlerc.blog/slides/2024-llvm-generic-implementation/#/))
+-   The Carbon Language: Road to 0.1, NDC {TechTown}
+    ([video](https://youtu.be/bBvLmDJrzvI),
+    [slides](https://chandlerc.blog/slides/2024-ndc-techtown-carbon-road-to-0-dot-1))
+-   How designing Carbon with C++ interop taught me about C++ variadics and
+    overloads, CppNorth ([video](https://youtu.be/8SGMy9ENGz8),
+    [slides](https://chandlerc.blog/slides/2024-cppnorth-design-stories))
+-   Generic Arity: Definition-Checked Variadics in Carbon, C++Now
+    ([video](https://youtu.be/Y_px536l_80),
+    [slides](https://docs.google.com/presentation/d/10aM1mFMN6Cd5ZkE4OfeiZtSnkVNbo33N-V0et21umww/edit))
+-   Carbon: An experiment in different tradeoffs, panel session, EuroLLVM
+    ([video](https://youtu.be/Za_KWj5RMR8),
+    [slides](https://llvm.org/devmtg/2024-04/slides/LightningTalks/Smith-Carbons-high-level-semanticIR.pdf))
     -   [Alex Bradbury's notes](https://muxup.com/2024q2/notes-from-the-carbon-panel-session-at-eurollvm)
--   [Generic Arity: Definition-Checked Variadics in Carbon](https://schedule.cppnow.org/session/generic-arity-definition-checked-variadics-in-carbon/),
-    C++Now
+-   Carbon's high-level semantic IR lightning talk, EuroLLVM
+    ([video](https://youtu.be/vIWT4RhUcyw))
 
-### Upcoming
+### 2023
 
--   [How designing Carbon with C++ interop taught me about C++ variadics and overloads](https://cppnorth.ca/speaker-chandler-carruth.html),
-    CppNorth, July 21-24
--   [The Carbon Language: Road to 0.1](https://ndctechtown.com/agenda/the-carbon-language-road-to-01-0sqv/0526yb03a59),
-    NDC {TechTown}, Sept. 11
+-   Carbon’s Successor Strategy: From C++ interop to memory safety, C++Now
+    ([video](https://youtu.be/1ZTJ9omXOQ0),
+    [slides](https://chandlerc.blog/slides/2023-cppnow-carbon-strategy/index.html#/))
+-   Definition-Checked Generics, C++Now
+    -   Part 1 ([video](https://youtu.be/FKC8WACSMP0),
+        [slides](https://chandlerc.blog/slides/2023-cppnow-generics-1/#/))
+    -   Part 2 ([video](https://youtu.be/VxQ3PwxiSzk),
+        [slides](https://chandlerc.blog/slides/2023-cppnow-generics-2/#/))
+-   Modernizing Compiler Design for Carbon’s Toolchain, C++Now
+    ([video](https://youtu.be/ZI198eFghJk),
+    [slides](https://chandlerc.blog/slides/2023-cppnow-compiler/index.html#/))
+
+### 2022
+
+-   Carbon Language: Syntax and trade-offs, Core C++
+    ([video](https://youtu.be/9Y2ivB8VaIs),
+    [slides](https://docs.google.com/presentation/d/1znvL12xCuEfcsP6tpPdrQPnh-UoPFOLnC_RVXZteYaM/edit))
+-   Carbon Language: An experimental successor to C++, CppNorth
+    ([video](https://youtu.be/omrY53kbVoA),
+    [slides](https://chandlerc.blog/slides/2022-07-19-cppnorth-keynote/#/))
+
+### Other videos
+
+We additionally have [toolchain videos](/toolchain/docs/README.md#videos).
 
 ## Join us
 

SECURITY.md

@@ -1,11 +1,11 @@
+# Security policy
+
 <!--
 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
 -->
 
-# Security policy
-
 It's important to us that the Carbon Language provides a secure implementation.
 Thank you for taking the time to report vulnerabilities.
 
@@ -13,7 +13,7 @@ The Carbon Language is still an
 [experimental project](/README.md#project-status), so please be careful if using
 it in security-sensitive environments.
 
-# Reporting a vulnerability
+## Reporting a vulnerability
 
 Please use
 <https://github.com/carbon-language/carbon-lang/security/advisories/new> to
@@ -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))

WORKSPACE

@@ -1,57 +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
-
-workspace(name = "carbon")
-
-load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
-
-###############################################################################
-# Example conversion repositories
-###############################################################################
-
-local_repository(
-    name = "brotli",
-    path = "third_party/examples/brotli/original",
-)
-
-new_local_repository(
-    name = "woff2",
-    build_file = "third_party/examples/woff2/BUILD.original",
-    path = "third_party/examples/woff2/original",
-    workspace_file = "third_party/examples/woff2/WORKSPACE.original",
-)
-
-local_repository(
-    name = "woff2_carbon",
-    path = "third_party/examples/woff2/carbon",
-)
-
-###############################################################################
-# Treesitter rules
-###############################################################################
-
-http_archive(
-    name = "rules_nodejs",
-    sha256 = "d124665ea12f89153086746821cf6c9ef93ab88360a50c1aeefa1fe522421704",
-    strip_prefix = "rules_nodejs-6.0.0-beta1",
-    url = "https://github.com/bazelbuild/rules_nodejs/releases/download/v6.0.0-beta1/rules_nodejs-v6.0.0-beta1.tar.gz",
-)
-
-load("@rules_nodejs//nodejs:repositories.bzl", "DEFAULT_NODE_VERSION", "nodejs_register_toolchains")
-
-nodejs_register_toolchains(
-    name = "nodejs",
-    node_version = DEFAULT_NODE_VERSION,
-)
-
-http_archive(
-    name = "rules_tree_sitter",
-    sha256 = "a09f177a2b8acb2f8a84def6ca0c41a5bd26b25634aa7313f22ade6c54e57ca1",
-    strip_prefix = "rules_tree_sitter-bc3a2131053207de7dfd9b24046b811ce770e35d",
-    urls = ["https://github.com/Maan2003/rules_tree_sitter/archive/bc3a2131053207de7dfd9b24046b811ce770e35d.tar.gz"],
-)
-
-load("@rules_tree_sitter//tree_sitter:tree_sitter.bzl", "tree_sitter_register_toolchains")
-
-tree_sitter_register_toolchains()

bazel-execroot

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

bazel/carbon_rules/BUILD

@@ -1,3 +1,26 @@
 # 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("@bazel_skylib//rules:common_settings.bzl", "bool_flag")
+
+package(default_visibility = ["//visibility:public"])
+
+# Flag controlling whether the target config is used for the `carbon_*` Bazel
+# rules. The default is to use the exec config as that is more correct in cases
+# where the target config is not compatible with the exec (cross compiling), and
+# for library users of Carbon likely the most efficient as it will provide an
+# optimized toolchain.
+#
+# However, for building the Carbon project itself, this will roughly double the
+# build cost by forcing a build in both target and exec config. As a consequence
+# we disable the flag in the `.bazelrc` of the project for its builds.
+bool_flag(
+    name = "use_target_config_carbon_rules",
+    build_setting_default = False,
+)
+
+config_setting(
+    name = "use_target_config_carbon_rules_config",
+    flag_values = {":use_target_config_carbon_rules": "True"},
+)

bazel/carbon_rules/defs.bzl

@@ -4,51 +4,392 @@
 
 """Provides rules for building Carbon files using the toolchain."""
 
-def carbon_binary(name, srcs):
+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.
+    srcs_and_flags = [(ctx.files.srcs, 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_files + [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"] +
+                            [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 = depset(direct = objs + dep_link_inputs),
+        executable = toolchain_driver,
+        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 = {
+        "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",
+        ),
+        "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"),
+        "_default_deps": attr.label_list(default = [Label("//core:io")]),
+    },
+    executable = True,
+    fragments = ["cpp"],
+)
+
+_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.
     """
-    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_root` based rule similar to linking when
-        # the prelude moves there.
-        out = src + ".o"
-        srcs_reordered = [s for s in srcs if s != src] + [src]
-        native.genrule(
-            name = src + ".compile",
-            tools = [
-                "//toolchain/install:prefix_root/bin/carbon",
-                "//toolchain/install:install_data",
-            ],
-            cmd = "$(execpath //toolchain/install:prefix_root/bin/carbon) compile --output=$@ $(SRCS)",
-            srcs = srcs_reordered,
-            outs = [out],
-        )
+    _carbon_binary_internal(
+        name = name,
+        srcs = srcs,
+        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,
+    )
 
-    # For now, we assume that the prelude doesn't produce any necessary object
-    # code, and don't include the .o files for //core/prelude... in the final
-    # linked binary.
-    #
-    # TODO: This will need to be revisited eventually.
-    objs = [s + ".o" for s in srcs]
-    native.genrule(
-        name = name + ".link",
-        tools = [
-            "//toolchain/install:prefix_root/bin/carbon",
-            "//toolchain/install:install_data",
-        ],
-        cmd = "$(execpath //toolchain/install:prefix_root/bin/carbon) link --output=$@ $(SRCS)",
-        srcs = objs,
-        outs = [name],
+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_rules/BUILD

@@ -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
+
+# Empty; only defs.bzl is needed.

bazel/cc_rules/defs.bzl

@@ -0,0 +1,33 @@
+# 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
+
+"""Wraps standard cc rules with the `cc_env` addition.
+
+These should generally be used in place of `@rules_cc`.
+"""
+
+load(
+    "@rules_cc//cc:defs.bzl",
+    actual_cc_binary = "cc_binary",
+    actual_cc_library = "cc_library",
+    actual_cc_test = "cc_test",
+)
+load("//bazel/cc_toolchains:defs.bzl", "cc_env")
+
+# Expose cc_library directly, for consistency.
+cc_library = actual_cc_library
+
+def cc_binary(env = {}, **kwargs):
+    """Wraps `cc_binary`, adding `cc_env`."""
+    actual_cc_binary(
+        env = cc_env() | env,
+        **kwargs
+    )
+
+def cc_test(env = {}, **kwargs):
+    """Wraps `cc_binary`, adding `cc_env`."""
+    actual_cc_test(
+        env = cc_env() | env,
+        **kwargs
+    )

bazel/cc_toolchains/BUILD

@@ -3,8 +3,14 @@
 # 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")
 
-# For use by rules.bzl.
+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(
     name = "macos_asan",
@@ -14,14 +20,14 @@ selects.config_setting_group(
     ],
 )
 
-# For use by rules.bzl.
+# For use by defs.bzl.
 # Matches macOS platforms.
 config_setting(
     name = "is_macos",
-    constraint_values = ["@platforms//os:osx"],
+    constraint_values = ["@platforms//os:macos"],
 )
 
-# For use by rules.bzl.
+# For use by defs.bzl.
 # Matches build modes where asan is enabled.
 selects.config_setting_group(
     name = "macos_asan_build_modes",
@@ -31,16 +37,59 @@ selects.config_setting_group(
     ],
 )
 
-# For use by rules.bzl.
+# For use by defs.bzl.
 # Matches dbg.
 config_setting(
     name = "dbg",
     values = {"compilation_mode": "dbg"},
 )
 
-# For use by rules.bzl.
+# For use by defs.bzl.
 # Matches fastbuild.
 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()