2026-01-19— Last Week in Carbon

[josh11b]

News

• Chandler will be speaking at NDC Toronto in May 2026 https://ndctoronto.com/speakers/chandler-carruth
• An example of C++ interop using std::vector: https://carbon.godbolt.org/z/34s18WMMo

Updates on leads issues

• Decisions
  • (none)
• New issues
  • (none)
• Active discussions
  • (none)

Updates on proposals

• Decisions
  • (none)
• New RFC proposals
  • (none)
• Active discussions
  • (none)

Updates on moderation across our community spaces (Discord and GitHub)

• Moderation interventions last week:
  • (none)
• Activity in the past week:
  • GitHub pulse
  • 9 authors have pushed 42 commits to trunk and 42 commits to all branches.
  • On trunk, 598 files have changed and there have been 13,190 additions and 9,186 deletions
  • We merged 42 PRs, opened 4 PRs, closed 0 issues, and opened 2 new issues.

Activity on toolchain

• Toolchain release notes
• PRs:
  • LLM (AI) policy update in #6477
  • Implementing forms in #6570 #6577 #6586 #6588 #6593 #6618 #6619
  • Lowering with C++ interop in #6569 #6595
  • Extending C++ interop type/method support in #6573 #6575 #6576 #6584 #6604 #6621
  • Build system improvements in #6579 #6580 #6581 #6587 #6598 #6599 #6600 #6601 #6605 #6606 #6607 #6608 #6609 #6610 #6611 #6612 #6613 #6614
  • Lambdas support in #6583
  • Lowering in #6591
  • Generics implementation in #6592 #6602
  • Documentation improvements in #6596
  • More advent of code examples in #6597
  • others in #6557 #6574 #6589 #6594 #6624

Activity on C++ interop

• 01-13 How to generalize heterogeneous operators impls for CppCompat.Long32, where we need 2 different implementations depending on the type of the other operand: for N <= 32, the result should be Long32, for N > 32, it should be Int(N).
  • This is not supported at the moment, discussed possible workarounds (e.g. provide an interface LessThan(A:! IntLiteral, B:! IntLiteral); provide a custom witness when A < B and constrain the Long32 impls to cases for example where N < 32).
• 01-13 Also discussed how C++ overloads work, how macros work and the Vtable interop progress.

Activity on memory safety

• 01-12 How to write alias sets in a pointer and ref type. Removing the || bars from alias sets in general.
  • Classes need alias sets sometimes but need to omit them sometimes.
  • Converging toward alias sets being more like types, rather than less (in generics and impl lookup etc).
  • Discussion of the model for alias sets. Are they symbolic and part of specifics or no?
    • May need to be part of specifics for templates to work.
    • But don’t want each name to be a different specific. Maybe a higher order function that looks at two specifics with alias sets, and determines if they are actually the same/interchangeable in order to collapse to fewer specifics.
  • “Templates are the tool for undoing where you shifted to the left too far.”
• 01-13 What does const mean for generics if it’s part of an alias set.
  • Writing const on a generic input alias set means the code is “generic over const”, it accepts const or mutable inputs.
  • The caller still knows if it was const or not, so returning something with that alias set doesn’t force the caller to view it as const.
  • Questions of whether a callback is allowed to mutate given the generic function is treating it as const, and whether a template is allowed to observe the true const-ness and potentially mutate out from underneath the const-generic function.
  • Both lead to soundness issues if the generic function has acquired a value binding and holds it across the mutation.
  • Clarifications that if a generic function has a const-generic alias set (pointer) and passes it to a callback without passing it as explicitly const, then callback can mutate so the function must assume mutation happens, and overlapping value bindings are invalidated by the call.
  • Still not sure about templates, if they can see the “dynamic type” of an alias set which includes the true constness.
• 01-13 Question about if you can take a value binding acquisition of something in a global alias set, since other non-local pointers to it can exist, and possibly mutate your value.
• 01-13 Do we need a separate immutable mechanism for safety beyond values?
  • Deep immutability can be useful for passing arbitrary pointery structures across threads, where the pointers are all “live forever” pointers.
  • A deep immutable value works, but then prevents access to the address, compared to a deep immutable ref.
• #safety What is “ghost state” in Rust? A concept that uses the borrow checker to enforce arbitrary constraints in the type system, such as that an index is in bounds so that runtime bounds checks are not needed. GhostCell represents this, and S6.3 of this thesis discusses it: https://carleton.scholaris.ca/items/45f84fac-f77d-4a73-85eb-968ac7fab902/full
• #safety Discussion of destroy and move, question of whether destroy effect happens on the destruction of the object, or of the place in memory.
  • Reaffirming we’re pursuing invalidation (an effect) over exclusivity (in types) for its flexibility, and that we plan to use it to address thread safety (which is a temporal safety problem).
• #initialization Discussion of the “The Algebra of Loans in Rust” blog post.
  • If we had own references, maybe we would want to leverage the value type representation for those references, if we don't always need access to the address?
  • Alias set relationships will make visible when an input reference appears in an output value, in order to keep that value unchanged in the caller too, while the binding is acquired.

Other active discussions

These include Discord Chat, GitHub Discussions, or open discussion sessions.

• #generics-and-templates How will we write constraints on IntLiterals like impl forall [N:! Core.IntLiteral] Core.Int(N) as Z where N <= 32?
  • We will need some language feature here.
  • Leads issue #2153 has some related discussion, needs some thought wrt forms.
• #generics-and-templates Details of the implementation of making extend require impls extend the containing name scope. The found interface does not have a specific that matches what we find later with impl lookup. The former is not specialized for the self-type of the name lookup, whereas the impl lookup result is; the mismatch makes impl lookup fail.
• #generics-and-templates Incorrect diagnostic requiring Self in the parameters of a named constraint, but it should only be required in interfaces, though includes interfaces found through a named constraint.
• #generics-and-templates Contemplating having two generics for an interface, so that there is a generic that includes a binding for the inner Self inside the interface’s definition, which allows a specific to replace it.
• #generics-and-templates A crash on lowering a class without a definition. Filed #6617
• #generics-and-templates A crash on a require impls requiring an interface that constrains Self beyond type. Discussion if it should be diagnosed as an error accepted with implied constraints. Belief that it would be nice to accept it and extend the design’s implied constraints to apply to named constraints (or interfaces?) that contain a require impls declaration.
• #toolchain Discussion of planned work around build system improvements.
• #toolchain LLVM symbolizer hangs in debug, the “debug” libc++ hardening makes the symbolization effectively infinite. Switching debug builds to “extensive” libc++ hardening.
• #toolchain Extraneous getelementptr instructions in the semir.
• #toolchain How should Carbon slot into a build system like bazel when being used as the C++ compiler?
• #toolchain Are forms types? (Yes) Would we benefit from a FormInstId for instructions of type Form like we have TypeInstId for instructions of type type?
• #toolchain Should we prioritize the TODOs to make Convert() non-recursive? (not now)
• #infra How to implement prebuilt runtimes caching for Compiler Explorer. Is it enough or do we really need on-demand runtimes on CE too?
  • #infra CE is not going to be able to support long-running builds of runtimes on demand, and won’t be able to cache the result on the fly.
• #infra PRs to fix linking timeouts on CE by caching prebuilt runtimes when downloading the compiler, and using them.
• #infra Merge commits on Github with git vs jj
• #getting-started CE is broken for linking, but fix is in progress
• #llvm “A list of opportunities to improve LLVM" by the lead maintainer of the LLVM project
• #llvm Where does cc_library_wrapper come from? Turns out github search doesn’t index third-party code in a repo.
• #llvm Could we use PCHs to make building LLVM faster? Seems too complicated to do (in Bazel?).
• #typesystem Initializing expressions when calling C++ with a thunk, want to allow in-place initialization to avoid unnecessary copies.
• #typesystem When is the initialization of a returned var visible outside the function on the variable being initialized by that function? We will model both the returned var and the var being initialized by it as being the same object.
• #interop Using std::vector in interop, an example: https://carbon.godbolt.org/z/34s18WMMo
• #strategy Chandler is speaking at the NDC Toronto conference: https://ndctoronto.com/speakers/chandler-carruth
• #general-design Pattern matching operates from the outside in.

RSS Feed for "Last Week in Carbon" here

[DomiOh]

An example of C++ interop using std::vector: https://carbon.godbolt.org/z/nc6qPT594
does not really work for me. Compiler Error.

[danakj]

Both compiler explorer and the toolchain have had changes in the meantime that broke things. Here's a working link (for now): https://carbon.godbolt.org/z/34s18WMMo I have edited the original post as well.