Rust 1.23 removes redundant argument copies in the compiler

An intermediate representation can retain work that made sense in an older compiler design. Once the design changes, that work can survive as redundant instructions and duplicated information. Rust 1.23 includes a correction of this kind. Today's release announcement reports lower compiler memory use after eliminating some unnecessary copies, alongside a documentation transition that makes Markdown rendering more explicit.

The memory result has a defined scope. The announcement reports a reduction of five to ten percent when using rustc, and explicitly says other programs may differ. That is evidence about the measured compiler workload. It is not a promise that installing this release reduces every Rust application's memory consumption by the same proportion.

I find Rust's attention to these details appealing. A language intended for systems work needs its implementation to account for costs that source-level abstractions can conceal. Removing a redundant representation can improve the implementation without asking application authors to rewrite otherwise reasonable code.

The compiler no longer needs the old distinction

The implementation change in pull request 45380 explains the history. MIR originally distinguished arguments from local variables. That distinction led the compiler to copy incoming arguments into locals even for simple bindings. By the time of this change, the distinction had gone away while the extra copies remained.

Removing them reduces the MIR and LLVM IR the compiler emits. The mechanism is therefore more specific than a general assertion that a new optimizer makes Rust faster. It eliminates operations introduced by the compiler's own earlier organization. There is less intermediate work to represent and carry into later processing.

This matters when interpreting performance claims. A smaller intermediate program can reduce compiler work even where later optimization would have removed a copy from the final executable. Compiler resource use and application execution are different measurements. The release announcement's compiler-memory result is consistent with that distinction, without establishing a universal runtime effect.

The change also addresses debug information. Its description explains that the old behavior could describe an incoming argument and immediately shadow it with a same-named local. A debugger separating arguments from locals could then show confusing information, especially when the binding changed. Avoiding the artificial duplication makes the representation closer to the binding the programmer sees.

Rustdoc compares two renderers during migration

The documentation change takes a different approach to compatibility. Rustdoc is moving toward CommonMark, but this release still renders output with its previous Hoedown renderer. It also renders with a CommonMark implementation and warns when the results differ. Authors receive evidence about their documentation before the planned default changes.

The warning change is part of that preparation. A renderer transition can affect meaning conveyed by layout even when the source text does not change. A code block rendered as ordinary text or a list parsed differently can make an explanation misleading. Documentation therefore needs a migration mechanism just as an executable interface does.

The warning compares interpretations rather than requiring authors to guess which Markdown constructions might change. An author can examine a reported difference and revise the source to render correctly under both. The release announcement says the team is not aware of a case where that compatibility is impossible. That describes their knowledge at release, not a proof about every document.

I prefer this staged approach because documentation is part of how a library communicates its contract. A silent renderer replacement would ask maintainers to discover changed presentation after it had already become the default. A warning gives them a specific piece of source to correct while the existing output remains available.

Library changes preserve older callers

Rust 1.23 also moves ASCII-related methods directly onto the types that provide them. Previously, callers brought AsciiExt into scope to use those methods. The trait remains available for compatibility, including code that still supports older compilers. Removing the import can follow a project's decision to require the newer compiler.

This is a small example of the distinction between simplifying new source and invalidating old source. New callers no longer need the trait import. Existing callers retain a path that works across their supported compiler versions. A change can improve the common spelling while allowing maintainers to choose when to narrow their support range.

Cargo also gains the ability to check unit tests through cargo check, documented by the Cargo implementation change. Checking test code supplies feedback about code that an ordinary application check can omit. It does not establish that assertions pass during execution. The available operation lets a developer request compiler feedback on that additional code before running the tests themselves.

These changes affect different parts of development, but each has a specific mechanism. The compiler removes argument copies its representation no longer needs. Rustdoc reports incompatible renderings while retaining the previous output. Library callers can omit an import once their compiler requirement permits it. Those are concrete improvements a maintainer can adopt without treating the release as a reason to redesign an application.