stabilize raw_ref_op

Author: RalfJung

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -524,7 +524,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
         }
     }
     gate_all!(gen_blocks, "gen blocks are experimental");
-    gate_all!(raw_ref_op, "raw address of syntax is experimental");
     gate_all!(const_trait_impl, "const trait impls are experimental");
     gate_all!(
         half_open_range_patterns_in_slices,

compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs

@@ -6,8 +6,7 @@
     extern_types,
     naked_functions,
     thread_local,
-    repr_simd,
-    raw_ref_op
+    repr_simd
 )]
 #![no_core]
 #![allow(dead_code, non_camel_case_types, internal_features)]

compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs

@@ -2,7 +2,7 @@
 
 #![feature(
     no_core, unboxed_closures, start, lang_items, never_type, linkage,
-    extern_types, thread_local, raw_ref_op
+    extern_types, thread_local
 )]
 #![no_core]
 #![allow(dead_code, internal_features, non_camel_case_types)]

compiler/rustc_error_codes/src/error_codes/E0745.md

@@ -3,7 +3,6 @@ The address of temporary value was taken.
 Erroneous code example:
 
 ```compile_fail,E0745
-# #![feature(raw_ref_op)]
 fn temp_address() {
     let ptr = &raw const 2; // error!
 }
@@ -15,7 +14,6 @@ In this example, `2` is destroyed right after the assignment, which means that
 To avoid this error, first bind the temporary to a named local variable:
 
 ```
-# #![feature(raw_ref_op)]
 fn temp_address() {
     let val = 2;
     let ptr = &raw const val; // ok!

compiler/rustc_feature/src/accepted.rs

@@ -42,6 +42,10 @@ declare_features! (
     // feature-group-start: accepted features
     // -------------------------------------------------------------------------
 
+    // Note that the version indicates when it got *stabilized*.
+    // When moving an unstable feature here, set the version number to
+    // `CURRENT-RUSTC-VERSION` with `-` replaced by `_`.
+
     /// Allows `#[target_feature(...)]` on aarch64 platforms
     (accepted, aarch64_target_feature, "1.61.0", Some(44839)),
     /// Allows using the `efiapi` ABI.
@@ -310,6 +314,8 @@ declare_features! (
     (accepted, raw_dylib, "1.71.0", Some(58713)),
     /// Allows keywords to be escaped for use as identifiers.
     (accepted, raw_identifiers, "1.30.0", Some(48589)),
+    /// Allows `&raw const $place_expr` and `&raw mut $place_expr` expressions.
+    (accepted, raw_ref_op, "CURRENT_RUSTC_VERSION", Some(64490)),
     /// Allows relaxing the coherence rules such that
     /// `impl<T> ForeignTrait<LocalType> for ForeignType<T>` is permitted.
     (accepted, re_rebalance_coherence, "1.41.0", Some(55437)),

compiler/rustc_feature/src/removed.rs

@@ -32,6 +32,10 @@ declare_features! (
     // feature-group-start: removed features
     // -------------------------------------------------------------------------
 
+    // Note that the version indicates when it got *removed*.
+    // When moving an unstable feature here, set the version number to
+    // `CURRENT-RUSTC-VERSION` with `-` replaced by `_`.
+
     /// Allows using the `amdgpu-kernel` ABI.
     (removed, abi_amdgpu_kernel, "1.77.0", Some(51575), None),
     (removed, advanced_slice_patterns, "1.0.0", Some(62254),

compiler/rustc_feature/src/unstable.rs

@@ -571,8 +571,6 @@ declare_features! (
     (unstable, precise_capturing, "1.79.0", Some(123432)),
     /// Allows macro attributes on expressions, statements and non-inline modules.
     (unstable, proc_macro_hygiene, "1.30.0", Some(54727)),
-    /// Allows `&raw const $place_expr` and `&raw mut $place_expr` expressions.
-    (unstable, raw_ref_op, "1.41.0", Some(64490)),
     /// Makes `&` and `&mut` patterns eat only one layer of references in Rust 2024.
     (incomplete, ref_pat_eat_one_layer_2024, "1.79.0", Some(123076)),
     /// Makes `&` and `&mut` patterns eat only one layer of references in Rust 2024—structural variant

compiler/rustc_parse/src/parser/expr.rs

@@ -846,7 +846,7 @@ impl<'a> Parser<'a> {
         self.expect_and()?;
         let has_lifetime = self.token.is_lifetime() && self.look_ahead(1, |t| t != &token::Colon);
         let lifetime = has_lifetime.then(|| self.expect_lifetime()); // For recovery, see below.
-        let (borrow_kind, mutbl) = self.parse_borrow_modifiers(lo);
+        let (borrow_kind, mutbl) = self.parse_borrow_modifiers();
         let attrs = self.parse_outer_attributes()?;
         let expr = if self.token.is_range_separator() {
             self.parse_expr_prefix_range(attrs)
@@ -866,13 +866,12 @@ impl<'a> Parser<'a> {
     }
 
     /// Parse `mut?` or `raw [ const | mut ]`.
-    fn parse_borrow_modifiers(&mut self, lo: Span) -> (ast::BorrowKind, ast::Mutability) {
+    fn parse_borrow_modifiers(&mut self) -> (ast::BorrowKind, ast::Mutability) {
         if self.check_keyword(kw::Raw) && self.look_ahead(1, Token::is_mutability) {
             // `raw [ const | mut ]`.
             let found_raw = self.eat_keyword(kw::Raw);
             assert!(found_raw);
             let mutability = self.parse_const_or_mut().unwrap();
-            self.psess.gated_spans.gate(sym::raw_ref_op, lo.to(self.prev_token.span));
             (ast::BorrowKind::Raw, mutability)
         } else {
             // `mut?`

src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.rs

@@ -1,7 +1,6 @@
 //@revisions: stack tree none
 //@[tree]compile-flags: -Zmiri-tree-borrows
 //@[none]compile-flags: -Zmiri-disable-stacked-borrows
-#![feature(raw_ref_op)]
 #![feature(core_intrinsics)]
 #![feature(custom_mir)]
 

src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.rs

@@ -1,7 +1,6 @@
 // This does need an aliasing model.
 //@revisions: stack tree
 //@[tree]compile-flags: -Zmiri-tree-borrows
-#![feature(raw_ref_op)]
 #![feature(core_intrinsics)]
 #![feature(custom_mir)]
 

src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.rs

@@ -1,6 +1,5 @@
 // Doesn't need an aliasing model.
 //@compile-flags: -Zmiri-disable-stacked-borrows
-#![feature(raw_ref_op)]
 #![feature(core_intrinsics)]
 #![feature(custom_mir)]
 

src/tools/miri/tests/pass/function_calls/return_place_on_heap.rs

@@ -1,4 +1,3 @@
-#![feature(raw_ref_op)]
 #![feature(core_intrinsics)]
 #![feature(custom_mir)]
 

tests/mir-opt/const_prop/indirect_mutation.rs

@@ -1,6 +1,5 @@
 //@ test-mir-pass: GVN
 // Check that we do not propagate past an indirect mutation.
-#![feature(raw_ref_op)]
 
 // EMIT_MIR indirect_mutation.foo.GVN.diff
 fn foo() {

tests/mir-opt/copy-prop/reborrow.rs

@@ -3,8 +3,6 @@
 // Check that CopyProp considers reborrows as not mutating the pointer.
 //@ test-mir-pass: CopyProp
 
-#![feature(raw_ref_op)]
-
 #[inline(never)]
 fn opaque(_: impl Sized) {}
 

tests/mir-opt/gvn.rs

@@ -3,7 +3,6 @@
 // EMIT_MIR_FOR_EACH_PANIC_STRATEGY
 //@ only-64bit
 
-#![feature(raw_ref_op)]
 #![feature(rustc_attrs)]
 #![feature(custom_mir)]
 #![feature(core_intrinsics)]

tests/mir-opt/instsimplify/ref_of_deref.rs

@@ -1,6 +1,5 @@
 //@ test-mir-pass: InstSimplify
 #![crate_type = "lib"]
-#![feature(raw_ref_op)]
 
 // For each of these, only 2 of the 6 should simplify,
 // as the others have the wrong types.

tests/mir-opt/reference_prop.rs

@@ -2,7 +2,6 @@
 //@ test-mir-pass: ReferencePropagation
 //@ needs-unwind
 
-#![feature(raw_ref_op)]
 #![feature(core_intrinsics, custom_mir)]
 
 #[inline(never)]

tests/pretty/raw-address-of.rs

@@ -1,5 +1,4 @@
 //@ pp-exact
-#![feature(raw_ref_op)]
 
 const C_PTR: () = { let a = 1; &raw const a; };
 static S_PTR: () = { let b = false; &raw const b; };

tests/ui/borrowck/borrow-raw-address-of-borrowed.rs

@@ -1,5 +1,3 @@
-#![feature(raw_ref_op)]
-
 fn address_of_shared() {
     let mut x = 0;
     let y = &x;

tests/ui/borrowck/borrow-raw-address-of-borrowed.stderr

@@ -1,5 +1,5 @@
 error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
-  --> $DIR/borrow-raw-address-of-borrowed.rs:7:13
+  --> $DIR/borrow-raw-address-of-borrowed.rs:5:13
    |
 LL |     let y = &x;
    |             -- immutable borrow occurs here
@@ -11,7 +11,7 @@ LL |     drop(y);
    |          - immutable borrow later used here
 
 error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable
-  --> $DIR/borrow-raw-address-of-borrowed.rs:16:13
+  --> $DIR/borrow-raw-address-of-borrowed.rs:14:13
    |
 LL |     let y = &mut x;
    |             ------ mutable borrow occurs here
@@ -23,7 +23,7 @@ LL |     drop(y);
    |          - mutable borrow later used here
 
 error[E0499]: cannot borrow `x` as mutable more than once at a time
-  --> $DIR/borrow-raw-address-of-borrowed.rs:17:13
+  --> $DIR/borrow-raw-address-of-borrowed.rs:15:13
    |
 LL |     let y = &mut x;
    |             ------ first mutable borrow occurs here

tests/ui/borrowck/borrow-raw-address-of-deref-mutability-ok.rs

@@ -1,7 +1,5 @@
 //@ check-pass
 
-#![feature(raw_ref_op)]
-
 fn raw_reborrow() {
     let x = &0;
     let y = &mut 0;

tests/ui/borrowck/borrow-raw-address-of-deref-mutability.rs

@@ -1,7 +1,5 @@
 // Check that `&raw mut` cannot be used to turn a `&T` into a `*mut T`.
 
-#![feature(raw_ref_op)]
-
 fn raw_reborrow() {
     let x = &0;
 

tests/ui/borrowck/borrow-raw-address-of-deref-mutability.stderr

@@ -1,5 +1,5 @@
 error[E0596]: cannot borrow `*x` as mutable, as it is behind a `&` reference
-  --> $DIR/borrow-raw-address-of-deref-mutability.rs:8:13
+  --> $DIR/borrow-raw-address-of-deref-mutability.rs:6:13
    |
 LL |     let q = &raw mut *x;
    |             ^^^^^^^^^^^ `x` is a `&` reference, so the data it refers to cannot be borrowed as mutable
@@ -10,7 +10,7 @@ LL |     let x = &mut 0;
    |              +++
 
 error[E0596]: cannot borrow `*x` as mutable, as it is behind a `*const` pointer
-  --> $DIR/borrow-raw-address-of-deref-mutability.rs:14:13
+  --> $DIR/borrow-raw-address-of-deref-mutability.rs:12:13
    |
 LL |     let q = &raw mut *x;
    |             ^^^^^^^^^^^ `x` is a `*const` pointer, so the data it refers to cannot be borrowed as mutable

tests/ui/borrowck/borrow-raw-address-of-mutability-ok.rs

@@ -1,7 +1,5 @@
 //@ check-pass
 
-#![feature(raw_ref_op)]
-
 fn mutable_address_of() {
     let mut x = 0;
     let y = &raw mut x;

tests/ui/borrowck/borrow-raw-address-of-mutability.rs

@@ -1,5 +1,3 @@
-#![feature(raw_ref_op)]
-
 fn mutable_address_of() {
     let x = 0;
     let y = &raw mut x;                 //~ ERROR cannot borrow

tests/ui/borrowck/borrow-raw-address-of-mutability.stderr

@@ -1,5 +1,5 @@
 error[E0596]: cannot borrow `x` as mutable, as it is not declared as mutable
-  --> $DIR/borrow-raw-address-of-mutability.rs:5:13
+  --> $DIR/borrow-raw-address-of-mutability.rs:3:13
    |
 LL |     let y = &raw mut x;
    |             ^^^^^^^^^^ cannot borrow as mutable
@@ -10,7 +10,7 @@ LL |     let mut x = 0;
    |         +++
 
 error[E0596]: cannot borrow `x` as mutable, as it is not declared as mutable
-  --> $DIR/borrow-raw-address-of-mutability.rs:11:17
+  --> $DIR/borrow-raw-address-of-mutability.rs:9:17
    |
 LL |         let y = &raw mut x;
    |                 ^^^^^^^^^^ cannot borrow as mutable
@@ -21,7 +21,7 @@ LL |     let mut x = 0;
    |         +++
 
 error[E0596]: cannot borrow `f` as mutable, as it is not declared as mutable
-  --> $DIR/borrow-raw-address-of-mutability.rs:21:5
+  --> $DIR/borrow-raw-address-of-mutability.rs:19:5
    |
 LL |         let y = &raw mut x;
    |                          - calling `f` requires mutable binding due to mutable borrow of `x`
@@ -35,7 +35,7 @@ LL |     let mut f = || {
    |         +++
 
 error[E0596]: cannot borrow `x` as mutable, as it is a captured variable in a `Fn` closure
-  --> $DIR/borrow-raw-address-of-mutability.rs:29:17
+  --> $DIR/borrow-raw-address-of-mutability.rs:27:17
    |
 LL | fn make_fn<F: Fn()>(f: F) -> F { f }
    |                        - change this to accept `FnMut` instead of `Fn`
@@ -48,7 +48,7 @@ LL |         let y = &raw mut x;
    |                 ^^^^^^^^^^ cannot borrow as mutable
 
 error[E0596]: cannot borrow `x` as mutable, as it is a captured variable in a `Fn` closure
-  --> $DIR/borrow-raw-address-of-mutability.rs:37:17
+  --> $DIR/borrow-raw-address-of-mutability.rs:35:17
    |
 LL | fn make_fn<F: Fn()>(f: F) -> F { f }
    |                        - change this to accept `FnMut` instead of `Fn`

tests/ui/consts/const-address-of-interior-mut.rs

@@ -1,5 +1,3 @@
-#![feature(raw_ref_op)]
-
 use std::cell::Cell;
 
 const A: () = { let x = Cell::new(2); &raw const x; };      //~ ERROR interior mutability

tests/ui/consts/const-address-of-mut.rs

@@ -1,5 +1,3 @@
-#![feature(raw_ref_op)]
-
 const A: () = { let mut x = 2; &raw mut x; };           //~ mutable pointer
 
 static B: () = { let mut x = 2; &raw mut x; };          //~ mutable pointer

tests/ui/consts/const-address-of.rs

@@ -1,7 +1,5 @@
 //@ check-pass
 
-#![feature(raw_ref_op)]
-
 const A: *const i32 = &raw const *&2;
 static B: () = { &raw const *&2; };
 static mut C: *const i32 = &raw const *&2;

tests/ui/consts/const-mut-refs/const_mut_address_of.rs

@@ -1,6 +1,5 @@
 //@ check-pass
 #![feature(const_mut_refs)]
-#![feature(raw_ref_op)]
 
 struct Foo {
     x: usize

tests/ui/consts/const-mut-refs/mut_ref_in_final.rs

@@ -1,5 +1,4 @@
 #![feature(const_mut_refs)]
-#![feature(raw_ref_op)]
 
 const NULL: *mut i32 = std::ptr::null_mut();
 const A: *const i32 = &4;

tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs

@@ -2,7 +2,6 @@
 //@ normalize-stderr-test: "( 0x[0-9a-f][0-9a-f] │)? ([0-9a-f][0-9a-f] |__ |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> " HEX_DUMP"
 //@ normalize-stderr-test: "HEX_DUMP\s*\n\s*HEX_DUMP" -> "HEX_DUMP"
 #![feature(const_mut_refs, const_refs_to_static)]
-#![feature(raw_ref_op)]
 
 use std::sync::Mutex;
 

tests/ui/consts/min_const_fn/address_of.rs

@@ -1,5 +1,3 @@
-#![feature(raw_ref_op)]
-
 const fn mutable_address_of_in_const() {
     let mut a = 0;
     let b = &raw mut a;         //~ ERROR mutable pointer

tests/ui/consts/min_const_fn/address_of_const.rs

@@ -1,7 +1,5 @@
 //@ check-pass
 
-#![feature(raw_ref_op)]
-
 const fn const_address_of_in_const() {
     let mut a = 0;
     let b = &raw const a;

tests/ui/consts/qualif-indirect-mutation-fail.rs

@@ -2,7 +2,6 @@
 #![feature(const_mut_refs)]
 #![feature(const_precise_live_drops)]
 #![feature(const_swap)]
-#![feature(raw_ref_op)]
 
 // Mutable borrow of a field with drop impl.
 pub const fn f() {

tests/ui/lint/unused/lint-unused-mut-variables.rs

@@ -3,7 +3,7 @@
 // Exercise the unused_mut attribute in some positive and negative cases
 
 #![warn(unused_mut)]
-#![feature(async_closure, raw_ref_op)]
+#![feature(async_closure)]
 
 async fn baz_async(
     mut a: i32,

tests/ui/macros/stringify.rs

@@ -14,7 +14,6 @@
 #![feature(let_chains)]
 #![feature(more_qualified_paths)]
 #![feature(never_patterns)]
-#![feature(raw_ref_op)]
 #![feature(trait_alias)]
 #![feature(try_blocks)]
 #![feature(type_ascription)]

tests/ui/mir/mir_raw_fat_ptr.rs

@@ -2,7 +2,6 @@
 // check raw fat pointer ops in mir
 // FIXME: please improve this when we get monomorphization support
 
-#![feature(raw_ref_op)]
 #![allow(ambiguous_wide_pointer_comparisons)]
 
 use std::mem;

tests/ui/mir/mir_raw_fat_ptr.stderr

@@ -1,5 +1,5 @@
 warning: method `foo` is never used
-  --> $DIR/mir_raw_fat_ptr.rs:101:16
+  --> $DIR/mir_raw_fat_ptr.rs:100:16
    |
 LL | trait Foo { fn foo(&self) -> usize; }
    |       ---      ^^^