Implement MIR lowering for unsafe binders #130514

compiler-errors · 2024-09-18T14:47:21Z

This is the final bit of the unsafe binders puzzle. It implements MIR, CTFE, and codegen for unsafe binders, and enforces that (for now) they are Copy. Later on, I'll introduce a new trait that relaxes this requirement to being "is Copy or ManuallyDrop<T>" which more closely models how we treat union fields.

Namely, wrapping unsafe binders is now Rvalue::WrapUnsafeBinder, which acts much like an Rvalue::Aggregate. Unwrapping unsafe binders are implemented as a MIR projection ProjectionElem::UnwrapUnsafeBinder, which acts much like ProjectionElem::Field.

Tracking:

Tracking issue for unsafe binder types #130516

bors · 2024-09-23T05:23:32Z

☔ The latest upstream changes (presumably #130724) made this pull request unmergeable. Please resolve the merge conflicts.

bors · 2024-09-24T06:49:44Z

☔ The latest upstream changes (presumably #127117) made this pull request unmergeable. Please resolve the merge conflicts.

…, r=oli-obk Add AST support for unsafe binders I'm splitting up rust-lang#130514 into pieces. It's impossible for me to keep up with a huge PR like that. I'll land type system support for this next, probably w/o MIR lowering, which will come later. r? `@oli-obk` cc `@BoxyUwU` and `@lcnr` who also may want to look at this, though this PR doesn't do too much yet

Rollup merge of rust-lang#134140 - compiler-errors:unsafe-binders-ast, r=oli-obk Add AST support for unsafe binders I'm splitting up rust-lang#130514 into pieces. It's impossible for me to keep up with a huge PR like that. I'll land type system support for this next, probably w/o MIR lowering, which will come later. r? `@oli-obk` cc `@BoxyUwU` and `@lcnr` who also may want to look at this, though this PR doesn't do too much yet

…, r=oli-obk Add AST support for unsafe binders I'm splitting up rust-lang#130514 into pieces. It's impossible for me to keep up with a huge PR like that. I'll land type system support for this next, probably w/o MIR lowering, which will come later. r? `@oli-obk` cc `@BoxyUwU` and `@lcnr` who also may want to look at this, though this PR doesn't do too much yet

bors · 2024-12-17T15:21:24Z

☔ The latest upstream changes (presumably #134414) made this pull request unmergeable. Please resolve the merge conflicts.

bors · 2024-12-22T16:36:11Z

☔ The latest upstream changes (presumably #134326) made this pull request unmergeable. Please resolve the merge conflicts.

compiler/rustc_mir_build/messages.ftl

rustbot · 2025-01-31T02:17:12Z

Some changes occurred to MIR optimizations

cc @rust-lang/wg-mir-opt

Some changes occurred in match checking

cc @Nadrieril

Some changes occurred to the CTFE machinery

cc @rust-lang/wg-const-eval

Some changes occurred in compiler/rustc_codegen_cranelift

cc @bjorn3

Some changes occurred in rustc_ty_utils::consts.rs

cc @BoxyUwU

Some changes occurred to the CTFE / Miri interpreter

cc @rust-lang/miri

This PR changes MIR

cc @oli-obk, @RalfJung, @JakobDegen, @davidtwco, @vakaras

Some changes occurred in src/tools/clippy

cc @rust-lang/clippy

changes to the core type system

cc @compiler-errors, @lcnr

compiler-errors · 2025-01-31T02:17:14Z

@rustbot ready

compiler/rustc_const_eval/src/interpret/step.rs

compiler-errors · 2025-01-31T02:18:48Z

tests/ui/unsafe-binders/moves.rs

@@ -0,0 +1,41 @@
+//@ known-bug: unknown


This test will (after I add a new trait instead of using Copy) demonstrate that we reason about moves correctly with unsafe binders.

compiler/rustc_mir_transform/src/validate.rs

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

oli-obk · 2025-01-31T09:51:59Z

compiler/rustc_borrowck/src/prefixes.rs

@@ -66,6 +66,10 @@ impl<'tcx> Iterator for Prefixes<'tcx> {
                            self.next = Some(cursor_base);
                            return Some(cursor);
                        }
+                        ProjectionElem::UnwrapUnsafeBinder(_) => {
+                            self.next = Some(cursor_base);
+                            return Some(cursor);


Why not just roll over unwrapunsafebinder just like with opaquecast?

On the contrary, why is it valid to ignore this projection elem? I want to make sure I'm visiting it when tracking moves, right? Or am I misunderstanding how these prefixes are used?

In my brain, unsafe binders are equivalent to structs with a single field, so we should be treating this much like a field elem.

These are just used for improving diagnostics, to be able to inform ppl when to split their borrows. It is useful to handle field accesses here, because borrowck can understand that any projection that goes through a field does not conflict with a projection that goes through another field. I unfortunately can't figure out how to make it care about the unsafe wrapper at all, so... 🤷 let's go with this and figure things out when we actually are using unsafe binders a lot and see some real world examples and conflicts.

oli-obk · 2025-02-01T09:37:23Z

@bors r+

bors · 2025-02-01T09:37:26Z

📌 Commit 442b9a9 has been approved by oli-obk

It is now in the queue for this repository.

…oli-obk Implement MIR lowering for unsafe binders This is the final bit of the unsafe binders puzzle. It implements MIR, CTFE, and codegen for unsafe binders, and enforces that (for now) they are `Copy`. Later on, I'll introduce a new trait that relaxes this requirement to being "is `Copy` or `ManuallyDrop<T>`" which more closely models how we treat union fields. Namely, wrapping unsafe binders is now `Rvalue::WrapUnsafeBinder`, which acts much like an `Rvalue::Aggregate`. Unwrapping unsafe binders are implemented as a MIR projection `ProjectionElem::UnwrapUnsafeBinder`, which acts much like `ProjectionElem::Field`. Tracking: - rust-lang#130516

…iaskrgr Rollup of 7 pull requests Successful merges: - rust-lang#130514 (Implement MIR lowering for unsafe binders) - rust-lang#135684 (docs: Documented Send and Sync requirements for Mutex + MutexGuard) - rust-lang#135760 (Add `unchecked_disjoint_bitor` per ACP373) - rust-lang#136154 (Use +secure-plt for powerpc-unknown-linux-gnu{,spe}) - rust-lang#136309 (set rustc dylib on manually constructed rustc command) - rust-lang#136339 (CompileTest: Add Directives to Ignore `arm-unknown-*` Targets) - rust-lang#136368 (Make comma separated lists of anything easier to make for errors) r? `@ghost` `@rustbot` modify labels: rollup

…iaskrgr Rollup of 6 pull requests Successful merges: - rust-lang#130514 (Implement MIR lowering for unsafe binders) - rust-lang#135684 (docs: Documented Send and Sync requirements for Mutex + MutexGuard) - rust-lang#136307 (Implement all mix/max functions in a (hopefully) more optimization amendable way) - rust-lang#136360 (Stabilize `once_wait`) - rust-lang#136364 (document that ptr cmp is unsigned) - rust-lang#136374 (Add link attribute for Enzyme's LLVMRust FFI) r? `@ghost` `@rustbot` modify labels: rollup

Rollup merge of rust-lang#130514 - compiler-errors:unsafe-binders, r=oli-obk Implement MIR lowering for unsafe binders This is the final bit of the unsafe binders puzzle. It implements MIR, CTFE, and codegen for unsafe binders, and enforces that (for now) they are `Copy`. Later on, I'll introduce a new trait that relaxes this requirement to being "is `Copy` or `ManuallyDrop<T>`" which more closely models how we treat union fields. Namely, wrapping unsafe binders is now `Rvalue::WrapUnsafeBinder`, which acts much like an `Rvalue::Aggregate`. Unwrapping unsafe binders are implemented as a MIR projection `ProjectionElem::UnwrapUnsafeBinder`, which acts much like `ProjectionElem::Field`. Tracking: - rust-lang#130516

compiler-errors changed the title ~~Initial implementation of unsafe binders~~ Initial implementation of unsafe binder types Sep 18, 2024

traviscross mentioned this pull request Sep 18, 2024

Tracking issue for unsafe binder types #130516

Open

7 tasks