Rustc pull update #2493
Closed
Rustc pull update #2493
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
![github-actions[bot]](https://avatars.githubusercontent.com/in/15368?s=60&v=4){kind=small}
…=jdonszelmann,oli-obk Port `#[no_implicit_prelude]` to the new attribute parsing infrastructure Ports no_implicit_prelude to the new attribute parsing infrastructure for rust-lang/rust#131229 (comment) r? `@oli-obk` cc `@jdonszelmann`
Avoid depending on forever-red DepNode when encoding metadata. Split from rust-lang/rust#114669 for perf r? `@petrochenkov`
…elinval Refactor StableMIR This PR refactors stable-mir according to the guidance in [this doc](https://hackmd.io/jBRkZLqAQL2EVgwIIeNMHg). It reverses the dependency between `rustc_smir` and `stable_mir`, making `rustc_smir` completely agnostic of `stable_mir`. Under the new architecture, the `rustc_smir` crate would retain direct access to rustc queries, while `stable_mir` should proxy all such requests through `rustc_smir` instead of accessing rustc's internals directly. `stable_mir` would only be responsible for the conversion between internal and stable constructs. This PR mainly introduces these changes: - **Bridge / Tables<'tcx, B: Bridge>** ```rust /// A trait defining types that are used to emulate StableMIR components, which is really /// useful when programming in stable_mir-agnostic settings. pub trait Bridge { type DefId: Copy + Debug + PartialEq + IndexedVal; type AllocId: Copy + Debug + PartialEq + IndexedVal; type Span: Copy + Debug + PartialEq + IndexedVal; type Ty: Copy + Debug + PartialEq + IndexedVal; type InstanceDef: Copy + Debug + PartialEq + IndexedVal; type TyConstId: Copy + Debug + PartialEq + IndexedVal; type MirConstId: Copy + Debug + PartialEq + IndexedVal; type Layout: Copy + Debug + PartialEq + IndexedVal; type Error: SmirError; } pub struct Tables<'tcx, B: Bridge> { tcx: TyCtxt<'tcx>, pub(crate) def_ids: IndexMap<DefId, B::DefId>, pub(crate) alloc_ids: IndexMap<AllocId, B::AllocId>, pub(crate) spans: IndexMap<rustc_span::Span, B::Span>, pub(crate) types: IndexMap<Ty<'tcx>, B::Ty>, pub(crate) instances: IndexMap<ty::Instance<'tcx>, B::InstanceDef>, pub(crate) ty_consts: IndexMap<ty::Const<'tcx>, B::TyConstId>, pub(crate) mir_consts: IndexMap<mir::Const<'tcx>, B::MirConstId>, pub(crate) layouts: IndexMap<rustc_abi::Layout<'tcx>, B::Layout>, } ``` Since `rustc_smir` needs these stable types somewhere, using associated types is a good approach. - **SmirContainer / SmirInterface** ```rust /// A container which is used for TLS. pub struct SmirContainer<'tcx, B: Bridge> { pub tables: RefCell<Tables<'tcx, B>>, pub cx: RefCell<SmirCtxt<'tcx, B>>, } impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { // ... } /// Provides direct access to rustc's internal queries. /// /// The [`crate::stable_mir::compiler_interface::SmirInterface`] must go through /// this context to obtain rustc-level information. pub struct SmirCtxt<'tcx, B: Bridge> { tcx: TyCtxt<'tcx>, _marker: PhantomData<B>, } ``` This PR moves `Tables` from `SmirCtxt` to a new `SmirContainer` struct, since mutable borrows of `tables` should only be managed by `SmirInterface`. This change prevents `SmirCtxt` from holding separate borrows and requires passing `tables` explicitly when needed: ```rust impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> { // ... /// Get the body of an Instance which is already monomorphized. pub fn instance_body( &self, instance: ty::Instance<'tcx>, tables: &mut Tables<'tcx, B>, ) -> Option<Body<'tcx>> { tables .instance_has_body(instance) .then(|| BodyBuilder::new(self.tcx, instance).build(tables)) } // ... } ``` This PR introduces `SmirContainer` as a separate struct rather than bundling it into a `SmirInterface` struct. This separation makes the architecture more modular and easier to reason about. - **context/traits.rs** We use this file to define traits that are used for encapsulating the associated functions in the rustc's internals. This is much easier to use and maintain than directly cramming everything into `SmirCtxt`. Here is a real-world use case: ```rust impl RustcInternal for ExistentialTraitRef { type T<'tcx> = rustc_ty::ExistentialTraitRef<'tcx>; fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, cx: &SmirCtxt<'tcx, BridgeTys>, ) -> Self::T<'tcx> { use rustc_smir::context::SmirExistentialTraitRef; cx.new_from_args(self.def_id.0.internal(tables, cx), self.generic_args.internal(tables, cx)) } } ``` - **Separation of `rustc_smir::alloc`** The previous `rustc_smir::alloc` had many direct calls to rustc queries. This PR splits it into two parts: `rustc_smir::alloc` and `stable_mir::alloc`. Following the same pattern as `SmirCtxt` and `SmirInterface`, the `rustc_smir::alloc` handles all direct interactions with rustc queries and performs the actual memory allocations, while the `stable_mir::alloc` is responsible for constructing stable components. - **Removal of `convert/error.rs`** We use `SmirError::from_internal` instead, since implementing `Stable` for these internal errors would be redundant—`tables` is not actually used. If we later need to add something like `LayoutError` to `stable_mir`, we could implement it as follows: ```rust impl SmirError for stable_mir::LayoutError { fn from_internal<T: Debug>(err: T) -> Self { // ... } } ``` **Unresolved questions:** - There are still a few direct calls to rustc's internals scattered across `impl Stable`s, but most of them appear to be relatively stable, e.g., `mir::interpret::ConstAllocation::inner(self)` and `mir::syntax::SwitchTargets::otherwise(self)`. r? `@celinval`
…pkin Make -Ztrack-diagnostics emit like a note [#t-compiler/diagnostics > Rendering -Ztrack-diagnostics like a note](https://rust-lang.zulipchat.com/#narrow/channel/147480-t-compiler.2Fdiagnostics/topic/Rendering.20-Ztrack-diagnostics.20like.20a.20note/with/526608647) As discussed on the Zulip thread above, I want to make `-Ztrack-diagnostics` emit like a `note`. This is because I find its current output jarring, and the fact that it gets rendered completely left-aligned, [even in the middle of a snippet](https://github.com/rust-lang/rust/blob/86e05cd300fac9e83e812c4d46582b48db780d8f/tests/ui/track-diagnostics/track6.stderr), seems like something that should be changed. Turning it into a `note` seems like the best choice, as it would align it with the rest of the output, and `note` is already used for somewhat similar things, like seeing why a lint was fired. --- Note: turning `-Ztrack-diagnostics` into a `note` will also make `annotate-snippets` API a bit cleaner
Remove `PointerLike` trait r? oli-obk
Make __rust_alloc_error_handler_should_panic a function Fixes rust-lang/rust#143253 `__rust_alloc_error_handler_should_panic` is a static but was being exported as a function. For most targets this doesn't matter, but Arm64EC Windows uses different decorations for exported variables vs functions, hence it fails to link when `-Z oom=abort` is enabled. We've had issues in the past with statics like this (see rust-lang/rust#141061) but the tldr; is that Arm64EC needs symbols correctly exported as either a function or data, and data MUST and MUST ONLY be marked `dllimport` when the symbol is being imported from another binary, which is non-trivial to calculate for these compiler-generated statics. So, instead, the easiest thing to do is to make `__rust_alloc_error_handler_should_panic` a function instead. Since `__rust_alloc_error_handler_should_panic` isn't involved in any linking shenanigans, I've marked it as `AlwaysInline` with the hopes that the various backends will see that it is just returning a constant and perform the same optimizations as the previous implementation. r? `@bjorn3`
Port `#[rustc_pass_by_value]` to the new attribute system Part of rust-lang/rust#131229 r? `@oli-obk`
rustc-dev-guide subtree update Subtree update of https://github.com/rust-lang/rustc-dev-guide. Created using https://github.com/rust-lang/josh-sync. r? `@jieyouxu`
Rollup of 7 pull requests Successful merges: - rust-lang/rust#140643 (Refactor StableMIR) - rust-lang/rust#143286 (Make -Ztrack-diagnostics emit like a note) - rust-lang/rust#143308 (Remove `PointerLike` trait) - rust-lang/rust#143387 (Make __rust_alloc_error_handler_should_panic a function) - rust-lang/rust#143400 (Port `#[rustc_pass_by_value]` to the new attribute system) - rust-lang/rust#143417 (bump termize dep) - rust-lang/rust#143420 (rustc-dev-guide subtree update) r? `@ghost` `@rustbot` modify labels: rollup
Make metadata a workproduct and reuse it This PR aims to skip the generation of metadata by reusing the infrastructure that already exists for compiled codegen-units, namely "workproducts". This can yield substantial gains (~10%) when we can demonstrate that metadata does not change between an incremental session and the next. This is the case if the crate is unchanged, or if all the changes are in upstream crates and have no effect on it. This latter case is most interesting, as it arises regularly for users with several crates in their workspace. TODO: - [x] Materialize the fact that metadata encoding relies on the relative order of definitions; - [x] Refactor the handling of doc links.
Allow `enum` and `union` literals to also create SSA values Today, `Some(x)` always goes through an `alloca`, even in trivial cases where the niching means the constructor doesn't even change the value. For example, <https://rust.godbolt.org/z/6KG6PqoYz> ```rust pub fn demo(r: &i32) -> Option<&i32> { Some(r) } ``` currently emits the IR ```llvm define align 4 ptr `@demo(ptr` align 4 %r) unnamed_addr { start: %_0 = alloca [8 x i8], align 8 store ptr %r, ptr %_0, align 8 %0 = load ptr, ptr %_0, align 8 ret ptr %0 } ``` but with this PR it becomes just ```llvm define align 4 ptr `@demo(ptr` align 4 %r) unnamed_addr { start: ret ptr %r } ``` (Of course the optimizer can clean that up, but it'd be nice if it didn't have to -- especially in debug where it doesn't run. This is like rust-lang/rust#123886, but that only handled non-simd `struct`s -- this PR generalizes it to all non-simd ADTs.) Doing this means handing variants other than `FIRST_VARIANT`, handling the active field for unions, refactoring the discriminant code so the Place and Operand parts can share the calculation, etc. Other PRs that led up to this one: - rust-lang/rust#142005 - rust-lang/rust#142103 - rust-lang/rust#142324 - rust-lang/rust#142383 --- try-job: aarch64-gnu
Pretend in bootstrap snapshot tests that we always build in-tree LLVM Otherwise, depending on whether CI LLVM is inhibited or if an externally-provided LLVM is used, bootstrap host LLVM build step could be missing in step snapshots. Note that I'm not sure if this is the *right* solution (this might be *a* solution). I imagine we do want to control for the set of configuration that these snapshot tests are run, as much as possible. r? `@Kobzol`
Update LLVM submodule Fixes rust-lang/rust#140686, fixes rust-lang/rust#141913, fixes rust-lang/rust#142752, fixes rust-lang/rust#143399.
… r=Kobzol Port streaming commands in bootstrap to `BootstrapCommand` and remove `as_command_mut` This PR adds streaming capabilities to BootstrapCommand and migrate existing command streaming scenario's used in bootstrap. r? `@Kobzol`
Specialize sleep_until implementation for unix (except mac) related tracking issue: rust-lang/rust#113752 Supersedes rust-lang/rust#118480 for the reasons see: rust-lang/rust#113752 (comment) Replaces the generic catch all implementation with target_os specific ones for: linux/netbsd/freebsd/android/solaris/illumos etc. Other platforms like wasi, macos/ios/tvos/watchos and windows will follow in later separate PR's (once this is merged).
This updates the rust-version file to ca98d4d4b3114116203699c2734805547df86f9a.
Pull recent changes from https://github.com/rust-lang/rust via Josh. Upstream ref: ca98d4d4b3114116203699c2734805547df86f9a Filtered ref: 1ea0aaa This merge was created using https://github.com/rust-lang/josh-sync.
|
Thanks for the PR. If you have write access, feel free to merge this PR if it does not need reviews. You can request a review using |
rustbot
added
the
S-waiting-on-review
rustbot
removed
the
S-waiting-on-review
|
empty |
|
Note that you don't need to close the PR, we can just let the bot update it continuously. When we keep closing the PRs it's a bit hard to keep track. |
|
what happened a few times in the past is that when I let that bot update the pr, it fails to do a merge next time there are real changes, forcing me to close the pr and re-run the ci job @Kobzol |
|
I see. The bot shouldn't open PRs without actual changes anymore, so hopefully that won't happen so much. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Latest update from rustc.