Getting Rust for Linux into stable Rust: language features

[nikomatsakis]

Metadata
Point of contact	@tomassedovic
Team(s)	compiler
Goal document	2025h2/Rust-for-Linux-compiler

Summary

Continue working towards Rust for Linux on stable. In particular, this goal is focused on the Rust language features.

Tasks and status

• Discussion and moral support (compiler )
• Discussion and moral support (lang )

Tasks and status

• Discussion and moral support (compiler, rustdoc, cargo )
• Overall program management (@tomassedovic)
• Deref/Receiver
• Stabilize arbitrary self types (blocked on Deref/Receiver)
• Stabilize derive(CoercePointee) (blocked on arbitrary self types)
• support for pointers with asm_const
• Supertrait Auto-impl
• Stabilize cfg(no_fp_fmt_parse) unstable implemation
• Stabilize NUL-terminated files with #[track_caller]`

github.com/rust-lang/compiler-team) )

Rustdoc features to extract doc tests

• Author RFC ()
• RFC decision (rustdoc )
• Implementation ()
• Standard reviews (rustdoc )
• Experimentation in RFL (@ojeda)
• Stabilization decision (rustdoc )

Clippy configuration

• RFC text (pre-RFC draft)
• Stabilization decision (clippy )

Related goals

• Field projections
• In-place initialization / emplacement
• Rust for Linux Compiler features

---

Note: we have updated the body to match the 2025h2 goal. Your original text is preserved below.

Details

Metadata
Point of contact	@tomassedovic
Team(s)	lang, lang-docs
Goal document	2025h2/Rust-for-Linux-language

Summary

Continue working towards Rust for Linux on stable. In particular, this goal is focused on the language features.

Tasks and status

• Discussion and moral support (lang )

Finish and stabilize arbitrary_self_types and derive_coerce_pointee

• Discussion and moral support (lang )
• Finalize remaining work (@dingxiangfei2009)
• Author Reference PR (@dingxiangfei2009)
• Review/revise Reference PR (lang-docs )
• Author stabilization report (@dingxiangfei2009)
• Author stabilization PR (@dingxiangfei2009)
• Stabilization decision (lang )

---

Note: we have updated the body to match the 2025h2 goal. Your original text is preserved below.

Metadata
Point of contact	@nikomatsakis
Team(s)	cargo, clippy, compiler, rustdoc
Goal document	2025h1/rfl

Summary

Continue working towards Rust for Linux on stable, turning focus to compiler and tooling.

Why this goal?

This goal continues our work from 2024H2 in supporting the experimental support for Rust development in the Linux kernel. Whereas in 2024H2 we were focused on stabilizing required language features, our focus in 2025H1 is stabilizing compiler flags and tooling options. We will (1) implement RFC #3716 which lays out a design for ABI-modifying flags; (2) take the first step towards stabilizing build-std by creating a stable way to rebuild core with specific compiler options; (3) extending rustdoc, clippy, and the compiler with features that extract metadata for integration into other build systems (in this case, the kernel's build system).

Tasks and status

• Discussion and moral support (compiler, rustdoc, cargo )
• Overall program management (@nikomatsakis)

Finalizing 2024h2 goals

• Stabilize derive(CoercePointee) (blocked on #136764 / #136776)
• Stabilize arbitrary self types v2 (blocked on #136764 / #136776 / #143527)
• stabilize asm-goto (blocked on reference PR)
• support for pointers with asm_const Tracking issue: Support for pointers with asm_const rust#128464

ABI-modifying compiler flags

• Author RFC (@Darksonn)
• RFC decision (compiler )
• Implementation (draft PR from @azhogin)
• Standard reviews (compiler )
• Stabilization decision (compiler )

Configure no-std externally

• Author an RFC to stabilize RFC #3791
• Implementation ()
• Standard reviews (compiler )
• Stabilization decision (compiler )

Rustdoc features to extract doc tests

• Author RFC ()
• RFC decision (rustdoc )
• Implementation ()
• Standard reviews (rustdoc )
• Experimentation in RFL (@ojeda)
• Stabilization decision (rustdoc )

Clippy configuration

• RFC text (pre-RFC draft)
• Stabilization decision (clippy )

-Zsanitize-kcfi-arity

• Tracking issue: Tracking Issue for -Zsanitize-kcfi-arity rust#138311
• Implementation (KCFI: Add KCFI arity indicator support rust#138368, already reviewed by davidtwco)
• Stabilization

[nikomatsakis]

This issue is intended for status updates only.

For general questions or comments, please contact the owner(s) directly.

[nikomatsakis]

Key developments:

• Implementation work is proceeding in many areas (arbitrary self types v2, derive smart pointer, and sanitizer support.
• Extended offset_of syntax is stable on nightly! 🎉 Credit to @dingxiangfei2009 for driving this.
• RFL on Rust CI is implemented but still waiting on documented policy. The first breakage was detected (and fixed) in #129416. Reading over the PR comments suggests that the policy has not been well communicated to the Rust devs, who weren't clear on who was responsible to fix the breakage etc. Suggested follow-up is to improve the bot message to link to the policy and (as an interim measure) send an email to all@ and post an Inside Rust blog post.
• Stabilization report for Pointers to Statics in Constants is now in FCP. @dingxiangfei2009 to prepare stabilization PR. 💜

Next steps

• Need to decide on a name for derive-smart pointer. @nikomatsakis to follow-up.
• Experimentation with asm-goto has revealed that a weak point in the design. A typical use case for this feature is to design control-flow, where you have some assembly code that decides which block to branch to. The current design looks like inline_asm!(..., exit1 = { ... }, exit2 = { ... }), in which the assembly code can jump to exit1 or exit2. The problem is that, since inline_asm! must be in an unsafe block, this implies the blocks associated with those labels will be allowed to use unsafe code. To circumvent this, the RFL team is having those blocks simply break from an outer block with a false return value, and then branching on that if value outside. That's the same as the C code does, as it happens, but. it's not as nice nor efficient as it could be. Discussion in the meeting suggested that the block bodies should be limited to safe code unless marked as unsafe. @joshtriplett to follow-up.
• For Sanitizer support, we will need to stabilize the -Zfixed-x18 flag as a first step. @Darksonn to start drafting a stabilization report, possibly delegating some questions to @nikomatsakis.

[nikomatsakis]

Key developments:

• Kangrejos, the Rust for Linux Workshop, took place Sep 7-8 in Copenhagen. Session listing and slides are available on https://kangrejos.com.
• @Darksonn has opened RFC #3716 proposing an approach to manage compiler flags that modify the target ABI and which therefore are only sound if used by all crates. The kernel makes use of a wide number of such flags and it is not practical to have a distinct target for all of the possible combinations. In authoring the RFC it was discovered that there are more such flags than were previously recognized, such as flags that modify LLVM behavior.
• Due to the fact that an increasing number of discussion topics had to do with the compiler, @wesleywiser and @davidtwco from the compiler team have started to join our meetings, which has been helpful in getting faster input from the compiler team.
• The final naming for the "derive-smart-pointer" feature has been settled; it will henceforth be called #[derive(CoercePointee)]. @dingxiangfei2009 prepared PR #131284 to do the rename and is preparing a patch and PR to the rust-for-linux repository.
• @nbdd0121 authored a hackmd outlining RFL's experiences with the asm-goto feature and in particular areas for improvement. From this we derived two immediate action items, making the target blocks safe-by-default (Tracking Issue for asm_goto_with_outputs rust#119364) and extending const to support embedded pointers (Tracking issue: Support for pointers with asm_const rust#128464).

Next steps:

• RFC #3716 to be considered by the compiler team.
• Land PR Rename macro SmartPointer to CoercePointee rust#131284 and port code in the Rust-for-Linux repo to use it. Author stabilization report.
• Once FCP completes on Decide whether blocks inside asm goto should default to safe rust#132078, review and merge Make asm label blocks safe context rust#131544 making asm-goto target blocks safe-by-default.
• Decide on extending const to support embedded pointers (Tracking issue: Support for pointers with asm_const rust#128464).
• Stabilization PR for embedding pointers to statics in constants (to be done by @dingxiangfei2009)

[nikomatsakis]

Brief updates from today's meeting (minutes):

• Discussed what goal to set for the next round of project goals. Miguel to prepare a candidate list of stabilization targets, prioritizing language changes (which require widespread edits to the codebase to rebase over) and outright hacks (as is used with rustdoc) and otherwise focusing on "what is needed to get some concrete production use case working". Candidate production use cases we discussed are the android linux kernel configuration or the configuration used by a popular linux distro.
• Discussed synchronization with Debian to see if we can ensure that the version of Rust in their next LTS includes support for Rust 2024, which would make it much easier for the RfL work (along with other crates in the ecosystem) to migrate.
• Compiler team documented policy with respect to RfL on their CI, so that item is done.
• Stabilizationj PR for pointers-to-statics-in-constants (Tracking Issue for const_refs_to_static rust#119618) has landed and is stable on nightly, work is needed to update the reference.
• RFC for ABI-relevant compiler flags ([RFC] Target Modifiers rfcs#3716) to be reviewed by compiler team and moved to FCP if appropriate. @wesleywiser to call attention to it in the next compiler team meeting.