Auto merge of #3513 - rust-lang:rustup-2024-04-25, r=RalfJung

Automatic Rustup
rust-lang · Apr 25, 2024 · 0893456 · 0893456
2 parents c2c7072 + 15b04db
commit 0893456
Show file tree

Hide file tree

Showing 8 changed files with 155 additions and 88 deletions.
diff --git a/rust-version b/rust-version
@@ -1 +1 @@
-c1feb3eceef7d5f0126c309a87062cf413fe0a25
+cb3752d20e0f5d24348062211102a08d46fbecff
diff --git a/src/lib.rs b/src/lib.rs
@@ -12,7 +12,6 @@
 #![feature(let_chains)]
 #![feature(lint_reasons)]
 #![feature(trait_upcasting)]
-#![feature(absolute_path)]
 // Configure clippy and other lints
 #![allow(
     clippy::collapsible_else_if,

diff --git a/tests/fail/coroutine-pinned-moved.rs b/tests/fail/coroutine-pinned-moved.rs
@@ -1,12 +1,13 @@
 //@compile-flags: -Zmiri-disable-validation -Zmiri-disable-stacked-borrows
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
 
 use std::{
     ops::{Coroutine, CoroutineState},
     pin::Pin,
 };
 
 fn firstn() -> impl Coroutine<Yield = u64, Return = ()> {
+    #[coroutine]
     static move || {
         let mut num = 0;
         let num = &mut num;

diff --git a/tests/pass/coroutine.rs b/tests/pass/coroutine.rs
@@ -1,6 +1,6 @@
 //@revisions: stack tree
 //@[tree]compile-flags: -Zmiri-tree-borrows
-#![feature(coroutines, coroutine_trait, never_type)]
+#![feature(coroutines, coroutine_trait, never_type, stmt_expr_attributes)]
 
 use std::fmt::Debug;
 use std::mem::ManuallyDrop;
@@ -43,94 +43,144 @@ fn basic() {
         panic!()
     }
 
-    finish(1, false, || yield 1);
+    finish(
+        1,
+        false,
+        #[coroutine]
+        || yield 1,
+    );
 
-    finish(3, false, || {
-        let mut x = 0;
-        yield 1;
-        x += 1;
-        yield 1;
-        x += 1;
-        yield 1;
-        assert_eq!(x, 2);
-    });
+    finish(
+        3,
+        false,
+        #[coroutine]
+        || {
+            let mut x = 0;
+            yield 1;
+            x += 1;
+            yield 1;
+            x += 1;
+            yield 1;
+            assert_eq!(x, 2);
+        },
+    );
 
-    finish(7 * 8 / 2, false, || {
-        for i in 0..8 {
-            yield i;
-        }
-    });
+    finish(
+        7 * 8 / 2,
+        false,
+        #[coroutine]
+        || {
+            for i in 0..8 {
+                yield i;
+            }
+        },
+    );
 
-    finish(1, false, || {
-        if true {
-            yield 1;
-        } else {
-        }
-    });
+    finish(
+        1,
+        false,
+        #[coroutine]
+        || {
+            if true {
+                yield 1;
+            } else {
+            }
+        },
+    );
 
-    finish(1, false, || {
-        if false {
-        } else {
-            yield 1;
-        }
-    });
+    finish(
+        1,
+        false,
+        #[coroutine]
+        || {
+            if false {
+            } else {
+                yield 1;
+            }
+        },
+    );
 
-    finish(2, false, || {
-        if {
-            yield 1;
-            false
-        } {
+    finish(
+        2,
+        false,
+        #[coroutine]
+        || {
+            if {
+                yield 1;
+                false
+            } {
+                yield 1;
+                panic!()
+            }
             yield 1;
-            panic!()
-        }
-        yield 1;
-    });
+        },
+    );
 
     // also test self-referential coroutines
     assert_eq!(
-        finish(5, true, static || {
-            let mut x = 5;
-            let y = &mut x;
-            *y = 5;
-            yield *y;
-            *y = 10;
-            x
-        }),
+        finish(
+            5,
+            true,
+            #[coroutine]
+            static || {
+                let mut x = 5;
+                let y = &mut x;
+                *y = 5;
+                yield *y;
+                *y = 10;
+                x
+            }
+        ),
         10
     );
     assert_eq!(
-        finish(5, true, || {
-            let mut x = Box::new(5);
-            let y = &mut *x;
-            *y = 5;
-            yield *y;
-            *y = 10;
-            *x
-        }),
+        finish(
+            5,
+            true,
+            #[coroutine]
+            || {
+                let mut x = Box::new(5);
+                let y = &mut *x;
+                *y = 5;
+                yield *y;
+                *y = 10;
+                *x
+            }
+        ),
         10
     );
 
     let b = true;
-    finish(1, false, || {
-        yield 1;
-        if b {
-            return;
-        }
-        #[allow(unused)]
-        let x = never();
-        #[allow(unreachable_code)]
-        yield 2;
-        drop(x);
-    });
-
-    finish(3, false, || {
-        yield 1;
-        #[allow(unreachable_code)]
-        let _x: (String, !) = (String::new(), {
+    finish(
+        1,
+        false,
+        #[coroutine]
+        || {
+            yield 1;
+            if b {
+                return;
+            }
+            #[allow(unused)]
+            let x = never();
+            #[allow(unreachable_code)]
             yield 2;
-            return;
-        });
-    });
+            drop(x);
+        },
+    );
+
+    finish(
+        3,
+        false,
+        #[coroutine]
+        || {
+            yield 1;
+            #[allow(unreachable_code)]
+            let _x: (String, !) = (String::new(), {
+                yield 2;
+                return;
+            });
+        },
+    );
 }
 
 fn smoke_resume_arg() {
@@ -172,7 +222,8 @@ fn smoke_resume_arg() {
     }
 
     drain(
-        &mut |mut b| {
+        &mut #[coroutine]
+        |mut b| {
             while b != 0 {
                 b = yield (b + 1);
             }
@@ -181,21 +232,35 @@ fn smoke_resume_arg() {
         vec![(1, Yielded(2)), (-45, Yielded(-44)), (500, Yielded(501)), (0, Complete(-1))],
     );
 
-    expect_drops(2, || drain(&mut |a| yield a, vec![(DropMe, Yielded(DropMe))]));
+    expect_drops(2, || {
+        drain(
+            &mut #[coroutine]
+            |a| yield a,
+            vec![(DropMe, Yielded(DropMe))],
+        )
+    });
 
     expect_drops(6, || {
         drain(
-            &mut |a| yield yield a,
+            &mut #[coroutine]
+            |a| yield yield a,
             vec![(DropMe, Yielded(DropMe)), (DropMe, Yielded(DropMe)), (DropMe, Complete(DropMe))],
         )
     });
 
     #[allow(unreachable_code)]
-    expect_drops(2, || drain(&mut |a| yield return a, vec![(DropMe, Complete(DropMe))]));
+    expect_drops(2, || {
+        drain(
+            &mut #[coroutine]
+            |a| yield return a,
+            vec![(DropMe, Complete(DropMe))],
+        )
+    });
 
     expect_drops(2, || {
         drain(
-            &mut |a: DropMe| {
+            &mut #[coroutine]
+            |a: DropMe| {
                 if false { yield () } else { a }
             },
             vec![(DropMe, Complete(DropMe))],
@@ -205,7 +270,8 @@ fn smoke_resume_arg() {
     expect_drops(4, || {
         drain(
             #[allow(unused_assignments, unused_variables)]
-            &mut |mut a: DropMe| {
+            &mut #[coroutine]
+            |mut a: DropMe| {
                 a = yield;
                 a = yield;
                 a = yield;
@@ -228,7 +294,8 @@ fn uninit_fields() {
     }
 
     fn run<T>(x: bool, y: bool) {
-        let mut c = || {
+        let mut c = #[coroutine]
+        || {
             if x {
                 let _a: T;
                 if y {

diff --git a/tests/pass/portable-simd.rs b/tests/pass/portable-simd.rs
@@ -1,5 +1,5 @@
 //@compile-flags: -Zmiri-strict-provenance
-#![feature(portable_simd, adt_const_params, inline_const, core_intrinsics)]
+#![feature(portable_simd, adt_const_params, core_intrinsics)]
 #![allow(incomplete_features, internal_features)]
 use std::intrinsics::simd as intrinsics;
 use std::ptr;

diff --git a/tests/pass/shims/path.rs b/tests/pass/shims/path.rs
@@ -1,5 +1,4 @@
 //@compile-flags: -Zmiri-disable-isolation
-#![feature(absolute_path)]
 use std::path::{absolute, Path};
 
 #[track_caller]

diff --git a/tests/pass/stacked-borrows/coroutine-self-referential.rs b/tests/pass/stacked-borrows/coroutine-self-referential.rs
@@ -1,13 +1,14 @@
 // See https://github.com/rust-lang/unsafe-code-guidelines/issues/148:
 // this fails when Stacked Borrows is strictly applied even to `!Unpin` types.
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
 
 use std::{
     ops::{Coroutine, CoroutineState},
     pin::Pin,
 };
 
 fn firstn() -> impl Coroutine<Yield = u64, Return = ()> {
+    #[coroutine]
     static move || {
         let mut num = 0;
         let num = &mut num;

diff --git a/tests/pass/track-caller-attribute.rs b/tests/pass/track-caller-attribute.rs
@@ -232,7 +232,7 @@ fn test_coroutine() {
     }
 
     #[rustfmt::skip]
-    let coroutine = #[track_caller] |arg: String| {
+    let coroutine = #[track_caller] #[coroutine] |arg: String| {
         yield ("first", arg.clone(), Location::caller());
         yield ("second", arg.clone(), Location::caller());
     };
@@ -255,15 +255,15 @@ fn test_coroutine() {
     assert_eq!(mono_loc.column(), 42);
 
     #[rustfmt::skip]
-    let non_tracked_coroutine = || { yield Location::caller(); };
+    let non_tracked_coroutine = #[coroutine] || { yield Location::caller(); };
     let non_tracked_line = line!() - 1; // This is the line of the coroutine, not its caller
     let non_tracked_loc = match Box::pin(non_tracked_coroutine).as_mut().resume(()) {
         CoroutineState::Yielded(val) => val,
         _ => unreachable!(),
     };
     assert_eq!(non_tracked_loc.file(), file!());
     assert_eq!(non_tracked_loc.line(), non_tracked_line);
-    assert_eq!(non_tracked_loc.column(), 44);
+    assert_eq!(non_tracked_loc.column(), 57);
 }
 
 fn main() {
Original file line number	Diff line number	Diff line change
		@@ -1 +1 @@
		c1feb3eceef7d5f0126c309a87062cf413fe0a25
		cb3752d20e0f5d24348062211102a08d46fbecff