diff --git a/compiler/rustc_ast_lowering/messages.ftl b/compiler/rustc_ast_lowering/messages.ftl
index a23e714ef017e..73001c9990c8b 100644
--- a/compiler/rustc_ast_lowering/messages.ftl
+++ b/compiler/rustc_ast_lowering/messages.ftl
@@ -163,3 +163,6 @@ ast_lowering_underscore_expr_lhs_assign =
.label = `_` not allowed here
ast_lowering_use_angle_brackets = use angle brackets instead
+ast_lowering_yield_in_closure =
+ `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+ .suggestion = use `#[coroutine]` to make this closure a coroutine
diff --git a/compiler/rustc_ast_lowering/src/errors.rs b/compiler/rustc_ast_lowering/src/errors.rs
index ca0821e2c9edb..5f8c0acedea2c 100644
--- a/compiler/rustc_ast_lowering/src/errors.rs
+++ b/compiler/rustc_ast_lowering/src/errors.rs
@@ -421,3 +421,12 @@ pub(crate) struct NoPreciseCapturesOnApit {
#[primary_span]
pub span: Span,
}
+
+#[derive(Diagnostic)]
+#[diag(ast_lowering_yield_in_closure)]
+pub(crate) struct YieldInClosure {
+ #[primary_span]
+ pub span: Span,
+ #[suggestion(code = "#[coroutine] ", applicability = "maybe-incorrect", style = "verbose")]
+ pub suggestion: Option<Span>,
+}
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 2305cc07795db..5cc05d7336eed 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -8,6 +8,7 @@ use super::errors::{
};
use super::ResolverAstLoweringExt;
use super::{ImplTraitContext, LoweringContext, ParamMode, ParenthesizedGenericArgs};
+use crate::errors::YieldInClosure;
use crate::{FnDeclKind, ImplTraitPosition};
use rustc_ast::ptr::P as AstP;
use rustc_ast::*;
@@ -217,6 +218,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
binder,
*capture_clause,
e.id,
+ hir_id,
*constness,
*movability,
fn_decl,
@@ -955,6 +957,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
binder: &ClosureBinder,
capture_clause: CaptureBy,
closure_id: NodeId,
+ closure_hir_id: hir::HirId,
constness: Const,
movability: Movability,
decl: &FnDecl,
@@ -965,8 +968,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
let (binder_clause, generic_params) = self.lower_closure_binder(binder);
let (body_id, closure_kind) = self.with_new_scopes(fn_decl_span, move |this| {
- let mut coroutine_kind = None;
+ let mut coroutine_kind = if this
+ .attrs
+ .get(&closure_hir_id.local_id)
+ .is_some_and(|attrs| attrs.iter().any(|attr| attr.has_name(sym::coroutine)))
+ {
+ Some(hir::CoroutineKind::Coroutine(Movability::Movable))
+ } else {
+ None
+ };
let body_id = this.lower_fn_body(decl, |this| {
+ this.coroutine_kind = coroutine_kind;
let e = this.lower_expr_mut(body);
coroutine_kind = this.coroutine_kind;
e
@@ -1565,7 +1577,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
)
.emit();
}
+ let suggestion = self.current_item.map(|s| s.shrink_to_lo());
+ self.dcx().emit_err(YieldInClosure { span, suggestion });
self.coroutine_kind = Some(hir::CoroutineKind::Coroutine(Movability::Movable));
+
false
}
};
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index e4c633aa324a8..1d52b4107d7b5 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -203,7 +203,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
body,
..
}) => {
- self.with_new_scopes(ident.span, |this| {
+ self.with_new_scopes(*fn_sig_span, |this| {
// Note: we don't need to change the return type from `T` to
// `impl Future<Output = T>` here because lower_body
// only cares about the input argument patterns in the function
diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index 70a3ccb0f4402..d86196cbaa9ab 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -556,7 +556,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
half_open_range_patterns_in_slices,
"half-open range patterns in slices are unstable"
);
- gate_all!(inline_const, "inline-const is experimental");
gate_all!(inline_const_pat, "inline-const in pattern position is experimental");
gate_all!(associated_const_equality, "associated const equality is incomplete");
gate_all!(yeet_expr, "`do yeet` expression is experimental");
diff --git a/compiler/rustc_codegen_cranelift/example/polymorphize_coroutine.rs b/compiler/rustc_codegen_cranelift/example/polymorphize_coroutine.rs
index c965b34e13b90..407da94c0f092 100644
--- a/compiler/rustc_codegen_cranelift/example/polymorphize_coroutine.rs
+++ b/compiler/rustc_codegen_cranelift/example/polymorphize_coroutine.rs
@@ -1,4 +1,4 @@
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
use std::pin::Pin;
@@ -8,7 +8,8 @@ fn main() {
}
fn run_coroutine<T>() {
- let mut coroutine = || {
+ let mut coroutine = #[coroutine]
+ || {
yield;
return;
};
diff --git a/compiler/rustc_codegen_cranelift/example/std_example.rs b/compiler/rustc_codegen_cranelift/example/std_example.rs
index 2fee912e52ccf..170b210243101 100644
--- a/compiler/rustc_codegen_cranelift/example/std_example.rs
+++ b/compiler/rustc_codegen_cranelift/example/std_example.rs
@@ -1,6 +1,7 @@
#![feature(
core_intrinsics,
coroutines,
+ stmt_expr_attributes,
coroutine_trait,
is_sorted,
repr_simd,
@@ -122,9 +123,12 @@ fn main() {
test_simd();
}
- Box::pin(move |mut _task_context| {
- yield ();
- })
+ Box::pin(
+ #[coroutine]
+ move |mut _task_context| {
+ yield ();
+ },
+ )
.as_mut()
.resume(0);
diff --git a/compiler/rustc_codegen_gcc/example/std_example.rs b/compiler/rustc_codegen_gcc/example/std_example.rs
index ad69409eb6590..8ab8fcc525e5c 100644
--- a/compiler/rustc_codegen_gcc/example/std_example.rs
+++ b/compiler/rustc_codegen_gcc/example/std_example.rs
@@ -1,5 +1,5 @@
#![allow(internal_features)]
-#![feature(core_intrinsics, coroutines, coroutine_trait, is_sorted)]
+#![feature(core_intrinsics, coroutines, coroutine_trait, is_sorted, stmt_expr_attributes)]
#[cfg(feature="master")]
#[cfg(target_arch="x86_64")]
@@ -103,7 +103,7 @@ fn main() {
test_simd();
}
- Box::pin(move |mut _task_context| {
+ Box::pin(#[coroutine] move |mut _task_context| {
yield ();
}).as_mut().resume(0);
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index a62dfe132047e..9e85c2d88f9b4 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -260,7 +260,8 @@ impl<'ll> CodegenCx<'ll, '_> {
#[instrument(level = "debug", skip(self, llty))]
pub(crate) fn get_static_inner(&self, def_id: DefId, llty: &'ll Type) -> &'ll Value {
- if let Some(&g) = self.instances.borrow().get(&Instance::mono(self.tcx, def_id)) {
+ let instance = Instance::mono(self.tcx, def_id);
+ if let Some(&g) = self.instances.borrow().get(&instance) {
trace!("used cached value");
return g;
}
@@ -273,7 +274,7 @@ impl<'ll> CodegenCx<'ll, '_> {
statics defined in the same CGU, but did not for `{def_id:?}`"
);
- let sym = self.tcx.symbol_name(Instance::mono(self.tcx, def_id)).name;
+ let sym = self.tcx.symbol_name(instance).name;
let fn_attrs = self.tcx.codegen_fn_attrs(def_id);
debug!(?sym, ?fn_attrs);
@@ -363,7 +364,7 @@ impl<'ll> CodegenCx<'ll, '_> {
}
}
- self.instances.borrow_mut().insert(Instance::mono(self.tcx, def_id), g);
+ self.instances.borrow_mut().insert(instance, g);
g
}
diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
index f6937dc145d5b..b79d7441acac7 100644
--- a/compiler/rustc_const_eval/messages.ftl
+++ b/compiler/rustc_const_eval/messages.ftl
@@ -82,12 +82,6 @@ const_eval_double_storage_live =
const_eval_dyn_call_not_a_method =
`dyn` call trying to call something that is not a method
-const_eval_dyn_call_vtable_mismatch =
- `dyn` call on a pointer whose vtable does not match its type
-
-const_eval_dyn_star_call_vtable_mismatch =
- `dyn*` call on a pointer whose vtable does not match its type
-
const_eval_error = {$error_kind ->
[static] could not evaluate static initializer
[const] evaluation of constant value failed
@@ -192,6 +186,8 @@ const_eval_invalid_uninit_bytes_unknown =
const_eval_invalid_vtable_pointer =
using {$pointer} as vtable pointer but it does not point to a vtable
+const_eval_invalid_vtable_trait =
+ using vtable for trait `{$vtable_trait}` but trait `{$expected_trait}` was expected
const_eval_live_drop =
destructor of `{$dropped_ty}` cannot be evaluated at compile-time
@@ -401,9 +397,6 @@ const_eval_unterminated_c_string =
const_eval_unwind_past_top =
unwinding past the topmost frame of the stack
-const_eval_upcast_mismatch =
- upcast on a pointer whose vtable does not match its type
-
## The `front_matter`s here refer to either `const_eval_front_matter_invalid_value` or `const_eval_front_matter_invalid_value_with_path`.
## (We'd love to sort this differently to make that more clear but tidy won't let us...)
const_eval_validation_box_to_static = {$front_matter}: encountered a box pointing to a static variable in a constant
@@ -450,6 +443,7 @@ const_eval_validation_invalid_fn_ptr = {$front_matter}: encountered {$value}, bu
const_eval_validation_invalid_ref_meta = {$front_matter}: encountered invalid reference metadata: total size is bigger than largest supported object
const_eval_validation_invalid_ref_slice_meta = {$front_matter}: encountered invalid reference metadata: slice is bigger than largest supported object
const_eval_validation_invalid_vtable_ptr = {$front_matter}: encountered {$value}, but expected a vtable pointer
+const_eval_validation_invalid_vtable_trait = {$front_matter}: wrong trait in wide pointer vtable: expected `{$ref_trait}`, but encountered `{$vtable_trait}`
const_eval_validation_mutable_ref_to_immutable = {$front_matter}: encountered mutable reference or box pointing to read-only memory
const_eval_validation_never_val = {$front_matter}: encountered a value of the never type `!`
const_eval_validation_null_box = {$front_matter}: encountered a null box
diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs
index a60cedd6500d5..90d4f1168e4fd 100644
--- a/compiler/rustc_const_eval/src/errors.rs
+++ b/compiler/rustc_const_eval/src/errors.rs
@@ -498,6 +498,7 @@ impl<'a> ReportErrorExt for UndefinedBehaviorInfo<'a> {
InvalidTag(_) => const_eval_invalid_tag,
InvalidFunctionPointer(_) => const_eval_invalid_function_pointer,
InvalidVTablePointer(_) => const_eval_invalid_vtable_pointer,
+ InvalidVTableTrait { .. } => const_eval_invalid_vtable_trait,
InvalidStr(_) => const_eval_invalid_str,
InvalidUninitBytes(None) => const_eval_invalid_uninit_bytes_unknown,
InvalidUninitBytes(Some(_)) => const_eval_invalid_uninit_bytes,
@@ -537,6 +538,7 @@ impl<'a> ReportErrorExt for UndefinedBehaviorInfo<'a> {
| DeadLocal
| UninhabitedEnumVariantWritten(_)
| UninhabitedEnumVariantRead(_) => {}
+
BoundsCheckFailed { len, index } => {
diag.arg("len", len);
diag.arg("index", index);
@@ -544,6 +546,13 @@ impl<'a> ReportErrorExt for UndefinedBehaviorInfo<'a> {
UnterminatedCString(ptr) | InvalidFunctionPointer(ptr) | InvalidVTablePointer(ptr) => {
diag.arg("pointer", ptr);
}
+ InvalidVTableTrait { expected_trait, vtable_trait } => {
+ diag.arg("expected_trait", expected_trait.to_string());
+ diag.arg(
+ "vtable_trait",
+ vtable_trait.map(|t| t.to_string()).unwrap_or_else(|| format!("<trivial>")),
+ );
+ }
PointerUseAfterFree(alloc_id, msg) => {
diag.arg("alloc_id", alloc_id)
.arg("bad_pointer_message", bad_pointer_message(msg, dcx));
@@ -634,6 +643,7 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
UninhabitedEnumVariant => const_eval_validation_uninhabited_enum_variant,
Uninit { .. } => const_eval_validation_uninit,
InvalidVTablePtr { .. } => const_eval_validation_invalid_vtable_ptr,
+ InvalidMetaWrongTrait { .. } => const_eval_validation_invalid_vtable_trait,
InvalidMetaSliceTooLarge { ptr_kind: PointerKind::Box } => {
const_eval_validation_invalid_box_slice_meta
}
@@ -773,6 +783,13 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
DanglingPtrNoProvenance { pointer, .. } => {
err.arg("pointer", pointer);
}
+ InvalidMetaWrongTrait { expected_trait: ref_trait, vtable_trait } => {
+ err.arg("ref_trait", ref_trait.to_string());
+ err.arg(
+ "vtable_trait",
+ vtable_trait.map(|t| t.to_string()).unwrap_or_else(|| format!("<trivial>")),
+ );
+ }
NullPtr { .. }
| PtrToStatic { .. }
| ConstRefToMutable
diff --git a/compiler/rustc_const_eval/src/interpret/cast.rs b/compiler/rustc_const_eval/src/interpret/cast.rs
index 9447d18fe8c93..76e59ea90559f 100644
--- a/compiler/rustc_const_eval/src/interpret/cast.rs
+++ b/compiler/rustc_const_eval/src/interpret/cast.rs
@@ -393,6 +393,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let val = self.read_immediate(src)?;
if data_a.principal() == data_b.principal() {
// A NOP cast that doesn't actually change anything, should be allowed even with mismatching vtables.
+ // (But currently mismatching vtables violate the validity invariant so UB is triggered anyway.)
return self.write_immediate(*val, dest);
}
let (old_data, old_vptr) = val.to_scalar_pair();
@@ -400,7 +401,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let old_vptr = old_vptr.to_pointer(self)?;
let (ty, old_trait) = self.get_ptr_vtable(old_vptr)?;
if old_trait != data_a.principal() {
- throw_ub_custom!(fluent::const_eval_upcast_mismatch);
+ throw_ub!(InvalidVTableTrait {
+ expected_trait: data_a,
+ vtable_trait: old_trait,
+ });
}
let new_vptr = self.get_vtable_ptr(ty, data_b.principal())?;
self.write_immediate(Immediate::new_dyn_trait(old_data, new_vptr, self), dest)
diff --git a/compiler/rustc_const_eval/src/interpret/place.rs b/compiler/rustc_const_eval/src/interpret/place.rs
index 8364a5a8d186a..e5241f1ba19e1 100644
--- a/compiler/rustc_const_eval/src/interpret/place.rs
+++ b/compiler/rustc_const_eval/src/interpret/place.rs
@@ -1020,16 +1020,20 @@ where
pub(super) fn unpack_dyn_trait(
&self,
mplace: &MPlaceTy<'tcx, M::Provenance>,
+ expected_trait: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
) -> InterpResult<'tcx, (MPlaceTy<'tcx, M::Provenance>, Pointer<Option<M::Provenance>>)> {
assert!(
matches!(mplace.layout.ty.kind(), ty::Dynamic(_, _, ty::Dyn)),
"`unpack_dyn_trait` only makes sense on `dyn*` types"
);
let vtable = mplace.meta().unwrap_meta().to_pointer(self)?;
- let (ty, _) = self.get_ptr_vtable(vtable)?;
- let layout = self.layout_of(ty)?;
+ let (ty, vtable_trait) = self.get_ptr_vtable(vtable)?;
+ if expected_trait.principal() != vtable_trait {
+ throw_ub!(InvalidVTableTrait { expected_trait, vtable_trait });
+ }
// This is a kind of transmute, from a place with unsized type and metadata to
// a place with sized type and no metadata.
+ let layout = self.layout_of(ty)?;
let mplace =
MPlaceTy { mplace: MemPlace { meta: MemPlaceMeta::None, ..mplace.mplace }, layout };
Ok((mplace, vtable))
@@ -1040,6 +1044,7 @@ where
pub(super) fn unpack_dyn_star<P: Projectable<'tcx, M::Provenance>>(
&self,
val: &P,
+ expected_trait: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
) -> InterpResult<'tcx, (P, Pointer<Option<M::Provenance>>)> {
assert!(
matches!(val.layout().ty.kind(), ty::Dynamic(_, _, ty::DynStar)),
@@ -1048,10 +1053,12 @@ where
let data = self.project_field(val, 0)?;
let vtable = self.project_field(val, 1)?;
let vtable = self.read_pointer(&vtable.to_op(self)?)?;
- let (ty, _) = self.get_ptr_vtable(vtable)?;
+ let (ty, vtable_trait) = self.get_ptr_vtable(vtable)?;
+ if expected_trait.principal() != vtable_trait {
+ throw_ub!(InvalidVTableTrait { expected_trait, vtable_trait });
+ }
+ // `data` is already the right thing but has the wrong type. So we transmute it.
let layout = self.layout_of(ty)?;
- // `data` is already the right thing but has the wrong type. So we transmute it, by
- // projecting with offset 0.
let data = data.transmute(layout, self)?;
Ok((data, vtable))
}
diff --git a/compiler/rustc_const_eval/src/interpret/terminator.rs b/compiler/rustc_const_eval/src/interpret/terminator.rs
index c0e27e86d500a..0c3b01d449bd8 100644
--- a/compiler/rustc_const_eval/src/interpret/terminator.rs
+++ b/compiler/rustc_const_eval/src/interpret/terminator.rs
@@ -802,11 +802,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let (vptr, dyn_ty, adjusted_receiver) = if let ty::Dynamic(data, _, ty::DynStar) =
receiver_place.layout.ty.kind()
{
- let (recv, vptr) = self.unpack_dyn_star(&receiver_place)?;
- let (dyn_ty, dyn_trait) = self.get_ptr_vtable(vptr)?;
- if dyn_trait != data.principal() {
- throw_ub_custom!(fluent::const_eval_dyn_star_call_vtable_mismatch);
- }
+ let (recv, vptr) = self.unpack_dyn_star(&receiver_place, data)?;
+ let (dyn_ty, _dyn_trait) = self.get_ptr_vtable(vptr)?;
(vptr, dyn_ty, recv.ptr())
} else {
@@ -828,7 +825,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let vptr = receiver_place.meta().unwrap_meta().to_pointer(self)?;
let (dyn_ty, dyn_trait) = self.get_ptr_vtable(vptr)?;
if dyn_trait != data.principal() {
- throw_ub_custom!(fluent::const_eval_dyn_call_vtable_mismatch);
+ throw_ub!(InvalidVTableTrait {
+ expected_trait: data,
+ vtable_trait: dyn_trait,
+ });
}
// It might be surprising that we use a pointer as the receiver even if this
@@ -938,13 +938,13 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let place = self.force_allocation(place)?;
let place = match place.layout.ty.kind() {
- ty::Dynamic(_, _, ty::Dyn) => {
+ ty::Dynamic(data, _, ty::Dyn) => {
// Dropping a trait object. Need to find actual drop fn.
- self.unpack_dyn_trait(&place)?.0
+ self.unpack_dyn_trait(&place, data)?.0
}
- ty::Dynamic(_, _, ty::DynStar) => {
+ ty::Dynamic(data, _, ty::DynStar) => {
// Dropping a `dyn*`. Need to find actual drop fn.
- self.unpack_dyn_star(&place)?.0
+ self.unpack_dyn_star(&place, data)?.0
}
_ => {
debug_assert_eq!(
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index b8a1733e45ad6..14566719ccd72 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -339,16 +339,22 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
) -> InterpResult<'tcx> {
let tail = self.ecx.tcx.struct_tail_erasing_lifetimes(pointee.ty, self.ecx.param_env);
match tail.kind() {
- ty::Dynamic(_, _, ty::Dyn) => {
+ ty::Dynamic(data, _, ty::Dyn) => {
let vtable = meta.unwrap_meta().to_pointer(self.ecx)?;
// Make sure it is a genuine vtable pointer.
- let (_ty, _trait) = try_validation!(
+ let (_dyn_ty, dyn_trait) = try_validation!(
self.ecx.get_ptr_vtable(vtable),
self.path,
Ub(DanglingIntPointer(..) | InvalidVTablePointer(..)) =>
InvalidVTablePtr { value: format!("{vtable}") }
);
- // FIXME: check if the type/trait match what ty::Dynamic says?
+ // Make sure it is for the right trait.
+ if dyn_trait != data.principal() {
+ throw_validation_failure!(
+ self.path,
+ InvalidMetaWrongTrait { expected_trait: data, vtable_trait: dyn_trait }
+ );
+ }
}
ty::Slice(..) | ty::Str => {
let _len = meta.unwrap_meta().to_target_usize(self.ecx)?;
@@ -933,7 +939,16 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx, M>
}
}
_ => {
- self.walk_value(op)?; // default handler
+ // default handler
+ try_validation!(
+ self.walk_value(op),
+ self.path,
+ // It's not great to catch errors here, since we can't give a very good path,
+ // but it's better than ICEing.
+ Ub(InvalidVTableTrait { expected_trait, vtable_trait }) => {
+ InvalidMetaWrongTrait { expected_trait, vtable_trait: *vtable_trait }
+ },
+ );
}
}
diff --git a/compiler/rustc_const_eval/src/interpret/visitor.rs b/compiler/rustc_const_eval/src/interpret/visitor.rs
index 0e824f3f592d4..84557b8e2d600 100644
--- a/compiler/rustc_const_eval/src/interpret/visitor.rs
+++ b/compiler/rustc_const_eval/src/interpret/visitor.rs
@@ -88,22 +88,22 @@ pub trait ValueVisitor<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>>: Sized {
// Special treatment for special types, where the (static) layout is not sufficient.
match *ty.kind() {
// If it is a trait object, switch to the real type that was used to create it.
- ty::Dynamic(_, _, ty::Dyn) => {
+ ty::Dynamic(data, _, ty::Dyn) => {
// Dyn types. This is unsized, and the actual dynamic type of the data is given by the
// vtable stored in the place metadata.
// unsized values are never immediate, so we can assert_mem_place
let op = v.to_op(self.ecx())?;
let dest = op.assert_mem_place();
- let inner_mplace = self.ecx().unpack_dyn_trait(&dest)?.0;
+ let inner_mplace = self.ecx().unpack_dyn_trait(&dest, data)?.0;
trace!("walk_value: dyn object layout: {:#?}", inner_mplace.layout);
// recurse with the inner type
return self.visit_field(v, 0, &inner_mplace.into());
}
- ty::Dynamic(_, _, ty::DynStar) => {
+ ty::Dynamic(data, _, ty::DynStar) => {
// DynStar types. Very different from a dyn type (but strangely part of the
// same variant in `TyKind`): These are pairs where the 2nd component is the
// vtable, and the first component is the data (which must be ptr-sized).
- let data = self.ecx().unpack_dyn_star(v)?.0;
+ let data = self.ecx().unpack_dyn_star(v, data)?.0;
return self.visit_field(v, 0, &data);
}
// Slices do not need special handling here: they have `Array` field
diff --git a/compiler/rustc_error_codes/src/error_codes/E0626.md b/compiler/rustc_error_codes/src/error_codes/E0626.md
index e2534415d8307..28d543350ffd8 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0626.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0626.md
@@ -4,10 +4,10 @@ yield point.
Erroneous code example:
```compile_fail,E0626
-# #![feature(coroutines, coroutine_trait, pin)]
+# #![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
# use std::ops::Coroutine;
# use std::pin::Pin;
-let mut b = || {
+let mut b = #[coroutine] || {
let a = &String::new(); // <-- This borrow...
yield (); // ...is still in scope here, when the yield occurs.
println!("{}", a);
@@ -23,10 +23,10 @@ resolve the previous example by removing the borrow and just storing
the integer by value:
```
-# #![feature(coroutines, coroutine_trait, pin)]
+# #![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
# use std::ops::Coroutine;
# use std::pin::Pin;
-let mut b = || {
+let mut b = #[coroutine] || {
let a = 3;
yield ();
println!("{}", a);
@@ -41,10 +41,10 @@ in those cases, something like the `Rc` or `Arc` types may be useful.
This error also frequently arises with iteration:
```compile_fail,E0626
-# #![feature(coroutines, coroutine_trait, pin)]
+# #![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
# use std::ops::Coroutine;
# use std::pin::Pin;
-let mut b = || {
+let mut b = #[coroutine] || {
let v = vec![1,2,3];
for &x in &v { // <-- borrow of `v` is still in scope...
yield x; // ...when this yield occurs.
@@ -57,10 +57,10 @@ Such cases can sometimes be resolved by iterating "by value" (or using
`into_iter()`) to avoid borrowing:
```
-# #![feature(coroutines, coroutine_trait, pin)]
+# #![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
# use std::ops::Coroutine;
# use std::pin::Pin;
-let mut b = || {
+let mut b = #[coroutine] || {
let v = vec![1,2,3];
for x in v { // <-- Take ownership of the values instead!
yield x; // <-- Now yield is OK.
@@ -72,10 +72,10 @@ Pin::new(&mut b).resume(());
If taking ownership is not an option, using indices can work too:
```
-# #![feature(coroutines, coroutine_trait, pin)]
+# #![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
# use std::ops::Coroutine;
# use std::pin::Pin;
-let mut b = || {
+let mut b = #[coroutine] || {
let v = vec![1,2,3];
let len = v.len(); // (*)
for i in 0..len {
diff --git a/compiler/rustc_error_codes/src/error_codes/E0627.md b/compiler/rustc_error_codes/src/error_codes/E0627.md
index 5d366f78fc575..da2e2d355a160 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0627.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0627.md
@@ -3,7 +3,7 @@ A yield expression was used outside of the coroutine literal.
Erroneous code example:
```compile_fail,E0627
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
fn fake_coroutine() -> &'static str {
yield 1;
@@ -19,10 +19,10 @@ The error occurs because keyword `yield` can only be used inside the coroutine
literal. This can be fixed by constructing the coroutine correctly.
```
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
fn main() {
- let mut coroutine = || {
+ let mut coroutine = #[coroutine] || {
yield 1;
return "foo"
};
diff --git a/compiler/rustc_error_codes/src/error_codes/E0628.md b/compiler/rustc_error_codes/src/error_codes/E0628.md
index ce19bcd56cc78..d0d387cf6c7ef 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0628.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0628.md
@@ -3,10 +3,10 @@ More than one parameter was used for a coroutine.
Erroneous code example:
```compile_fail,E0628
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
fn main() {
- let coroutine = |a: i32, b: i32| {
+ let coroutine = #[coroutine] |a: i32, b: i32| {
// error: too many parameters for a coroutine
// Allowed only 0 or 1 parameter
yield a;
@@ -20,10 +20,10 @@ at most 1 parameter for the coroutine. For example, we might resolve
the previous example by passing only one parameter.
```
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
fn main() {
- let coroutine = |a: i32| {
+ let coroutine = #[coroutine] |a: i32| {
yield a;
};
}
diff --git a/compiler/rustc_error_codes/src/error_codes/E0727.md b/compiler/rustc_error_codes/src/error_codes/E0727.md
index fde35885c9208..7754186508f11 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0727.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0727.md
@@ -3,10 +3,10 @@ A `yield` clause was used in an `async` context.
Erroneous code example:
```compile_fail,E0727,edition2018
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
fn main() {
- let coroutine = || {
+ let coroutine = #[coroutine] || {
async {
yield;
}
@@ -20,10 +20,10 @@ which is not yet supported.
To fix this error, you have to move `yield` out of the `async` block:
```edition2018
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
fn main() {
- let coroutine = || {
+ let coroutine = #[coroutine] || {
yield;
};
}
diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index 1eee11604cef8..c0e664f6eeda2 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -211,6 +211,8 @@ declare_features! (
(accepted, inclusive_range_syntax, "1.26.0", Some(28237)),
/// Allows inferring outlives requirements (RFC 2093).
(accepted, infer_outlives_requirements, "1.30.0", Some(44493)),
+ /// Allow anonymous constants from an inline `const` block
+ (accepted, inline_const, "CURRENT_RUSTC_VERSION", Some(76001)),
/// Allows irrefutable patterns in `if let` and `while let` statements (RFC 2086).
(accepted, irrefutable_let_patterns, "1.33.0", Some(44495)),
/// Allows `#[instruction_set(_)]` attribute.
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 4f62323231a73..2c5511d67fd0b 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -534,6 +534,12 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
EncodeCrossCrate::Yes, experimental!(cfi_encoding)
),
+ // `#[coroutine]` attribute to be applied to closures to make them coroutines instead
+ gated!(
+ coroutine, Normal, template!(Word), ErrorFollowing,
+ EncodeCrossCrate::No, coroutines, experimental!(coroutines)
+ ),
+
// ==========================================================================
// Internal attributes: Stability, deprecation, and unsafe:
// ==========================================================================
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 9641d336c3f3c..2647f09c8c96a 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -501,8 +501,6 @@ declare_features! (
(unstable, impl_trait_in_fn_trait_return, "1.64.0", Some(99697)),
/// Allows associated types in inherent impls.
(incomplete, inherent_associated_types, "1.52.0", Some(8995)),
- /// Allow anonymous constants from an inline `const` block
- (unstable, inline_const, "1.49.0", Some(76001)),
/// Allow anonymous constants from an inline `const` block in pattern position
(unstable, inline_const_pat, "1.58.0", Some(76001)),
/// Allows using `pointer` and `reference` in intra-doc links
diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs
index 596da58b091f4..6f390b25a10de 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder.rs
@@ -1260,30 +1260,34 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
id: DefIndex,
sess: &'a Session,
) -> impl Iterator<Item = ModChild> + 'a {
- iter::from_coroutine(move || {
- if let Some(data) = &self.root.proc_macro_data {
- // If we are loading as a proc macro, we want to return
- // the view of this crate as a proc macro crate.
- if id == CRATE_DEF_INDEX {
- for child_index in data.macros.decode(self) {
+ iter::from_coroutine(
+ #[cfg_attr(not(bootstrap), coroutine)]
+ move || {
+ if let Some(data) = &self.root.proc_macro_data {
+ // If we are loading as a proc macro, we want to return
+ // the view of this crate as a proc macro crate.
+ if id == CRATE_DEF_INDEX {
+ for child_index in data.macros.decode(self) {
+ yield self.get_mod_child(child_index, sess);
+ }
+ }
+ } else {
+ // Iterate over all children.
+ let non_reexports =
+ self.root.tables.module_children_non_reexports.get(self, id);
+ for child_index in non_reexports.unwrap().decode(self) {
yield self.get_mod_child(child_index, sess);
}
- }
- } else {
- // Iterate over all children.
- let non_reexports = self.root.tables.module_children_non_reexports.get(self, id);
- for child_index in non_reexports.unwrap().decode(self) {
- yield self.get_mod_child(child_index, sess);
- }
- let reexports = self.root.tables.module_children_reexports.get(self, id);
- if !reexports.is_default() {
- for reexport in reexports.decode((self, sess)) {
- yield reexport;
+ let reexports = self.root.tables.module_children_reexports.get(self, id);
+ if !reexports.is_default() {
+ for reexport in reexports.decode((self, sess)) {
+ yield reexport;
+ }
}
}
- }
- })
+ },
+ )
}
fn is_ctfe_mir_available(self, id: DefIndex) -> bool {
diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs
index e52a5863fd03d..da908d842a743 100644
--- a/compiler/rustc_middle/src/lib.rs
+++ b/compiler/rustc_middle/src/lib.rs
@@ -35,9 +35,10 @@
#![feature(const_type_name)]
#![feature(discriminant_kind)]
#![feature(coroutines)]
+#![feature(stmt_expr_attributes)]
#![feature(generic_nonzero)]
#![feature(if_let_guard)]
-#![feature(inline_const)]
+#![cfg_attr(bootstrap, feature(inline_const))]
#![feature(iter_from_coroutine)]
#![feature(negative_impls)]
#![feature(never_type)]
diff --git a/compiler/rustc_middle/src/mir/interpret/error.rs b/compiler/rustc_middle/src/mir/interpret/error.rs
index 65ce1cd8f50c6..a3d16d4f097a8 100644
--- a/compiler/rustc_middle/src/mir/interpret/error.rs
+++ b/compiler/rustc_middle/src/mir/interpret/error.rs
@@ -2,7 +2,7 @@ use super::{AllocId, AllocRange, ConstAllocation, Pointer, Scalar};
use crate::error;
use crate::mir::{ConstAlloc, ConstValue};
-use crate::ty::{layout, tls, Ty, TyCtxt, ValTree};
+use crate::ty::{self, layout, tls, Ty, TyCtxt, ValTree};
use rustc_ast_ir::Mutability;
use rustc_data_structures::sync::Lock;
@@ -344,6 +344,11 @@ pub enum UndefinedBehaviorInfo<'tcx> {
InvalidFunctionPointer(Pointer<AllocId>),
/// Using a pointer-not-to-a-vtable as vtable pointer.
InvalidVTablePointer(Pointer<AllocId>),
+ /// Using a vtable for the wrong trait.
+ InvalidVTableTrait {
+ expected_trait: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
+ vtable_trait: Option<ty::PolyExistentialTraitRef<'tcx>>,
+ },
/// Using a string that is not valid UTF-8,
InvalidStr(std::str::Utf8Error),
/// Using uninitialized data where it is not allowed.
@@ -414,34 +419,86 @@ impl From<PointerKind> for ExpectedKind {
#[derive(Debug)]
pub enum ValidationErrorKind<'tcx> {
- PointerAsInt { expected: ExpectedKind },
+ PointerAsInt {
+ expected: ExpectedKind,
+ },
PartialPointer,
- PtrToUninhabited { ptr_kind: PointerKind, ty: Ty<'tcx> },
- PtrToStatic { ptr_kind: PointerKind },
+ PtrToUninhabited {
+ ptr_kind: PointerKind,
+ ty: Ty<'tcx>,
+ },
+ PtrToStatic {
+ ptr_kind: PointerKind,
+ },
ConstRefToMutable,
ConstRefToExtern,
MutableRefToImmutable,
UnsafeCellInImmutable,
NullFnPtr,
NeverVal,
- NullablePtrOutOfRange { range: WrappingRange, max_value: u128 },
- PtrOutOfRange { range: WrappingRange, max_value: u128 },
- OutOfRange { value: String, range: WrappingRange, max_value: u128 },
- UninhabitedVal { ty: Ty<'tcx> },
- InvalidEnumTag { value: String },
+ NullablePtrOutOfRange {
+ range: WrappingRange,
+ max_value: u128,
+ },
+ PtrOutOfRange {
+ range: WrappingRange,
+ max_value: u128,
+ },
+ OutOfRange {
+ value: String,
+ range: WrappingRange,
+ max_value: u128,
+ },
+ UninhabitedVal {
+ ty: Ty<'tcx>,
+ },
+ InvalidEnumTag {
+ value: String,
+ },
UninhabitedEnumVariant,
- Uninit { expected: ExpectedKind },
- InvalidVTablePtr { value: String },
- InvalidMetaSliceTooLarge { ptr_kind: PointerKind },
- InvalidMetaTooLarge { ptr_kind: PointerKind },
- UnalignedPtr { ptr_kind: PointerKind, required_bytes: u64, found_bytes: u64 },
- NullPtr { ptr_kind: PointerKind },
- DanglingPtrNoProvenance { ptr_kind: PointerKind, pointer: String },
- DanglingPtrOutOfBounds { ptr_kind: PointerKind },
- DanglingPtrUseAfterFree { ptr_kind: PointerKind },
- InvalidBool { value: String },
- InvalidChar { value: String },
- InvalidFnPtr { value: String },
+ Uninit {
+ expected: ExpectedKind,
+ },
+ InvalidVTablePtr {
+ value: String,
+ },
+ InvalidMetaWrongTrait {
+ expected_trait: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
+ vtable_trait: Option<ty::PolyExistentialTraitRef<'tcx>>,
+ },
+ InvalidMetaSliceTooLarge {
+ ptr_kind: PointerKind,
+ },
+ InvalidMetaTooLarge {
+ ptr_kind: PointerKind,
+ },
+ UnalignedPtr {
+ ptr_kind: PointerKind,
+ required_bytes: u64,
+ found_bytes: u64,
+ },
+ NullPtr {
+ ptr_kind: PointerKind,
+ },
+ DanglingPtrNoProvenance {
+ ptr_kind: PointerKind,
+ pointer: String,
+ },
+ DanglingPtrOutOfBounds {
+ ptr_kind: PointerKind,
+ },
+ DanglingPtrUseAfterFree {
+ ptr_kind: PointerKind,
+ },
+ InvalidBool {
+ value: String,
+ },
+ InvalidChar {
+ value: String,
+ },
+ InvalidFnPtr {
+ value: String,
+ },
}
/// Error information for when the program did something that might (or might not) be correct
diff --git a/compiler/rustc_middle/src/ty/closure.rs b/compiler/rustc_middle/src/ty/closure.rs
index 11167515b7ca0..b66c664e6ae1d 100644
--- a/compiler/rustc_middle/src/ty/closure.rs
+++ b/compiler/rustc_middle/src/ty/closure.rs
@@ -422,49 +422,53 @@ pub fn analyze_coroutine_closure_captures<'a, 'tcx: 'a, T>(
child_captures: impl IntoIterator<Item = &'a CapturedPlace<'tcx>>,
mut for_each: impl FnMut((usize, &'a CapturedPlace<'tcx>), (usize, &'a CapturedPlace<'tcx>)) -> T,
) -> impl Iterator<Item = T> + Captures<'a> + Captures<'tcx> {
- std::iter::from_coroutine(move || {
- let mut child_captures = child_captures.into_iter().enumerate().peekable();
-
- // One parent capture may correspond to several child captures if we end up
- // refining the set of captures via edition-2021 precise captures. We want to
- // match up any number of child captures with one parent capture, so we keep
- // peeking off this `Peekable` until the child doesn't match anymore.
- for (parent_field_idx, parent_capture) in parent_captures.into_iter().enumerate() {
- // Make sure we use every field at least once, b/c why are we capturing something
- // if it's not used in the inner coroutine.
- let mut field_used_at_least_once = false;
-
- // A parent matches a child if they share the same prefix of projections.
- // The child may have more, if it is capturing sub-fields out of
- // something that is captured by-move in the parent closure.
- while child_captures.peek().map_or(false, |(_, child_capture)| {
- child_prefix_matches_parent_projections(parent_capture, child_capture)
- }) {
- let (child_field_idx, child_capture) = child_captures.next().unwrap();
- // This analysis only makes sense if the parent capture is a
- // prefix of the child capture.
- assert!(
- child_capture.place.projections.len() >= parent_capture.place.projections.len(),
- "parent capture ({parent_capture:#?}) expected to be prefix of \
+ std::iter::from_coroutine(
+ #[cfg_attr(not(bootstrap), coroutine)]
+ move || {
+ let mut child_captures = child_captures.into_iter().enumerate().peekable();
+
+ // One parent capture may correspond to several child captures if we end up
+ // refining the set of captures via edition-2021 precise captures. We want to
+ // match up any number of child captures with one parent capture, so we keep
+ // peeking off this `Peekable` until the child doesn't match anymore.
+ for (parent_field_idx, parent_capture) in parent_captures.into_iter().enumerate() {
+ // Make sure we use every field at least once, b/c why are we capturing something
+ // if it's not used in the inner coroutine.
+ let mut field_used_at_least_once = false;
+
+ // A parent matches a child if they share the same prefix of projections.
+ // The child may have more, if it is capturing sub-fields out of
+ // something that is captured by-move in the parent closure.
+ while child_captures.peek().map_or(false, |(_, child_capture)| {
+ child_prefix_matches_parent_projections(parent_capture, child_capture)
+ }) {
+ let (child_field_idx, child_capture) = child_captures.next().unwrap();
+ // This analysis only makes sense if the parent capture is a
+ // prefix of the child capture.
+ assert!(
+ child_capture.place.projections.len()
+ >= parent_capture.place.projections.len(),
+ "parent capture ({parent_capture:#?}) expected to be prefix of \
child capture ({child_capture:#?})"
- );
+ );
- yield for_each(
- (parent_field_idx, parent_capture),
- (child_field_idx, child_capture),
- );
+ yield for_each(
+ (parent_field_idx, parent_capture),
+ (child_field_idx, child_capture),
+ );
- field_used_at_least_once = true;
- }
+ field_used_at_least_once = true;
+ }
- // Make sure the field was used at least once.
- assert!(
- field_used_at_least_once,
- "we captured {parent_capture:#?} but it was not used in the child coroutine?"
- );
- }
- assert_eq!(child_captures.next(), None, "leftover child captures?");
- })
+ // Make sure the field was used at least once.
+ assert!(
+ field_used_at_least_once,
+ "we captured {parent_capture:#?} but it was not used in the child coroutine?"
+ );
+ }
+ assert_eq!(child_captures.next(), None, "leftover child captures?");
+ },
+ )
}
fn child_prefix_matches_parent_projections(
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 6275c5d2a1194..538d2bcc7b10f 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -1262,20 +1262,23 @@ impl<'tcx> TyCtxt<'tcx> {
self.dep_graph.read_index(DepNodeIndex::FOREVER_RED_NODE);
let definitions = &self.untracked.definitions;
- std::iter::from_coroutine(|| {
- let mut i = 0;
-
- // Recompute the number of definitions each time, because our caller may be creating
- // new ones.
- while i < { definitions.read().num_definitions() } {
- let local_def_index = rustc_span::def_id::DefIndex::from_usize(i);
- yield LocalDefId { local_def_index };
- i += 1;
- }
+ std::iter::from_coroutine(
+ #[cfg_attr(not(bootstrap), coroutine)]
+ || {
+ let mut i = 0;
+
+ // Recompute the number of definitions each time, because our caller may be creating
+ // new ones.
+ while i < { definitions.read().num_definitions() } {
+ let local_def_index = rustc_span::def_id::DefIndex::from_usize(i);
+ yield LocalDefId { local_def_index };
+ i += 1;
+ }
- // Freeze definitions once we finish iterating on them, to prevent adding new ones.
- definitions.freeze();
- })
+ // Freeze definitions once we finish iterating on them, to prevent adding new ones.
+ definitions.freeze();
+ },
+ )
}
pub fn def_path_table(self) -> &'tcx rustc_hir::definitions::DefPathTable {
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index 6381bd190ac0a..897d6f5662f60 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -338,6 +338,10 @@ impl<'tcx> SizeSkeleton<'tcx> {
debug_assert!(tail.has_non_region_param());
Ok(SizeSkeleton::Pointer { non_zero, tail: tcx.erase_regions(tail) })
}
+ ty::Error(guar) => {
+ // Fixes ICE #124031
+ return Err(tcx.arena.alloc(LayoutError::ReferencesError(*guar)));
+ }
_ => bug!(
"SizeSkeleton::compute({ty}): layout errored ({err:?}), yet \
tail `{tail}` is not a type parameter or a projection",
diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
index e477c068229ff..ab2368a1ef00b 100644
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -4,7 +4,7 @@
#![feature(cow_is_borrowed)]
#![feature(decl_macro)]
#![feature(impl_trait_in_assoc_type)]
-#![feature(inline_const)]
+#![cfg_attr(bootstrap, feature(inline_const))]
#![feature(is_sorted)]
#![feature(let_chains)]
#![feature(map_try_insert)]
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 4a996f89a9a3d..d657e109edd99 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -1254,8 +1254,6 @@ impl<'a> Parser<'a> {
fn parse_const_block(&mut self, span: Span, pat: bool) -> PResult<'a, P<Expr>> {
if pat {
self.psess.gated_spans.gate(sym::inline_const_pat, span);
- } else {
- self.psess.gated_spans.gate(sym::inline_const, span);
}
self.eat_keyword(kw::Const);
let (attrs, blk) = self.parse_inner_attrs_and_block()?;
diff --git a/compiler/rustc_serialize/src/lib.rs b/compiler/rustc_serialize/src/lib.rs
index 5a9403e0a8590..5d79669717209 100644
--- a/compiler/rustc_serialize/src/lib.rs
+++ b/compiler/rustc_serialize/src/lib.rs
@@ -12,7 +12,7 @@
#![feature(const_option)]
#![feature(core_intrinsics)]
#![feature(generic_nonzero)]
-#![feature(inline_const)]
+#![cfg_attr(bootstrap, feature(inline_const))]
#![feature(min_specialization)]
#![feature(never_type)]
#![feature(ptr_sub_ptr)]
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index 397e104512fd7..d7de0dd3bbf8f 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -183,7 +183,7 @@ pub enum TyKind<I: Interner> {
///
/// ```
/// #![feature(coroutines)]
- /// static |a| {
+ /// #[coroutine] static |a| {
/// let x = &vec![3];
/// yield a;
/// yield x[0];
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index dec04d7e421e3..dd9a8c175390f 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -129,7 +129,6 @@
#![feature(generic_nonzero)]
#![feature(hasher_prefixfree_extras)]
#![feature(hint_assert_unchecked)]
-#![feature(inline_const)]
#![feature(inplace_iteration)]
#![feature(iter_advance_by)]
#![feature(iter_next_chunk)]
@@ -170,6 +169,7 @@
// Language features:
// tidy-alphabetical-start
#![cfg_attr(bootstrap, feature(associated_type_bounds))]
+#![cfg_attr(bootstrap, feature(inline_const))]
#![cfg_attr(not(bootstrap), rustc_preserve_ub_checks)]
#![cfg_attr(not(test), feature(coroutine_trait))]
#![cfg_attr(test, feature(panic_update_hook))]
diff --git a/library/core/src/iter/sources/from_coroutine.rs b/library/core/src/iter/sources/from_coroutine.rs
index bf413b24d4177..9bac9037a024b 100644
--- a/library/core/src/iter/sources/from_coroutine.rs
+++ b/library/core/src/iter/sources/from_coroutine.rs
@@ -14,7 +14,7 @@ use crate::pin::Pin;
/// #![feature(coroutines)]
/// #![feature(iter_from_coroutine)]
///
-/// let it = std::iter::from_coroutine(|| {
+/// let it = std::iter::from_coroutine(#[cfg_attr(not(bootstrap), coroutine)] || {
/// yield 1;
/// yield 2;
/// yield 3;
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 154565b6fee17..6925a7d1da1fb 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -201,6 +201,7 @@
//
// Language features:
// tidy-alphabetical-start
+#![cfg_attr(bootstrap, feature(inline_const))]
#![feature(abi_unadjusted)]
#![feature(adt_const_params)]
#![feature(allow_internal_unsafe)]
@@ -231,7 +232,6 @@
#![feature(fundamental)]
#![feature(generic_arg_infer)]
#![feature(if_let_guard)]
-#![feature(inline_const)]
#![feature(intra_doc_pointers)]
#![feature(intrinsics)]
#![feature(lang_items)]
diff --git a/library/core/src/ops/coroutine.rs b/library/core/src/ops/coroutine.rs
index 6e067f95da92d..5250be15fe43a 100644
--- a/library/core/src/ops/coroutine.rs
+++ b/library/core/src/ops/coroutine.rs
@@ -40,12 +40,13 @@ pub enum CoroutineState<Y, R> {
/// ```rust
/// #![feature(coroutines)]
/// #![feature(coroutine_trait)]
+/// #![feature(stmt_expr_attributes)]
///
/// use std::ops::{Coroutine, CoroutineState};
/// use std::pin::Pin;
///
/// fn main() {
-/// let mut coroutine = || {
+/// let mut coroutine = #[cfg_attr(not(bootstrap), coroutine)] || {
/// yield 1;
/// "foo"
/// };
diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index efd525aeb3b74..a11c6c742d7dc 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -1809,7 +1809,7 @@ impl<Ptr, U> DispatchFromDyn<Pin<U>> for Pin<Ptr> where Ptr: DispatchFromDyn<U>
/// fn coroutine_fn() -> impl Coroutine<Yield = usize, Return = ()> /* not Unpin */ {
/// // Allow coroutine to be self-referential (not `Unpin`)
/// // vvvvvv so that locals can cross yield points.
-/// static || {
+/// #[cfg_attr(not(bootstrap), coroutine)] static || {
/// let foo = String::from("foo");
/// let foo_ref = &foo; // ------+
/// yield 0; // | <- crosses yield point!
diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs
index c8fd997a5da62..073459fcb0032 100644
--- a/library/core/src/sync/atomic.rs
+++ b/library/core/src/sync/atomic.rs
@@ -511,7 +511,8 @@ impl AtomicBool {
/// # Examples
///
/// ```
- /// #![feature(atomic_from_mut, inline_const)]
+ /// #![feature(atomic_from_mut)]
+ /// # #![cfg_attr(bootstrap, feature(inline_const))]
/// use std::sync::atomic::{AtomicBool, Ordering};
///
/// let mut some_bools = [const { AtomicBool::new(false) }; 10];
@@ -1313,7 +1314,8 @@ impl<T> AtomicPtr<T> {
/// # Examples
///
/// ```
- /// #![feature(atomic_from_mut, inline_const)]
+ /// #![feature(atomic_from_mut)]
+ /// # #![cfg_attr(bootstrap, feature(inline_const))]
/// use std::ptr::null_mut;
/// use std::sync::atomic::{AtomicPtr, Ordering};
///
@@ -2303,7 +2305,8 @@ macro_rules! atomic_int {
/// # Examples
///
/// ```
- /// #![feature(atomic_from_mut, inline_const)]
+ /// #![feature(atomic_from_mut)]
+ /// # #![cfg_attr(bootstrap, feature(inline_const))]
#[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
///
#[doc = concat!("let mut some_ints = [const { ", stringify!($atomic_type), "::new(0) }; 10];")]
diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs
index e741149e7ce21..e9298a30d8dea 100644
--- a/library/core/tests/lib.rs
+++ b/library/core/tests/lib.rs
@@ -47,7 +47,7 @@
#![feature(hasher_prefixfree_extras)]
#![feature(hashmap_internals)]
#![feature(try_find)]
-#![feature(inline_const)]
+#![cfg_attr(bootstrap, feature(inline_const))]
#![feature(is_sorted)]
#![feature(layout_for_ptr)]
#![feature(pattern)]
diff --git a/library/portable-simd/crates/core_simd/src/lib.rs b/library/portable-simd/crates/core_simd/src/lib.rs
index 48514e52587f0..331b66262490c 100644
--- a/library/portable-simd/crates/core_simd/src/lib.rs
+++ b/library/portable-simd/crates/core_simd/src/lib.rs
@@ -7,7 +7,6 @@
convert_float_to_int,
core_intrinsics,
decl_macro,
- inline_const,
intra_doc_pointers,
repr_simd,
simd_ffi,
diff --git a/src/doc/unstable-book/src/language-features/coroutines.md b/src/doc/unstable-book/src/language-features/coroutines.md
index f8e5a22fbd5c8..9fb07594650f4 100644
--- a/src/doc/unstable-book/src/language-features/coroutines.md
+++ b/src/doc/unstable-book/src/language-features/coroutines.md
@@ -26,13 +26,13 @@ tweaks to the overall design.
A syntactical example of a coroutine is:
```rust
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::{Coroutine, CoroutineState};
use std::pin::Pin;
fn main() {
- let mut coroutine = || {
+ let mut coroutine = #[coroutine] || {
yield 1;
return "foo"
};
@@ -48,7 +48,8 @@ fn main() {
}
```
-Coroutines are closure-like literals which can contain a `yield` statement. The
+Coroutines are closure-like literals which are annotated with `#[coroutine]`
+and can contain a `yield` statement. The
`yield` statement takes an optional expression of a value to yield out of the
coroutine. All coroutine literals implement the `Coroutine` trait in the
`std::ops` module. The `Coroutine` trait has one main method, `resume`, which
@@ -58,13 +59,13 @@ An example of the control flow of coroutines is that the following example
prints all numbers in order:
```rust
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
use std::pin::Pin;
fn main() {
- let mut coroutine = || {
+ let mut coroutine = #[coroutine] || {
println!("2");
yield;
println!("4");
@@ -78,9 +79,9 @@ fn main() {
}
```
-At this time the main intended use case of coroutines is an implementation
-primitive for async/await syntax, but coroutines will likely be extended to
-ergonomic implementations of iterators and other primitives in the future.
+At this time the main use case of coroutines is an implementation
+primitive for `async`/`await` and `gen` syntax, but coroutines
+will likely be extended to other primitives in the future.
Feedback on the design and usage is always appreciated!
### The `Coroutine` trait
@@ -163,14 +164,14 @@ which point all state is saved off in the coroutine and a value is returned.
Let's take a look at an example to see what's going on here:
```rust
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
use std::pin::Pin;
fn main() {
let ret = "foo";
- let mut coroutine = move || {
+ let mut coroutine = #[coroutine] move || {
yield 1;
return ret
};
@@ -183,7 +184,7 @@ fn main() {
This coroutine literal will compile down to something similar to:
```rust
-#![feature(arbitrary_self_types, coroutines, coroutine_trait)]
+#![feature(arbitrary_self_types, coroutine_trait)]
use std::ops::{Coroutine, CoroutineState};
use std::pin::Pin;
diff --git a/src/doc/unstable-book/src/language-features/inline-const-pat.md b/src/doc/unstable-book/src/language-features/inline-const-pat.md
index 5f0f7547a0a89..c6f54d79cfce8 100644
--- a/src/doc/unstable-book/src/language-features/inline-const-pat.md
+++ b/src/doc/unstable-book/src/language-features/inline-const-pat.md
@@ -2,8 +2,6 @@
The tracking issue for this feature is: [#76001]
-See also [`inline_const`](inline-const.md)
-
------
This feature allows you to use inline constant expressions in pattern position:
diff --git a/src/doc/unstable-book/src/language-features/inline-const.md b/src/doc/unstable-book/src/language-features/inline-const.md
deleted file mode 100644
index 7be70eed6cedc..0000000000000
--- a/src/doc/unstable-book/src/language-features/inline-const.md
+++ /dev/null
@@ -1,32 +0,0 @@
-# `inline_const`
-
-The tracking issue for this feature is: [#76001]
-
-See also [`inline_const_pat`](inline-const-pat.md)
-
-------
-
-This feature allows you to use inline constant expressions. For example, you can
-turn this code:
-
-```rust
-# fn add_one(x: i32) -> i32 { x + 1 }
-const MY_COMPUTATION: i32 = 1 + 2 * 3 / 4;
-
-fn main() {
- let x = add_one(MY_COMPUTATION);
-}
-```
-
-into this code:
-
-```rust
-#![feature(inline_const)]
-
-# fn add_one(x: i32) -> i32 { x + 1 }
-fn main() {
- let x = add_one(const { 1 + 2 * 3 / 4 });
-}
-```
-
-[#76001]: https://github.com/rust-lang/rust/issues/76001
diff --git a/src/doc/unstable-book/src/the-unstable-book.md b/src/doc/unstable-book/src/the-unstable-book.md
index 0f4fb405669a1..63134f7ae28c4 100644
--- a/src/doc/unstable-book/src/the-unstable-book.md
+++ b/src/doc/unstable-book/src/the-unstable-book.md
@@ -5,13 +5,13 @@ each one organized by a "feature flag." That is, when using an unstable
feature of Rust, you must use a flag, like this:
```rust
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::{Coroutine, CoroutineState};
use std::pin::Pin;
fn main() {
- let mut coroutine = || {
+ let mut coroutine = #[coroutine] || {
yield 1;
return "foo"
};
diff --git a/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.rs b/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.rs
index 4ae75544c60c4..232bccf6a1543 100644
--- a/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.rs
+++ b/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.rs
@@ -1,4 +1,3 @@
-#![feature(inline_const)]
#![warn(clippy::indexing_slicing)]
// We also check the out_of_bounds_indexing lint here, because it lints similar things and
// we want to avoid false positives.
diff --git a/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.stderr b/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.stderr
index 120f5c35cb036..5ce2ed2ffaeec 100644
--- a/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.stderr
+++ b/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.stderr
@@ -1,5 +1,5 @@
error: indexing may panic
- --> tests/ui-toml/suppress_lint_in_const/test.rs:27:5
+ --> tests/ui-toml/suppress_lint_in_const/test.rs:26:5
|
LL | x[index];
| ^^^^^^^^
@@ -9,7 +9,7 @@ LL | x[index];
= help: to override `-D warnings` add `#[allow(clippy::indexing_slicing)]`
error: indexing may panic
- --> tests/ui-toml/suppress_lint_in_const/test.rs:42:5
+ --> tests/ui-toml/suppress_lint_in_const/test.rs:41:5
|
LL | v[0];
| ^^^^
@@ -17,7 +17,7 @@ LL | v[0];
= help: consider using `.get(n)` or `.get_mut(n)` instead
error: indexing may panic
- --> tests/ui-toml/suppress_lint_in_const/test.rs:43:5
+ --> tests/ui-toml/suppress_lint_in_const/test.rs:42:5
|
LL | v[10];
| ^^^^^
@@ -25,7 +25,7 @@ LL | v[10];
= help: consider using `.get(n)` or `.get_mut(n)` instead
error: indexing may panic
- --> tests/ui-toml/suppress_lint_in_const/test.rs:44:5
+ --> tests/ui-toml/suppress_lint_in_const/test.rs:43:5
|
LL | v[1 << 3];
| ^^^^^^^^^
@@ -33,7 +33,7 @@ LL | v[1 << 3];
= help: consider using `.get(n)` or `.get_mut(n)` instead
error: indexing may panic
- --> tests/ui-toml/suppress_lint_in_const/test.rs:50:5
+ --> tests/ui-toml/suppress_lint_in_const/test.rs:49:5
|
LL | v[N];
| ^^^^
@@ -41,7 +41,7 @@ LL | v[N];
= help: consider using `.get(n)` or `.get_mut(n)` instead
error: indexing may panic
- --> tests/ui-toml/suppress_lint_in_const/test.rs:51:5
+ --> tests/ui-toml/suppress_lint_in_const/test.rs:50:5
|
LL | v[M];
| ^^^^
diff --git a/src/tools/clippy/tests/ui/arithmetic_side_effects.rs b/src/tools/clippy/tests/ui/arithmetic_side_effects.rs
index b454c29aef4db..fdec14a1528f7 100644
--- a/src/tools/clippy/tests/ui/arithmetic_side_effects.rs
+++ b/src/tools/clippy/tests/ui/arithmetic_side_effects.rs
@@ -10,7 +10,7 @@
arithmetic_overflow,
unconditional_panic
)]
-#![feature(const_mut_refs, inline_const)]
+#![feature(const_mut_refs)]
#![warn(clippy::arithmetic_side_effects)]
extern crate proc_macro_derive;
diff --git a/src/tools/clippy/tests/ui/bool_to_int_with_if.fixed b/src/tools/clippy/tests/ui/bool_to_int_with_if.fixed
index 167263d31df82..f7dad28b0369a 100644
--- a/src/tools/clippy/tests/ui/bool_to_int_with_if.fixed
+++ b/src/tools/clippy/tests/ui/bool_to_int_with_if.fixed
@@ -1,4 +1,4 @@
-#![feature(let_chains, inline_const)]
+#![feature(let_chains)]
#![warn(clippy::bool_to_int_with_if)]
#![allow(unused, dead_code, clippy::unnecessary_operation, clippy::no_effect)]
diff --git a/src/tools/clippy/tests/ui/bool_to_int_with_if.rs b/src/tools/clippy/tests/ui/bool_to_int_with_if.rs
index f3f055eb7f065..d22871d2c8f2e 100644
--- a/src/tools/clippy/tests/ui/bool_to_int_with_if.rs
+++ b/src/tools/clippy/tests/ui/bool_to_int_with_if.rs
@@ -1,4 +1,4 @@
-#![feature(let_chains, inline_const)]
+#![feature(let_chains)]
#![warn(clippy::bool_to_int_with_if)]
#![allow(unused, dead_code, clippy::unnecessary_operation, clippy::no_effect)]
diff --git a/src/tools/clippy/tests/ui/const_is_empty.rs b/src/tools/clippy/tests/ui/const_is_empty.rs
index ae37a82e4f936..04e0de91ecfbf 100644
--- a/src/tools/clippy/tests/ui/const_is_empty.rs
+++ b/src/tools/clippy/tests/ui/const_is_empty.rs
@@ -1,4 +1,3 @@
-#![feature(inline_const)]
#![warn(clippy::const_is_empty)]
#![allow(clippy::needless_late_init, unused_must_use)]
diff --git a/src/tools/clippy/tests/ui/const_is_empty.stderr b/src/tools/clippy/tests/ui/const_is_empty.stderr
index 0e09da77bb469..7f80b520b1a44 100644
--- a/src/tools/clippy/tests/ui/const_is_empty.stderr
+++ b/src/tools/clippy/tests/ui/const_is_empty.stderr
@@ -1,5 +1,5 @@
error: this expression always evaluates to true
- --> tests/ui/const_is_empty.rs:6:8
+ --> tests/ui/const_is_empty.rs:5:8
|
LL | if "".is_empty() {
| ^^^^^^^^^^^^^
@@ -8,151 +8,151 @@ LL | if "".is_empty() {
= help: to override `-D warnings` add `#[allow(clippy::const_is_empty)]`
error: this expression always evaluates to false
- --> tests/ui/const_is_empty.rs:9:8
+ --> tests/ui/const_is_empty.rs:8:8
|
LL | if "foobar".is_empty() {
| ^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to true
- --> tests/ui/const_is_empty.rs:15:8
+ --> tests/ui/const_is_empty.rs:14:8
|
LL | if b"".is_empty() {
| ^^^^^^^^^^^^^^
error: this expression always evaluates to false
- --> tests/ui/const_is_empty.rs:18:8
+ --> tests/ui/const_is_empty.rs:17:8
|
LL | if b"foobar".is_empty() {
| ^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to true
- --> tests/ui/const_is_empty.rs:35:8
+ --> tests/ui/const_is_empty.rs:34:8
|
LL | if empty2.is_empty() {
| ^^^^^^^^^^^^^^^^^
error: this expression always evaluates to false
- --> tests/ui/const_is_empty.rs:38:8
+ --> tests/ui/const_is_empty.rs:37:8
|
LL | if non_empty2.is_empty() {
| ^^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to true
- --> tests/ui/const_is_empty.rs:60:13
+ --> tests/ui/const_is_empty.rs:59:13
|
LL | let _ = EMPTY_STR.is_empty();
| ^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to false
- --> tests/ui/const_is_empty.rs:62:13
+ --> tests/ui/const_is_empty.rs:61:13
|
LL | let _ = NON_EMPTY_STR.is_empty();
| ^^^^^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to true
- --> tests/ui/const_is_empty.rs:64:13
+ --> tests/ui/const_is_empty.rs:63:13
|
LL | let _ = EMPTY_BSTR.is_empty();
| ^^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to false
- --> tests/ui/const_is_empty.rs:66:13
+ --> tests/ui/const_is_empty.rs:65:13
|
LL | let _ = NON_EMPTY_BSTR.is_empty();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to true
- --> tests/ui/const_is_empty.rs:68:13
+ --> tests/ui/const_is_empty.rs:67:13
|
LL | let _ = EMPTY_ARRAY.is_empty();
| ^^^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to true
- --> tests/ui/const_is_empty.rs:70:13
+ --> tests/ui/const_is_empty.rs:69:13
|
LL | let _ = EMPTY_ARRAY_REPEAT.is_empty();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to true
- --> tests/ui/const_is_empty.rs:72:13
+ --> tests/ui/const_is_empty.rs:71:13
|
LL | let _ = EMPTY_U8_SLICE.is_empty();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to false
- --> tests/ui/const_is_empty.rs:74:13
+ --> tests/ui/const_is_empty.rs:73:13
|
LL | let _ = NON_EMPTY_U8_SLICE.is_empty();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to false
- --> tests/ui/const_is_empty.rs:76:13
+ --> tests/ui/const_is_empty.rs:75:13
|
LL | let _ = NON_EMPTY_ARRAY.is_empty();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to false
- --> tests/ui/const_is_empty.rs:78:13
+ --> tests/ui/const_is_empty.rs:77:13
|
LL | let _ = NON_EMPTY_ARRAY_REPEAT.is_empty();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to true
- --> tests/ui/const_is_empty.rs:80:13
+ --> tests/ui/const_is_empty.rs:79:13
|
LL | let _ = EMPTY_REF_ARRAY.is_empty();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to false
- --> tests/ui/const_is_empty.rs:82:13
+ --> tests/ui/const_is_empty.rs:81:13
|
LL | let _ = NON_EMPTY_REF_ARRAY.is_empty();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to true
- --> tests/ui/const_is_empty.rs:84:13
+ --> tests/ui/const_is_empty.rs:83:13
|
LL | let _ = EMPTY_SLICE.is_empty();
| ^^^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to false
- --> tests/ui/const_is_empty.rs:86:13
+ --> tests/ui/const_is_empty.rs:85:13
|
LL | let _ = NON_EMPTY_SLICE.is_empty();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to false
- --> tests/ui/const_is_empty.rs:88:13
+ --> tests/ui/const_is_empty.rs:87:13
|
LL | let _ = NON_EMPTY_SLICE_REPEAT.is_empty();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: this expression always evaluates to false
- --> tests/ui/const_is_empty.rs:94:13
+ --> tests/ui/const_is_empty.rs:93:13
|
LL | let _ = value.is_empty();
| ^^^^^^^^^^^^^^^^
error: this expression always evaluates to false
- --> tests/ui/const_is_empty.rs:97:13
+ --> tests/ui/const_is_empty.rs:96:13
|
LL | let _ = x.is_empty();
| ^^^^^^^^^^^^
error: this expression always evaluates to true
- --> tests/ui/const_is_empty.rs:99:13
+ --> tests/ui/const_is_empty.rs:98:13
|
LL | let _ = "".is_empty();
| ^^^^^^^^^^^^^
error: this expression always evaluates to true
- --> tests/ui/const_is_empty.rs:101:13
+ --> tests/ui/const_is_empty.rs:100:13
|
LL | let _ = b"".is_empty();
| ^^^^^^^^^^^^^^
error: this expression always evaluates to true
- --> tests/ui/const_is_empty.rs:155:13
+ --> tests/ui/const_is_empty.rs:154:13
|
LL | let _ = val.is_empty();
| ^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5238.rs b/src/tools/clippy/tests/ui/crashes/ice-5238.rs
index b1fc3fb9d2511..fe03a39ad1ba8 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-5238.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-5238.rs
@@ -1,9 +1,9 @@
// Regression test for #5238 / https://github.com/rust-lang/rust/pull/69562
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
fn main() {
- let _ = || {
+ let _ = #[coroutine] || {
yield;
};
}
diff --git a/src/tools/clippy/tests/ui/indexing_slicing_index.rs b/src/tools/clippy/tests/ui/indexing_slicing_index.rs
index 27ee2f91594bf..2e726141649e7 100644
--- a/src/tools/clippy/tests/ui/indexing_slicing_index.rs
+++ b/src/tools/clippy/tests/ui/indexing_slicing_index.rs
@@ -1,6 +1,5 @@
//@compile-flags: -Zdeduplicate-diagnostics=yes
-#![feature(inline_const)]
#![warn(clippy::indexing_slicing)]
// We also check the out_of_bounds_indexing lint here, because it lints similar things and
// we want to avoid false positives.
diff --git a/src/tools/clippy/tests/ui/indexing_slicing_index.stderr b/src/tools/clippy/tests/ui/indexing_slicing_index.stderr
index 5f62ec9b55655..386f91becf14d 100644
--- a/src/tools/clippy/tests/ui/indexing_slicing_index.stderr
+++ b/src/tools/clippy/tests/ui/indexing_slicing_index.stderr
@@ -1,5 +1,5 @@
error: indexing may panic
- --> tests/ui/indexing_slicing_index.rs:16:20
+ --> tests/ui/indexing_slicing_index.rs:15:20
|
LL | const REF: &i32 = &ARR[idx()]; // This should be linted, since `suppress-restriction-lint-in-const` default is false.
| ^^^^^^^^^^
@@ -10,19 +10,19 @@ LL | const REF: &i32 = &ARR[idx()]; // This should be linted, since `suppress-re
= help: to override `-D warnings` add `#[allow(clippy::indexing_slicing)]`
error[E0080]: evaluation of `main::{constant#3}` failed
- --> tests/ui/indexing_slicing_index.rs:48:14
+ --> tests/ui/indexing_slicing_index.rs:47:14
|
LL | const { &ARR[idx4()] };
| ^^^^^^^^^^^ index out of bounds: the length is 2 but the index is 4
note: erroneous constant encountered
- --> tests/ui/indexing_slicing_index.rs:48:5
+ --> tests/ui/indexing_slicing_index.rs:47:5
|
LL | const { &ARR[idx4()] };
| ^^^^^^^^^^^^^^^^^^^^^^
error: indexing may panic
- --> tests/ui/indexing_slicing_index.rs:29:5
+ --> tests/ui/indexing_slicing_index.rs:28:5
|
LL | x[index];
| ^^^^^^^^
@@ -30,7 +30,7 @@ LL | x[index];
= help: consider using `.get(n)` or `.get_mut(n)` instead
error: index is out of bounds
- --> tests/ui/indexing_slicing_index.rs:32:5
+ --> tests/ui/indexing_slicing_index.rs:31:5
|
LL | x[4];
| ^^^^
@@ -39,13 +39,13 @@ LL | x[4];
= help: to override `-D warnings` add `#[allow(clippy::out_of_bounds_indexing)]`
error: index is out of bounds
- --> tests/ui/indexing_slicing_index.rs:34:5
+ --> tests/ui/indexing_slicing_index.rs:33:5
|
LL | x[1 << 3];
| ^^^^^^^^^
error: indexing may panic
- --> tests/ui/indexing_slicing_index.rs:45:14
+ --> tests/ui/indexing_slicing_index.rs:44:14
|
LL | const { &ARR[idx()] };
| ^^^^^^^^^^
@@ -54,7 +54,7 @@ LL | const { &ARR[idx()] };
= note: the suggestion might not be applicable in constant blocks
error: indexing may panic
- --> tests/ui/indexing_slicing_index.rs:48:14
+ --> tests/ui/indexing_slicing_index.rs:47:14
|
LL | const { &ARR[idx4()] };
| ^^^^^^^^^^^
@@ -63,13 +63,13 @@ LL | const { &ARR[idx4()] };
= note: the suggestion might not be applicable in constant blocks
error: index is out of bounds
- --> tests/ui/indexing_slicing_index.rs:55:5
+ --> tests/ui/indexing_slicing_index.rs:54:5
|
LL | y[4];
| ^^^^
error: indexing may panic
- --> tests/ui/indexing_slicing_index.rs:58:5
+ --> tests/ui/indexing_slicing_index.rs:57:5
|
LL | v[0];
| ^^^^
@@ -77,7 +77,7 @@ LL | v[0];
= help: consider using `.get(n)` or `.get_mut(n)` instead
error: indexing may panic
- --> tests/ui/indexing_slicing_index.rs:60:5
+ --> tests/ui/indexing_slicing_index.rs:59:5
|
LL | v[10];
| ^^^^^
@@ -85,7 +85,7 @@ LL | v[10];
= help: consider using `.get(n)` or `.get_mut(n)` instead
error: indexing may panic
- --> tests/ui/indexing_slicing_index.rs:62:5
+ --> tests/ui/indexing_slicing_index.rs:61:5
|
LL | v[1 << 3];
| ^^^^^^^^^
@@ -93,13 +93,13 @@ LL | v[1 << 3];
= help: consider using `.get(n)` or `.get_mut(n)` instead
error: index is out of bounds
- --> tests/ui/indexing_slicing_index.rs:70:5
+ --> tests/ui/indexing_slicing_index.rs:69:5
|
LL | x[N];
| ^^^^
error: indexing may panic
- --> tests/ui/indexing_slicing_index.rs:73:5
+ --> tests/ui/indexing_slicing_index.rs:72:5
|
LL | v[N];
| ^^^^
@@ -107,7 +107,7 @@ LL | v[N];
= help: consider using `.get(n)` or `.get_mut(n)` instead
error: indexing may panic
- --> tests/ui/indexing_slicing_index.rs:75:5
+ --> tests/ui/indexing_slicing_index.rs:74:5
|
LL | v[M];
| ^^^^
@@ -115,7 +115,7 @@ LL | v[M];
= help: consider using `.get(n)` or `.get_mut(n)` instead
error: index is out of bounds
- --> tests/ui/indexing_slicing_index.rs:79:13
+ --> tests/ui/indexing_slicing_index.rs:78:13
|
LL | let _ = x[4];
| ^^^^
diff --git a/src/tools/clippy/tests/ui/large_futures.fixed b/src/tools/clippy/tests/ui/large_futures.fixed
index aa8c3021b9708..1e87859f45263 100644
--- a/src/tools/clippy/tests/ui/large_futures.fixed
+++ b/src/tools/clippy/tests/ui/large_futures.fixed
@@ -1,4 +1,3 @@
-#![feature(coroutines)]
#![warn(clippy::large_futures)]
#![allow(clippy::never_loop)]
#![allow(clippy::future_not_send)]
diff --git a/src/tools/clippy/tests/ui/large_futures.rs b/src/tools/clippy/tests/ui/large_futures.rs
index fc6ea458d3dbd..3f4ea2ebf8bbe 100644
--- a/src/tools/clippy/tests/ui/large_futures.rs
+++ b/src/tools/clippy/tests/ui/large_futures.rs
@@ -1,4 +1,3 @@
-#![feature(coroutines)]
#![warn(clippy::large_futures)]
#![allow(clippy::never_loop)]
#![allow(clippy::future_not_send)]
diff --git a/src/tools/clippy/tests/ui/large_futures.stderr b/src/tools/clippy/tests/ui/large_futures.stderr
index 5709c7b77a0a5..00082e579c597 100644
--- a/src/tools/clippy/tests/ui/large_futures.stderr
+++ b/src/tools/clippy/tests/ui/large_futures.stderr
@@ -1,5 +1,5 @@
error: large future with a size of 16385 bytes
- --> tests/ui/large_futures.rs:11:9
+ --> tests/ui/large_futures.rs:10:9
|
LL | big_fut([0u8; 1024 * 16]).await;
| ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Box::pin` on it: `Box::pin(big_fut([0u8; 1024 * 16]))`
@@ -8,37 +8,37 @@ LL | big_fut([0u8; 1024 * 16]).await;
= help: to override `-D warnings` add `#[allow(clippy::large_futures)]`
error: large future with a size of 16386 bytes
- --> tests/ui/large_futures.rs:15:5
+ --> tests/ui/large_futures.rs:14:5
|
LL | f.await
| ^ help: consider `Box::pin` on it: `Box::pin(f)`
error: large future with a size of 16387 bytes
- --> tests/ui/large_futures.rs:20:9
+ --> tests/ui/large_futures.rs:19:9
|
LL | wait().await;
| ^^^^^^ help: consider `Box::pin` on it: `Box::pin(wait())`
error: large future with a size of 16387 bytes
- --> tests/ui/large_futures.rs:25:13
+ --> tests/ui/large_futures.rs:24:13
|
LL | wait().await;
| ^^^^^^ help: consider `Box::pin` on it: `Box::pin(wait())`
error: large future with a size of 65540 bytes
- --> tests/ui/large_futures.rs:33:5
+ --> tests/ui/large_futures.rs:32:5
|
LL | foo().await;
| ^^^^^ help: consider `Box::pin` on it: `Box::pin(foo())`
error: large future with a size of 49159 bytes
- --> tests/ui/large_futures.rs:35:5
+ --> tests/ui/large_futures.rs:34:5
|
LL | calls_fut(fut).await;
| ^^^^^^^^^^^^^^ help: consider `Box::pin` on it: `Box::pin(calls_fut(fut))`
error: large future with a size of 65540 bytes
- --> tests/ui/large_futures.rs:48:5
+ --> tests/ui/large_futures.rs:47:5
|
LL | / async {
LL | |
@@ -59,7 +59,7 @@ LL + })
|
error: large future with a size of 65540 bytes
- --> tests/ui/large_futures.rs:60:13
+ --> tests/ui/large_futures.rs:59:13
|
LL | / async {
LL | | let x = [0i32; 1024 * 16];
diff --git a/src/tools/clippy/tests/ui/manual_float_methods.rs b/src/tools/clippy/tests/ui/manual_float_methods.rs
index f3e95d6807d33..80781ecda721a 100644
--- a/src/tools/clippy/tests/ui/manual_float_methods.rs
+++ b/src/tools/clippy/tests/ui/manual_float_methods.rs
@@ -2,7 +2,6 @@
//@aux-build:proc_macros.rs
#![allow(clippy::needless_if, unused)]
#![warn(clippy::manual_is_infinite, clippy::manual_is_finite)]
-#![feature(inline_const)]
#[macro_use]
extern crate proc_macros;
diff --git a/src/tools/clippy/tests/ui/manual_float_methods.stderr b/src/tools/clippy/tests/ui/manual_float_methods.stderr
index dae96839262d1..930df0b97cb3f 100644
--- a/src/tools/clippy/tests/ui/manual_float_methods.stderr
+++ b/src/tools/clippy/tests/ui/manual_float_methods.stderr
@@ -1,5 +1,5 @@
error: manually checking if a float is infinite
- --> tests/ui/manual_float_methods.rs:23:8
+ --> tests/ui/manual_float_methods.rs:22:8
|
LL | if x == f32::INFINITY || x == f32::NEG_INFINITY {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
@@ -8,7 +8,7 @@ LL | if x == f32::INFINITY || x == f32::NEG_INFINITY {}
= help: to override `-D warnings` add `#[allow(clippy::manual_is_infinite)]`
error: manually checking if a float is finite
- --> tests/ui/manual_float_methods.rs:24:8
+ --> tests/ui/manual_float_methods.rs:23:8
|
LL | if x != f32::INFINITY && x != f32::NEG_INFINITY {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -29,13 +29,13 @@ LL | if !x.is_infinite() {}
| ~~~~~~~~~~~~~~~~
error: manually checking if a float is infinite
- --> tests/ui/manual_float_methods.rs:25:8
+ --> tests/ui/manual_float_methods.rs:24:8
|
LL | if x == INFINITE || x == NEG_INFINITE {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
error: manually checking if a float is finite
- --> tests/ui/manual_float_methods.rs:26:8
+ --> tests/ui/manual_float_methods.rs:25:8
|
LL | if x != INFINITE && x != NEG_INFINITE {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -54,13 +54,13 @@ LL | if !x.is_infinite() {}
| ~~~~~~~~~~~~~~~~
error: manually checking if a float is infinite
- --> tests/ui/manual_float_methods.rs:28:8
+ --> tests/ui/manual_float_methods.rs:27:8
|
LL | if x == f64::INFINITY || x == f64::NEG_INFINITY {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
error: manually checking if a float is finite
- --> tests/ui/manual_float_methods.rs:29:8
+ --> tests/ui/manual_float_methods.rs:28:8
|
LL | if x != f64::INFINITY && x != f64::NEG_INFINITY {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/never_loop.rs b/src/tools/clippy/tests/ui/never_loop.rs
index 92f173d9db4a3..93c69209c6980 100644
--- a/src/tools/clippy/tests/ui/never_loop.rs
+++ b/src/tools/clippy/tests/ui/never_loop.rs
@@ -1,4 +1,4 @@
-#![feature(inline_const, try_blocks)]
+#![feature(try_blocks)]
#![allow(
clippy::eq_op,
clippy::single_match,
diff --git a/src/tools/clippy/tests/ui/panicking_macros.rs b/src/tools/clippy/tests/ui/panicking_macros.rs
index dccfbd409e503..2bbf5792ec4c2 100644
--- a/src/tools/clippy/tests/ui/panicking_macros.rs
+++ b/src/tools/clippy/tests/ui/panicking_macros.rs
@@ -1,5 +1,4 @@
#![allow(clippy::assertions_on_constants, clippy::eq_op, clippy::let_unit_value)]
-#![feature(inline_const)]
#![warn(clippy::unimplemented, clippy::unreachable, clippy::todo, clippy::panic)]
extern crate core;
diff --git a/src/tools/clippy/tests/ui/panicking_macros.stderr b/src/tools/clippy/tests/ui/panicking_macros.stderr
index 06025859c0c6d..7c0f0a7d37644 100644
--- a/src/tools/clippy/tests/ui/panicking_macros.stderr
+++ b/src/tools/clippy/tests/ui/panicking_macros.stderr
@@ -1,5 +1,5 @@
error: `panic` should not be present in production code
- --> tests/ui/panicking_macros.rs:23:5
+ --> tests/ui/panicking_macros.rs:22:5
|
LL | panic!();
| ^^^^^^^^
@@ -8,19 +8,19 @@ LL | panic!();
= help: to override `-D warnings` add `#[allow(clippy::panic)]`
error: `panic` should not be present in production code
- --> tests/ui/panicking_macros.rs:26:5
+ --> tests/ui/panicking_macros.rs:25:5
|
LL | panic!("message");
| ^^^^^^^^^^^^^^^^^
error: `panic` should not be present in production code
- --> tests/ui/panicking_macros.rs:28:5
+ --> tests/ui/panicking_macros.rs:27:5
|
LL | panic!("{} {}", "panic with", "multiple arguments");
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: `todo` should not be present in production code
- --> tests/ui/panicking_macros.rs:35:5
+ --> tests/ui/panicking_macros.rs:34:5
|
LL | todo!();
| ^^^^^^^
@@ -29,19 +29,19 @@ LL | todo!();
= help: to override `-D warnings` add `#[allow(clippy::todo)]`
error: `todo` should not be present in production code
- --> tests/ui/panicking_macros.rs:38:5
+ --> tests/ui/panicking_macros.rs:37:5
|
LL | todo!("message");
| ^^^^^^^^^^^^^^^^
error: `todo` should not be present in production code
- --> tests/ui/panicking_macros.rs:40:5
+ --> tests/ui/panicking_macros.rs:39:5
|
LL | todo!("{} {}", "panic with", "multiple arguments");
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: `unimplemented` should not be present in production code
- --> tests/ui/panicking_macros.rs:47:5
+ --> tests/ui/panicking_macros.rs:46:5
|
LL | unimplemented!();
| ^^^^^^^^^^^^^^^^
@@ -50,19 +50,19 @@ LL | unimplemented!();
= help: to override `-D warnings` add `#[allow(clippy::unimplemented)]`
error: `unimplemented` should not be present in production code
- --> tests/ui/panicking_macros.rs:50:5
+ --> tests/ui/panicking_macros.rs:49:5
|
LL | unimplemented!("message");
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error: `unimplemented` should not be present in production code
- --> tests/ui/panicking_macros.rs:52:5
+ --> tests/ui/panicking_macros.rs:51:5
|
LL | unimplemented!("{} {}", "panic with", "multiple arguments");
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: usage of the `unreachable!` macro
- --> tests/ui/panicking_macros.rs:59:5
+ --> tests/ui/panicking_macros.rs:58:5
|
LL | unreachable!();
| ^^^^^^^^^^^^^^
@@ -71,37 +71,37 @@ LL | unreachable!();
= help: to override `-D warnings` add `#[allow(clippy::unreachable)]`
error: usage of the `unreachable!` macro
- --> tests/ui/panicking_macros.rs:62:5
+ --> tests/ui/panicking_macros.rs:61:5
|
LL | unreachable!("message");
| ^^^^^^^^^^^^^^^^^^^^^^^
error: usage of the `unreachable!` macro
- --> tests/ui/panicking_macros.rs:64:5
+ --> tests/ui/panicking_macros.rs:63:5
|
LL | unreachable!("{} {}", "panic with", "multiple arguments");
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: `panic` should not be present in production code
- --> tests/ui/panicking_macros.rs:71:5
+ --> tests/ui/panicking_macros.rs:70:5
|
LL | panic!();
| ^^^^^^^^
error: `todo` should not be present in production code
- --> tests/ui/panicking_macros.rs:73:5
+ --> tests/ui/panicking_macros.rs:72:5
|
LL | todo!();
| ^^^^^^^
error: `unimplemented` should not be present in production code
- --> tests/ui/panicking_macros.rs:75:5
+ --> tests/ui/panicking_macros.rs:74:5
|
LL | unimplemented!();
| ^^^^^^^^^^^^^^^^
error: usage of the `unreachable!` macro
- --> tests/ui/panicking_macros.rs:77:5
+ --> tests/ui/panicking_macros.rs:76:5
|
LL | unreachable!();
| ^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/redundant_locals.rs b/src/tools/clippy/tests/ui/redundant_locals.rs
index f6909828aa9a7..e9d77182a9196 100644
--- a/src/tools/clippy/tests/ui/redundant_locals.rs
+++ b/src/tools/clippy/tests/ui/redundant_locals.rs
@@ -1,7 +1,7 @@
//@aux-build:proc_macros.rs
#![allow(unused, clippy::no_effect, clippy::needless_pass_by_ref_mut)]
#![warn(clippy::redundant_locals)]
-#![feature(async_closure, coroutines)]
+#![feature(async_closure, coroutines, stmt_expr_attributes)]
extern crate proc_macros;
use proc_macros::{external, with_span};
@@ -191,11 +191,11 @@ fn issue12225() {
let v4 = v4;
dbg!(&v4);
});
- assert_static(static || {
+ assert_static(#[coroutine] static || {
let v5 = v5;
yield;
});
- assert_static(|| {
+ assert_static(#[coroutine] || {
let v6 = v6;
yield;
});
diff --git a/src/tools/miri/tests/fail/coroutine-pinned-moved.rs b/src/tools/miri/tests/fail/coroutine-pinned-moved.rs
index 005ae7e91323c..8648be2a2641a 100644
--- a/src/tools/miri/tests/fail/coroutine-pinned-moved.rs
+++ b/src/tools/miri/tests/fail/coroutine-pinned-moved.rs
@@ -1,5 +1,5 @@
//@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},
@@ -7,7 +7,7 @@ use std::{
};
fn firstn() -> impl Coroutine<Yield = u64, Return = ()> {
- static move || {
+ #[coroutine] static move || {
let mut num = 0;
let num = &mut num;
*num += 0;
diff --git a/src/tools/miri/tests/fail/dyn-call-trait-mismatch.rs b/src/tools/miri/tests/fail/dyn-call-trait-mismatch.rs
index 13f913454dcdf..f71df9a1c909d 100644
--- a/src/tools/miri/tests/fail/dyn-call-trait-mismatch.rs
+++ b/src/tools/miri/tests/fail/dyn-call-trait-mismatch.rs
@@ -1,3 +1,6 @@
+// Validation stops this too early.
+//@compile-flags: -Zmiri-disable-validation
+
trait T1 {
#[allow(dead_code)]
fn method1(self: Box<Self>);
@@ -13,5 +16,5 @@ impl T1 for i32 {
fn main() {
let r = Box::new(0) as Box<dyn T1>;
let r2: Box<dyn T2> = unsafe { std::mem::transmute(r) };
- r2.method2(); //~ERROR: call on a pointer whose vtable does not match its type
+ r2.method2(); //~ERROR: using vtable for trait `T1` but trait `T2` was expected
}
diff --git a/src/tools/miri/tests/fail/dyn-call-trait-mismatch.stderr b/src/tools/miri/tests/fail/dyn-call-trait-mismatch.stderr
index 365186bcc4b41..019a55bcdcb1a 100644
--- a/src/tools/miri/tests/fail/dyn-call-trait-mismatch.stderr
+++ b/src/tools/miri/tests/fail/dyn-call-trait-mismatch.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: `dyn` call on a pointer whose vtable does not match its type
+error: Undefined Behavior: using vtable for trait `T1` but trait `T2` was expected
--> $DIR/dyn-call-trait-mismatch.rs:LL:CC
|
LL | r2.method2();
- | ^^^^^^^^^^^^ `dyn` call on a pointer whose vtable does not match its type
+ | ^^^^^^^^^^^^ using vtable for trait `T1` but trait `T2` was expected
|
= help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
= help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
diff --git a/src/tools/miri/tests/fail/dyn-upcast-nop-wrong-trait.rs b/src/tools/miri/tests/fail/dyn-upcast-nop-wrong-trait.rs
new file mode 100644
index 0000000000000..dff5a21c4c777
--- /dev/null
+++ b/src/tools/miri/tests/fail/dyn-upcast-nop-wrong-trait.rs
@@ -0,0 +1,15 @@
+// This upcast is currently forbidden because it involves an invalid value.
+// However, if in the future we relax the validity requirements for raw pointer vtables,
+// we could consider allowing this again -- the cast itself isn't doing anything wrong,
+// only the transmutes needed to set up the testcase are wrong.
+
+use std::fmt;
+
+fn main() {
+ // vtable_mismatch_nop_cast
+ let ptr: &dyn fmt::Display = &0;
+ let ptr: *const (dyn fmt::Debug + Send + Sync) = unsafe { std::mem::transmute(ptr) }; //~ERROR: wrong trait
+ // Even though the vtable is for the wrong trait, this cast doesn't actually change the needed
+ // vtable so it should still be allowed -- if we ever allow the line above.
+ let _ptr2 = ptr as *const dyn fmt::Debug;
+}
diff --git a/src/tools/miri/tests/fail/dyn-upcast-nop-wrong-trait.stderr b/src/tools/miri/tests/fail/dyn-upcast-nop-wrong-trait.stderr
new file mode 100644
index 0000000000000..4165d5ea15d97
--- /dev/null
+++ b/src/tools/miri/tests/fail/dyn-upcast-nop-wrong-trait.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: constructing invalid value: wrong trait in wide pointer vtable: expected `std::fmt::Debug + std::marker::Send + std::marker::Sync`, but encountered `std::fmt::Display`
+ --> $DIR/dyn-upcast-nop-wrong-trait.rs:LL:CC
+ |
+LL | let ptr: *const (dyn fmt::Debug + Send + Sync) = unsafe { std::mem::transmute(ptr) };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value: wrong trait in wide pointer vtable: expected `std::fmt::Debug + std::marker::Send + std::marker::Sync`, but encountered `std::fmt::Display`
+ |
+ = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+ = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+ = note: BACKTRACE:
+ = note: inside `main` at $DIR/dyn-upcast-nop-wrong-trait.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/fail/dyn-upcast-trait-mismatch.rs b/src/tools/miri/tests/fail/dyn-upcast-trait-mismatch.rs
index 982f33b0a3102..1d6b6777032de 100644
--- a/src/tools/miri/tests/fail/dyn-upcast-trait-mismatch.rs
+++ b/src/tools/miri/tests/fail/dyn-upcast-trait-mismatch.rs
@@ -1,3 +1,6 @@
+// Validation stops this too early.
+//@compile-flags: -Zmiri-disable-validation
+
#![feature(trait_upcasting)]
#![allow(incomplete_features)]
@@ -57,7 +60,7 @@ impl Baz for i32 {
fn main() {
let baz: &dyn Baz = &1;
- let baz_fake: &dyn Bar = unsafe { std::mem::transmute(baz) };
- let _err = baz_fake as &dyn Foo;
- //~^ERROR: upcast on a pointer whose vtable does not match its type
+ let baz_fake: *const dyn Bar = unsafe { std::mem::transmute(baz) };
+ let _err = baz_fake as *const dyn Foo;
+ //~^ERROR: using vtable for trait `Baz` but trait `Bar` was expected
}
diff --git a/src/tools/miri/tests/fail/dyn-upcast-trait-mismatch.stderr b/src/tools/miri/tests/fail/dyn-upcast-trait-mismatch.stderr
index 8bac908b864bc..6a2415cf57e29 100644
--- a/src/tools/miri/tests/fail/dyn-upcast-trait-mismatch.stderr
+++ b/src/tools/miri/tests/fail/dyn-upcast-trait-mismatch.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: upcast on a pointer whose vtable does not match its type
+error: Undefined Behavior: using vtable for trait `Baz` but trait `Bar` was expected
--> $DIR/dyn-upcast-trait-mismatch.rs:LL:CC
|
-LL | let _err = baz_fake as &dyn Foo;
- | ^^^^^^^^ upcast on a pointer whose vtable does not match its type
+LL | let _err = baz_fake as *const dyn Foo;
+ | ^^^^^^^^ using vtable for trait `Baz` but trait `Bar` was expected
|
= help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
= help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
diff --git a/src/tools/miri/tests/fail/validity/wrong-dyn-trait-generic.rs b/src/tools/miri/tests/fail/validity/wrong-dyn-trait-generic.rs
new file mode 100644
index 0000000000000..9b1cefc4b1d3d
--- /dev/null
+++ b/src/tools/miri/tests/fail/validity/wrong-dyn-trait-generic.rs
@@ -0,0 +1,12 @@
+use std::mem;
+
+// Make sure we notice the mismatch also if the difference is "only" in the generic
+// parameters of the trait.
+
+trait Trait<T> {}
+impl<T> Trait<T> for T {}
+
+fn main() {
+ let x: &dyn Trait<i32> = &0;
+ let _y: *const dyn Trait<u32> = unsafe { mem::transmute(x) }; //~ERROR: wrong trait
+}
diff --git a/src/tools/miri/tests/fail/validity/wrong-dyn-trait-generic.stderr b/src/tools/miri/tests/fail/validity/wrong-dyn-trait-generic.stderr
new file mode 100644
index 0000000000000..1219f9f88cf8c
--- /dev/null
+++ b/src/tools/miri/tests/fail/validity/wrong-dyn-trait-generic.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: constructing invalid value: wrong trait in wide pointer vtable: expected `Trait<u32>`, but encountered `Trait<i32>`
+ --> $DIR/wrong-dyn-trait-generic.rs:LL:CC
+ |
+LL | let _y: *const dyn Trait<u32> = unsafe { mem::transmute(x) };
+ | ^^^^^^^^^^^^^^^^^ constructing invalid value: wrong trait in wide pointer vtable: expected `Trait<u32>`, but encountered `Trait<i32>`
+ |
+ = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+ = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+ = note: BACKTRACE:
+ = note: inside `main` at $DIR/wrong-dyn-trait-generic.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/fail/validity/wrong-dyn-trait.rs b/src/tools/miri/tests/fail/validity/wrong-dyn-trait.rs
new file mode 100644
index 0000000000000..d6049196f2662
--- /dev/null
+++ b/src/tools/miri/tests/fail/validity/wrong-dyn-trait.rs
@@ -0,0 +1,6 @@
+use std::{fmt, mem};
+
+fn main() {
+ let x: &dyn Send = &0;
+ let _y: *const dyn fmt::Debug = unsafe { mem::transmute(x) }; //~ERROR: wrong trait
+}
diff --git a/src/tools/miri/tests/fail/validity/wrong-dyn-trait.stderr b/src/tools/miri/tests/fail/validity/wrong-dyn-trait.stderr
new file mode 100644
index 0000000000000..e3503323b31a7
--- /dev/null
+++ b/src/tools/miri/tests/fail/validity/wrong-dyn-trait.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: constructing invalid value: wrong trait in wide pointer vtable: expected `std::fmt::Debug`, but encountered `<trivial>`
+ --> $DIR/wrong-dyn-trait.rs:LL:CC
+ |
+LL | let _y: *const dyn fmt::Debug = unsafe { mem::transmute(x) };
+ | ^^^^^^^^^^^^^^^^^ constructing invalid value: wrong trait in wide pointer vtable: expected `std::fmt::Debug`, but encountered `<trivial>`
+ |
+ = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+ = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+ = note: BACKTRACE:
+ = note: inside `main` at $DIR/wrong-dyn-trait.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/pass/cast-rfc0401-vtable-kinds.rs b/src/tools/miri/tests/pass/cast-rfc0401-vtable-kinds.rs
index 2491bda0917d3..adbf5df62cc5d 100644
--- a/src/tools/miri/tests/pass/cast-rfc0401-vtable-kinds.rs
+++ b/src/tools/miri/tests/pass/cast-rfc0401-vtable-kinds.rs
@@ -25,7 +25,7 @@ impl Foo<u32> for u32 {
impl Bar for () {}
unsafe fn round_trip_and_call<'a>(t: *const (dyn Foo<u32> + 'a)) -> u32 {
- let foo_e: *const dyn Foo<u16> = t as *const _;
+ let foo_e: *const dyn Foo<u32> = t as *const _;
let r_1 = foo_e as *mut dyn Foo<u32>;
(&*r_1).foo(0)
diff --git a/src/tools/miri/tests/pass/coroutine.rs b/src/tools/miri/tests/pass/coroutine.rs
index 7e1f64df04d4c..e76abfc4185de 100644
--- a/src/tools/miri/tests/pass/coroutine.rs
+++ b/src/tools/miri/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,9 +43,9 @@ fn basic() {
panic!()
}
- finish(1, false, || yield 1);
+ finish(1, false, #[coroutine] || yield 1);
- finish(3, false, || {
+ finish(3, false, #[coroutine] || {
let mut x = 0;
yield 1;
x += 1;
@@ -55,27 +55,27 @@ fn basic() {
assert_eq!(x, 2);
});
- finish(7 * 8 / 2, false, || {
+ finish(7 * 8 / 2, false, #[coroutine] || {
for i in 0..8 {
yield i;
}
});
- finish(1, false, || {
+ finish(1, false, #[coroutine] || {
if true {
yield 1;
} else {
}
});
- finish(1, false, || {
+ finish(1, false, #[coroutine] || {
if false {
} else {
yield 1;
}
});
- finish(2, false, || {
+ finish(2, false, #[coroutine] || {
if {
yield 1;
false
@@ -88,7 +88,7 @@ fn basic() {
// also test self-referential coroutines
assert_eq!(
- finish(5, true, static || {
+ finish(5, true, #[coroutine] static || {
let mut x = 5;
let y = &mut x;
*y = 5;
@@ -99,7 +99,7 @@ fn basic() {
10
);
assert_eq!(
- finish(5, true, || {
+ finish(5, true, #[coroutine] || {
let mut x = Box::new(5);
let y = &mut *x;
*y = 5;
@@ -111,7 +111,7 @@ fn basic() {
);
let b = true;
- finish(1, false, || {
+ finish(1, false, #[coroutine] || {
yield 1;
if b {
return;
@@ -123,7 +123,7 @@ fn basic() {
drop(x);
});
- finish(3, false, || {
+ finish(3, false, #[coroutine] || {
yield 1;
#[allow(unreachable_code)]
let _x: (String, !) = (String::new(), {
@@ -172,7 +172,7 @@ fn smoke_resume_arg() {
}
drain(
- &mut |mut b| {
+ &mut #[coroutine] |mut b| {
while b != 0 {
b = yield (b + 1);
}
@@ -181,21 +181,21 @@ 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 +205,7 @@ 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 +228,7 @@ 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/src/tools/miri/tests/pass/dyn-upcast.rs b/src/tools/miri/tests/pass/dyn-upcast.rs
index 529b9c471d426..ddc4bdcf082a8 100644
--- a/src/tools/miri/tests/pass/dyn-upcast.rs
+++ b/src/tools/miri/tests/pass/dyn-upcast.rs
@@ -1,24 +1,26 @@
#![feature(trait_upcasting)]
#![allow(incomplete_features)]
+use std::fmt;
+
fn main() {
basic();
diamond();
struct_();
replace_vptr();
- vtable_mismatch_nop_cast();
+ vtable_nop_cast();
}
-fn vtable_mismatch_nop_cast() {
- let ptr: &dyn std::fmt::Display = &0;
- // Even though the vtable is for the wrong trait, this cast doesn't actually change the needed
- // vtable so it should still be allowed.
- let ptr: *const (dyn std::fmt::Debug + Send + Sync) = unsafe { std::mem::transmute(ptr) };
- let _ptr2 = ptr as *const dyn std::fmt::Debug;
+fn vtable_nop_cast() {
+ let ptr: &dyn fmt::Debug = &0;
+ // We transmute things around, but the principal trait does not change, so this is allowed.
+ let ptr: *const (dyn fmt::Debug + Send + Sync) = unsafe { std::mem::transmute(ptr) };
+ // This cast is a NOP and should be allowed.
+ let _ptr2 = ptr as *const dyn fmt::Debug;
}
fn basic() {
- trait Foo: PartialEq<i32> + std::fmt::Debug + Send + Sync {
+ trait Foo: PartialEq<i32> + fmt::Debug + Send + Sync {
fn a(&self) -> i32 {
10
}
@@ -67,7 +69,7 @@ fn basic() {
}
let baz: &dyn Baz = &1;
- let _: &dyn std::fmt::Debug = baz;
+ let _: &dyn fmt::Debug = baz;
assert_eq!(*baz, 1);
assert_eq!(baz.a(), 100);
assert_eq!(baz.b(), 200);
@@ -77,7 +79,7 @@ fn basic() {
assert_eq!(baz.w(), 21);
let bar: &dyn Bar = baz;
- let _: &dyn std::fmt::Debug = bar;
+ let _: &dyn fmt::Debug = bar;
assert_eq!(*bar, 1);
assert_eq!(bar.a(), 100);
assert_eq!(bar.b(), 200);
@@ -86,14 +88,14 @@ fn basic() {
assert_eq!(bar.w(), 21);
let foo: &dyn Foo = baz;
- let _: &dyn std::fmt::Debug = foo;
+ let _: &dyn fmt::Debug = foo;
assert_eq!(*foo, 1);
assert_eq!(foo.a(), 100);
assert_eq!(foo.z(), 11);
assert_eq!(foo.y(), 12);
let foo: &dyn Foo = bar;
- let _: &dyn std::fmt::Debug = foo;
+ let _: &dyn fmt::Debug = foo;
assert_eq!(*foo, 1);
assert_eq!(foo.a(), 100);
assert_eq!(foo.z(), 11);
@@ -101,7 +103,7 @@ fn basic() {
}
fn diamond() {
- trait Foo: PartialEq<i32> + std::fmt::Debug + Send + Sync {
+ trait Foo: PartialEq<i32> + fmt::Debug + Send + Sync {
fn a(&self) -> i32 {
10
}
@@ -166,7 +168,7 @@ fn diamond() {
}
let baz: &dyn Baz = &1;
- let _: &dyn std::fmt::Debug = baz;
+ let _: &dyn fmt::Debug = baz;
assert_eq!(*baz, 1);
assert_eq!(baz.a(), 100);
assert_eq!(baz.b(), 200);
@@ -178,7 +180,7 @@ fn diamond() {
assert_eq!(baz.v(), 31);
let bar1: &dyn Bar1 = baz;
- let _: &dyn std::fmt::Debug = bar1;
+ let _: &dyn fmt::Debug = bar1;
assert_eq!(*bar1, 1);
assert_eq!(bar1.a(), 100);
assert_eq!(bar1.b(), 200);
@@ -187,7 +189,7 @@ fn diamond() {
assert_eq!(bar1.w(), 21);
let bar2: &dyn Bar2 = baz;
- let _: &dyn std::fmt::Debug = bar2;
+ let _: &dyn fmt::Debug = bar2;
assert_eq!(*bar2, 1);
assert_eq!(bar2.a(), 100);
assert_eq!(bar2.c(), 300);
@@ -196,17 +198,17 @@ fn diamond() {
assert_eq!(bar2.v(), 31);
let foo: &dyn Foo = baz;
- let _: &dyn std::fmt::Debug = foo;
+ let _: &dyn fmt::Debug = foo;
assert_eq!(*foo, 1);
assert_eq!(foo.a(), 100);
let foo: &dyn Foo = bar1;
- let _: &dyn std::fmt::Debug = foo;
+ let _: &dyn fmt::Debug = foo;
assert_eq!(*foo, 1);
assert_eq!(foo.a(), 100);
let foo: &dyn Foo = bar2;
- let _: &dyn std::fmt::Debug = foo;
+ let _: &dyn fmt::Debug = foo;
assert_eq!(*foo, 1);
assert_eq!(foo.a(), 100);
}
@@ -215,7 +217,7 @@ fn struct_() {
use std::rc::Rc;
use std::sync::Arc;
- trait Foo: PartialEq<i32> + std::fmt::Debug + Send + Sync {
+ trait Foo: PartialEq<i32> + fmt::Debug + Send + Sync {
fn a(&self) -> i32 {
10
}
diff --git a/src/tools/miri/tests/pass/portable-simd.rs b/src/tools/miri/tests/pass/portable-simd.rs
index cdb441b450b36..1fc713d48dcc4 100644
--- a/src/tools/miri/tests/pass/portable-simd.rs
+++ b/src/tools/miri/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/src/tools/miri/tests/pass/stacked-borrows/coroutine-self-referential.rs b/src/tools/miri/tests/pass/stacked-borrows/coroutine-self-referential.rs
index c4b15c8758bef..bb98e024a0a1a 100644
--- a/src/tools/miri/tests/pass/stacked-borrows/coroutine-self-referential.rs
+++ b/src/tools/miri/tests/pass/stacked-borrows/coroutine-self-referential.rs
@@ -1,6 +1,6 @@
// 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},
@@ -8,7 +8,7 @@ use std::{
};
fn firstn() -> impl Coroutine<Yield = u64, Return = ()> {
- static move || {
+ #[coroutine] static move || {
let mut num = 0;
let num = &mut num;
diff --git a/src/tools/miri/tests/pass/track-caller-attribute.rs b/src/tools/miri/tests/pass/track-caller-attribute.rs
index d88bcc98858f5..c3803af3cc8ec 100644
--- a/src/tools/miri/tests/pass/track-caller-attribute.rs
+++ b/src/tools/miri/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,7 +255,7 @@ 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,
@@ -263,7 +263,7 @@ fn test_coroutine() {
};
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() {
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs b/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs
index d50088e6cf1d9..c92d4e78ffa71 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs
@@ -3869,7 +3869,7 @@ use std::ops::{Coroutine, CoroutineState};
use std::pin::Pin;
fn main() {
- let mut coroutine = || {
+ let mut coroutine = #[coroutine] || {
yield 1;
return "foo"
};
@@ -3901,7 +3901,7 @@ use std::ops::Coroutine;
use std::pin::Pin;
fn main() {
- let mut coroutine = || {
+ let mut coroutine = #[coroutine] || {
println!("2");
yield;
println!("4");
@@ -4007,7 +4007,7 @@ use std::pin::Pin;
fn main() {
let ret = "foo";
- let mut coroutine = move || {
+ let mut coroutine = #[coroutine] move || {
yield 1;
return ret
};
diff --git a/src/tools/rustfmt/tests/source/immovable_coroutines.rs b/src/tools/rustfmt/tests/source/immovable_coroutines.rs
index 3b94af0c96ce4..539049577a00e 100644
--- a/src/tools/rustfmt/tests/source/immovable_coroutines.rs
+++ b/src/tools/rustfmt/tests/source/immovable_coroutines.rs
@@ -1,7 +1,8 @@
#![feature(coroutines)]
unsafe fn foo() {
- let mut ga = static || {
+ let mut ga = #[coroutine]
+ static || {
yield 1;
};
}
diff --git a/src/tools/rustfmt/tests/target/immovable_coroutines.rs b/src/tools/rustfmt/tests/target/immovable_coroutines.rs
index f52cfa00f9783..539049577a00e 100644
--- a/src/tools/rustfmt/tests/target/immovable_coroutines.rs
+++ b/src/tools/rustfmt/tests/target/immovable_coroutines.rs
@@ -1,7 +1,8 @@
#![feature(coroutines)]
unsafe fn foo() {
- let mut ga = static || {
+ let mut ga = #[coroutine]
+ static || {
yield 1;
};
}
diff --git a/tests/codegen/const_scalar_pair.rs b/tests/codegen/const_scalar_pair.rs
index 0aa430a8efa08..f142896c31f19 100644
--- a/tests/codegen/const_scalar_pair.rs
+++ b/tests/codegen/const_scalar_pair.rs
@@ -1,7 +1,5 @@
//@ compile-flags: --crate-type=lib -Copt-level=0 -Zmir-opt-level=0 -C debuginfo=2
-#![feature(inline_const)]
-
// Test that we don't generate a memory allocation for the constant
// and read the fields from that, but instead just create the value pair directly.
pub fn foo() -> (i32, i32) {
diff --git a/tests/codegen/coroutine-debug-msvc.rs b/tests/codegen/coroutine-debug-msvc.rs
index fb1b46fe497f1..f8adb35478621 100644
--- a/tests/codegen/coroutine-debug-msvc.rs
+++ b/tests/codegen/coroutine-debug-msvc.rs
@@ -11,6 +11,7 @@
use std::ops::Coroutine;
fn coroutine_test() -> impl Coroutine<Yield = i32, Return = ()> {
+ #[coroutine]
|| {
yield 0;
let s = String::from("foo");
diff --git a/tests/codegen/coroutine-debug.rs b/tests/codegen/coroutine-debug.rs
index 7eaee669559e4..914515f58b85c 100644
--- a/tests/codegen/coroutine-debug.rs
+++ b/tests/codegen/coroutine-debug.rs
@@ -11,7 +11,7 @@
use std::ops::Coroutine;
fn coroutine_test() -> impl Coroutine<Yield = i32, Return = ()> {
- || {
+ #[coroutine] || {
yield 0;
let s = String::from("foo");
yield 1;
diff --git a/tests/codegen/intrinsics/transmute.rs b/tests/codegen/intrinsics/transmute.rs
index f858562b5f11d..f8ac1e2ab15d1 100644
--- a/tests/codegen/intrinsics/transmute.rs
+++ b/tests/codegen/intrinsics/transmute.rs
@@ -4,7 +4,6 @@
#![crate_type = "lib"]
#![feature(core_intrinsics)]
#![feature(custom_mir)]
-#![feature(inline_const)]
#![allow(unreachable_code)]
use std::intrinsics::{transmute, transmute_unchecked};
diff --git a/tests/codegen/issues/issue-96274.rs b/tests/codegen/issues/issue-96274.rs
index d278796dd02af..ffefd5f43f8ca 100644
--- a/tests/codegen/issues/issue-96274.rs
+++ b/tests/codegen/issues/issue-96274.rs
@@ -1,7 +1,6 @@
//@ compile-flags: -O
#![crate_type = "lib"]
-#![feature(inline_const)]
use std::mem::MaybeUninit;
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs
index ca781a99296be..6c3d991af9f14 100644
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs
+++ b/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs
@@ -5,7 +5,7 @@
//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
#![crate_type="lib"]
-#![feature(inline_const, type_alias_impl_trait)]
+#![feature(type_alias_impl_trait)]
extern crate core;
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs
index 488be2a8629dd..c416f4d28bb53 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs
@@ -4,7 +4,6 @@
#![crate_type = "lib"]
#![allow(non_camel_case_types)]
#![feature(repr_simd, intrinsics)]
-#![feature(inline_const)]
#[repr(simd)]
#[derive(Copy, Clone)]
diff --git a/tests/coverage/coroutine.cov-map b/tests/coverage/coroutine.cov-map
index ef9faab590b33..255708d365ee4 100644
--- a/tests/coverage/coroutine.cov-map
+++ b/tests/coverage/coroutine.cov-map
@@ -43,11 +43,11 @@ Number of file 0 mappings: 9
= ((c4 - c5) - c6)
Function name: coroutine::main::{closure#0}
-Raw bytes (14): 0x[01, 01, 00, 02, 01, 15, 1c, 01, 1f, 05, 02, 10, 01, 06]
+Raw bytes (14): 0x[01, 01, 00, 02, 01, 15, 29, 01, 1f, 05, 02, 10, 01, 06]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 21, 28) to (start + 1, 31)
+- Code(Counter(0)) at (prev + 21, 41) to (start + 1, 31)
- Code(Counter(1)) at (prev + 2, 16) to (start + 1, 6)
diff --git a/tests/coverage/coroutine.rs b/tests/coverage/coroutine.rs
index 2aa689466fc3e..7f72e0d8bd424 100644
--- a/tests/coverage/coroutine.rs
+++ b/tests/coverage/coroutine.rs
@@ -1,4 +1,4 @@
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::{Coroutine, CoroutineState};
use std::pin::Pin;
@@ -18,7 +18,7 @@ fn get_u32(val: bool) -> Result<u32, String> {
fn main() {
let is_true = std::env::args().len() == 1;
- let mut coroutine = || {
+ let mut coroutine = #[coroutine] || {
yield get_u32(is_true);
return "foo";
};
diff --git a/tests/coverage/yield.cov-map b/tests/coverage/yield.cov-map
index 9cc67dfe88ac4..a273c688e248a 100644
--- a/tests/coverage/yield.cov-map
+++ b/tests/coverage/yield.cov-map
@@ -1,5 +1,5 @@
Function name: yield::main
-Raw bytes (106): 0x[01, 01, 0b, 05, 00, 0d, 11, 22, 15, 0d, 11, 11, 15, 22, 15, 0d, 11, 22, 15, 0d, 11, 19, 1d, 25, 29, 10, 01, 07, 01, 01, 16, 01, 06, 0b, 00, 2e, 0d, 01, 27, 00, 29, 03, 01, 0e, 00, 34, 0d, 02, 0b, 00, 2e, 22, 01, 22, 00, 27, 1e, 00, 2c, 00, 2e, 13, 01, 0e, 00, 34, 1e, 03, 09, 00, 16, 1e, 07, 0b, 00, 2e, 21, 01, 27, 00, 29, 27, 01, 0e, 00, 34, 21, 02, 0b, 00, 2e, 2d, 01, 27, 00, 29, 2b, 01, 0e, 00, 34, 2d, 02, 01, 00, 02]
+Raw bytes (106): 0x[01, 01, 0b, 05, 00, 0d, 11, 22, 15, 0d, 11, 11, 15, 22, 15, 0d, 11, 22, 15, 0d, 11, 19, 1d, 25, 29, 10, 01, 07, 01, 01, 16, 01, 07, 0b, 00, 2e, 0d, 01, 27, 00, 29, 03, 01, 0e, 00, 34, 0d, 02, 0b, 00, 2e, 22, 01, 22, 00, 27, 1e, 00, 2c, 00, 2e, 13, 01, 0e, 00, 34, 1e, 03, 09, 00, 16, 1e, 08, 0b, 00, 2e, 21, 01, 27, 00, 29, 27, 01, 0e, 00, 34, 21, 02, 0b, 00, 2e, 2d, 01, 27, 00, 29, 2b, 01, 0e, 00, 34, 2d, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 11
@@ -16,7 +16,7 @@ Number of expressions: 11
- expression 10 operands: lhs = Counter(9), rhs = Counter(10)
Number of file 0 mappings: 16
- Code(Counter(0)) at (prev + 7, 1) to (start + 1, 22)
-- Code(Counter(0)) at (prev + 6, 11) to (start + 0, 46)
+- Code(Counter(0)) at (prev + 7, 11) to (start + 0, 46)
- Code(Counter(3)) at (prev + 1, 39) to (start + 0, 41)
- Code(Expression(0, Add)) at (prev + 1, 14) to (start + 0, 52)
= (c1 + Zero)
@@ -29,7 +29,7 @@ Number of file 0 mappings: 16
= (c4 + c5)
- Code(Expression(7, Sub)) at (prev + 3, 9) to (start + 0, 22)
= ((c3 - c4) - c5)
-- Code(Expression(7, Sub)) at (prev + 7, 11) to (start + 0, 46)
+- Code(Expression(7, Sub)) at (prev + 8, 11) to (start + 0, 46)
= ((c3 - c4) - c5)
- Code(Counter(8)) at (prev + 1, 39) to (start + 0, 41)
- Code(Expression(9, Add)) at (prev + 1, 14) to (start + 0, 52)
@@ -41,21 +41,21 @@ Number of file 0 mappings: 16
- Code(Counter(11)) at (prev + 2, 1) to (start + 0, 2)
Function name: yield::main::{closure#0}
-Raw bytes (14): 0x[01, 01, 00, 02, 01, 08, 1c, 01, 10, 05, 02, 10, 01, 06]
+Raw bytes (14): 0x[01, 01, 00, 02, 01, 09, 08, 01, 10, 05, 02, 10, 01, 06]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 8, 28) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 9, 8) to (start + 1, 16)
- Code(Counter(1)) at (prev + 2, 16) to (start + 1, 6)
Function name: yield::main::{closure#1}
-Raw bytes (24): 0x[01, 01, 00, 04, 01, 16, 1c, 01, 10, 05, 02, 09, 00, 10, 09, 01, 09, 00, 10, 0d, 01, 10, 01, 06]
+Raw bytes (24): 0x[01, 01, 00, 04, 01, 18, 08, 01, 10, 05, 02, 09, 00, 10, 09, 01, 09, 00, 10, 0d, 01, 10, 01, 06]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 22, 28) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 24, 8) to (start + 1, 16)
- Code(Counter(1)) at (prev + 2, 9) to (start + 0, 16)
- Code(Counter(2)) at (prev + 1, 9) to (start + 0, 16)
- Code(Counter(3)) at (prev + 1, 16) to (start + 1, 6)
diff --git a/tests/coverage/yield.rs b/tests/coverage/yield.rs
index b7e2ba31b59c1..e02e3d3561243 100644
--- a/tests/coverage/yield.rs
+++ b/tests/coverage/yield.rs
@@ -1,11 +1,12 @@
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
#![allow(unused_assignments)]
use std::ops::{Coroutine, CoroutineState};
use std::pin::Pin;
fn main() {
- let mut coroutine = || {
+ let mut coroutine = #[coroutine]
+ || {
yield 1;
return "foo";
};
@@ -19,7 +20,8 @@ fn main() {
_ => panic!("unexpected value from resume"),
}
- let mut coroutine = || {
+ let mut coroutine = #[coroutine]
+ || {
yield 1;
yield 2;
yield 3;
diff --git a/tests/debuginfo/coroutine-locals.rs b/tests/debuginfo/coroutine-locals.rs
index 54b5cd577c8b9..c019998040b93 100644
--- a/tests/debuginfo/coroutine-locals.rs
+++ b/tests/debuginfo/coroutine-locals.rs
@@ -46,7 +46,7 @@
// lldb-command:v c
// lldb-check:(int) c = 6
-#![feature(omit_gdb_pretty_printer_section, coroutines, coroutine_trait)]
+#![feature(omit_gdb_pretty_printer_section, coroutines, coroutine_trait, stmt_expr_attributes)]
#![omit_gdb_pretty_printer_section]
use std::ops::Coroutine;
@@ -54,7 +54,8 @@ use std::pin::Pin;
fn main() {
let mut a = 5;
- let mut b = || {
+ let mut b = #[coroutine]
+ || {
let c = 6; // Live across multiple yield points
let d = 7; // Live across only one yield point
@@ -76,4 +77,6 @@ fn main() {
_zzz(); // #break
}
-fn _zzz() {()}
+fn _zzz() {
+ ()
+}
diff --git a/tests/debuginfo/coroutine-objects.rs b/tests/debuginfo/coroutine-objects.rs
index 9e1bd5d62e7a1..e13f20455a864 100644
--- a/tests/debuginfo/coroutine-objects.rs
+++ b/tests/debuginfo/coroutine-objects.rs
@@ -63,7 +63,7 @@
// cdb-check: b : Returned [Type: enum2$<coroutine_objects::main::coroutine_env$0>]
// cdb-check: [+0x[...]] _ref__a : 0x[...] : 6 [Type: int *]
-#![feature(omit_gdb_pretty_printer_section, coroutines, coroutine_trait)]
+#![feature(omit_gdb_pretty_printer_section, coroutines, coroutine_trait, stmt_expr_attributes)]
#![omit_gdb_pretty_printer_section]
use std::ops::Coroutine;
@@ -71,7 +71,8 @@ use std::pin::Pin;
fn main() {
let mut a = 5;
- let mut b = || {
+ let mut b = #[coroutine]
+ || {
let mut c = 6;
let mut d = 7;
diff --git a/tests/debuginfo/function-names.rs b/tests/debuginfo/function-names.rs
index 1e4be43244554..2b0c2593676b4 100644
--- a/tests/debuginfo/function-names.rs
+++ b/tests/debuginfo/function-names.rs
@@ -83,7 +83,7 @@
#![allow(unused_variables)]
#![feature(omit_gdb_pretty_printer_section)]
#![omit_gdb_pretty_printer_section]
-#![feature(adt_const_params, coroutines, coroutine_trait)]
+#![feature(adt_const_params, coroutines, coroutine_trait, stmt_expr_attributes)]
#![allow(incomplete_features)]
use std::ops::Coroutine;
@@ -111,7 +111,8 @@ fn main() {
closure();
// Coroutine
- let mut coroutine = || {
+ let mut coroutine = #[coroutine]
+ || {
yield;
return;
};
diff --git a/tests/debuginfo/issue-57822.rs b/tests/debuginfo/issue-57822.rs
index 93e1a2558f693..995779a6a9ca8 100644
--- a/tests/debuginfo/issue-57822.rs
+++ b/tests/debuginfo/issue-57822.rs
@@ -26,7 +26,7 @@
// lldb-command:v b
// lldbg-check:(issue_57822::main::{coroutine_env#3}) b =
-#![feature(omit_gdb_pretty_printer_section, coroutines, coroutine_trait)]
+#![feature(omit_gdb_pretty_printer_section, coroutines, coroutine_trait, stmt_expr_attributes)]
#![omit_gdb_pretty_printer_section]
use std::ops::Coroutine;
@@ -38,11 +38,13 @@ fn main() {
let g = move || f();
let mut y = 2;
- let mut a = move || {
+ let mut a = #[coroutine]
+ move || {
y += 1;
yield;
};
- let mut b = move || {
+ let mut b = #[coroutine]
+ move || {
Pin::new(&mut a).resume(());
yield;
};
diff --git a/tests/mir-opt/building/custom/arrays.rs b/tests/mir-opt/building/custom/arrays.rs
index fe6abc546879c..e9a53b7aacb76 100644
--- a/tests/mir-opt/building/custom/arrays.rs
+++ b/tests/mir-opt/building/custom/arrays.rs
@@ -1,5 +1,5 @@
// skip-filecheck
-#![feature(custom_mir, core_intrinsics, inline_const)]
+#![feature(custom_mir, core_intrinsics)]
extern crate core;
use core::intrinsics::mir::*;
diff --git a/tests/mir-opt/building/custom/consts.rs b/tests/mir-opt/building/custom/consts.rs
index 42abf5019e559..1a410177fa549 100644
--- a/tests/mir-opt/building/custom/consts.rs
+++ b/tests/mir-opt/building/custom/consts.rs
@@ -1,5 +1,5 @@
// skip-filecheck
-#![feature(custom_mir, core_intrinsics, inline_const)]
+#![feature(custom_mir, core_intrinsics)]
extern crate core;
use core::intrinsics::mir::*;
diff --git a/tests/mir-opt/building/custom/operators.rs b/tests/mir-opt/building/custom/operators.rs
index bc72ed8dfe393..eb97bcc73b7e1 100644
--- a/tests/mir-opt/building/custom/operators.rs
+++ b/tests/mir-opt/building/custom/operators.rs
@@ -1,6 +1,6 @@
// skip-filecheck
//@ compile-flags: --crate-type=lib
-#![feature(custom_mir, core_intrinsics, inline_const)]
+#![feature(custom_mir, core_intrinsics)]
use std::intrinsics::mir::*;
// EMIT_MIR operators.f.built.after.mir
diff --git a/tests/mir-opt/const_prop/invalid_constant.rs b/tests/mir-opt/const_prop/invalid_constant.rs
index afd8746af5fb4..2b7271f63ff2f 100644
--- a/tests/mir-opt/const_prop/invalid_constant.rs
+++ b/tests/mir-opt/const_prop/invalid_constant.rs
@@ -4,7 +4,6 @@
// Verify that we can pretty print invalid constants.
#![feature(adt_const_params)]
-#![feature(inline_const)]
#![allow(incomplete_features)]
#[derive(Copy, Clone)]
diff --git a/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-abort.mir b/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-abort.mir
index 7214b01c60164..7e033916fd348 100644
--- a/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-abort.mir
+++ b/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-abort.mir
@@ -1,6 +1,6 @@
// MIR for `main::{closure#0}` 0 coroutine_drop
-fn main::{closure#0}(_1: *mut {coroutine@$DIR/coroutine_drop_cleanup.rs:11:15: 11:17}) -> () {
+fn main::{closure#0}(_1: *mut {coroutine@$DIR/coroutine_drop_cleanup.rs:12:5: 12:7}) -> () {
let mut _0: ();
let mut _2: ();
let _3: std::string::String;
diff --git a/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-unwind.mir b/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-unwind.mir
index 00769a493b5a1..613ef2909b5e4 100644
--- a/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-unwind.mir
+++ b/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-unwind.mir
@@ -1,6 +1,6 @@
// MIR for `main::{closure#0}` 0 coroutine_drop
-fn main::{closure#0}(_1: *mut {coroutine@$DIR/coroutine_drop_cleanup.rs:11:15: 11:17}) -> () {
+fn main::{closure#0}(_1: *mut {coroutine@$DIR/coroutine_drop_cleanup.rs:12:5: 12:7}) -> () {
let mut _0: ();
let mut _2: ();
let _3: std::string::String;
diff --git a/tests/mir-opt/coroutine_drop_cleanup.rs b/tests/mir-opt/coroutine_drop_cleanup.rs
index 69984c737fed6..33fdd2dd0d9cb 100644
--- a/tests/mir-opt/coroutine_drop_cleanup.rs
+++ b/tests/mir-opt/coroutine_drop_cleanup.rs
@@ -1,5 +1,5 @@
// skip-filecheck
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
@@ -8,7 +8,8 @@
// EMIT_MIR coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.mir
fn main() {
- let gen = || {
+ let gen = #[coroutine]
+ || {
let _s = String::new();
yield;
};
diff --git a/tests/mir-opt/coroutine_storage_dead_unwind.main-{closure#0}.StateTransform.before.panic-abort.mir b/tests/mir-opt/coroutine_storage_dead_unwind.main-{closure#0}.StateTransform.before.panic-abort.mir
index 8369a3e60dd9a..4731aed335d9f 100644
--- a/tests/mir-opt/coroutine_storage_dead_unwind.main-{closure#0}.StateTransform.before.panic-abort.mir
+++ b/tests/mir-opt/coroutine_storage_dead_unwind.main-{closure#0}.StateTransform.before.panic-abort.mir
@@ -1,6 +1,6 @@
// MIR for `main::{closure#0}` before StateTransform
-fn main::{closure#0}(_1: {coroutine@$DIR/coroutine_storage_dead_unwind.rs:23:16: 23:18}, _2: ()) -> ()
+fn main::{closure#0}(_1: {coroutine@$DIR/coroutine_storage_dead_unwind.rs:24:5: 24:7}, _2: ()) -> ()
yields ()
{
let mut _0: ();
diff --git a/tests/mir-opt/coroutine_storage_dead_unwind.main-{closure#0}.StateTransform.before.panic-unwind.mir b/tests/mir-opt/coroutine_storage_dead_unwind.main-{closure#0}.StateTransform.before.panic-unwind.mir
index 1773db1abffe3..14e1782b86016 100644
--- a/tests/mir-opt/coroutine_storage_dead_unwind.main-{closure#0}.StateTransform.before.panic-unwind.mir
+++ b/tests/mir-opt/coroutine_storage_dead_unwind.main-{closure#0}.StateTransform.before.panic-unwind.mir
@@ -1,6 +1,6 @@
// MIR for `main::{closure#0}` before StateTransform
-fn main::{closure#0}(_1: {coroutine@$DIR/coroutine_storage_dead_unwind.rs:23:16: 23:18}, _2: ()) -> ()
+fn main::{closure#0}(_1: {coroutine@$DIR/coroutine_storage_dead_unwind.rs:24:5: 24:7}, _2: ()) -> ()
yields ()
{
let mut _0: ();
diff --git a/tests/mir-opt/coroutine_storage_dead_unwind.rs b/tests/mir-opt/coroutine_storage_dead_unwind.rs
index 253be1ff698d1..ce9bad483af83 100644
--- a/tests/mir-opt/coroutine_storage_dead_unwind.rs
+++ b/tests/mir-opt/coroutine_storage_dead_unwind.rs
@@ -6,7 +6,7 @@
// Basic block and local names can safely change, but the StorageDead statements
// should not go away.
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
struct Foo(i32);
@@ -20,7 +20,8 @@ fn take<T>(_x: T) {}
// EMIT_MIR coroutine_storage_dead_unwind.main-{closure#0}.StateTransform.before.mir
fn main() {
- let _gen = || {
+ let _gen = #[coroutine]
+ || {
let a = Foo(5);
let b = Bar(6);
yield;
diff --git a/tests/mir-opt/coroutine_tiny.main-{closure#0}.coroutine_resume.0.mir b/tests/mir-opt/coroutine_tiny.main-{closure#0}.coroutine_resume.0.mir
index 165aa3a05cb7d..f8b3f68d21e63 100644
--- a/tests/mir-opt/coroutine_tiny.main-{closure#0}.coroutine_resume.0.mir
+++ b/tests/mir-opt/coroutine_tiny.main-{closure#0}.coroutine_resume.0.mir
@@ -4,7 +4,7 @@
_0: CoroutineSavedTy {
ty: HasDrop,
source_info: SourceInfo {
- span: $DIR/coroutine_tiny.rs:21:13: 21:15 (#0),
+ span: $DIR/coroutine_tiny.rs:22:13: 22:15 (#0),
scope: scope[0],
},
ignore_for_traits: false,
@@ -21,7 +21,7 @@
},
} */
-fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine_tiny.rs:20:16: 20:24}>, _2: u8) -> CoroutineState<(), ()> {
+fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine_tiny.rs:21:5: 21:13}>, _2: u8) -> CoroutineState<(), ()> {
debug _x => _10;
let mut _0: std::ops::CoroutineState<(), ()>;
let _3: HasDrop;
@@ -34,18 +34,18 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine_tiny.rs:20:16: 20:24
let _10: u8;
let mut _11: u32;
scope 1 {
- debug _d => (((*(_1.0: &mut {coroutine@$DIR/coroutine_tiny.rs:20:16: 20:24})) as variant#3).0: HasDrop);
+ debug _d => (((*(_1.0: &mut {coroutine@$DIR/coroutine_tiny.rs:21:5: 21:13})) as variant#3).0: HasDrop);
}
bb0: {
- _11 = discriminant((*(_1.0: &mut {coroutine@$DIR/coroutine_tiny.rs:20:16: 20:24})));
+ _11 = discriminant((*(_1.0: &mut {coroutine@$DIR/coroutine_tiny.rs:21:5: 21:13})));
switchInt(move _11) -> [0: bb1, 3: bb5, otherwise: bb6];
}
bb1: {
_10 = move _2;
nop;
- (((*(_1.0: &mut {coroutine@$DIR/coroutine_tiny.rs:20:16: 20:24})) as variant#3).0: HasDrop) = HasDrop;
+ (((*(_1.0: &mut {coroutine@$DIR/coroutine_tiny.rs:21:5: 21:13})) as variant#3).0: HasDrop) = HasDrop;
StorageLive(_4);
goto -> bb2;
}
@@ -58,7 +58,7 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine_tiny.rs:20:16: 20:24
StorageDead(_4);
StorageDead(_6);
StorageDead(_7);
- discriminant((*(_1.0: &mut {coroutine@$DIR/coroutine_tiny.rs:20:16: 20:24}))) = 3;
+ discriminant((*(_1.0: &mut {coroutine@$DIR/coroutine_tiny.rs:21:5: 21:13}))) = 3;
return;
}
diff --git a/tests/mir-opt/coroutine_tiny.rs b/tests/mir-opt/coroutine_tiny.rs
index 9728425f2326e..81e9940541ba0 100644
--- a/tests/mir-opt/coroutine_tiny.rs
+++ b/tests/mir-opt/coroutine_tiny.rs
@@ -5,7 +5,7 @@
//@ compile-flags: -C panic=abort
//@ no-prefer-dynamic
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
struct HasDrop;
@@ -17,7 +17,8 @@ fn callee() {}
// EMIT_MIR coroutine_tiny.main-{closure#0}.coroutine_resume.0.mir
fn main() {
- let _gen = |_x: u8| {
+ let _gen = #[coroutine]
+ |_x: u8| {
let _d = HasDrop;
loop {
yield;
diff --git a/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-abort.diff
index 859082c311190..07031a298bc36 100644
--- a/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-abort.diff
@@ -4,24 +4,24 @@
fn main() -> () {
let mut _0: ();
let _1: std::ops::CoroutineState<i32, bool>;
- let mut _2: std::pin::Pin<&mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8}>;
- let mut _3: &mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8};
- let mut _4: {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8};
+ let mut _2: std::pin::Pin<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}>;
+ let mut _3: &mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8};
+ let mut _4: {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8};
+ let mut _5: bool;
scope 1 {
debug _r => _1;
}
+ scope 2 (inlined g) {
+ }
-+ scope 3 (inlined Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8}>::new) {
++ scope 3 (inlined Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}>::new) {
+ debug pointer => _3;
-+ scope 4 (inlined Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8}>::new_unchecked) {
++ scope 4 (inlined Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}>::new_unchecked) {
+ debug pointer => _3;
+ }
+ }
+ scope 5 (inlined g::{closure#0}) {
+ debug a => _5;
-+ let mut _6: &mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8};
++ let mut _6: &mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8};
+ let mut _7: u32;
+ let mut _8: i32;
+ }
@@ -32,22 +32,22 @@
StorageLive(_3);
StorageLive(_4);
- _4 = g() -> [return: bb1, unwind unreachable];
-+ _4 = {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8 (#0)};
++ _4 = {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8 (#0)};
+ _3 = &mut _4;
-+ _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8}> { __pointer: _3 };
++ _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}> { __pointer: _3 };
+ StorageDead(_3);
+ StorageLive(_5);
+ _5 = const false;
+ StorageLive(_6);
+ StorageLive(_7);
-+ _6 = (_2.0: &mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8});
++ _6 = (_2.0: &mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8});
+ _7 = discriminant((*_6));
+ switchInt(move _7) -> [0: bb3, 1: bb7, 3: bb8, otherwise: bb9];
}
bb1: {
- _3 = &mut _4;
-- _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8}>::new(move _3) -> [return: bb2, unwind unreachable];
+- _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}>::new(move _3) -> [return: bb2, unwind unreachable];
+ StorageDead(_4);
+ _0 = const ();
+ StorageDead(_1);
@@ -56,7 +56,7 @@
bb2: {
- StorageDead(_3);
-- _1 = <{coroutine@$DIR/inline_coroutine.rs:19:5: 19:8} as Coroutine<bool>>::resume(move _2, const false) -> [return: bb3, unwind unreachable];
+- _1 = <{coroutine@$DIR/inline_coroutine.rs:20:5: 20:8} as Coroutine<bool>>::resume(move _2, const false) -> [return: bb3, unwind unreachable];
+ StorageDead(_7);
+ StorageDead(_6);
+ StorageDead(_5);
diff --git a/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-unwind.diff
index 44b06c34972af..ab6c62b0baf56 100644
--- a/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-unwind.diff
@@ -4,24 +4,24 @@
fn main() -> () {
let mut _0: ();
let _1: std::ops::CoroutineState<i32, bool>;
- let mut _2: std::pin::Pin<&mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8}>;
- let mut _3: &mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8};
- let mut _4: {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8};
+ let mut _2: std::pin::Pin<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}>;
+ let mut _3: &mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8};
+ let mut _4: {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8};
+ let mut _5: bool;
scope 1 {
debug _r => _1;
}
+ scope 2 (inlined g) {
+ }
-+ scope 3 (inlined Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8}>::new) {
++ scope 3 (inlined Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}>::new) {
+ debug pointer => _3;
-+ scope 4 (inlined Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8}>::new_unchecked) {
++ scope 4 (inlined Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}>::new_unchecked) {
+ debug pointer => _3;
+ }
+ }
+ scope 5 (inlined g::{closure#0}) {
+ debug a => _5;
-+ let mut _6: &mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8};
++ let mut _6: &mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8};
+ let mut _7: u32;
+ let mut _8: i32;
+ }
@@ -32,22 +32,22 @@
StorageLive(_3);
StorageLive(_4);
- _4 = g() -> [return: bb1, unwind continue];
-+ _4 = {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8 (#0)};
++ _4 = {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8 (#0)};
+ _3 = &mut _4;
-+ _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8}> { __pointer: _3 };
++ _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}> { __pointer: _3 };
+ StorageDead(_3);
+ StorageLive(_5);
+ _5 = const false;
+ StorageLive(_6);
+ StorageLive(_7);
-+ _6 = (_2.0: &mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8});
++ _6 = (_2.0: &mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8});
+ _7 = discriminant((*_6));
+ switchInt(move _7) -> [0: bb5, 1: bb9, 3: bb10, otherwise: bb11];
}
bb1: {
- _3 = &mut _4;
-- _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:19:5: 19:8}>::new(move _3) -> [return: bb2, unwind: bb5];
+- _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}>::new(move _3) -> [return: bb2, unwind: bb5];
+ StorageDead(_4);
+ _0 = const ();
+ StorageDead(_1);
@@ -56,7 +56,7 @@
- bb2: {
- StorageDead(_3);
-- _1 = <{coroutine@$DIR/inline_coroutine.rs:19:5: 19:8} as Coroutine<bool>>::resume(move _2, const false) -> [return: bb3, unwind: bb5];
+- _1 = <{coroutine@$DIR/inline_coroutine.rs:20:5: 20:8} as Coroutine<bool>>::resume(move _2, const false) -> [return: bb3, unwind: bb5];
+ bb2 (cleanup): {
+ drop(_4) -> [return: bb3, unwind terminate(cleanup)];
}
diff --git a/tests/mir-opt/inline/inline_coroutine.rs b/tests/mir-opt/inline/inline_coroutine.rs
index 180f9d4a6fddd..07f8fb20f7ea2 100644
--- a/tests/mir-opt/inline/inline_coroutine.rs
+++ b/tests/mir-opt/inline/inline_coroutine.rs
@@ -16,5 +16,6 @@ fn main() {
#[inline]
pub fn g() -> impl Coroutine<bool> {
#[inline]
- |a| { yield if a { 7 } else { 13 } }
+ #[coroutine]
+ |a| yield if a { 7 } else { 13 }
}
diff --git a/tests/pretty/stmt_expr_attributes.rs b/tests/pretty/stmt_expr_attributes.rs
index 98ad98b863ac6..01a503ce7eeaf 100644
--- a/tests/pretty/stmt_expr_attributes.rs
+++ b/tests/pretty/stmt_expr_attributes.rs
@@ -1,6 +1,5 @@
//@ pp-exact
-#![feature(inline_const)]
#![feature(inline_const_pat)]
#![feature(rustc_attrs)]
#![feature(stmt_expr_attributes)]
diff --git a/tests/ui/async-await/async-outside-of-await-issue-121096.stderr b/tests/ui/async-await/async-outside-of-await-issue-121096.stderr
index b0677a83864e0..d7caf6b3c0d21 100644
--- a/tests/ui/async-await/async-outside-of-await-issue-121096.stderr
+++ b/tests/ui/async-await/async-outside-of-await-issue-121096.stderr
@@ -2,7 +2,7 @@ error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/async-outside-of-await-issue-121096.rs:7:7
|
LL | fn main() {
- | ---- this is not `async`
+ | --------- this is not `async`
...
LL | }.await
| ^^^^^ only allowed inside `async` functions and blocks
diff --git a/tests/ui/async-await/await-keyword/incorrect-syntax-suggestions.stderr b/tests/ui/async-await/await-keyword/incorrect-syntax-suggestions.stderr
index 928eb0b821db1..a98bb0764c0e6 100644
--- a/tests/ui/async-await/await-keyword/incorrect-syntax-suggestions.stderr
+++ b/tests/ui/async-await/await-keyword/incorrect-syntax-suggestions.stderr
@@ -141,7 +141,7 @@ error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:68:19
|
LL | fn foo13() -> Result<(), ()> {
- | ----- this is not `async`
+ | ---------------------------- this is not `async`
LL | let _ = bar().await();
| ^^^^^ only allowed inside `async` functions and blocks
@@ -149,7 +149,7 @@ error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:73:19
|
LL | fn foo14() -> Result<(), ()> {
- | ----- this is not `async`
+ | ---------------------------- this is not `async`
LL | let _ = bar().await()?;
| ^^^^^ only allowed inside `async` functions and blocks
@@ -157,7 +157,7 @@ error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:78:19
|
LL | fn foo15() -> Result<(), ()> {
- | ----- this is not `async`
+ | ---------------------------- this is not `async`
LL | let _ = bar().await;
| ^^^^^ only allowed inside `async` functions and blocks
@@ -165,7 +165,7 @@ error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:82:19
|
LL | fn foo16() -> Result<(), ()> {
- | ----- this is not `async`
+ | ---------------------------- this is not `async`
LL | let _ = bar().await?;
| ^^^^^ only allowed inside `async` functions and blocks
@@ -173,7 +173,7 @@ error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:87:23
|
LL | fn foo() -> Result<(), ()> {
- | --- this is not `async`
+ | -------------------------- this is not `async`
LL | let _ = bar().await?;
| ^^^^^ only allowed inside `async` functions and blocks
diff --git a/tests/ui/async-await/coroutine-not-future.rs b/tests/ui/async-await/coroutine-not-future.rs
index 2993f58378a44..4522743550785 100644
--- a/tests/ui/async-await/coroutine-not-future.rs
+++ b/tests/ui/async-await/coroutine-not-future.rs
@@ -1,5 +1,5 @@
//@ edition:2018
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::future::Future;
use std::ops::Coroutine;
@@ -9,6 +9,7 @@ fn returns_async_block() -> impl Future<Output = ()> {
async {}
}
fn returns_coroutine() -> impl Coroutine<(), Yield = (), Return = ()> {
+ #[coroutine]
|| {
let _: () = yield ();
}
@@ -23,9 +24,12 @@ fn main() {
takes_future(returns_async_block());
takes_future(async {});
takes_coroutine(returns_coroutine());
- takes_coroutine(|| {
- let _: () = yield ();
- });
+ takes_coroutine(
+ #[coroutine]
+ || {
+ let _: () = yield ();
+ },
+ );
// async futures are not coroutines:
takes_coroutine(async_fn());
@@ -38,8 +42,11 @@ fn main() {
// coroutines are not futures:
takes_future(returns_coroutine());
//~^ ERROR is not a future
- takes_future(|ctx| {
- //~^ ERROR is not a future
- ctx = yield ();
- });
+ takes_future(
+ #[coroutine]
+ |ctx| {
+ //~^ ERROR is not a future
+ ctx = yield ();
+ },
+ );
}
diff --git a/tests/ui/async-await/coroutine-not-future.stderr b/tests/ui/async-await/coroutine-not-future.stderr
index 580217fb4f821..403e547a7538e 100644
--- a/tests/ui/async-await/coroutine-not-future.stderr
+++ b/tests/ui/async-await/coroutine-not-future.stderr
@@ -1,5 +1,5 @@
error[E0277]: the trait bound `impl Future<Output = ()>: Coroutine<_>` is not satisfied
- --> $DIR/coroutine-not-future.rs:31:21
+ --> $DIR/coroutine-not-future.rs:35:21
|
LL | takes_coroutine(async_fn());
| --------------- ^^^^^^^^^^ the trait `Coroutine<_>` is not implemented for `impl Future<Output = ()>`
@@ -7,13 +7,13 @@ LL | takes_coroutine(async_fn());
| required by a bound introduced by this call
|
note: required by a bound in `takes_coroutine`
- --> $DIR/coroutine-not-future.rs:18:39
+ --> $DIR/coroutine-not-future.rs:19:39
|
LL | fn takes_coroutine<ResumeTy>(_g: impl Coroutine<ResumeTy, Yield = (), Return = ()>) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `takes_coroutine`
error[E0277]: the trait bound `impl Future<Output = ()>: Coroutine<_>` is not satisfied
- --> $DIR/coroutine-not-future.rs:33:21
+ --> $DIR/coroutine-not-future.rs:37:21
|
LL | takes_coroutine(returns_async_block());
| --------------- ^^^^^^^^^^^^^^^^^^^^^ the trait `Coroutine<_>` is not implemented for `impl Future<Output = ()>`
@@ -21,27 +21,27 @@ LL | takes_coroutine(returns_async_block());
| required by a bound introduced by this call
|
note: required by a bound in `takes_coroutine`
- --> $DIR/coroutine-not-future.rs:18:39
+ --> $DIR/coroutine-not-future.rs:19:39
|
LL | fn takes_coroutine<ResumeTy>(_g: impl Coroutine<ResumeTy, Yield = (), Return = ()>) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `takes_coroutine`
-error[E0277]: the trait bound `{async block@$DIR/coroutine-not-future.rs:35:21: 35:29}: Coroutine<_>` is not satisfied
- --> $DIR/coroutine-not-future.rs:35:21
+error[E0277]: the trait bound `{async block@$DIR/coroutine-not-future.rs:39:21: 39:29}: Coroutine<_>` is not satisfied
+ --> $DIR/coroutine-not-future.rs:39:21
|
LL | takes_coroutine(async {});
- | --------------- ^^^^^^^^ the trait `Coroutine<_>` is not implemented for `{async block@$DIR/coroutine-not-future.rs:35:21: 35:29}`
+ | --------------- ^^^^^^^^ the trait `Coroutine<_>` is not implemented for `{async block@$DIR/coroutine-not-future.rs:39:21: 39:29}`
| |
| required by a bound introduced by this call
|
note: required by a bound in `takes_coroutine`
- --> $DIR/coroutine-not-future.rs:18:39
+ --> $DIR/coroutine-not-future.rs:19:39
|
LL | fn takes_coroutine<ResumeTy>(_g: impl Coroutine<ResumeTy, Yield = (), Return = ()>) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `takes_coroutine`
error[E0277]: `impl Coroutine<Yield = (), Return = ()>` is not a future
- --> $DIR/coroutine-not-future.rs:39:18
+ --> $DIR/coroutine-not-future.rs:43:18
|
LL | takes_future(returns_coroutine());
| ------------ ^^^^^^^^^^^^^^^^^^^ `impl Coroutine<Yield = (), Return = ()>` is not a future
@@ -50,26 +50,26 @@ LL | takes_future(returns_coroutine());
|
= help: the trait `Future` is not implemented for `impl Coroutine<Yield = (), Return = ()>`
note: required by a bound in `takes_future`
- --> $DIR/coroutine-not-future.rs:17:26
+ --> $DIR/coroutine-not-future.rs:18:26
|
LL | fn takes_future(_f: impl Future<Output = ()>) {}
| ^^^^^^^^^^^^^^^^^^^ required by this bound in `takes_future`
-error[E0277]: `{coroutine@$DIR/coroutine-not-future.rs:41:18: 41:23}` is not a future
- --> $DIR/coroutine-not-future.rs:41:18
+error[E0277]: `{coroutine@$DIR/coroutine-not-future.rs:47:9: 47:14}` is not a future
+ --> $DIR/coroutine-not-future.rs:47:9
|
-LL | takes_future(|ctx| {
- | _____------------_^
- | | |
- | | required by a bound introduced by this call
+LL | takes_future(
+ | ------------ required by a bound introduced by this call
+LL | #[coroutine]
+LL | / |ctx| {
LL | |
-LL | | ctx = yield ();
-LL | | });
- | |_____^ `{coroutine@$DIR/coroutine-not-future.rs:41:18: 41:23}` is not a future
+LL | | ctx = yield ();
+LL | | },
+ | |_________^ `{coroutine@$DIR/coroutine-not-future.rs:47:9: 47:14}` is not a future
|
- = help: the trait `Future` is not implemented for `{coroutine@$DIR/coroutine-not-future.rs:41:18: 41:23}`
+ = help: the trait `Future` is not implemented for `{coroutine@$DIR/coroutine-not-future.rs:47:9: 47:14}`
note: required by a bound in `takes_future`
- --> $DIR/coroutine-not-future.rs:17:26
+ --> $DIR/coroutine-not-future.rs:18:26
|
LL | fn takes_future(_f: impl Future<Output = ()>) {}
| ^^^^^^^^^^^^^^^^^^^ required by this bound in `takes_future`
diff --git a/tests/ui/async-await/issues/issue-51751.stderr b/tests/ui/async-await/issues/issue-51751.stderr
index ba256b19948c0..ab12e0427b47a 100644
--- a/tests/ui/async-await/issues/issue-51751.stderr
+++ b/tests/ui/async-await/issues/issue-51751.stderr
@@ -2,7 +2,7 @@ error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/issue-51751.rs:9:27
|
LL | fn main() {
- | ---- this is not `async`
+ | --------- this is not `async`
LL | let result = inc(10000);
LL | let finished = result.await;
| ^^^^^ only allowed inside `async` functions and blocks
diff --git a/tests/ui/async-await/issues/issue-62009-1.stderr b/tests/ui/async-await/issues/issue-62009-1.stderr
index 02933f4f2f233..f8a4b5d9af8b2 100644
--- a/tests/ui/async-await/issues/issue-62009-1.stderr
+++ b/tests/ui/async-await/issues/issue-62009-1.stderr
@@ -2,7 +2,7 @@ error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/issue-62009-1.rs:6:23
|
LL | fn main() {
- | ---- this is not `async`
+ | --------- this is not `async`
LL | async { let (); }.await;
| ^^^^^ only allowed inside `async` functions and blocks
@@ -10,7 +10,7 @@ error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/issue-62009-1.rs:10:7
|
LL | fn main() {
- | ---- this is not `async`
+ | --------- this is not `async`
...
LL | }.await;
| ^^^^^ only allowed inside `async` functions and blocks
@@ -19,7 +19,7 @@ error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/issue-62009-1.rs:12:16
|
LL | fn main() {
- | ---- this is not `async`
+ | --------- this is not `async`
...
LL | (|_| 2333).await;
| ^^^^^ only allowed inside `async` functions and blocks
diff --git a/tests/ui/async-await/issues/issue-62009-2.stderr b/tests/ui/async-await/issues/issue-62009-2.stderr
index 80a831cc5475f..0004f99f9018d 100644
--- a/tests/ui/async-await/issues/issue-62009-2.stderr
+++ b/tests/ui/async-await/issues/issue-62009-2.stderr
@@ -2,7 +2,7 @@ error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/issue-62009-2.rs:8:23
|
LL | fn main() {
- | ---- this is not `async`
+ | --------- this is not `async`
LL | (async || 2333)().await;
| ^^^^^ only allowed inside `async` functions and blocks
diff --git a/tests/ui/async-await/issues/issue-65419/issue-65419-coroutine-resume-after-completion.rs b/tests/ui/async-await/issues/issue-65419/issue-65419-coroutine-resume-after-completion.rs
index f937311a5a0f7..6b7dfc1235e8e 100644
--- a/tests/ui/async-await/issues/issue-65419/issue-65419-coroutine-resume-after-completion.rs
+++ b/tests/ui/async-await/issues/issue-65419/issue-65419-coroutine-resume-after-completion.rs
@@ -6,15 +6,13 @@
//@ error-pattern:coroutine resumed after completion
//@ edition:2018
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
-use std::{
- ops::Coroutine,
- pin::Pin,
-};
+use std::{ops::Coroutine, pin::Pin};
fn main() {
- let mut g = || {
+ let mut g = #[coroutine]
+ || {
yield;
};
Pin::new(&mut g).resume(()); // Yields once.
diff --git a/tests/ui/async-await/issues/non-async-enclosing-span.stderr b/tests/ui/async-await/issues/non-async-enclosing-span.stderr
index 91a9e5aa6cabf..9c26de1c5047c 100644
--- a/tests/ui/async-await/issues/non-async-enclosing-span.stderr
+++ b/tests/ui/async-await/issues/non-async-enclosing-span.stderr
@@ -2,7 +2,7 @@ error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/non-async-enclosing-span.rs:9:28
|
LL | fn main() {
- | ---- this is not `async`
+ | --------- this is not `async`
LL | let x = move || {};
LL | let y = do_the_thing().await;
| ^^^^^ only allowed inside `async` functions and blocks
diff --git a/tests/ui/async-await/non-trivial-drop.rs b/tests/ui/async-await/non-trivial-drop.rs
index 71b8812421972..95de3c5b0054d 100644
--- a/tests/ui/async-await/non-trivial-drop.rs
+++ b/tests/ui/async-await/non-trivial-drop.rs
@@ -8,7 +8,7 @@ fn main() {
}
fn foo() {
- || {
+ #[coroutine] || {
yield drop(Config {
nickname: NonCopy,
b: NonCopy2,
diff --git a/tests/ui/cast/cast-rfc0401-vtable-kinds.rs b/tests/ui/cast/cast-rfc0401-vtable-kinds.rs
index 410e15d024fab..0d8f92f013fba 100644
--- a/tests/ui/cast/cast-rfc0401-vtable-kinds.rs
+++ b/tests/ui/cast/cast-rfc0401-vtable-kinds.rs
@@ -17,7 +17,7 @@ impl Foo<u32> for u32 { fn foo(&self, _: u32) -> u32 { self+43 } }
impl Bar for () {}
unsafe fn round_trip_and_call<'a>(t: *const (dyn Foo<u32>+'a)) -> u32 {
- let foo_e : *const dyn Foo<u16> = t as *const _;
+ let foo_e : *const dyn Foo<u32> = t as *const _;
let r_1 = foo_e as *mut dyn Foo<u32>;
(&*r_1).foo(0)
diff --git a/tests/ui/coherence/coherence-with-coroutine.rs b/tests/ui/coherence/coherence-with-coroutine.rs
index 1ba9834467265..6b0617e950b7d 100644
--- a/tests/ui/coherence/coherence-with-coroutine.rs
+++ b/tests/ui/coherence/coherence-with-coroutine.rs
@@ -8,6 +8,7 @@
type OpaqueCoroutine = impl Sized;
fn defining_use() -> OpaqueCoroutine {
+ #[coroutine]
|| {
for i in 0..10 {
yield i;
diff --git a/tests/ui/coherence/coherence-with-coroutine.stock.stderr b/tests/ui/coherence/coherence-with-coroutine.stock.stderr
index 9cf20ea493649..5f58b3088f14d 100644
--- a/tests/ui/coherence/coherence-with-coroutine.stock.stderr
+++ b/tests/ui/coherence/coherence-with-coroutine.stock.stderr
@@ -1,5 +1,5 @@
error[E0119]: conflicting implementations of trait `Trait` for type `Wrapper<OpaqueCoroutine>`
- --> $DIR/coherence-with-coroutine.rs:21:1
+ --> $DIR/coherence-with-coroutine.rs:22:1
|
LL | impl Trait for Wrapper<OpaqueCoroutine> {}
| --------------------------------------- first implementation here
diff --git a/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.rs b/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.rs
index 7332a8f03c05f..f1305202ad452 100644
--- a/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.rs
+++ b/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.rs
@@ -1,4 +1,4 @@
-#![feature(inline_const, generic_const_exprs)]
+#![feature(generic_const_exprs)]
//~^ WARN the feature `generic_const_exprs` is incomplete
fn foo<T>() {
diff --git a/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.stderr b/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.stderr
index a85e0cbcf7e99..03b0004bf0bdb 100644
--- a/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.stderr
@@ -1,8 +1,8 @@
warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
- --> $DIR/const-block-is-poly.rs:1:26
+ --> $DIR/const-block-is-poly.rs:1:12
|
-LL | #![feature(inline_const, generic_const_exprs)]
- | ^^^^^^^^^^^^^^^^^^^
+LL | #![feature(generic_const_exprs)]
+ | ^^^^^^^^^^^^^^^^^^^
|
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= note: `#[warn(incomplete_features)]` on by default
diff --git a/tests/ui/const-generics/generic_const_exprs/const_kind_expr/relate_ty_with_infer_2.rs b/tests/ui/const-generics/generic_const_exprs/const_kind_expr/relate_ty_with_infer_2.rs
index 4333ec9f5522d..f9cf8210d6512 100644
--- a/tests/ui/const-generics/generic_const_exprs/const_kind_expr/relate_ty_with_infer_2.rs
+++ b/tests/ui/const-generics/generic_const_exprs/const_kind_expr/relate_ty_with_infer_2.rs
@@ -1,5 +1,5 @@
//@ check-pass
-#![feature(inline_const, generic_const_exprs)]
+#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
use std::marker::PhantomData;
diff --git a/tests/ui/const-generics/generic_const_exprs/inline-const-in-const-generic-defaults.rs b/tests/ui/const-generics/generic_const_exprs/inline-const-in-const-generic-defaults.rs
index 3bc02f4c6bbfb..073e0fe0a7fdb 100644
--- a/tests/ui/const-generics/generic_const_exprs/inline-const-in-const-generic-defaults.rs
+++ b/tests/ui/const-generics/generic_const_exprs/inline-const-in-const-generic-defaults.rs
@@ -1,7 +1,6 @@
//@ check-pass
#![feature(generic_const_exprs)]
-#![feature(inline_const)]
#![allow(incomplete_features)]
pub struct ConstDefaultUnstable<const N: usize = { const { 3 } }>;
diff --git a/tests/ui/const_prop/dont-propagate-generic-instance-2.rs b/tests/ui/const_prop/dont-propagate-generic-instance-2.rs
index 768c9b3171a82..08064bc658991 100644
--- a/tests/ui/const_prop/dont-propagate-generic-instance-2.rs
+++ b/tests/ui/const_prop/dont-propagate-generic-instance-2.rs
@@ -1,7 +1,5 @@
//@ run-pass
-#![feature(inline_const)]
-
// Makes sure we don't propagate generic instances of `Self: ?Sized` blanket impls.
// This is relevant when we have an overlapping impl and builtin dyn instance.
// See <https://github.com/rust-lang/rust/pull/114941> for more context.
diff --git a/tests/ui/consts/closure-structural-match-issue-90013.rs b/tests/ui/consts/closure-structural-match-issue-90013.rs
index 7a5d9b69ee4a0..454341a77843e 100644
--- a/tests/ui/consts/closure-structural-match-issue-90013.rs
+++ b/tests/ui/consts/closure-structural-match-issue-90013.rs
@@ -1,6 +1,5 @@
// Regression test for issue 90013.
//@ check-pass
-#![feature(inline_const)]
fn main() {
const { || {} };
diff --git a/tests/ui/consts/const-block-const-bound.rs b/tests/ui/consts/const-block-const-bound.rs
index b0d5e19ad5541..933eb6cfc0afb 100644
--- a/tests/ui/consts/const-block-const-bound.rs
+++ b/tests/ui/consts/const-block-const-bound.rs
@@ -1,7 +1,7 @@
//@ known-bug: #103507
#![allow(unused)]
-#![feature(const_trait_impl, inline_const, negative_impls)]
+#![feature(const_trait_impl, negative_impls)]
use std::marker::Destruct;
diff --git a/tests/ui/consts/const-blocks/fn-call-in-const.rs b/tests/ui/consts/const-blocks/fn-call-in-const.rs
index 9bf267b7de9aa..a3e24ddae7d1e 100644
--- a/tests/ui/consts/const-blocks/fn-call-in-const.rs
+++ b/tests/ui/consts/const-blocks/fn-call-in-const.rs
@@ -1,6 +1,5 @@
//@ run-pass
-#![feature(inline_const)]
#![allow(unused)]
// Some type that is not copyable.
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_zero_sized.rs b/tests/ui/consts/const-eval/heap/alloc_intrinsic_zero_sized.rs
index 6c4fca3562607..2517560c2c34c 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_zero_sized.rs
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_zero_sized.rs
@@ -1,7 +1,6 @@
//@ run-pass
#![feature(core_intrinsics)]
#![feature(const_heap)]
-#![feature(inline_const)]
use std::intrinsics;
diff --git a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_zero_sized.rs b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_zero_sized.rs
index 146a87862e8c7..c53bb36f4a2ce 100644
--- a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_zero_sized.rs
+++ b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_zero_sized.rs
@@ -1,7 +1,6 @@
//@ run-pass
#![feature(core_intrinsics)]
#![feature(const_heap)]
-#![feature(inline_const)]
use std::intrinsics;
diff --git a/tests/ui/consts/issue-102117.rs b/tests/ui/consts/issue-102117.rs
index 3ed90aed2350d..6cb9832bcd81b 100644
--- a/tests/ui/consts/issue-102117.rs
+++ b/tests/ui/consts/issue-102117.rs
@@ -1,4 +1,4 @@
-#![feature(inline_const, const_type_id)]
+#![feature(const_type_id)]
use std::alloc::Layout;
use std::any::TypeId;
diff --git a/tests/ui/coroutine/addassign-yield.rs b/tests/ui/coroutine/addassign-yield.rs
index 8718e73512f71..8329b53d715e6 100644
--- a/tests/ui/coroutine/addassign-yield.rs
+++ b/tests/ui/coroutine/addassign-yield.rs
@@ -5,21 +5,21 @@
// is being used), we were failing to account for all types that might
// possibly be live across a yield point.
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
fn foo() {
- let _x = static || {
+ let _x = #[coroutine] static || {
let mut s = String::new();
s += { yield; "" };
};
- let _y = static || {
+ let _y = #[coroutine] static || {
let x = &mut 0;
*{ yield; x } += match String::new() { _ => 0 };
};
// Please don't ever actually write something like this
- let _z = static || {
+ let _z = #[coroutine] static || {
let x = &mut 0;
*{
let inner = &mut 1;
diff --git a/tests/ui/coroutine/auto-trait-regions.rs b/tests/ui/coroutine/auto-trait-regions.rs
index 5fce70e8e54d2..4c239f9ee76cf 100644
--- a/tests/ui/coroutine/auto-trait-regions.rs
+++ b/tests/ui/coroutine/auto-trait-regions.rs
@@ -1,4 +1,4 @@
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
#![feature(auto_traits)]
#![feature(negative_impls)]
@@ -23,7 +23,7 @@ fn assert_foo<T: Foo>(f: T) {}
fn main() {
// Make sure 'static is erased for coroutine interiors so we can't match it in trait selection
let x: &'static _ = &OnlyFooIfStaticRef(No);
- let gen = move || {
+ let gen = #[coroutine] move || {
let x = x;
yield;
assert_foo(x);
@@ -33,7 +33,7 @@ fn main() {
// Allow impls which matches any lifetime
let x = &OnlyFooIfRef(No);
- let gen = move || {
+ let gen = #[coroutine] move || {
let x = x;
yield;
assert_foo(x);
@@ -41,7 +41,7 @@ fn main() {
assert_foo(gen); // ok
// Disallow impls which relates lifetimes in the coroutine interior
- let gen = move || {
+ let gen = #[coroutine] move || {
let a = A(&mut true, &mut true, No);
//~^ temporary value dropped while borrowed
//~| temporary value dropped while borrowed
diff --git a/tests/ui/coroutine/auxiliary/metadata-sufficient-for-layout.rs b/tests/ui/coroutine/auxiliary/metadata-sufficient-for-layout.rs
index 8af6973134a67..8ecb8c0c09793 100644
--- a/tests/ui/coroutine/auxiliary/metadata-sufficient-for-layout.rs
+++ b/tests/ui/coroutine/auxiliary/metadata-sufficient-for-layout.rs
@@ -5,6 +5,7 @@ use std::marker::Unpin;
use std::ops::Coroutine;
pub fn g() -> impl Coroutine<(), Yield = (), Return = ()> {
+ #[coroutine]
|| {
yield;
}
diff --git a/tests/ui/coroutine/auxiliary/unwind-aux.rs b/tests/ui/coroutine/auxiliary/unwind-aux.rs
index ff1e8ed32cd49..5d5e5c2218d39 100644
--- a/tests/ui/coroutine/auxiliary/unwind-aux.rs
+++ b/tests/ui/coroutine/auxiliary/unwind-aux.rs
@@ -2,9 +2,10 @@
//@ no-prefer-dynamic
//@ edition:2021
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
pub fn run<T>(a: T) {
- let _ = move || {
+ let _ = #[coroutine]
+ move || {
drop(a);
yield;
};
diff --git a/tests/ui/coroutine/auxiliary/xcrate-reachable.rs b/tests/ui/coroutine/auxiliary/xcrate-reachable.rs
index 673153f0619ea..0b5d18823004a 100644
--- a/tests/ui/coroutine/auxiliary/xcrate-reachable.rs
+++ b/tests/ui/coroutine/auxiliary/xcrate-reachable.rs
@@ -7,6 +7,7 @@ fn msg() -> u32 {
}
pub fn foo() -> impl Coroutine<(), Yield = (), Return = u32> {
+ #[coroutine]
|| {
yield;
return msg();
diff --git a/tests/ui/coroutine/auxiliary/xcrate.rs b/tests/ui/coroutine/auxiliary/xcrate.rs
index f749a95ad35a3..52f188135bd1b 100644
--- a/tests/ui/coroutine/auxiliary/xcrate.rs
+++ b/tests/ui/coroutine/auxiliary/xcrate.rs
@@ -1,9 +1,10 @@
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::marker::Unpin;
use std::ops::Coroutine;
pub fn foo() -> impl Coroutine<(), Yield = (), Return = ()> {
+ #[coroutine]
|| {
if false {
yield;
@@ -12,7 +13,10 @@ pub fn foo() -> impl Coroutine<(), Yield = (), Return = ()> {
}
pub fn bar<T: 'static>(t: T) -> Box<Coroutine<(), Yield = T, Return = ()> + Unpin> {
- Box::new(|| {
- yield t;
- })
+ Box::new(
+ #[coroutine]
+ || {
+ yield t;
+ },
+ )
}
diff --git a/tests/ui/coroutine/borrow-in-tail-expr.rs b/tests/ui/coroutine/borrow-in-tail-expr.rs
index 2f0aa62019e83..380e95cfc7765 100644
--- a/tests/ui/coroutine/borrow-in-tail-expr.rs
+++ b/tests/ui/coroutine/borrow-in-tail-expr.rs
@@ -1,9 +1,9 @@
//@ run-pass
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
fn main() {
- let _a = || {
+ let _a = #[coroutine] || {
yield;
let a = String::new();
a.len()
diff --git a/tests/ui/coroutine/borrowing.rs b/tests/ui/coroutine/borrowing.rs
index 778eed8bd0d9f..a6628766c1bad 100644
--- a/tests/ui/coroutine/borrowing.rs
+++ b/tests/ui/coroutine/borrowing.rs
@@ -1,4 +1,4 @@
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
use std::pin::Pin;
@@ -6,13 +6,13 @@ use std::pin::Pin;
fn main() {
let _b = {
let a = 3;
- Pin::new(&mut || yield &a).resume(())
+ Pin::new(&mut #[coroutine] || yield &a).resume(())
//~^ ERROR: `a` does not live long enough
};
let _b = {
let a = 3;
- || {
+ #[coroutine] || {
yield &a
//~^ ERROR: `a` does not live long enough
}
diff --git a/tests/ui/coroutine/borrowing.stderr b/tests/ui/coroutine/borrowing.stderr
index acd4cdafdfdf7..9132e5d84eddf 100644
--- a/tests/ui/coroutine/borrowing.stderr
+++ b/tests/ui/coroutine/borrowing.stderr
@@ -1,13 +1,13 @@
error[E0597]: `a` does not live long enough
- --> $DIR/borrowing.rs:9:33
+ --> $DIR/borrowing.rs:9:46
|
LL | let _b = {
| -- borrow later stored here
LL | let a = 3;
-LL | Pin::new(&mut || yield &a).resume(())
- | -- ^ borrowed value does not live long enough
- | |
- | value captured here by coroutine
+LL | Pin::new(&mut #[coroutine] || yield &a).resume(())
+ | -- ^ borrowed value does not live long enough
+ | |
+ | value captured here by coroutine
LL |
LL | };
| - `a` dropped here while still borrowed
@@ -18,8 +18,8 @@ error[E0597]: `a` does not live long enough
LL | let _b = {
| -- borrow later stored here
LL | let a = 3;
-LL | || {
- | -- value captured here by coroutine
+LL | #[coroutine] || {
+ | -- value captured here by coroutine
LL | yield &a
| ^ borrowed value does not live long enough
...
diff --git a/tests/ui/coroutine/check-resume-ty-lifetimes-2.rs b/tests/ui/coroutine/check-resume-ty-lifetimes-2.rs
index a316c50e86732..327756ebe6604 100644
--- a/tests/ui/coroutine/check-resume-ty-lifetimes-2.rs
+++ b/tests/ui/coroutine/check-resume-ty-lifetimes-2.rs
@@ -7,27 +7,27 @@ struct Contravariant<'a>(fn(&'a ()));
struct Covariant<'a>(fn() -> &'a ());
fn bad1<'short, 'long: 'short>() -> impl Coroutine<Covariant<'short>> {
- |_: Covariant<'short>| {
+ #[coroutine] |_: Covariant<'short>| {
let a: Covariant<'long> = yield ();
//~^ ERROR lifetime may not live long enough
}
}
fn bad2<'short, 'long: 'short>() -> impl Coroutine<Contravariant<'long>> {
- |_: Contravariant<'long>| {
+ #[coroutine] |_: Contravariant<'long>| {
let a: Contravariant<'short> = yield ();
//~^ ERROR lifetime may not live long enough
}
}
fn good1<'short, 'long: 'short>() -> impl Coroutine<Covariant<'long>> {
- |_: Covariant<'long>| {
+ #[coroutine] |_: Covariant<'long>| {
let a: Covariant<'short> = yield ();
}
}
fn good2<'short, 'long: 'short>() -> impl Coroutine<Contravariant<'short>> {
- |_: Contravariant<'short>| {
+ #[coroutine] |_: Contravariant<'short>| {
let a: Contravariant<'long> = yield ();
}
}
diff --git a/tests/ui/coroutine/check-resume-ty-lifetimes-2.stderr b/tests/ui/coroutine/check-resume-ty-lifetimes-2.stderr
index e0cbca2dd5267..8eb7ab3501b35 100644
--- a/tests/ui/coroutine/check-resume-ty-lifetimes-2.stderr
+++ b/tests/ui/coroutine/check-resume-ty-lifetimes-2.stderr
@@ -5,15 +5,15 @@ LL | fn bad1<'short, 'long: 'short>() -> impl Coroutine<Covariant<'short>> {
| ------ ----- lifetime `'long` defined here
| |
| lifetime `'short` defined here
-LL | |_: Covariant<'short>| {
+LL | #[coroutine] |_: Covariant<'short>| {
LL | let a: Covariant<'long> = yield ();
| ^^^^^^^^^^^^^^^^ type annotation requires that `'short` must outlive `'long`
|
= help: consider adding the following bound: `'short: 'long`
help: consider adding 'move' keyword before the nested closure
|
-LL | move |_: Covariant<'short>| {
- | ++++
+LL | #[coroutine] move |_: Covariant<'short>| {
+ | ++++
error: lifetime may not live long enough
--> $DIR/check-resume-ty-lifetimes-2.rs:18:40
@@ -22,15 +22,15 @@ LL | fn bad2<'short, 'long: 'short>() -> impl Coroutine<Contravariant<'long>> {
| ------ ----- lifetime `'long` defined here
| |
| lifetime `'short` defined here
-LL | |_: Contravariant<'long>| {
+LL | #[coroutine] |_: Contravariant<'long>| {
LL | let a: Contravariant<'short> = yield ();
| ^^^^^^^^ yielding this value requires that `'short` must outlive `'long`
|
= help: consider adding the following bound: `'short: 'long`
help: consider adding 'move' keyword before the nested closure
|
-LL | move |_: Contravariant<'long>| {
- | ++++
+LL | #[coroutine] move |_: Contravariant<'long>| {
+ | ++++
error: aborting due to 2 previous errors
diff --git a/tests/ui/coroutine/check-resume-ty-lifetimes.rs b/tests/ui/coroutine/check-resume-ty-lifetimes.rs
index add0b5080a8a8..b75e46c541cc5 100644
--- a/tests/ui/coroutine/check-resume-ty-lifetimes.rs
+++ b/tests/ui/coroutine/check-resume-ty-lifetimes.rs
@@ -1,5 +1,5 @@
#![feature(coroutine_trait)]
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
#![allow(unused)]
use std::ops::Coroutine;
@@ -9,11 +9,14 @@ use std::pin::pin;
fn mk_static(s: &str) -> &'static str {
let mut storage: Option<&'static str> = None;
- let mut coroutine = pin!(|_: &str| {
- let x: &'static str = yield ();
- //~^ ERROR lifetime may not live long enough
- storage = Some(x);
- });
+ let mut coroutine = pin!(
+ #[coroutine]
+ |_: &str| {
+ let x: &'static str = yield ();
+ //~^ ERROR lifetime may not live long enough
+ storage = Some(x);
+ }
+ );
coroutine.as_mut().resume(s);
coroutine.as_mut().resume(s);
diff --git a/tests/ui/coroutine/check-resume-ty-lifetimes.stderr b/tests/ui/coroutine/check-resume-ty-lifetimes.stderr
index f373aa778a82c..1fbaeb9f7fa41 100644
--- a/tests/ui/coroutine/check-resume-ty-lifetimes.stderr
+++ b/tests/ui/coroutine/check-resume-ty-lifetimes.stderr
@@ -1,11 +1,11 @@
error: lifetime may not live long enough
- --> $DIR/check-resume-ty-lifetimes.rs:13:16
+ --> $DIR/check-resume-ty-lifetimes.rs:15:20
|
LL | fn mk_static(s: &str) -> &'static str {
| - let's call the lifetime of this reference `'1`
...
-LL | let x: &'static str = yield ();
- | ^^^^^^^^^^^^ type annotation requires that `'1` must outlive `'static`
+LL | let x: &'static str = yield ();
+ | ^^^^^^^^^^^^ type annotation requires that `'1` must outlive `'static`
error: aborting due to 1 previous error
diff --git a/tests/ui/coroutine/clone-impl-static.rs b/tests/ui/coroutine/clone-impl-static.rs
index 9a165cf4672e6..56d1ccac70350 100644
--- a/tests/ui/coroutine/clone-impl-static.rs
+++ b/tests/ui/coroutine/clone-impl-static.rs
@@ -1,10 +1,11 @@
// gate-test-coroutine_clone
// Verifies that static coroutines cannot be cloned/copied.
-#![feature(coroutines, coroutine_clone)]
+#![feature(coroutines, coroutine_clone, stmt_expr_attributes)]
fn main() {
- let gen = static move || {
+ let gen = #[coroutine]
+ static move || {
yield;
};
check_copy(&gen);
diff --git a/tests/ui/coroutine/clone-impl-static.stderr b/tests/ui/coroutine/clone-impl-static.stderr
index 8fa9fb12bf685..43920326d5dfd 100644
--- a/tests/ui/coroutine/clone-impl-static.stderr
+++ b/tests/ui/coroutine/clone-impl-static.stderr
@@ -1,27 +1,27 @@
-error[E0277]: the trait bound `{static coroutine@$DIR/clone-impl-static.rs:7:15: 7:29}: Copy` is not satisfied
- --> $DIR/clone-impl-static.rs:10:16
+error[E0277]: the trait bound `{static coroutine@$DIR/clone-impl-static.rs:8:5: 8:19}: Copy` is not satisfied
+ --> $DIR/clone-impl-static.rs:11:16
|
LL | check_copy(&gen);
- | ---------- ^^^^ the trait `Copy` is not implemented for `{static coroutine@$DIR/clone-impl-static.rs:7:15: 7:29}`
+ | ---------- ^^^^ the trait `Copy` is not implemented for `{static coroutine@$DIR/clone-impl-static.rs:8:5: 8:19}`
| |
| required by a bound introduced by this call
|
note: required by a bound in `check_copy`
- --> $DIR/clone-impl-static.rs:16:18
+ --> $DIR/clone-impl-static.rs:17:18
|
LL | fn check_copy<T: Copy>(_x: &T) {}
| ^^^^ required by this bound in `check_copy`
-error[E0277]: the trait bound `{static coroutine@$DIR/clone-impl-static.rs:7:15: 7:29}: Clone` is not satisfied
- --> $DIR/clone-impl-static.rs:12:17
+error[E0277]: the trait bound `{static coroutine@$DIR/clone-impl-static.rs:8:5: 8:19}: Clone` is not satisfied
+ --> $DIR/clone-impl-static.rs:13:17
|
LL | check_clone(&gen);
- | ----------- ^^^^ the trait `Clone` is not implemented for `{static coroutine@$DIR/clone-impl-static.rs:7:15: 7:29}`
+ | ----------- ^^^^ the trait `Clone` is not implemented for `{static coroutine@$DIR/clone-impl-static.rs:8:5: 8:19}`
| |
| required by a bound introduced by this call
|
note: required by a bound in `check_clone`
- --> $DIR/clone-impl-static.rs:17:19
+ --> $DIR/clone-impl-static.rs:18:19
|
LL | fn check_clone<T: Clone>(_x: &T) {}
| ^^^^^ required by this bound in `check_clone`
diff --git a/tests/ui/coroutine/clone-impl.rs b/tests/ui/coroutine/clone-impl.rs
index eed6f851bd028..e13846f6f8767 100644
--- a/tests/ui/coroutine/clone-impl.rs
+++ b/tests/ui/coroutine/clone-impl.rs
@@ -2,7 +2,7 @@
// Verifies that non-static coroutines can be cloned/copied if all their upvars and locals held
// across awaits can be cloned/copied.
-#![feature(coroutines, coroutine_clone)]
+#![feature(coroutines, coroutine_clone, stmt_expr_attributes)]
struct NonClone;
@@ -12,13 +12,13 @@ fn main() {
let clonable_1: Vec<u32> = Vec::new();
let non_clonable: NonClone = NonClone;
- let gen_copy_0 = move || {
+ let gen_copy_0 = #[coroutine] move || {
yield;
drop(copyable);
};
check_copy(&gen_copy_0);
check_clone(&gen_copy_0);
- let gen_copy_1 = move || {
+ let gen_copy_1 = #[coroutine] move || {
/*
let v = vec!['a'];
let n = NonClone;
@@ -33,7 +33,7 @@ fn main() {
};
check_copy(&gen_copy_1);
check_clone(&gen_copy_1);
- let gen_clone_0 = move || {
+ let gen_clone_0 = #[coroutine] move || {
let v = vec!['a'];
yield;
drop(v);
@@ -43,7 +43,7 @@ fn main() {
//~^ ERROR the trait bound `Vec<u32>: Copy` is not satisfied
//~| ERROR the trait bound `Vec<char>: Copy` is not satisfied
check_clone(&gen_clone_0);
- let gen_clone_1 = move || {
+ let gen_clone_1 = #[coroutine] move || {
let v = vec!['a'];
/*
let n = NonClone;
@@ -59,7 +59,7 @@ fn main() {
//~^ ERROR the trait bound `Vec<u32>: Copy` is not satisfied
//~| ERROR the trait bound `Vec<char>: Copy` is not satisfied
check_clone(&gen_clone_1);
- let gen_non_clone = move || {
+ let gen_non_clone = #[coroutine] move || {
yield;
drop(non_clonable);
};
diff --git a/tests/ui/coroutine/clone-impl.stderr b/tests/ui/coroutine/clone-impl.stderr
index 1d4804501d8bc..d481c7feb4b37 100644
--- a/tests/ui/coroutine/clone-impl.stderr
+++ b/tests/ui/coroutine/clone-impl.stderr
@@ -1,11 +1,11 @@
-error[E0277]: the trait bound `Vec<u32>: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:36:23: 36:30}`
+error[E0277]: the trait bound `Vec<u32>: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:36:36: 36:43}`
--> $DIR/clone-impl.rs:42:5
|
-LL | let gen_clone_0 = move || {
- | ------- within this `{coroutine@$DIR/clone-impl.rs:36:23: 36:30}`
+LL | let gen_clone_0 = #[coroutine] move || {
+ | ------- within this `{coroutine@$DIR/clone-impl.rs:36:36: 36:43}`
...
LL | check_copy(&gen_clone_0);
- | ^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:36:23: 36:30}`, the trait `Copy` is not implemented for `Vec<u32>`, which is required by `{coroutine@$DIR/clone-impl.rs:36:23: 36:30}: Copy`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:36:36: 36:43}`, the trait `Copy` is not implemented for `Vec<u32>`, which is required by `{coroutine@$DIR/clone-impl.rs:36:36: 36:43}: Copy`
|
note: captured value does not implement `Copy`
--> $DIR/clone-impl.rs:40:14
@@ -18,14 +18,14 @@ note: required by a bound in `check_copy`
LL | fn check_copy<T: Copy>(_x: &T) {}
| ^^^^ required by this bound in `check_copy`
-error[E0277]: the trait bound `Vec<char>: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:36:23: 36:30}`
+error[E0277]: the trait bound `Vec<char>: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:36:36: 36:43}`
--> $DIR/clone-impl.rs:42:5
|
-LL | let gen_clone_0 = move || {
- | ------- within this `{coroutine@$DIR/clone-impl.rs:36:23: 36:30}`
+LL | let gen_clone_0 = #[coroutine] move || {
+ | ------- within this `{coroutine@$DIR/clone-impl.rs:36:36: 36:43}`
...
LL | check_copy(&gen_clone_0);
- | ^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:36:23: 36:30}`, the trait `Copy` is not implemented for `Vec<char>`, which is required by `{coroutine@$DIR/clone-impl.rs:36:23: 36:30}: Copy`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:36:36: 36:43}`, the trait `Copy` is not implemented for `Vec<char>`, which is required by `{coroutine@$DIR/clone-impl.rs:36:36: 36:43}: Copy`
|
note: coroutine does not implement `Copy` as this value is used across a yield
--> $DIR/clone-impl.rs:38:9
@@ -40,14 +40,14 @@ note: required by a bound in `check_copy`
LL | fn check_copy<T: Copy>(_x: &T) {}
| ^^^^ required by this bound in `check_copy`
-error[E0277]: the trait bound `Vec<u32>: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:46:23: 46:30}`
+error[E0277]: the trait bound `Vec<u32>: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:46:36: 46:43}`
--> $DIR/clone-impl.rs:58:5
|
-LL | let gen_clone_1 = move || {
- | ------- within this `{coroutine@$DIR/clone-impl.rs:46:23: 46:30}`
+LL | let gen_clone_1 = #[coroutine] move || {
+ | ------- within this `{coroutine@$DIR/clone-impl.rs:46:36: 46:43}`
...
LL | check_copy(&gen_clone_1);
- | ^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:46:23: 46:30}`, the trait `Copy` is not implemented for `Vec<u32>`, which is required by `{coroutine@$DIR/clone-impl.rs:46:23: 46:30}: Copy`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:46:36: 46:43}`, the trait `Copy` is not implemented for `Vec<u32>`, which is required by `{coroutine@$DIR/clone-impl.rs:46:36: 46:43}: Copy`
|
note: captured value does not implement `Copy`
--> $DIR/clone-impl.rs:56:14
@@ -60,14 +60,14 @@ note: required by a bound in `check_copy`
LL | fn check_copy<T: Copy>(_x: &T) {}
| ^^^^ required by this bound in `check_copy`
-error[E0277]: the trait bound `Vec<char>: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:46:23: 46:30}`
+error[E0277]: the trait bound `Vec<char>: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:46:36: 46:43}`
--> $DIR/clone-impl.rs:58:5
|
-LL | let gen_clone_1 = move || {
- | ------- within this `{coroutine@$DIR/clone-impl.rs:46:23: 46:30}`
+LL | let gen_clone_1 = #[coroutine] move || {
+ | ------- within this `{coroutine@$DIR/clone-impl.rs:46:36: 46:43}`
...
LL | check_copy(&gen_clone_1);
- | ^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:46:23: 46:30}`, the trait `Copy` is not implemented for `Vec<char>`, which is required by `{coroutine@$DIR/clone-impl.rs:46:23: 46:30}: Copy`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:46:36: 46:43}`, the trait `Copy` is not implemented for `Vec<char>`, which is required by `{coroutine@$DIR/clone-impl.rs:46:36: 46:43}: Copy`
|
note: coroutine does not implement `Copy` as this value is used across a yield
--> $DIR/clone-impl.rs:52:9
@@ -83,14 +83,14 @@ note: required by a bound in `check_copy`
LL | fn check_copy<T: Copy>(_x: &T) {}
| ^^^^ required by this bound in `check_copy`
-error[E0277]: the trait bound `NonClone: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:62:25: 62:32}`
+error[E0277]: the trait bound `NonClone: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:62:38: 62:45}`
--> $DIR/clone-impl.rs:66:5
|
-LL | let gen_non_clone = move || {
- | ------- within this `{coroutine@$DIR/clone-impl.rs:62:25: 62:32}`
+LL | let gen_non_clone = #[coroutine] move || {
+ | ------- within this `{coroutine@$DIR/clone-impl.rs:62:38: 62:45}`
...
LL | check_copy(&gen_non_clone);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:62:25: 62:32}`, the trait `Copy` is not implemented for `NonClone`, which is required by `{coroutine@$DIR/clone-impl.rs:62:25: 62:32}: Copy`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:62:38: 62:45}`, the trait `Copy` is not implemented for `NonClone`, which is required by `{coroutine@$DIR/clone-impl.rs:62:38: 62:45}: Copy`
|
note: captured value does not implement `Copy`
--> $DIR/clone-impl.rs:64:14
@@ -108,14 +108,14 @@ LL + #[derive(Copy)]
LL | struct NonClone;
|
-error[E0277]: the trait bound `NonClone: Clone` is not satisfied in `{coroutine@$DIR/clone-impl.rs:62:25: 62:32}`
+error[E0277]: the trait bound `NonClone: Clone` is not satisfied in `{coroutine@$DIR/clone-impl.rs:62:38: 62:45}`
--> $DIR/clone-impl.rs:68:5
|
-LL | let gen_non_clone = move || {
- | ------- within this `{coroutine@$DIR/clone-impl.rs:62:25: 62:32}`
+LL | let gen_non_clone = #[coroutine] move || {
+ | ------- within this `{coroutine@$DIR/clone-impl.rs:62:38: 62:45}`
...
LL | check_clone(&gen_non_clone);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:62:25: 62:32}`, the trait `Clone` is not implemented for `NonClone`, which is required by `{coroutine@$DIR/clone-impl.rs:62:25: 62:32}: Clone`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:62:38: 62:45}`, the trait `Clone` is not implemented for `NonClone`, which is required by `{coroutine@$DIR/clone-impl.rs:62:38: 62:45}: Clone`
|
note: captured value does not implement `Clone`
--> $DIR/clone-impl.rs:64:14
diff --git a/tests/ui/coroutine/clone-rpit.next.stderr b/tests/ui/coroutine/clone-rpit.next.stderr
index 41aa2d63af016..c223f1f211ac6 100644
--- a/tests/ui/coroutine/clone-rpit.next.stderr
+++ b/tests/ui/coroutine/clone-rpit.next.stderr
@@ -5,32 +5,32 @@ LL | pub fn foo<'a, 'b>() -> impl Clone {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: ...which requires coroutine witness types for `foo::{closure#0}`...
- --> $DIR/clone-rpit.rs:14:5
+ --> $DIR/clone-rpit.rs:15:5
|
LL | move |_: ()| {
| ^^^^^^^^^^^^
note: ...which requires promoting constants in MIR for `foo::{closure#0}`...
- --> $DIR/clone-rpit.rs:14:5
+ --> $DIR/clone-rpit.rs:15:5
|
LL | move |_: ()| {
| ^^^^^^^^^^^^
note: ...which requires checking if `foo::{closure#0}` contains FFI-unwind calls...
- --> $DIR/clone-rpit.rs:14:5
+ --> $DIR/clone-rpit.rs:15:5
|
LL | move |_: ()| {
| ^^^^^^^^^^^^
note: ...which requires building MIR for `foo::{closure#0}`...
- --> $DIR/clone-rpit.rs:14:5
+ --> $DIR/clone-rpit.rs:15:5
|
LL | move |_: ()| {
| ^^^^^^^^^^^^
note: ...which requires match-checking `foo::{closure#0}`...
- --> $DIR/clone-rpit.rs:14:5
+ --> $DIR/clone-rpit.rs:15:5
|
LL | move |_: ()| {
| ^^^^^^^^^^^^
note: ...which requires type-checking `foo::{closure#0}`...
- --> $DIR/clone-rpit.rs:14:5
+ --> $DIR/clone-rpit.rs:15:5
|
LL | move |_: ()| {
| ^^^^^^^^^^^^
diff --git a/tests/ui/coroutine/clone-rpit.rs b/tests/ui/coroutine/clone-rpit.rs
index 0df9bf616018f..66569b4f42741 100644
--- a/tests/ui/coroutine/clone-rpit.rs
+++ b/tests/ui/coroutine/clone-rpit.rs
@@ -11,6 +11,7 @@
// witness types, which we don't know until after borrowck. When we later check
// the goal for correctness, we want to be able to bind the `impl Clone` opaque.
pub fn foo<'a, 'b>() -> impl Clone {
+ #[coroutine]
move |_: ()| {
let () = yield ();
}
diff --git a/tests/ui/coroutine/conditional-drop.rs b/tests/ui/coroutine/conditional-drop.rs
index 65d3a9e701ee4..52e1b561946c7 100644
--- a/tests/ui/coroutine/conditional-drop.rs
+++ b/tests/ui/coroutine/conditional-drop.rs
@@ -3,7 +3,7 @@
//@ revisions: default nomiropt
//@[nomiropt]compile-flags: -Z mir-opt-level=0
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
use std::pin::Pin;
@@ -29,7 +29,7 @@ fn main() {
}
fn t1() {
- let mut a = || {
+ let mut a = #[coroutine] || {
let b = B;
if test() {
drop(b);
@@ -45,7 +45,7 @@ fn t1() {
}
fn t2() {
- let mut a = || {
+ let mut a = #[coroutine] || {
let b = B;
if test2() {
drop(b);
diff --git a/tests/ui/coroutine/control-flow.rs b/tests/ui/coroutine/control-flow.rs
index 9070ba17856c9..f64b6f7388366 100644
--- a/tests/ui/coroutine/control-flow.rs
+++ b/tests/ui/coroutine/control-flow.rs
@@ -3,7 +3,7 @@
//@ revisions: default nomiropt
//@[nomiropt]compile-flags: -Z mir-opt-level=0
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::{CoroutineState, Coroutine};
use std::pin::Pin;
@@ -24,25 +24,25 @@ fn finish<T>(mut amt: usize, mut t: T) -> T::Return
}
fn main() {
- finish(1, || yield);
- finish(8, || {
+ finish(1, #[coroutine] || yield);
+ finish(8, #[coroutine] || {
for _ in 0..8 {
yield;
}
});
- finish(1, || {
+ finish(1, #[coroutine] || {
if true {
yield;
} else {
}
});
- finish(1, || {
+ finish(1, #[coroutine] || {
if false {
} else {
yield;
}
});
- finish(2, || {
+ finish(2, #[coroutine] || {
if { yield; false } {
yield;
panic!()
diff --git a/tests/ui/coroutine/coroutine-region-requirements.rs b/tests/ui/coroutine/coroutine-region-requirements.rs
index 8bc34fdd2f053..ab6f16995e276 100644
--- a/tests/ui/coroutine/coroutine-region-requirements.rs
+++ b/tests/ui/coroutine/coroutine-region-requirements.rs
@@ -1,9 +1,9 @@
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::{Coroutine, CoroutineState};
use std::pin::Pin;
fn dangle(x: &mut i32) -> &'static mut i32 {
- let mut g = || {
+ let mut g = #[coroutine] || {
yield;
x
};
diff --git a/tests/ui/coroutine/coroutine-resume-after-panic.rs b/tests/ui/coroutine/coroutine-resume-after-panic.rs
index 8445bf7e6352c..2745ebc61326f 100644
--- a/tests/ui/coroutine/coroutine-resume-after-panic.rs
+++ b/tests/ui/coroutine/coroutine-resume-after-panic.rs
@@ -5,7 +5,7 @@
// Test that we get the correct message for resuming a panicked coroutine.
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::{
ops::Coroutine,
@@ -14,7 +14,7 @@ use std::{
};
fn main() {
- let mut g = || {
+ let mut g = #[coroutine] || {
panic!();
yield;
};
diff --git a/tests/ui/coroutine/coroutine-with-nll.rs b/tests/ui/coroutine/coroutine-with-nll.rs
index 28a3643fbc9cd..fa77ab4e04958 100644
--- a/tests/ui/coroutine/coroutine-with-nll.rs
+++ b/tests/ui/coroutine/coroutine-with-nll.rs
@@ -1,6 +1,7 @@
#![feature(coroutines)]
fn main() {
+ #[coroutine]
|| {
// The reference in `_a` is a Legal with NLL since it ends before the yield
let _a = &mut true;
diff --git a/tests/ui/coroutine/coroutine-with-nll.stderr b/tests/ui/coroutine/coroutine-with-nll.stderr
index 77e8bb1f92ee9..3f3d51da31180 100644
--- a/tests/ui/coroutine/coroutine-with-nll.stderr
+++ b/tests/ui/coroutine/coroutine-with-nll.stderr
@@ -1,5 +1,5 @@
error[E0626]: borrow may still be in use when coroutine yields
- --> $DIR/coroutine-with-nll.rs:7:17
+ --> $DIR/coroutine-with-nll.rs:8:17
|
LL | let b = &mut true;
| ^^^^^^^^^
diff --git a/tests/ui/coroutine/coroutine-yielding-or-returning-itself.rs b/tests/ui/coroutine/coroutine-yielding-or-returning-itself.rs
index 3c91b3c932951..f3110d71d0d72 100644
--- a/tests/ui/coroutine/coroutine-yielding-or-returning-itself.rs
+++ b/tests/ui/coroutine/coroutine-yielding-or-returning-itself.rs
@@ -1,5 +1,5 @@
#![feature(coroutine_trait)]
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
// Test that we cannot create a coroutine that returns a value of its
// own type.
@@ -12,7 +12,7 @@ pub fn want_cyclic_coroutine_return<T>(_: T)
}
fn supply_cyclic_coroutine_return() {
- want_cyclic_coroutine_return(|| {
+ want_cyclic_coroutine_return(#[coroutine] || {
//~^ ERROR type mismatch
if false { yield None.unwrap(); }
None.unwrap()
@@ -25,7 +25,7 @@ pub fn want_cyclic_coroutine_yield<T>(_: T)
}
fn supply_cyclic_coroutine_yield() {
- want_cyclic_coroutine_yield(|| {
+ want_cyclic_coroutine_yield(#[coroutine] || {
//~^ ERROR type mismatch
if false { yield None.unwrap(); }
None.unwrap()
diff --git a/tests/ui/coroutine/coroutine-yielding-or-returning-itself.stderr b/tests/ui/coroutine/coroutine-yielding-or-returning-itself.stderr
index 325030524ba8d..32799148ae1da 100644
--- a/tests/ui/coroutine/coroutine-yielding-or-returning-itself.stderr
+++ b/tests/ui/coroutine/coroutine-yielding-or-returning-itself.stderr
@@ -1,8 +1,8 @@
-error[E0271]: type mismatch resolving `<{coroutine@$DIR/coroutine-yielding-or-returning-itself.rs:15:34: 15:36} as Coroutine>::Return == {coroutine@$DIR/coroutine-yielding-or-returning-itself.rs:15:34: 15:36}`
- --> $DIR/coroutine-yielding-or-returning-itself.rs:15:34
+error[E0271]: type mismatch resolving `<{coroutine@$DIR/coroutine-yielding-or-returning-itself.rs:15:47: 15:49} as Coroutine>::Return == {coroutine@$DIR/coroutine-yielding-or-returning-itself.rs:15:47: 15:49}`
+ --> $DIR/coroutine-yielding-or-returning-itself.rs:15:47
|
-LL | want_cyclic_coroutine_return(|| {
- | _____----------------------------_^
+LL | want_cyclic_coroutine_return(#[coroutine] || {
+ | _____----------------------------______________^
| | |
| | required by a bound introduced by this call
LL | |
@@ -23,11 +23,11 @@ LL | pub fn want_cyclic_coroutine_return<T>(_: T)
LL | where T: Coroutine<Yield = (), Return = T>
| ^^^^^^^^^^ required by this bound in `want_cyclic_coroutine_return`
-error[E0271]: type mismatch resolving `<{coroutine@$DIR/coroutine-yielding-or-returning-itself.rs:28:33: 28:35} as Coroutine>::Yield == {coroutine@$DIR/coroutine-yielding-or-returning-itself.rs:28:33: 28:35}`
- --> $DIR/coroutine-yielding-or-returning-itself.rs:28:33
+error[E0271]: type mismatch resolving `<{coroutine@$DIR/coroutine-yielding-or-returning-itself.rs:28:46: 28:48} as Coroutine>::Yield == {coroutine@$DIR/coroutine-yielding-or-returning-itself.rs:28:46: 28:48}`
+ --> $DIR/coroutine-yielding-or-returning-itself.rs:28:46
|
-LL | want_cyclic_coroutine_yield(|| {
- | _____---------------------------_^
+LL | want_cyclic_coroutine_yield(#[coroutine] || {
+ | _____---------------------------______________^
| | |
| | required by a bound introduced by this call
LL | |
diff --git a/tests/ui/coroutine/derived-drop-parent-expr.rs b/tests/ui/coroutine/derived-drop-parent-expr.rs
index f70a732c90f08..cc217e4960e90 100644
--- a/tests/ui/coroutine/derived-drop-parent-expr.rs
+++ b/tests/ui/coroutine/derived-drop-parent-expr.rs
@@ -1,7 +1,7 @@
//@ build-pass
//! Like drop-tracking-parent-expression, but also tests that this doesn't ICE when building MIR
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
fn assert_send<T: Send>(_thing: T) {}
@@ -9,8 +9,8 @@ fn assert_send<T: Send>(_thing: T) {}
pub struct Client { pub nickname: String }
fn main() {
- let g = move || match drop(Client { ..Client::default() }) {
- _status => yield,
- };
+ let g = #[coroutine] move || match drop(Client { ..Client::default() }) {
+ _status => yield,
+ };
assert_send(g);
}
diff --git a/tests/ui/coroutine/discriminant.rs b/tests/ui/coroutine/discriminant.rs
index a44d8f74746b6..d6879e2182556 100644
--- a/tests/ui/coroutine/discriminant.rs
+++ b/tests/ui/coroutine/discriminant.rs
@@ -86,7 +86,7 @@ fn cycle(
fn main() {
// Has only one invalid discr. value.
let gen_u8_tiny_niche = || {
- || {
+ #[coroutine] || {
// 3 reserved variants
yield250!(); // 253 variants
@@ -98,7 +98,7 @@ fn main() {
// Uses all values in the u8 discriminant.
let gen_u8_full = || {
- || {
+ #[coroutine] || {
// 3 reserved variants
yield250!(); // 253 variants
@@ -111,7 +111,7 @@ fn main() {
// Barely needs a u16 discriminant.
let gen_u16 = || {
- || {
+ #[coroutine] || {
// 3 reserved variants
yield250!(); // 253 variants
diff --git a/tests/ui/coroutine/drop-and-replace.rs b/tests/ui/coroutine/drop-and-replace.rs
index 6e30d76512b72..d3d7e000020a1 100644
--- a/tests/ui/coroutine/drop-and-replace.rs
+++ b/tests/ui/coroutine/drop-and-replace.rs
@@ -4,7 +4,7 @@
// #60187, this produced incorrect code for coroutines when a saved local was
// re-assigned.
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::{Coroutine, CoroutineState};
use std::pin::Pin;
@@ -17,7 +17,8 @@ impl Drop for Foo {
}
fn main() {
- let mut a = || {
+ let mut a = #[coroutine]
+ || {
let mut x = Foo(4);
yield;
assert_eq!(x.0, 4);
diff --git a/tests/ui/coroutine/drop-control-flow.rs b/tests/ui/coroutine/drop-control-flow.rs
index f4e8eed4f8dce..f576b1b759443 100644
--- a/tests/ui/coroutine/drop-control-flow.rs
+++ b/tests/ui/coroutine/drop-control-flow.rs
@@ -4,7 +4,7 @@
// and also that values that are dropped along all paths to a yield do not get
// included in the coroutine type.
-#![feature(coroutines, negative_impls)]
+#![feature(coroutines, negative_impls, stmt_expr_attributes)]
#![allow(unused_assignments, dead_code)]
struct Ptr;
@@ -19,7 +19,7 @@ fn assert_send<T: Send>(_: T) {}
// This test case is reduced from tests/ui/drop/dynamic-drop-async.rs
fn one_armed_if(arg: bool) {
- let _ = || {
+ let _ = #[coroutine] || {
let arr = [Ptr];
if arg {
drop(arr);
@@ -29,7 +29,7 @@ fn one_armed_if(arg: bool) {
}
fn two_armed_if(arg: bool) {
- assert_send(|| {
+ assert_send(#[coroutine] || {
let arr = [Ptr];
if arg {
drop(arr);
@@ -41,7 +41,7 @@ fn two_armed_if(arg: bool) {
}
fn if_let(arg: Option<i32>) {
- let _ = || {
+ let _ = #[coroutine] || {
let arr = [Ptr];
if let Some(_) = arg {
drop(arr);
@@ -51,7 +51,7 @@ fn if_let(arg: Option<i32>) {
}
fn init_in_if(arg: bool) {
- assert_send(|| {
+ assert_send(#[coroutine] || {
let mut x = NonSend;
drop(x);
if arg {
@@ -63,7 +63,7 @@ fn init_in_if(arg: bool) {
}
fn init_in_match_arm(arg: Option<i32>) {
- assert_send(|| {
+ assert_send(#[coroutine] || {
let mut x = NonSend;
drop(x);
match arg {
@@ -74,7 +74,7 @@ fn init_in_match_arm(arg: Option<i32>) {
}
fn reinit() {
- let _ = || {
+ let _ = #[coroutine] || {
let mut arr = [Ptr];
drop(arr);
arr = [Ptr];
@@ -83,7 +83,7 @@ fn reinit() {
}
fn loop_uninit() {
- let _ = || {
+ let _ = #[coroutine] || {
let mut arr = [Ptr];
let mut count = 0;
drop(arr);
@@ -96,7 +96,7 @@ fn loop_uninit() {
}
fn nested_loop() {
- let _ = || {
+ let _ = #[coroutine] || {
let mut arr = [Ptr];
let mut count = 0;
drop(arr);
@@ -111,7 +111,7 @@ fn nested_loop() {
}
fn loop_continue(b: bool) {
- let _ = || {
+ let _ = #[coroutine] || {
let mut arr = [Ptr];
let mut count = 0;
drop(arr);
diff --git a/tests/ui/coroutine/drop-env.rs b/tests/ui/coroutine/drop-env.rs
index b189ab8149956..d36228dc84904 100644
--- a/tests/ui/coroutine/drop-env.rs
+++ b/tests/ui/coroutine/drop-env.rs
@@ -3,7 +3,7 @@
//@ revisions: default nomiropt
//@[nomiropt]compile-flags: -Z mir-opt-level=0
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
#![allow(dropping_copy_types)]
use std::ops::Coroutine;
@@ -28,7 +28,7 @@ fn main() {
fn t1() {
let b = B;
- let mut foo = || {
+ let mut foo = #[coroutine] || {
yield;
drop(b);
};
@@ -42,7 +42,7 @@ fn t1() {
fn t2() {
let b = B;
- let mut foo = || {
+ let mut foo = #[coroutine] || {
yield b;
};
@@ -55,7 +55,7 @@ fn t2() {
fn t3() {
let b = B;
- let foo = || {
+ let foo = #[coroutine] || {
yield;
drop(b);
};
diff --git a/tests/ui/coroutine/drop-track-addassign-yield.rs b/tests/ui/coroutine/drop-track-addassign-yield.rs
index b1a4bd79f31c1..537e66c41b20b 100644
--- a/tests/ui/coroutine/drop-track-addassign-yield.rs
+++ b/tests/ui/coroutine/drop-track-addassign-yield.rs
@@ -3,10 +3,10 @@
// Based on addassign-yield.rs, but with drop tracking enabled. Originally we did not implement
// the fake_read callback on ExprUseVisitor which caused this case to break.
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
fn foo() {
- let _y = static || {
+ let _y = #[coroutine] static || {
let x = &mut 0;
*{
yield;
@@ -17,7 +17,7 @@ fn foo() {
};
// Please don't ever actually write something like this
- let _z = static || {
+ let _z = #[coroutine] static || {
let x = &mut 0;
*{
let inner = &mut 1;
diff --git a/tests/ui/coroutine/drop-tracking-parent-expression.rs b/tests/ui/coroutine/drop-tracking-parent-expression.rs
index 4d40192c07a27..0f4d99c893648 100644
--- a/tests/ui/coroutine/drop-tracking-parent-expression.rs
+++ b/tests/ui/coroutine/drop-tracking-parent-expression.rs
@@ -1,4 +1,4 @@
-#![feature(coroutines, negative_impls, rustc_attrs)]
+#![feature(coroutines, negative_impls, rustc_attrs, stmt_expr_attributes)]
macro_rules! type_combinations {
(
@@ -14,7 +14,7 @@ macro_rules! type_combinations {
// Struct update syntax. This fails because the Client used in the update is considered
// dropped *after* the yield.
{
- let g = move || match drop($name::Client { ..$name::Client::default() }) {
+ let g = #[coroutine] move || match drop($name::Client { ..$name::Client::default() }) {
//~^ `significant_drop::Client` which is not `Send`
//~| `insignificant_dtor::Client` which is not `Send`
//~| `derived_drop::Client` which is not `Send`
@@ -29,7 +29,7 @@ macro_rules! type_combinations {
// Simple owned value. This works because the Client is considered moved into `drop`,
// even though the temporary expression doesn't end until after the yield.
{
- let g = move || match drop($name::Client::default()) {
+ let g = #[coroutine] move || match drop($name::Client::default()) {
_ => yield,
};
assert_send(g);
diff --git a/tests/ui/coroutine/drop-tracking-parent-expression.stderr b/tests/ui/coroutine/drop-tracking-parent-expression.stderr
index 21aa35b9579bc..5f8d8495e4f14 100644
--- a/tests/ui/coroutine/drop-tracking-parent-expression.stderr
+++ b/tests/ui/coroutine/drop-tracking-parent-expression.stderr
@@ -13,12 +13,12 @@ LL | | };
LL | | );
| |_____- in this macro invocation
|
- = help: within `{coroutine@$DIR/drop-tracking-parent-expression.rs:17:21: 17:28}`, the trait `Send` is not implemented for `derived_drop::Client`, which is required by `{coroutine@$DIR/drop-tracking-parent-expression.rs:17:21: 17:28}: Send`
+ = help: within `{coroutine@$DIR/drop-tracking-parent-expression.rs:17:34: 17:41}`, the trait `Send` is not implemented for `derived_drop::Client`, which is required by `{coroutine@$DIR/drop-tracking-parent-expression.rs:17:34: 17:41}: Send`
note: coroutine is not `Send` as this value is used across a yield
--> $DIR/drop-tracking-parent-expression.rs:21:22
|
-LL | let g = move || match drop($name::Client { ..$name::Client::default() }) {
- | ------------------------ has type `derived_drop::Client` which is not `Send`
+LL | let g = #[coroutine] move || match drop($name::Client { ..$name::Client::default() }) {
+ | ------------------------ has type `derived_drop::Client` which is not `Send`
...
LL | _ => yield,
| ^^^^^ yield occurs here, with `$name::Client::default()` maybe used later
@@ -53,12 +53,12 @@ LL | | };
LL | | );
| |_____- in this macro invocation
|
- = help: within `{coroutine@$DIR/drop-tracking-parent-expression.rs:17:21: 17:28}`, the trait `Send` is not implemented for `significant_drop::Client`, which is required by `{coroutine@$DIR/drop-tracking-parent-expression.rs:17:21: 17:28}: Send`
+ = help: within `{coroutine@$DIR/drop-tracking-parent-expression.rs:17:34: 17:41}`, the trait `Send` is not implemented for `significant_drop::Client`, which is required by `{coroutine@$DIR/drop-tracking-parent-expression.rs:17:34: 17:41}: Send`
note: coroutine is not `Send` as this value is used across a yield
--> $DIR/drop-tracking-parent-expression.rs:21:22
|
-LL | let g = move || match drop($name::Client { ..$name::Client::default() }) {
- | ------------------------ has type `significant_drop::Client` which is not `Send`
+LL | let g = #[coroutine] move || match drop($name::Client { ..$name::Client::default() }) {
+ | ------------------------ has type `significant_drop::Client` which is not `Send`
...
LL | _ => yield,
| ^^^^^ yield occurs here, with `$name::Client::default()` maybe used later
@@ -93,12 +93,12 @@ LL | | };
LL | | );
| |_____- in this macro invocation
|
- = help: within `{coroutine@$DIR/drop-tracking-parent-expression.rs:17:21: 17:28}`, the trait `Send` is not implemented for `insignificant_dtor::Client`, which is required by `{coroutine@$DIR/drop-tracking-parent-expression.rs:17:21: 17:28}: Send`
+ = help: within `{coroutine@$DIR/drop-tracking-parent-expression.rs:17:34: 17:41}`, the trait `Send` is not implemented for `insignificant_dtor::Client`, which is required by `{coroutine@$DIR/drop-tracking-parent-expression.rs:17:34: 17:41}: Send`
note: coroutine is not `Send` as this value is used across a yield
--> $DIR/drop-tracking-parent-expression.rs:21:22
|
-LL | let g = move || match drop($name::Client { ..$name::Client::default() }) {
- | ------------------------ has type `insignificant_dtor::Client` which is not `Send`
+LL | let g = #[coroutine] move || match drop($name::Client { ..$name::Client::default() }) {
+ | ------------------------ has type `insignificant_dtor::Client` which is not `Send`
...
LL | _ => yield,
| ^^^^^ yield occurs here, with `$name::Client::default()` maybe used later
diff --git a/tests/ui/coroutine/drop-tracking-yielding-in-match-guards.rs b/tests/ui/coroutine/drop-tracking-yielding-in-match-guards.rs
index 0f94016f11b82..43e42fa85f7f4 100644
--- a/tests/ui/coroutine/drop-tracking-yielding-in-match-guards.rs
+++ b/tests/ui/coroutine/drop-tracking-yielding-in-match-guards.rs
@@ -1,10 +1,10 @@
//@ build-pass
//@ edition:2018
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
fn main() {
- let _ = static |x: u8| match x {
+ let _ = #[coroutine] static |x: u8| match x {
y if { yield } == y + 1 => (),
_ => (),
};
diff --git a/tests/ui/coroutine/drop-yield-twice.rs b/tests/ui/coroutine/drop-yield-twice.rs
index 015343a277626..7ac1345b2ff2e 100644
--- a/tests/ui/coroutine/drop-yield-twice.rs
+++ b/tests/ui/coroutine/drop-yield-twice.rs
@@ -1,10 +1,10 @@
-#![feature(negative_impls, coroutines)]
+#![feature(negative_impls, coroutines, stmt_expr_attributes)]
struct Foo(i32);
impl !Send for Foo {}
fn main() {
- assert_send(|| { //~ ERROR coroutine cannot be sent between threads safely
+ assert_send(#[coroutine] || { //~ ERROR coroutine cannot be sent between threads safely
let guard = Foo(42);
yield;
drop(guard);
diff --git a/tests/ui/coroutine/drop-yield-twice.stderr b/tests/ui/coroutine/drop-yield-twice.stderr
index c6a9e20b8b51f..362c6e943ade0 100644
--- a/tests/ui/coroutine/drop-yield-twice.stderr
+++ b/tests/ui/coroutine/drop-yield-twice.stderr
@@ -1,7 +1,7 @@
error: coroutine cannot be sent between threads safely
--> $DIR/drop-yield-twice.rs:7:5
|
-LL | / assert_send(|| {
+LL | / assert_send(#[coroutine] || {
LL | | let guard = Foo(42);
LL | | yield;
LL | | drop(guard);
@@ -9,7 +9,7 @@ LL | | yield;
LL | | })
| |______^ coroutine is not `Send`
|
- = help: within `{coroutine@$DIR/drop-yield-twice.rs:7:17: 7:19}`, the trait `Send` is not implemented for `Foo`, which is required by `{coroutine@$DIR/drop-yield-twice.rs:7:17: 7:19}: Send`
+ = help: within `{coroutine@$DIR/drop-yield-twice.rs:7:30: 7:32}`, the trait `Send` is not implemented for `Foo`, which is required by `{coroutine@$DIR/drop-yield-twice.rs:7:30: 7:32}: Send`
note: coroutine is not `Send` as this value is used across a yield
--> $DIR/drop-yield-twice.rs:9:9
|
diff --git a/tests/ui/coroutine/dropck-resume.rs b/tests/ui/coroutine/dropck-resume.rs
index 07ca4d37aba69..df014400f00fe 100644
--- a/tests/ui/coroutine/dropck-resume.rs
+++ b/tests/ui/coroutine/dropck-resume.rs
@@ -1,4 +1,4 @@
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::{Coroutine, CoroutineState};
use std::pin::Pin;
@@ -16,7 +16,8 @@ fn drop_using_coroutine() -> i32 {
let z = &mut y;
let r;
{
- let mut g = move |r| {
+ let mut g = #[coroutine]
+ move |r| {
let _s = SetToNone(r);
yield;
};
diff --git a/tests/ui/coroutine/dropck-resume.stderr b/tests/ui/coroutine/dropck-resume.stderr
index aa6e423c7604c..e9243ffa41e5d 100644
--- a/tests/ui/coroutine/dropck-resume.stderr
+++ b/tests/ui/coroutine/dropck-resume.stderr
@@ -1,5 +1,5 @@
error[E0502]: cannot borrow `y` as immutable because it is also borrowed as mutable
- --> $DIR/dropck-resume.rs:25:13
+ --> $DIR/dropck-resume.rs:26:13
|
LL | let z = &mut y;
| ------ mutable borrow occurs here
diff --git a/tests/ui/coroutine/dropck.rs b/tests/ui/coroutine/dropck.rs
index 450361c8dd03b..9331c1fa1d580 100644
--- a/tests/ui/coroutine/dropck.rs
+++ b/tests/ui/coroutine/dropck.rs
@@ -1,4 +1,4 @@
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::cell::RefCell;
use std::ops::Coroutine;
@@ -10,7 +10,8 @@ fn main() {
let ref_ = Box::leak(Box::new(Some(cell.borrow_mut())));
//~^ ERROR `*cell` does not live long enough [E0597]
// the upvar is the non-dropck `&mut Option<Ref<'a, i32>>`.
- gen = || {
+ gen = #[coroutine]
+ || {
// but the coroutine can use it to drop a `Ref<'a, i32>`.
let _d = ref_.take(); //~ ERROR `ref_` does not live long enough
yield;
diff --git a/tests/ui/coroutine/dropck.stderr b/tests/ui/coroutine/dropck.stderr
index 241d6dfe0a169..d6cd7c4cd47a8 100644
--- a/tests/ui/coroutine/dropck.stderr
+++ b/tests/ui/coroutine/dropck.stderr
@@ -16,10 +16,10 @@ LL | }
= note: values in a scope are dropped in the opposite order they are defined
error[E0597]: `ref_` does not live long enough
- --> $DIR/dropck.rs:15:18
+ --> $DIR/dropck.rs:16:18
|
-LL | gen = || {
- | -- value captured here by coroutine
+LL | || {
+ | -- value captured here by coroutine
LL | // but the coroutine can use it to drop a `Ref<'a, i32>`.
LL | let _d = ref_.take();
| ^^^^ borrowed value does not live long enough
diff --git a/tests/ui/coroutine/gen_block.e2024.stderr b/tests/ui/coroutine/gen_block.e2024.stderr
index 2b9eb4a820b65..322259cf2f84f 100644
--- a/tests/ui/coroutine/gen_block.e2024.stderr
+++ b/tests/ui/coroutine/gen_block.e2024.stderr
@@ -1,5 +1,25 @@
+error[E0658]: the `#[coroutines]` attribute is an experimental feature
+ --> $DIR/gen_block.rs:20:13
+ |
+LL | let _ = #[coroutine] || yield true;
+ | ^^^^^^^^^^^^
+ |
+ = note: see issue #43122 <https://github.com/rust-lang/rust/issues/43122> for more information
+ = help: add `#![feature(coroutines)]` to the crate attributes to enable
+ = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: the `#[coroutines]` attribute is an experimental feature
+ --> $DIR/gen_block.rs:24:13
+ |
+LL | let _ = #[coroutine] || {};
+ | ^^^^^^^^^^^^
+ |
+ = note: see issue #43122 <https://github.com/rust-lang/rust/issues/43122> for more information
+ = help: add `#![feature(coroutines)]` to the crate attributes to enable
+ = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
error[E0658]: yield syntax is experimental
- --> $DIR/gen_block.rs:15:16
+ --> $DIR/gen_block.rs:16:16
|
LL | let _ = || yield true;
| ^^^^^^^^^^
@@ -8,13 +28,34 @@ LL | let _ = || yield true;
= help: add `#![feature(coroutines)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+ --> $DIR/gen_block.rs:16:16
+ |
+LL | let _ = || yield true;
+ | ^^^^^^^^^^
+ |
+help: use `#[coroutine]` to make this closure a coroutine
+ |
+LL | let _ = #[coroutine] || yield true;
+ | ++++++++++++
+
+error[E0658]: yield syntax is experimental
+ --> $DIR/gen_block.rs:20:29
+ |
+LL | let _ = #[coroutine] || yield true;
+ | ^^^^^^^^^^
+ |
+ = note: see issue #43122 <https://github.com/rust-lang/rust/issues/43122> for more information
+ = help: add `#![feature(coroutines)]` to the crate attributes to enable
+ = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
error[E0282]: type annotations needed
- --> $DIR/gen_block.rs:6:13
+ --> $DIR/gen_block.rs:7:13
|
LL | let x = gen {};
| ^^^^^^ cannot infer type
-error: aborting due to 2 previous errors
+error: aborting due to 6 previous errors
Some errors have detailed explanations: E0282, E0658.
For more information about an error, try `rustc --explain E0282`.
diff --git a/tests/ui/coroutine/gen_block.none.stderr b/tests/ui/coroutine/gen_block.none.stderr
index 78a8c5e798ad8..64fa2be003de5 100644
--- a/tests/ui/coroutine/gen_block.none.stderr
+++ b/tests/ui/coroutine/gen_block.none.stderr
@@ -1,5 +1,5 @@
error: expected identifier, found reserved keyword `yield`
- --> $DIR/gen_block.rs:9:19
+ --> $DIR/gen_block.rs:10:19
|
LL | let y = gen { yield 42 };
| --- ^^^^^ expected identifier, found reserved keyword
@@ -7,25 +7,25 @@ LL | let y = gen { yield 42 };
| while parsing this struct
error[E0422]: cannot find struct, variant or union type `gen` in this scope
- --> $DIR/gen_block.rs:6:13
+ --> $DIR/gen_block.rs:7:13
|
LL | let x = gen {};
| ^^^ not found in this scope
error[E0422]: cannot find struct, variant or union type `gen` in this scope
- --> $DIR/gen_block.rs:9:13
+ --> $DIR/gen_block.rs:10:13
|
LL | let y = gen { yield 42 };
| ^^^ not found in this scope
error[E0422]: cannot find struct, variant or union type `gen` in this scope
- --> $DIR/gen_block.rs:12:5
+ --> $DIR/gen_block.rs:13:5
|
LL | gen {};
| ^^^ not found in this scope
error[E0658]: yield syntax is experimental
- --> $DIR/gen_block.rs:15:16
+ --> $DIR/gen_block.rs:16:16
|
LL | let _ = || yield true;
| ^^^^^^^^^^
@@ -35,17 +35,69 @@ LL | let _ = || yield true;
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: yield syntax is experimental
- --> $DIR/gen_block.rs:15:16
+ --> $DIR/gen_block.rs:20:29
+ |
+LL | let _ = #[coroutine] || yield true;
+ | ^^^^^^^^^^
+ |
+ = note: see issue #43122 <https://github.com/rust-lang/rust/issues/43122> for more information
+ = help: add `#![feature(coroutines)]` to the crate attributes to enable
+ = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: the `#[coroutines]` attribute is an experimental feature
+ --> $DIR/gen_block.rs:20:13
+ |
+LL | let _ = #[coroutine] || yield true;
+ | ^^^^^^^^^^^^
+ |
+ = note: see issue #43122 <https://github.com/rust-lang/rust/issues/43122> for more information
+ = help: add `#![feature(coroutines)]` to the crate attributes to enable
+ = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: the `#[coroutines]` attribute is an experimental feature
+ --> $DIR/gen_block.rs:24:13
+ |
+LL | let _ = #[coroutine] || {};
+ | ^^^^^^^^^^^^
+ |
+ = note: see issue #43122 <https://github.com/rust-lang/rust/issues/43122> for more information
+ = help: add `#![feature(coroutines)]` to the crate attributes to enable
+ = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: yield syntax is experimental
+ --> $DIR/gen_block.rs:16:16
+ |
+LL | let _ = || yield true;
+ | ^^^^^^^^^^
+ |
+ = note: see issue #43122 <https://github.com/rust-lang/rust/issues/43122> for more information
+ = help: add `#![feature(coroutines)]` to the crate attributes to enable
+ = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+ = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+ --> $DIR/gen_block.rs:16:16
|
LL | let _ = || yield true;
| ^^^^^^^^^^
|
+help: use `#[coroutine]` to make this closure a coroutine
+ |
+LL | let _ = #[coroutine] || yield true;
+ | ++++++++++++
+
+error[E0658]: yield syntax is experimental
+ --> $DIR/gen_block.rs:20:29
+ |
+LL | let _ = #[coroutine] || yield true;
+ | ^^^^^^^^^^
+ |
= note: see issue #43122 <https://github.com/rust-lang/rust/issues/43122> for more information
= help: add `#![feature(coroutines)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-error: aborting due to 6 previous errors
+error: aborting due to 11 previous errors
Some errors have detailed explanations: E0422, E0658.
For more information about an error, try `rustc --explain E0422`.
diff --git a/tests/ui/coroutine/gen_block.rs b/tests/ui/coroutine/gen_block.rs
index f6a775aa66199..7e87a572b9095 100644
--- a/tests/ui/coroutine/gen_block.rs
+++ b/tests/ui/coroutine/gen_block.rs
@@ -1,6 +1,7 @@
//@ revisions: e2024 none
//@[e2024] compile-flags: --edition 2024 -Zunstable-options
#![cfg_attr(e2024, feature(gen_blocks))]
+#![feature(stmt_expr_attributes)]
fn main() {
let x = gen {};
@@ -14,4 +15,12 @@ fn main() {
let _ = || yield true; //[none]~ ERROR yield syntax is experimental
//~^ ERROR yield syntax is experimental
+ //~^^ ERROR `yield` can only be used in
+
+ let _ = #[coroutine] || yield true; //[none]~ ERROR yield syntax is experimental
+ //~^ ERROR `#[coroutines]` attribute is an experimental feature
+ //~^^ ERROR yield syntax is experimental
+
+ let _ = #[coroutine] || {};
+ //~^ ERROR `#[coroutines]` attribute is an experimental feature
}
diff --git a/tests/ui/coroutine/issue-102645.rs b/tests/ui/coroutine/issue-102645.rs
index a0263510e1368..ccf82c3606ac2 100644
--- a/tests/ui/coroutine/issue-102645.rs
+++ b/tests/ui/coroutine/issue-102645.rs
@@ -1,11 +1,12 @@
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
use std::pin::Pin;
fn main() {
let mut a = 5;
- let mut b = || {
+ let mut b = #[coroutine]
+ || {
let d = 6;
yield;
_zzz(); // #break
diff --git a/tests/ui/coroutine/issue-102645.stderr b/tests/ui/coroutine/issue-102645.stderr
index 7a3b7f2b04c34..ab5e4a8459f4f 100644
--- a/tests/ui/coroutine/issue-102645.stderr
+++ b/tests/ui/coroutine/issue-102645.stderr
@@ -1,5 +1,5 @@
error[E0061]: this method takes 1 argument but 0 arguments were supplied
- --> $DIR/issue-102645.rs:14:22
+ --> $DIR/issue-102645.rs:15:22
|
LL | Pin::new(&mut b).resume();
| ^^^^^^-- an argument of type `()` is missing
diff --git a/tests/ui/coroutine/issue-105084.rs b/tests/ui/coroutine/issue-105084.rs
index 7801f1bcea0db..4e40bc127d780 100644
--- a/tests/ui/coroutine/issue-105084.rs
+++ b/tests/ui/coroutine/issue-105084.rs
@@ -11,7 +11,8 @@ fn copy<T: Copy>(x: T) -> T {
}
fn main() {
- let mut g = || {
+ let mut g = #[coroutine]
+ || {
// This is desuraged as 4 stages:
// - allocate a `*mut u8` with `exchange_malloc`;
// - create a Box that is ignored for trait computations;
diff --git a/tests/ui/coroutine/issue-105084.stderr b/tests/ui/coroutine/issue-105084.stderr
index c8a6522dbd938..6b1701f0c2abc 100644
--- a/tests/ui/coroutine/issue-105084.stderr
+++ b/tests/ui/coroutine/issue-105084.stderr
@@ -1,8 +1,8 @@
error[E0382]: borrow of moved value: `g`
- --> $DIR/issue-105084.rs:37:14
+ --> $DIR/issue-105084.rs:38:14
|
-LL | let mut g = || {
- | ----- move occurs because `g` has type `{coroutine@$DIR/issue-105084.rs:14:17: 14:19}`, which does not implement the `Copy` trait
+LL | let mut g = #[coroutine]
+ | ----- move occurs because `g` has type `{coroutine@$DIR/issue-105084.rs:15:5: 15:7}`, which does not implement the `Copy` trait
...
LL | let mut h = copy(g);
| - value moved here
@@ -22,17 +22,17 @@ help: consider cloning the value if the performance cost is acceptable
LL | let mut h = copy(g.clone());
| ++++++++
-error[E0277]: the trait bound `Box<(i32, ())>: Copy` is not satisfied in `{coroutine@$DIR/issue-105084.rs:14:17: 14:19}`
- --> $DIR/issue-105084.rs:31:17
+error[E0277]: the trait bound `Box<(i32, ())>: Copy` is not satisfied in `{coroutine@$DIR/issue-105084.rs:15:5: 15:7}`
+ --> $DIR/issue-105084.rs:32:17
|
-LL | let mut g = || {
- | -- within this `{coroutine@$DIR/issue-105084.rs:14:17: 14:19}`
+LL | || {
+ | -- within this `{coroutine@$DIR/issue-105084.rs:15:5: 15:7}`
...
LL | let mut h = copy(g);
- | ^^^^^^^ within `{coroutine@$DIR/issue-105084.rs:14:17: 14:19}`, the trait `Copy` is not implemented for `Box<(i32, ())>`, which is required by `{coroutine@$DIR/issue-105084.rs:14:17: 14:19}: Copy`
+ | ^^^^^^^ within `{coroutine@$DIR/issue-105084.rs:15:5: 15:7}`, the trait `Copy` is not implemented for `Box<(i32, ())>`, which is required by `{coroutine@$DIR/issue-105084.rs:15:5: 15:7}: Copy`
|
note: coroutine does not implement `Copy` as this value is used across a yield
- --> $DIR/issue-105084.rs:21:22
+ --> $DIR/issue-105084.rs:22:22
|
LL | Box::new((5, yield));
| -------------^^^^^--
diff --git a/tests/ui/coroutine/issue-110929-coroutine-conflict-error-ice.rs b/tests/ui/coroutine/issue-110929-coroutine-conflict-error-ice.rs
index 3d372ac9110c9..300c8fe6d4618 100644
--- a/tests/ui/coroutine/issue-110929-coroutine-conflict-error-ice.rs
+++ b/tests/ui/coroutine/issue-110929-coroutine-conflict-error-ice.rs
@@ -1,11 +1,12 @@
//@ edition:2021
//@ check-pass
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
fn main() {
let x = &mut ();
|| {
- let _c = || yield *&mut *x;
+ let _c = #[coroutine]
+ || yield *&mut *x;
|| _ = &mut *x;
};
}
diff --git a/tests/ui/coroutine/issue-113279.rs b/tests/ui/coroutine/issue-113279.rs
index f251c924c1331..98617af105c35 100644
--- a/tests/ui/coroutine/issue-113279.rs
+++ b/tests/ui/coroutine/issue-113279.rs
@@ -1,4 +1,4 @@
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
// `foo` attempts to dereference `""`, which results in an error being reported. Later, the
// coroutine transform for `foo` then produces a union which contains a `str` type - unions should
@@ -9,7 +9,8 @@
// makes sure that doesn't happen again.
fn foo() {
- let _y = static || {
+ let _y = #[coroutine]
+ static || {
let x = &mut 0;
*{
yield;
diff --git a/tests/ui/coroutine/issue-113279.stderr b/tests/ui/coroutine/issue-113279.stderr
index cc9b64ef9ac2f..a80fe670188d6 100644
--- a/tests/ui/coroutine/issue-113279.stderr
+++ b/tests/ui/coroutine/issue-113279.stderr
@@ -1,11 +1,11 @@
error[E0161]: cannot move a value of type `str`
- --> $DIR/issue-113279.rs:17:20
+ --> $DIR/issue-113279.rs:18:20
|
LL | } += match { *"" }.len() {
| ^^^^^^^ the size of `str` cannot be statically determined
error[E0507]: cannot move out of a shared reference
- --> $DIR/issue-113279.rs:17:22
+ --> $DIR/issue-113279.rs:18:22
|
LL | } += match { *"" }.len() {
| ^^^ move occurs because value has type `str`, which does not implement the `Copy` trait
diff --git a/tests/ui/coroutine/issue-44197.rs b/tests/ui/coroutine/issue-44197.rs
index e18bcc2c996f2..0240f7a7eaac2 100644
--- a/tests/ui/coroutine/issue-44197.rs
+++ b/tests/ui/coroutine/issue-44197.rs
@@ -10,7 +10,7 @@ fn foo(_: &str) -> String {
}
fn bar(baz: String) -> impl Coroutine<(), Yield = String, Return = ()> {
- move || {
+ #[coroutine] move || {
yield foo(&baz);
}
}
@@ -20,7 +20,7 @@ fn foo2(_: &str) -> Result<String, ()> {
}
fn bar2(baz: String) -> impl Coroutine<(), Yield = String, Return = ()> {
- move || {
+ #[coroutine] move || {
if let Ok(quux) = foo2(&baz) {
yield quux;
}
diff --git a/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.rs b/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.rs
index dab9c81bc8fe8..d90886b6b1d6e 100644
--- a/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.rs
+++ b/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.rs
@@ -1,7 +1,8 @@
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
fn main() {
- let _ = || {
+ let _ = #[coroutine]
+ || {
*(1 as *mut u32) = 42;
//~^ ERROR dereference of raw pointer is unsafe
yield;
diff --git a/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.stderr b/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.stderr
index 19949b4293962..f99c295bb9ebf 100644
--- a/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.stderr
+++ b/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.stderr
@@ -1,5 +1,5 @@
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
- --> $DIR/issue-45729-unsafe-in-coroutine.rs:5:9
+ --> $DIR/issue-45729-unsafe-in-coroutine.rs:6:9
|
LL | *(1 as *mut u32) = 42;
| ^^^^^^^^^^^^^^^^ dereference of raw pointer
diff --git a/tests/ui/coroutine/issue-48048.rs b/tests/ui/coroutine/issue-48048.rs
index b61b7c7707235..75664f20198b5 100644
--- a/tests/ui/coroutine/issue-48048.rs
+++ b/tests/ui/coroutine/issue-48048.rs
@@ -3,7 +3,7 @@
fn main() {
let x = (|_| {},);
- || {
+ #[coroutine] || {
let x = x;
x.0({ //~ ERROR borrow may still be in use when coroutine yields
diff --git a/tests/ui/coroutine/issue-52304.rs b/tests/ui/coroutine/issue-52304.rs
index 01ed181ab1dcb..552bc0028ee04 100644
--- a/tests/ui/coroutine/issue-52304.rs
+++ b/tests/ui/coroutine/issue-52304.rs
@@ -5,6 +5,7 @@
use std::ops::Coroutine;
pub fn example() -> impl Coroutine {
+ #[coroutine]
|| yield &1
}
diff --git a/tests/ui/coroutine/issue-52398.rs b/tests/ui/coroutine/issue-52398.rs
index 826ce6b9d9b3f..f8b2faf4eabf0 100644
--- a/tests/ui/coroutine/issue-52398.rs
+++ b/tests/ui/coroutine/issue-52398.rs
@@ -14,14 +14,14 @@ impl A {
fn main() {
// Test that the MIR local with type &A created for the auto-borrow adjustment
// is caught by typeck
- move || { //~ WARN unused coroutine that must be used
+ #[coroutine] move || { //~ WARN unused coroutine that must be used
A.test(yield);
};
// Test that the std::cell::Ref temporary returned from the `borrow` call
// is caught by typeck
let y = RefCell::new(true);
- static move || { //~ WARN unused coroutine that must be used
+ #[coroutine] static move || { //~ WARN unused coroutine that must be used
yield *y.borrow();
return "Done";
};
diff --git a/tests/ui/coroutine/issue-52398.stderr b/tests/ui/coroutine/issue-52398.stderr
index 18d816da4c611..806690cc33276 100644
--- a/tests/ui/coroutine/issue-52398.stderr
+++ b/tests/ui/coroutine/issue-52398.stderr
@@ -1,7 +1,8 @@
warning: unused coroutine that must be used
- --> $DIR/issue-52398.rs:17:5
+ --> $DIR/issue-52398.rs:17:18
|
-LL | / move || {
+LL | #[coroutine] move || {
+ | __________________^
LL | | A.test(yield);
LL | | };
| |_____^
@@ -10,9 +11,10 @@ LL | | };
= note: `#[warn(unused_must_use)]` on by default
warning: unused coroutine that must be used
- --> $DIR/issue-52398.rs:24:5
+ --> $DIR/issue-52398.rs:24:18
|
-LL | / static move || {
+LL | #[coroutine] static move || {
+ | __________________^
LL | | yield *y.borrow();
LL | | return "Done";
LL | | };
diff --git a/tests/ui/coroutine/issue-53548.rs b/tests/ui/coroutine/issue-53548.rs
index 6d55994137ff9..3b8dff2be28c1 100644
--- a/tests/ui/coroutine/issue-53548.rs
+++ b/tests/ui/coroutine/issue-53548.rs
@@ -17,7 +17,7 @@
//
//@ check-pass
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
use std::cell::RefCell;
use std::rc::Rc;
@@ -29,7 +29,7 @@ struct Store<C> {
}
fn main() {
- Box::new(static move || {
+ Box::new(#[coroutine] static move || {
let store = Store::<Box<dyn Trait>> {
inner: Default::default(),
};
diff --git a/tests/ui/coroutine/issue-57017.rs b/tests/ui/coroutine/issue-57017.rs
index b83d916932abd..19cd80ab4a653 100644
--- a/tests/ui/coroutine/issue-57017.rs
+++ b/tests/ui/coroutine/issue-57017.rs
@@ -1,5 +1,5 @@
//@ build-pass
-#![feature(coroutines, negative_impls)]
+#![feature(coroutines, negative_impls, stmt_expr_attributes)]
#![allow(dropping_references, dropping_copy_types)]
macro_rules! type_combinations {
@@ -21,7 +21,7 @@ macro_rules! type_combinations {
// This is the same bug as issue 57017, but using yield instead of await
{
- let g = move || match drop(&$name::unsync::Client::default()) {
+ let g = #[coroutine] move || match drop(&$name::unsync::Client::default()) {
_status => yield,
};
assert_send(g);
@@ -30,7 +30,7 @@ macro_rules! type_combinations {
// This tests that `Client` is properly considered to be dropped after moving it into the
// function.
{
- let g = move || match drop($name::unsend::Client::default()) {
+ let g = #[coroutine] move || match drop($name::unsend::Client::default()) {
_status => yield,
};
assert_send(g);
diff --git a/tests/ui/coroutine/issue-57084.rs b/tests/ui/coroutine/issue-57084.rs
index 51b0c8e1de96c..2df60550e0378 100644
--- a/tests/ui/coroutine/issue-57084.rs
+++ b/tests/ui/coroutine/issue-57084.rs
@@ -8,7 +8,7 @@ use std::ops::Coroutine;
fn with<F>(f: F) -> impl Coroutine<Yield=(), Return=()>
where F: Fn() -> ()
{
- move || {
+ #[coroutine] move || {
loop {
match f() {
_ => yield,
@@ -19,7 +19,7 @@ where F: Fn() -> ()
fn main() {
let data = &vec![1];
- || { //~ WARN unused coroutine that must be used
+ #[coroutine] || { //~ WARN unused coroutine that must be used
let _to_pin = with(move || println!("{:p}", data));
loop {
yield
diff --git a/tests/ui/coroutine/issue-57084.stderr b/tests/ui/coroutine/issue-57084.stderr
index 9f5b79a6ae8af..81bd27da91905 100644
--- a/tests/ui/coroutine/issue-57084.stderr
+++ b/tests/ui/coroutine/issue-57084.stderr
@@ -1,7 +1,8 @@
warning: unused coroutine that must be used
- --> $DIR/issue-57084.rs:22:5
+ --> $DIR/issue-57084.rs:22:18
|
-LL | / || {
+LL | #[coroutine] || {
+ | __________________^
LL | | let _to_pin = with(move || println!("{:p}", data));
LL | | loop {
LL | | yield
diff --git a/tests/ui/coroutine/issue-57478.rs b/tests/ui/coroutine/issue-57478.rs
index 5e479aaa9c1b3..494c2ee9843eb 100644
--- a/tests/ui/coroutine/issue-57478.rs
+++ b/tests/ui/coroutine/issue-57478.rs
@@ -1,16 +1,19 @@
//@ check-pass
-#![feature(negative_impls, coroutines)]
+#![feature(negative_impls, coroutines, stmt_expr_attributes)]
struct Foo;
impl !Send for Foo {}
fn main() {
- assert_send(|| {
- let guard = Foo;
- drop(guard);
- yield;
- })
+ assert_send(
+ #[coroutine]
+ || {
+ let guard = Foo;
+ drop(guard);
+ yield;
+ },
+ )
}
fn assert_send<T: Send>(_: T) {}
diff --git a/tests/ui/coroutine/issue-58888.rs b/tests/ui/coroutine/issue-58888.rs
index ce45f22dd6ef3..6266f97ce8c46 100644
--- a/tests/ui/coroutine/issue-58888.rs
+++ b/tests/ui/coroutine/issue-58888.rs
@@ -13,7 +13,7 @@ impl Database {
}
fn check_connection(&self) -> impl Coroutine<Yield = (), Return = ()> + '_ {
- move || {
+ #[coroutine] move || {
let iter = self.get_connection();
for i in iter {
yield i
diff --git a/tests/ui/coroutine/issue-61442-stmt-expr-with-drop.rs b/tests/ui/coroutine/issue-61442-stmt-expr-with-drop.rs
index 6280b777201fb..6f513c250a554 100644
--- a/tests/ui/coroutine/issue-61442-stmt-expr-with-drop.rs
+++ b/tests/ui/coroutine/issue-61442-stmt-expr-with-drop.rs
@@ -4,7 +4,7 @@
//@ check-pass
//@ edition:2018
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
@@ -14,12 +14,14 @@ async fn drop_and_await() {
}
fn drop_and_yield() {
- let x = || {
+ let x = #[coroutine]
+ || {
String::new();
yield;
};
Box::pin(x).as_mut().resume(());
- let y = static || {
+ let y = #[coroutine]
+ static || {
String::new();
yield;
};
diff --git a/tests/ui/coroutine/issue-64620-yield-array-element.rs b/tests/ui/coroutine/issue-64620-yield-array-element.rs
index a9307d306a617..0d898d014e80b 100644
--- a/tests/ui/coroutine/issue-64620-yield-array-element.rs
+++ b/tests/ui/coroutine/issue-64620-yield-array-element.rs
@@ -4,6 +4,7 @@
pub fn crash(arr: [usize; 1]) {
yield arr[0]; //~ ERROR: yield expression outside of coroutine literal
+ //~^ ERROR: `yield` can only be used in
}
fn main() {}
diff --git a/tests/ui/coroutine/issue-64620-yield-array-element.stderr b/tests/ui/coroutine/issue-64620-yield-array-element.stderr
index 347532fb7193e..1c030c5248e1e 100644
--- a/tests/ui/coroutine/issue-64620-yield-array-element.stderr
+++ b/tests/ui/coroutine/issue-64620-yield-array-element.stderr
@@ -1,9 +1,20 @@
+error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+ --> $DIR/issue-64620-yield-array-element.rs:6:5
+ |
+LL | yield arr[0];
+ | ^^^^^^^^^^^^
+ |
+help: use `#[coroutine]` to make this closure a coroutine
+ |
+LL | #[coroutine] pub fn crash(arr: [usize; 1]) {
+ | ++++++++++++
+
error[E0627]: yield expression outside of coroutine literal
--> $DIR/issue-64620-yield-array-element.rs:6:5
|
LL | yield arr[0];
| ^^^^^^^^^^^^
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0627`.
diff --git a/tests/ui/coroutine/issue-68112.rs b/tests/ui/coroutine/issue-68112.rs
index ccec2acc97623..b296772c90577 100644
--- a/tests/ui/coroutine/issue-68112.rs
+++ b/tests/ui/coroutine/issue-68112.rs
@@ -1,4 +1,4 @@
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::{
cell::RefCell,
@@ -30,7 +30,7 @@ fn make_non_send_coroutine() -> impl Coroutine<Return = Arc<RefCell<i32>>> {
}
fn test1() {
- let send_gen = || {
+ let send_gen = #[coroutine] || {
let _non_send_gen = make_non_send_coroutine();
//~^ NOTE not `Send`
yield;
@@ -46,7 +46,7 @@ fn test1() {
pub fn make_gen2<T>(t: T) -> impl Coroutine<Return = T> {
//~^ NOTE appears within the type
//~| NOTE expansion of desugaring
- || { //~ NOTE used within this coroutine
+ #[coroutine] || { //~ NOTE used within this coroutine
yield;
t
}
@@ -57,7 +57,7 @@ fn make_non_send_coroutine2() -> impl Coroutine<Return = Arc<RefCell<i32>>> { //
}
fn test2() {
- let send_gen = || { //~ NOTE used within this coroutine
+ let send_gen = #[coroutine] || { //~ NOTE used within this coroutine
let _non_send_gen = make_non_send_coroutine2();
yield;
};
diff --git a/tests/ui/coroutine/issue-68112.stderr b/tests/ui/coroutine/issue-68112.stderr
index 443195d36a30a..bcfcb5ec6e608 100644
--- a/tests/ui/coroutine/issue-68112.stderr
+++ b/tests/ui/coroutine/issue-68112.stderr
@@ -4,7 +4,7 @@ error: coroutine cannot be sent between threads safely
LL | require_send(send_gen);
| ^^^^^^^^^^^^^^^^^^^^^^ coroutine is not `Send`
|
- = help: the trait `Sync` is not implemented for `RefCell<i32>`, which is required by `{coroutine@$DIR/issue-68112.rs:33:20: 33:22}: Send`
+ = help: the trait `Sync` is not implemented for `RefCell<i32>`, which is required by `{coroutine@$DIR/issue-68112.rs:33:33: 33:35}: Send`
= note: if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` instead
note: coroutine is not `Send` as this value is used across a yield
--> $DIR/issue-68112.rs:36:9
@@ -26,14 +26,14 @@ error[E0277]: `RefCell<i32>` cannot be shared between threads safely
LL | require_send(send_gen);
| ^^^^^^^^^^^^^^^^^^^^^^ `RefCell<i32>` cannot be shared between threads safely
|
- = help: the trait `Sync` is not implemented for `RefCell<i32>`, which is required by `{coroutine@$DIR/issue-68112.rs:60:20: 60:22}: Send`
+ = help: the trait `Sync` is not implemented for `RefCell<i32>`, which is required by `{coroutine@$DIR/issue-68112.rs:60:33: 60:35}: Send`
= note: if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` instead
= note: required for `Arc<RefCell<i32>>` to implement `Send`
note: required because it's used within this coroutine
- --> $DIR/issue-68112.rs:49:5
+ --> $DIR/issue-68112.rs:49:18
|
-LL | || {
- | ^^
+LL | #[coroutine] || {
+ | ^^
note: required because it appears within the type `impl Coroutine<Return = Arc<RefCell<i32>>>`
--> $DIR/issue-68112.rs:46:30
|
@@ -45,10 +45,10 @@ note: required because it appears within the type `impl Coroutine<Return = Arc<R
LL | fn make_non_send_coroutine2() -> impl Coroutine<Return = Arc<RefCell<i32>>> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required because it's used within this coroutine
- --> $DIR/issue-68112.rs:60:20
+ --> $DIR/issue-68112.rs:60:33
|
-LL | let send_gen = || {
- | ^^
+LL | let send_gen = #[coroutine] || {
+ | ^^
note: required by a bound in `require_send`
--> $DIR/issue-68112.rs:22:25
|
diff --git a/tests/ui/coroutine/issue-69017.rs b/tests/ui/coroutine/issue-69017.rs
index 09bbf63a986e5..bf69e1dfdb13f 100644
--- a/tests/ui/coroutine/issue-69017.rs
+++ b/tests/ui/coroutine/issue-69017.rs
@@ -10,6 +10,7 @@
use std::ops::Coroutine;
fn gen() -> impl Coroutine<usize> {
+ #[coroutine]
|_: usize| {
println!("-> {}", yield);
}
diff --git a/tests/ui/coroutine/issue-69039.rs b/tests/ui/coroutine/issue-69039.rs
index fd12414c3d851..13cb50e582817 100644
--- a/tests/ui/coroutine/issue-69039.rs
+++ b/tests/ui/coroutine/issue-69039.rs
@@ -9,6 +9,7 @@ fn mkstr(my_name: String, my_mood: String) -> String {
}
fn my_scenario() -> impl Coroutine<String, Yield = &'static str, Return = String> {
+ #[coroutine]
|_arg: String| {
let my_name = yield "What is your name?";
let my_mood = yield "How are you feeling?";
diff --git a/tests/ui/coroutine/issue-87142.rs b/tests/ui/coroutine/issue-87142.rs
index f5c3805842c51..6c22ba3dd7560 100644
--- a/tests/ui/coroutine/issue-87142.rs
+++ b/tests/ui/coroutine/issue-87142.rs
@@ -22,6 +22,7 @@ pub struct Context<G: 'static + CoroutineProviderAlt> {
impl CoroutineProviderAlt for () {
type Coro = impl Coroutine<(), Return = (), Yield = ()>;
fn start(ctx: Context<Self>) -> Self::Coro {
+ #[coroutine]
move || {
match ctx {
_ => (),
diff --git a/tests/ui/coroutine/issue-88653.rs b/tests/ui/coroutine/issue-88653.rs
index ec4c205475877..3afd12a209379 100644
--- a/tests/ui/coroutine/issue-88653.rs
+++ b/tests/ui/coroutine/issue-88653.rs
@@ -11,6 +11,7 @@ fn foo(bar: bool) -> impl Coroutine<(bool,)> {
//~| NOTE: expected coroutine signature `fn((bool,)) -> _`
//~| NOTE: in this expansion of desugaring of `impl Trait`
//~| NOTE: in this expansion of desugaring of `impl Trait`
+ #[coroutine]
|bar| {
//~^ NOTE: found signature defined here
if bar {
diff --git a/tests/ui/coroutine/issue-91477.rs b/tests/ui/coroutine/issue-91477.rs
index c98546f7971cf..c215fd7948f33 100644
--- a/tests/ui/coroutine/issue-91477.rs
+++ b/tests/ui/coroutine/issue-91477.rs
@@ -2,6 +2,7 @@
fn foo() -> impl Sized {
yield 1; //~ ERROR E0627
+ //~^ ERROR: `yield` can only be used in
}
fn main() {}
diff --git a/tests/ui/coroutine/issue-91477.stderr b/tests/ui/coroutine/issue-91477.stderr
index ca8e43d8a26db..5e2151c4c35fe 100644
--- a/tests/ui/coroutine/issue-91477.stderr
+++ b/tests/ui/coroutine/issue-91477.stderr
@@ -1,9 +1,20 @@
+error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+ --> $DIR/issue-91477.rs:4:5
+ |
+LL | yield 1;
+ | ^^^^^^^
+ |
+help: use `#[coroutine]` to make this closure a coroutine
+ |
+LL | #[coroutine] fn foo() -> impl Sized {
+ | ++++++++++++
+
error[E0627]: yield expression outside of coroutine literal
--> $DIR/issue-91477.rs:4:5
|
LL | yield 1;
| ^^^^^^^
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0627`.
diff --git a/tests/ui/coroutine/iterator-count.rs b/tests/ui/coroutine/iterator-count.rs
index bb202ab2d33ed..1ca8ceaed2a9e 100644
--- a/tests/ui/coroutine/iterator-count.rs
+++ b/tests/ui/coroutine/iterator-count.rs
@@ -21,6 +21,7 @@ impl<T: Coroutine<(), Return = ()> + Unpin> Iterator for W<T> {
}
fn test() -> impl Coroutine<(), Return = (), Yield = u8> + Unpin {
+ #[coroutine]
|| {
for i in 1..6 {
yield i
@@ -32,6 +33,7 @@ fn main() {
let end = 11;
let closure_test = |start| {
+ #[coroutine]
move || {
for i in start..end {
yield i
diff --git a/tests/ui/coroutine/live-upvar-across-yield.rs b/tests/ui/coroutine/live-upvar-across-yield.rs
index 86c4716c9516d..d13d480dcdcce 100644
--- a/tests/ui/coroutine/live-upvar-across-yield.rs
+++ b/tests/ui/coroutine/live-upvar-across-yield.rs
@@ -1,13 +1,13 @@
//@ run-pass
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
use std::pin::Pin;
fn main() {
let b = |_| 3;
- let mut a = || {
+ let mut a = #[coroutine] || {
b(yield);
};
Pin::new(&mut a).resume(());
diff --git a/tests/ui/coroutine/match-bindings.rs b/tests/ui/coroutine/match-bindings.rs
index 9ea1deaab3623..2a0cd9af9f382 100644
--- a/tests/ui/coroutine/match-bindings.rs
+++ b/tests/ui/coroutine/match-bindings.rs
@@ -9,7 +9,7 @@ enum Enum {
}
fn main() {
- || { //~ WARN unused coroutine that must be used
+ #[coroutine] || { //~ WARN unused coroutine that must be used
loop {
if let true = true {
match Enum::A(String::new()) {
diff --git a/tests/ui/coroutine/match-bindings.stderr b/tests/ui/coroutine/match-bindings.stderr
index a7aa6eadb95f1..5525bfed1165b 100644
--- a/tests/ui/coroutine/match-bindings.stderr
+++ b/tests/ui/coroutine/match-bindings.stderr
@@ -1,7 +1,8 @@
warning: unused coroutine that must be used
- --> $DIR/match-bindings.rs:12:5
+ --> $DIR/match-bindings.rs:12:18
|
-LL | / || {
+LL | #[coroutine] || {
+ | __________________^
LL | | loop {
LL | | if let true = true {
LL | | match Enum::A(String::new()) {
diff --git a/tests/ui/coroutine/missing_coroutine_attr_suggestion.fixed b/tests/ui/coroutine/missing_coroutine_attr_suggestion.fixed
new file mode 100644
index 0000000000000..128f09a118439
--- /dev/null
+++ b/tests/ui/coroutine/missing_coroutine_attr_suggestion.fixed
@@ -0,0 +1,8 @@
+//@ run-rustfix
+
+#![feature(coroutines, gen_blocks, stmt_expr_attributes)]
+
+fn main() {
+ let _ = #[coroutine] || yield;
+ //~^ ERROR `yield` can only be used
+}
diff --git a/tests/ui/coroutine/missing_coroutine_attr_suggestion.rs b/tests/ui/coroutine/missing_coroutine_attr_suggestion.rs
new file mode 100644
index 0000000000000..dc95259149609
--- /dev/null
+++ b/tests/ui/coroutine/missing_coroutine_attr_suggestion.rs
@@ -0,0 +1,8 @@
+//@ run-rustfix
+
+#![feature(coroutines, gen_blocks, stmt_expr_attributes)]
+
+fn main() {
+ let _ = || yield;
+ //~^ ERROR `yield` can only be used
+}
diff --git a/tests/ui/coroutine/missing_coroutine_attr_suggestion.stderr b/tests/ui/coroutine/missing_coroutine_attr_suggestion.stderr
new file mode 100644
index 0000000000000..8d92471a361cd
--- /dev/null
+++ b/tests/ui/coroutine/missing_coroutine_attr_suggestion.stderr
@@ -0,0 +1,13 @@
+error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+ --> $DIR/missing_coroutine_attr_suggestion.rs:6:16
+ |
+LL | let _ = || yield;
+ | ^^^^^
+ |
+help: use `#[coroutine]` to make this closure a coroutine
+ |
+LL | let _ = #[coroutine] || yield;
+ | ++++++++++++
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/coroutine/nested_coroutine.rs b/tests/ui/coroutine/nested_coroutine.rs
index 7ff97abf4bb1f..2c12ab2adad41 100644
--- a/tests/ui/coroutine/nested_coroutine.rs
+++ b/tests/ui/coroutine/nested_coroutine.rs
@@ -1,13 +1,15 @@
//@ run-pass
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::{Coroutine, CoroutineState};
use std::pin::Pin;
fn main() {
- let _coroutine = || {
- let mut sub_coroutine = || {
+ let _coroutine = #[coroutine]
+ || {
+ let mut sub_coroutine = #[coroutine]
+ || {
yield 2;
};
diff --git a/tests/ui/coroutine/niche-in-coroutine.rs b/tests/ui/coroutine/niche-in-coroutine.rs
index 45b920ab9273e..117ee9e6f0386 100644
--- a/tests/ui/coroutine/niche-in-coroutine.rs
+++ b/tests/ui/coroutine/niche-in-coroutine.rs
@@ -2,7 +2,7 @@
//@ run-pass
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
use std::mem::size_of_val;
@@ -10,7 +10,7 @@ fn take<T>(_: T) {}
fn main() {
let x = false;
- let gen1 = || {
+ let gen1 = #[coroutine] || {
yield;
take(x);
};
diff --git a/tests/ui/coroutine/non-static-is-unpin.rs b/tests/ui/coroutine/non-static-is-unpin.rs
index 616a78d5fe2a2..b28bf1977145b 100644
--- a/tests/ui/coroutine/non-static-is-unpin.rs
+++ b/tests/ui/coroutine/non-static-is-unpin.rs
@@ -3,7 +3,7 @@
//@[next] compile-flags: -Znext-solver
//@ run-pass
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
#![allow(dropping_copy_types)]
use std::marker::PhantomPinned;
@@ -14,7 +14,7 @@ fn assert_unpin<G: Unpin>(_: G) {
fn main() {
// Even though this coroutine holds a `PhantomPinned` in its environment, it
// remains `Unpin`.
- assert_unpin(|| {
+ assert_unpin(#[coroutine] || {
let pinned = PhantomPinned;
yield;
drop(pinned);
diff --git a/tests/ui/coroutine/not-send-sync.rs b/tests/ui/coroutine/not-send-sync.rs
index dd6182c10de09..a46dcd14e8825 100644
--- a/tests/ui/coroutine/not-send-sync.rs
+++ b/tests/ui/coroutine/not-send-sync.rs
@@ -1,4 +1,4 @@
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
#![feature(negative_impls)]
struct NotSend;
@@ -11,14 +11,14 @@ fn main() {
fn assert_sync<T: Sync>(_: T) {}
fn assert_send<T: Send>(_: T) {}
- assert_sync(|| {
+ assert_sync(#[coroutine] || {
//~^ ERROR: coroutine cannot be shared between threads safely
let a = NotSync;
yield;
drop(a);
});
- assert_send(|| {
+ assert_send(#[coroutine] || {
//~^ ERROR: coroutine cannot be sent between threads safely
let a = NotSend;
yield;
diff --git a/tests/ui/coroutine/not-send-sync.stderr b/tests/ui/coroutine/not-send-sync.stderr
index 9228340c710dd..0f9cbdec1300e 100644
--- a/tests/ui/coroutine/not-send-sync.stderr
+++ b/tests/ui/coroutine/not-send-sync.stderr
@@ -1,7 +1,7 @@
error: coroutine cannot be shared between threads safely
--> $DIR/not-send-sync.rs:14:5
|
-LL | / assert_sync(|| {
+LL | / assert_sync(#[coroutine] || {
LL | |
LL | | let a = NotSync;
LL | | yield;
@@ -9,7 +9,7 @@ LL | | drop(a);
LL | | });
| |______^ coroutine is not `Sync`
|
- = help: within `{coroutine@$DIR/not-send-sync.rs:14:17: 14:19}`, the trait `Sync` is not implemented for `NotSync`, which is required by `{coroutine@$DIR/not-send-sync.rs:14:17: 14:19}: Sync`
+ = help: within `{coroutine@$DIR/not-send-sync.rs:14:30: 14:32}`, the trait `Sync` is not implemented for `NotSync`, which is required by `{coroutine@$DIR/not-send-sync.rs:14:30: 14:32}: Sync`
note: coroutine is not `Sync` as this value is used across a yield
--> $DIR/not-send-sync.rs:17:9
|
@@ -26,7 +26,7 @@ LL | fn assert_sync<T: Sync>(_: T) {}
error: coroutine cannot be sent between threads safely
--> $DIR/not-send-sync.rs:21:5
|
-LL | / assert_send(|| {
+LL | / assert_send(#[coroutine] || {
LL | |
LL | | let a = NotSend;
LL | | yield;
@@ -34,7 +34,7 @@ LL | | drop(a);
LL | | });
| |______^ coroutine is not `Send`
|
- = help: within `{coroutine@$DIR/not-send-sync.rs:21:17: 21:19}`, the trait `Send` is not implemented for `NotSend`, which is required by `{coroutine@$DIR/not-send-sync.rs:21:17: 21:19}: Send`
+ = help: within `{coroutine@$DIR/not-send-sync.rs:21:30: 21:32}`, the trait `Send` is not implemented for `NotSend`, which is required by `{coroutine@$DIR/not-send-sync.rs:21:30: 21:32}: Send`
note: coroutine is not `Send` as this value is used across a yield
--> $DIR/not-send-sync.rs:24:9
|
diff --git a/tests/ui/coroutine/overlap-locals.rs b/tests/ui/coroutine/overlap-locals.rs
index eea8595ed06fc..9cfa6e2a76dd2 100644
--- a/tests/ui/coroutine/overlap-locals.rs
+++ b/tests/ui/coroutine/overlap-locals.rs
@@ -1,9 +1,10 @@
//@ run-pass
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
fn main() {
- let a = || {
+ let a = #[coroutine]
+ || {
{
let w: i32 = 4;
yield;
diff --git a/tests/ui/coroutine/panic-drops-resume.rs b/tests/ui/coroutine/panic-drops-resume.rs
index 6d026e6edc8ac..b23666b7885fb 100644
--- a/tests/ui/coroutine/panic-drops-resume.rs
+++ b/tests/ui/coroutine/panic-drops-resume.rs
@@ -3,7 +3,7 @@
//@ run-pass
//@ needs-unwind
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
use std::panic::{catch_unwind, AssertUnwindSafe};
@@ -21,7 +21,7 @@ impl Drop for Dropper {
}
fn main() {
- let mut gen = |_arg| {
+ let mut gen = #[coroutine] |_arg| {
if true {
panic!();
}
diff --git a/tests/ui/coroutine/panic-drops.rs b/tests/ui/coroutine/panic-drops.rs
index c99abdc72461c..8c2cf560f2acc 100644
--- a/tests/ui/coroutine/panic-drops.rs
+++ b/tests/ui/coroutine/panic-drops.rs
@@ -1,8 +1,7 @@
//@ run-pass
//@ needs-unwind
-
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
use std::panic;
@@ -25,7 +24,8 @@ fn bool_true() -> bool {
fn main() {
let b = B;
- let mut foo = || {
+ let mut foo = #[coroutine]
+ || {
if bool_true() {
panic!();
}
@@ -34,13 +34,12 @@ fn main() {
};
assert_eq!(A.load(Ordering::SeqCst), 0);
- let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
- Pin::new(&mut foo).resume(())
- }));
+ let res = panic::catch_unwind(panic::AssertUnwindSafe(|| Pin::new(&mut foo).resume(())));
assert!(res.is_err());
assert_eq!(A.load(Ordering::SeqCst), 1);
- let mut foo = || {
+ let mut foo = #[coroutine]
+ || {
if bool_true() {
panic!();
}
@@ -49,9 +48,7 @@ fn main() {
};
assert_eq!(A.load(Ordering::SeqCst), 1);
- let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
- Pin::new(&mut foo).resume(())
- }));
+ let res = panic::catch_unwind(panic::AssertUnwindSafe(|| Pin::new(&mut foo).resume(())));
assert!(res.is_err());
assert_eq!(A.load(Ordering::SeqCst), 1);
}
diff --git a/tests/ui/coroutine/panic-safe.rs b/tests/ui/coroutine/panic-safe.rs
index 89dd09bf5203b..6b9b4cb33c322 100644
--- a/tests/ui/coroutine/panic-safe.rs
+++ b/tests/ui/coroutine/panic-safe.rs
@@ -2,14 +2,14 @@
//@ needs-unwind
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
use std::pin::Pin;
use std::panic;
fn main() {
- let mut foo = || {
+ let mut foo = #[coroutine] || {
if true {
panic!();
}
diff --git a/tests/ui/coroutine/parent-expression.rs b/tests/ui/coroutine/parent-expression.rs
index 4d40192c07a27..0f4d99c893648 100644
--- a/tests/ui/coroutine/parent-expression.rs
+++ b/tests/ui/coroutine/parent-expression.rs
@@ -1,4 +1,4 @@
-#![feature(coroutines, negative_impls, rustc_attrs)]
+#![feature(coroutines, negative_impls, rustc_attrs, stmt_expr_attributes)]
macro_rules! type_combinations {
(
@@ -14,7 +14,7 @@ macro_rules! type_combinations {
// Struct update syntax. This fails because the Client used in the update is considered
// dropped *after* the yield.
{
- let g = move || match drop($name::Client { ..$name::Client::default() }) {
+ let g = #[coroutine] move || match drop($name::Client { ..$name::Client::default() }) {
//~^ `significant_drop::Client` which is not `Send`
//~| `insignificant_dtor::Client` which is not `Send`
//~| `derived_drop::Client` which is not `Send`
@@ -29,7 +29,7 @@ macro_rules! type_combinations {
// Simple owned value. This works because the Client is considered moved into `drop`,
// even though the temporary expression doesn't end until after the yield.
{
- let g = move || match drop($name::Client::default()) {
+ let g = #[coroutine] move || match drop($name::Client::default()) {
_ => yield,
};
assert_send(g);
diff --git a/tests/ui/coroutine/parent-expression.stderr b/tests/ui/coroutine/parent-expression.stderr
index 5b3737069e6c1..2d817f1bfd9cb 100644
--- a/tests/ui/coroutine/parent-expression.stderr
+++ b/tests/ui/coroutine/parent-expression.stderr
@@ -13,12 +13,12 @@ LL | | };
LL | | );
| |_____- in this macro invocation
|
- = help: within `{coroutine@$DIR/parent-expression.rs:17:21: 17:28}`, the trait `Send` is not implemented for `derived_drop::Client`, which is required by `{coroutine@$DIR/parent-expression.rs:17:21: 17:28}: Send`
+ = help: within `{coroutine@$DIR/parent-expression.rs:17:34: 17:41}`, the trait `Send` is not implemented for `derived_drop::Client`, which is required by `{coroutine@$DIR/parent-expression.rs:17:34: 17:41}: Send`
note: coroutine is not `Send` as this value is used across a yield
--> $DIR/parent-expression.rs:21:22
|
-LL | let g = move || match drop($name::Client { ..$name::Client::default() }) {
- | ------------------------ has type `derived_drop::Client` which is not `Send`
+LL | let g = #[coroutine] move || match drop($name::Client { ..$name::Client::default() }) {
+ | ------------------------ has type `derived_drop::Client` which is not `Send`
...
LL | _ => yield,
| ^^^^^ yield occurs here, with `$name::Client::default()` maybe used later
@@ -53,12 +53,12 @@ LL | | };
LL | | );
| |_____- in this macro invocation
|
- = help: within `{coroutine@$DIR/parent-expression.rs:17:21: 17:28}`, the trait `Send` is not implemented for `significant_drop::Client`, which is required by `{coroutine@$DIR/parent-expression.rs:17:21: 17:28}: Send`
+ = help: within `{coroutine@$DIR/parent-expression.rs:17:34: 17:41}`, the trait `Send` is not implemented for `significant_drop::Client`, which is required by `{coroutine@$DIR/parent-expression.rs:17:34: 17:41}: Send`
note: coroutine is not `Send` as this value is used across a yield
--> $DIR/parent-expression.rs:21:22
|
-LL | let g = move || match drop($name::Client { ..$name::Client::default() }) {
- | ------------------------ has type `significant_drop::Client` which is not `Send`
+LL | let g = #[coroutine] move || match drop($name::Client { ..$name::Client::default() }) {
+ | ------------------------ has type `significant_drop::Client` which is not `Send`
...
LL | _ => yield,
| ^^^^^ yield occurs here, with `$name::Client::default()` maybe used later
@@ -93,12 +93,12 @@ LL | | };
LL | | );
| |_____- in this macro invocation
|
- = help: within `{coroutine@$DIR/parent-expression.rs:17:21: 17:28}`, the trait `Send` is not implemented for `insignificant_dtor::Client`, which is required by `{coroutine@$DIR/parent-expression.rs:17:21: 17:28}: Send`
+ = help: within `{coroutine@$DIR/parent-expression.rs:17:34: 17:41}`, the trait `Send` is not implemented for `insignificant_dtor::Client`, which is required by `{coroutine@$DIR/parent-expression.rs:17:34: 17:41}: Send`
note: coroutine is not `Send` as this value is used across a yield
--> $DIR/parent-expression.rs:21:22
|
-LL | let g = move || match drop($name::Client { ..$name::Client::default() }) {
- | ------------------------ has type `insignificant_dtor::Client` which is not `Send`
+LL | let g = #[coroutine] move || match drop($name::Client { ..$name::Client::default() }) {
+ | ------------------------ has type `insignificant_dtor::Client` which is not `Send`
...
LL | _ => yield,
| ^^^^^ yield occurs here, with `$name::Client::default()` maybe used later
diff --git a/tests/ui/coroutine/partial-drop.rs b/tests/ui/coroutine/partial-drop.rs
index ba13544712f13..9efb551c9c181 100644
--- a/tests/ui/coroutine/partial-drop.rs
+++ b/tests/ui/coroutine/partial-drop.rs
@@ -1,5 +1,5 @@
//@ check-pass
-#![feature(negative_impls, coroutines)]
+#![feature(negative_impls, coroutines, stmt_expr_attributes)]
struct Foo;
impl !Send for Foo {}
@@ -10,25 +10,34 @@ struct Bar {
}
fn main() {
- assert_send(|| {
- let guard = Bar { foo: Foo, x: 42 };
- drop(guard.foo);
- yield;
- });
+ assert_send(
+ #[coroutine]
+ || {
+ let guard = Bar { foo: Foo, x: 42 };
+ drop(guard.foo);
+ yield;
+ },
+ );
- assert_send(|| {
- let mut guard = Bar { foo: Foo, x: 42 };
- drop(guard);
- guard = Bar { foo: Foo, x: 23 };
- yield;
- });
+ assert_send(
+ #[coroutine]
+ || {
+ let mut guard = Bar { foo: Foo, x: 42 };
+ drop(guard);
+ guard = Bar { foo: Foo, x: 23 };
+ yield;
+ },
+ );
- assert_send(|| {
- let guard = Bar { foo: Foo, x: 42 };
- let Bar { foo, x } = guard;
- drop(foo);
- yield;
- });
+ assert_send(
+ #[coroutine]
+ || {
+ let guard = Bar { foo: Foo, x: 42 };
+ let Bar { foo, x } = guard;
+ drop(foo);
+ yield;
+ },
+ );
}
fn assert_send<T: Send>(_: T) {}
diff --git a/tests/ui/coroutine/partial-initialization-across-yield.rs b/tests/ui/coroutine/partial-initialization-across-yield.rs
index 75ad5a2280403..ab6f9c5b1e981 100644
--- a/tests/ui/coroutine/partial-initialization-across-yield.rs
+++ b/tests/ui/coroutine/partial-initialization-across-yield.rs
@@ -1,13 +1,13 @@
// Test that we don't allow yielding from a coroutine while a local is partially
// initialized.
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
struct S { x: i32, y: i32 }
struct T(i32, i32);
fn test_tuple() {
- let _ = || {
+ let _ = #[coroutine] || {
let mut t: (i32, i32);
t.0 = 42; //~ ERROR E0381
yield;
@@ -17,7 +17,7 @@ fn test_tuple() {
}
fn test_tuple_struct() {
- let _ = || {
+ let _ = #[coroutine] || {
let mut t: T;
t.0 = 42; //~ ERROR E0381
yield;
@@ -27,7 +27,7 @@ fn test_tuple_struct() {
}
fn test_struct() {
- let _ = || {
+ let _ = #[coroutine] || {
let mut t: S;
t.x = 42; //~ ERROR E0381
yield;
diff --git a/tests/ui/coroutine/pattern-borrow.rs b/tests/ui/coroutine/pattern-borrow.rs
index 76084433d4705..46547504abc9d 100644
--- a/tests/ui/coroutine/pattern-borrow.rs
+++ b/tests/ui/coroutine/pattern-borrow.rs
@@ -5,7 +5,7 @@ enum Test { A(i32), B, }
fn main() { }
fn fun(test: Test) {
- move || {
+ #[coroutine] move || {
if let Test::A(ref _a) = test { //~ ERROR borrow may still be in use when coroutine yields
yield ();
_a.use_ref();
diff --git a/tests/ui/coroutine/pin-box-coroutine.rs b/tests/ui/coroutine/pin-box-coroutine.rs
index 1ee6393d1d83a..d030f3ef214d1 100644
--- a/tests/ui/coroutine/pin-box-coroutine.rs
+++ b/tests/ui/coroutine/pin-box-coroutine.rs
@@ -1,6 +1,6 @@
//@ run-pass
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
@@ -8,6 +8,6 @@ fn assert_coroutine<G: Coroutine>(_: G) {
}
fn main() {
- assert_coroutine(static || yield);
- assert_coroutine(Box::pin(static || yield));
+ assert_coroutine(#[coroutine] static || yield);
+ assert_coroutine(Box::pin(#[coroutine] static || yield));
}
diff --git a/tests/ui/coroutine/polymorphize-args.rs b/tests/ui/coroutine/polymorphize-args.rs
index 21aa3c7aafd8c..5123bf412b553 100644
--- a/tests/ui/coroutine/polymorphize-args.rs
+++ b/tests/ui/coroutine/polymorphize-args.rs
@@ -1,14 +1,15 @@
//@ compile-flags: -Zpolymorphize=on
//@ build-pass
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
use std::pin::Pin;
use std::thread;
fn main() {
- let mut foo = || yield;
+ let mut foo = #[coroutine]
+ || yield;
thread::spawn(move || match Pin::new(&mut foo).resume(()) {
s => panic!("bad state: {:?}", s),
})
diff --git a/tests/ui/coroutine/print/coroutine-print-verbose-1.rs b/tests/ui/coroutine/print/coroutine-print-verbose-1.rs
index 73106328618ea..dc0165c9194da 100644
--- a/tests/ui/coroutine/print/coroutine-print-verbose-1.rs
+++ b/tests/ui/coroutine/print/coroutine-print-verbose-1.rs
@@ -2,7 +2,7 @@
// Same as: tests/ui/coroutine/issue-68112.stderr
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::{
cell::RefCell,
@@ -30,7 +30,7 @@ fn make_non_send_coroutine() -> impl Coroutine<Return = Arc<RefCell<i32>>> {
}
fn test1() {
- let send_gen = || {
+ let send_gen = #[coroutine] || {
let _non_send_gen = make_non_send_coroutine();
yield;
};
@@ -39,7 +39,7 @@ fn test1() {
}
pub fn make_gen2<T>(t: T) -> impl Coroutine<Return = T> {
- || {
+ #[coroutine] || {
yield;
t
}
@@ -49,7 +49,7 @@ fn make_non_send_coroutine2() -> impl Coroutine<Return = Arc<RefCell<i32>>> {
}
fn test2() {
- let send_gen = || {
+ let send_gen = #[coroutine] || {
let _non_send_gen = make_non_send_coroutine2();
yield;
};
diff --git a/tests/ui/coroutine/print/coroutine-print-verbose-1.stderr b/tests/ui/coroutine/print/coroutine-print-verbose-1.stderr
index 37db83d57f756..934ab08cf178d 100644
--- a/tests/ui/coroutine/print/coroutine-print-verbose-1.stderr
+++ b/tests/ui/coroutine/print/coroutine-print-verbose-1.stderr
@@ -29,10 +29,10 @@ LL | require_send(send_gen);
= note: if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` instead
= note: required for `Arc<RefCell<i32>>` to implement `Send`
note: required because it's used within this coroutine
- --> $DIR/coroutine-print-verbose-1.rs:42:5
+ --> $DIR/coroutine-print-verbose-1.rs:42:18
|
-LL | || {
- | ^^
+LL | #[coroutine] || {
+ | ^^
note: required because it appears within the type `Opaque(DefId(0:35 ~ coroutine_print_verbose_1[75fb]::make_gen2::{opaque#0}), [Arc<RefCell<i32>>])`
--> $DIR/coroutine-print-verbose-1.rs:41:30
|
@@ -44,10 +44,10 @@ note: required because it appears within the type `Opaque(DefId(0:36 ~ coroutine
LL | fn make_non_send_coroutine2() -> impl Coroutine<Return = Arc<RefCell<i32>>> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required because it's used within this coroutine
- --> $DIR/coroutine-print-verbose-1.rs:52:20
+ --> $DIR/coroutine-print-verbose-1.rs:52:33
|
-LL | let send_gen = || {
- | ^^
+LL | let send_gen = #[coroutine] || {
+ | ^^
note: required by a bound in `require_send`
--> $DIR/coroutine-print-verbose-1.rs:26:25
|
diff --git a/tests/ui/coroutine/print/coroutine-print-verbose-2.rs b/tests/ui/coroutine/print/coroutine-print-verbose-2.rs
index f9ea68a8cd942..ef7199cafdde0 100644
--- a/tests/ui/coroutine/print/coroutine-print-verbose-2.rs
+++ b/tests/ui/coroutine/print/coroutine-print-verbose-2.rs
@@ -1,7 +1,7 @@
//@ compile-flags: -Zverbose-internals
// Same as test/ui/coroutine/not-send-sync.rs
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
#![feature(negative_impls)]
struct NotSend;
@@ -14,14 +14,14 @@ fn main() {
fn assert_sync<T: Sync>(_: T) {}
fn assert_send<T: Send>(_: T) {}
- assert_sync(|| {
+ assert_sync(#[coroutine] || {
//~^ ERROR: coroutine cannot be shared between threads safely
let a = NotSync;
yield;
drop(a);
});
- assert_send(|| {
+ assert_send(#[coroutine] || {
//~^ ERROR: coroutine cannot be sent between threads safely
let a = NotSend;
yield;
diff --git a/tests/ui/coroutine/print/coroutine-print-verbose-2.stderr b/tests/ui/coroutine/print/coroutine-print-verbose-2.stderr
index 26c9c27743c01..0de53d9e1d7d5 100644
--- a/tests/ui/coroutine/print/coroutine-print-verbose-2.stderr
+++ b/tests/ui/coroutine/print/coroutine-print-verbose-2.stderr
@@ -1,7 +1,7 @@
error: coroutine cannot be shared between threads safely
--> $DIR/coroutine-print-verbose-2.rs:17:5
|
-LL | / assert_sync(|| {
+LL | / assert_sync(#[coroutine] || {
LL | |
LL | | let a = NotSync;
LL | | yield;
@@ -26,7 +26,7 @@ LL | fn assert_sync<T: Sync>(_: T) {}
error: coroutine cannot be sent between threads safely
--> $DIR/coroutine-print-verbose-2.rs:24:5
|
-LL | / assert_send(|| {
+LL | / assert_send(#[coroutine] || {
LL | |
LL | | let a = NotSend;
LL | | yield;
diff --git a/tests/ui/coroutine/print/coroutine-print-verbose-3.rs b/tests/ui/coroutine/print/coroutine-print-verbose-3.rs
index be6dbad9e1c2b..5dd15fc1b9516 100644
--- a/tests/ui/coroutine/print/coroutine-print-verbose-3.rs
+++ b/tests/ui/coroutine/print/coroutine-print-verbose-3.rs
@@ -1,12 +1,13 @@
//@ compile-flags: -Zverbose-internals
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
fn main() {
let x = "Type mismatch test";
- let coroutine :() = || {
- //~^ ERROR mismatched types
+ let coroutine: () = #[coroutine]
+ || {
+ //~^ ERROR mismatched types
yield 1i32;
- return x
+ return x;
};
}
diff --git a/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr b/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr
index e2973cde6d3cc..dce45aeae56a9 100644
--- a/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr
+++ b/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr
@@ -1,13 +1,12 @@
error[E0308]: mismatched types
- --> $DIR/coroutine-print-verbose-3.rs:7:25
+ --> $DIR/coroutine-print-verbose-3.rs:8:5
|
-LL | let coroutine :() = || {
- | ____________________--___^
- | | |
- | | expected due to this
+LL | let coroutine: () = #[coroutine]
+ | -- expected due to this
+LL | / || {
LL | |
LL | | yield 1i32;
-LL | | return x
+LL | | return x;
LL | | };
| |_____^ expected `()`, found coroutine
|
diff --git a/tests/ui/coroutine/reborrow-mut-upvar.rs b/tests/ui/coroutine/reborrow-mut-upvar.rs
index e1f6211baebda..716781e365c5a 100644
--- a/tests/ui/coroutine/reborrow-mut-upvar.rs
+++ b/tests/ui/coroutine/reborrow-mut-upvar.rs
@@ -3,7 +3,7 @@
#![feature(coroutines)]
fn _run(bar: &mut i32) {
- || { //~ WARN unused coroutine that must be used
+ #[coroutine] || { //~ WARN unused coroutine that must be used
{
let _baz = &*bar;
yield;
diff --git a/tests/ui/coroutine/reborrow-mut-upvar.stderr b/tests/ui/coroutine/reborrow-mut-upvar.stderr
index 5b614ac4be8b2..a05e84c5f3ef2 100644
--- a/tests/ui/coroutine/reborrow-mut-upvar.stderr
+++ b/tests/ui/coroutine/reborrow-mut-upvar.stderr
@@ -1,7 +1,8 @@
warning: unused coroutine that must be used
- --> $DIR/reborrow-mut-upvar.rs:6:5
+ --> $DIR/reborrow-mut-upvar.rs:6:18
|
-LL | / || {
+LL | #[coroutine] || {
+ | __________________^
LL | | {
LL | | let _baz = &*bar;
LL | | yield;
diff --git a/tests/ui/coroutine/ref-escapes-but-not-over-yield.rs b/tests/ui/coroutine/ref-escapes-but-not-over-yield.rs
index a9c13188ff386..0f9c56786da06 100644
--- a/tests/ui/coroutine/ref-escapes-but-not-over-yield.rs
+++ b/tests/ui/coroutine/ref-escapes-but-not-over-yield.rs
@@ -1,16 +1,17 @@
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
fn foo(x: &i32) {
// In this case, a reference to `b` escapes the coroutine, but not
// because of a yield. We see that there is no yield in the scope of
// `b` and give the more generic error message.
let mut a = &3;
- let mut b = move || {
- yield();
+ let mut b = #[coroutine]
+ move || {
+ yield ();
let b = 5;
a = &b;
//~^ ERROR borrowed data escapes outside of coroutine
};
}
-fn main() { }
+fn main() {}
diff --git a/tests/ui/coroutine/ref-escapes-but-not-over-yield.stderr b/tests/ui/coroutine/ref-escapes-but-not-over-yield.stderr
index 8811faf2fade5..6fa7082c0b8b7 100644
--- a/tests/ui/coroutine/ref-escapes-but-not-over-yield.stderr
+++ b/tests/ui/coroutine/ref-escapes-but-not-over-yield.stderr
@@ -1,5 +1,5 @@
error[E0521]: borrowed data escapes outside of coroutine
- --> $DIR/ref-escapes-but-not-over-yield.rs:11:9
+ --> $DIR/ref-escapes-but-not-over-yield.rs:12:9
|
LL | let mut a = &3;
| ----- `a` declared here, outside of the coroutine body
diff --git a/tests/ui/coroutine/ref-upvar-not-send.rs b/tests/ui/coroutine/ref-upvar-not-send.rs
index 487fdeea2dae9..89bb5e5495f45 100644
--- a/tests/ui/coroutine/ref-upvar-not-send.rs
+++ b/tests/ui/coroutine/ref-upvar-not-send.rs
@@ -1,7 +1,7 @@
// For `Send` coroutines, suggest a `T: Sync` requirement for `&T` upvars,
// and suggest a `T: Send` requirement for `&mut T` upvars.
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
fn assert_send<T: Send>(_: T) {}
//~^ NOTE required by a bound in `assert_send`
@@ -12,7 +12,7 @@ fn assert_send<T: Send>(_: T) {}
fn main() {
let x: &*mut () = &std::ptr::null_mut();
let y: &mut *mut () = &mut std::ptr::null_mut();
- assert_send(move || {
+ assert_send(#[coroutine] move || {
//~^ ERROR coroutine cannot be sent between threads safely
//~| NOTE coroutine is not `Send`
yield;
@@ -20,7 +20,7 @@ fn main() {
});
//~^^ NOTE captured value is not `Send` because `&` references cannot be sent unless their referent is `Sync`
//~| NOTE has type `&*mut ()` which is not `Send`, because `*mut ()` is not `Sync`
- assert_send(move || {
+ assert_send(#[coroutine] move || {
//~^ ERROR coroutine cannot be sent between threads safely
//~| NOTE coroutine is not `Send`
yield;
diff --git a/tests/ui/coroutine/ref-upvar-not-send.stderr b/tests/ui/coroutine/ref-upvar-not-send.stderr
index 0f91bcf40533f..4c7deab3f4c4d 100644
--- a/tests/ui/coroutine/ref-upvar-not-send.stderr
+++ b/tests/ui/coroutine/ref-upvar-not-send.stderr
@@ -1,8 +1,8 @@
error: coroutine cannot be sent between threads safely
- --> $DIR/ref-upvar-not-send.rs:15:17
+ --> $DIR/ref-upvar-not-send.rs:15:30
|
-LL | assert_send(move || {
- | _________________^
+LL | assert_send(#[coroutine] move || {
+ | ______________________________^
LL | |
LL | |
LL | | yield;
@@ -10,7 +10,7 @@ LL | | let _x = x;
LL | | });
| |_____^ coroutine is not `Send`
|
- = help: the trait `Sync` is not implemented for `*mut ()`, which is required by `{coroutine@$DIR/ref-upvar-not-send.rs:15:17: 15:24}: Send`
+ = help: the trait `Sync` is not implemented for `*mut ()`, which is required by `{coroutine@$DIR/ref-upvar-not-send.rs:15:30: 15:37}: Send`
note: captured value is not `Send` because `&` references cannot be sent unless their referent is `Sync`
--> $DIR/ref-upvar-not-send.rs:19:18
|
@@ -23,10 +23,10 @@ LL | fn assert_send<T: Send>(_: T) {}
| ^^^^ required by this bound in `assert_send`
error: coroutine cannot be sent between threads safely
- --> $DIR/ref-upvar-not-send.rs:23:17
+ --> $DIR/ref-upvar-not-send.rs:23:30
|
-LL | assert_send(move || {
- | _________________^
+LL | assert_send(#[coroutine] move || {
+ | ______________________________^
LL | |
LL | |
LL | | yield;
@@ -34,7 +34,7 @@ LL | | let _y = y;
LL | | });
| |_____^ coroutine is not `Send`
|
- = help: within `{coroutine@$DIR/ref-upvar-not-send.rs:23:17: 23:24}`, the trait `Send` is not implemented for `*mut ()`, which is required by `{coroutine@$DIR/ref-upvar-not-send.rs:23:17: 23:24}: Send`
+ = help: within `{coroutine@$DIR/ref-upvar-not-send.rs:23:30: 23:37}`, the trait `Send` is not implemented for `*mut ()`, which is required by `{coroutine@$DIR/ref-upvar-not-send.rs:23:30: 23:37}: Send`
note: captured value is not `Send` because `&mut` references cannot be sent unless their referent is `Send`
--> $DIR/ref-upvar-not-send.rs:27:18
|
diff --git a/tests/ui/coroutine/reinit-in-match-guard.rs b/tests/ui/coroutine/reinit-in-match-guard.rs
index 4a58420477314..0a97d9fbcb2f7 100644
--- a/tests/ui/coroutine/reinit-in-match-guard.rs
+++ b/tests/ui/coroutine/reinit-in-match-guard.rs
@@ -1,11 +1,11 @@
//@ build-pass
-#![feature(coroutines)]
-
+#![feature(coroutines, stmt_expr_attributes)]
#![allow(unused_assignments, dead_code)]
fn main() {
- let _ = || {
+ let _ = #[coroutine]
+ || {
let mut x = vec![22_usize];
std::mem::drop(x);
match y() {
diff --git a/tests/ui/coroutine/resume-after-return.rs b/tests/ui/coroutine/resume-after-return.rs
index 81f86de641f25..7028e1e81e55c 100644
--- a/tests/ui/coroutine/resume-after-return.rs
+++ b/tests/ui/coroutine/resume-after-return.rs
@@ -1,17 +1,17 @@
//@ run-pass
//@ needs-unwind
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
-#![feature(coroutines, coroutine_trait)]
-
-use std::ops::{CoroutineState, Coroutine};
-use std::pin::Pin;
+use std::ops::{Coroutine, CoroutineState};
use std::panic;
+use std::pin::Pin;
fn main() {
- let mut foo = || {
+ let mut foo = #[coroutine]
+ || {
if true {
- return
+ return;
}
yield;
};
diff --git a/tests/ui/coroutine/resume-arg-late-bound.rs b/tests/ui/coroutine/resume-arg-late-bound.rs
index 3c2ab41047e3d..e84184da631b5 100644
--- a/tests/ui/coroutine/resume-arg-late-bound.rs
+++ b/tests/ui/coroutine/resume-arg-late-bound.rs
@@ -1,14 +1,14 @@
//! Tests that we cannot produce a coroutine that accepts a resume argument
//! with any lifetime and then stores it across a `yield`.
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
fn test(a: impl for<'a> Coroutine<&'a mut bool>) {}
fn main() {
- let gen = |arg: &mut bool| {
+ let gen = #[coroutine] |arg: &mut bool| {
yield ();
*arg = true;
};
diff --git a/tests/ui/coroutine/resume-arg-late-bound.stderr b/tests/ui/coroutine/resume-arg-late-bound.stderr
index 4a4ee08c529ec..646abaf4f7bde 100644
--- a/tests/ui/coroutine/resume-arg-late-bound.stderr
+++ b/tests/ui/coroutine/resume-arg-late-bound.stderr
@@ -4,7 +4,7 @@ error: implementation of `Coroutine` is not general enough
LL | test(gen);
| ^^^^^^^^^ implementation of `Coroutine` is not general enough
|
- = note: `{coroutine@$DIR/resume-arg-late-bound.rs:11:15: 11:31}` must implement `Coroutine<&'1 mut bool>`, for any lifetime `'1`...
+ = note: `{coroutine@$DIR/resume-arg-late-bound.rs:11:28: 11:44}` must implement `Coroutine<&'1 mut bool>`, for any lifetime `'1`...
= note: ...but it actually implements `Coroutine<&'2 mut bool>`, for some specific lifetime `'2`
error: aborting due to 1 previous error
diff --git a/tests/ui/coroutine/resume-arg-size.rs b/tests/ui/coroutine/resume-arg-size.rs
index 81e96975c98f6..59740a28f428a 100644
--- a/tests/ui/coroutine/resume-arg-size.rs
+++ b/tests/ui/coroutine/resume-arg-size.rs
@@ -1,4 +1,4 @@
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
#![allow(dropping_copy_types)]
//@ run-pass
@@ -7,7 +7,8 @@ use std::mem::size_of_val;
fn main() {
// Coroutine taking a `Copy`able resume arg.
- let gen_copy = |mut x: usize| {
+ let gen_copy = #[coroutine]
+ |mut x: usize| {
loop {
drop(x);
x = yield;
@@ -15,7 +16,8 @@ fn main() {
};
// Coroutine taking a non-`Copy` resume arg.
- let gen_move = |mut x: Box<usize>| {
+ let gen_move = #[coroutine]
+ |mut x: Box<usize>| {
loop {
drop(x);
x = yield;
diff --git a/tests/ui/coroutine/resume-live-across-yield.rs b/tests/ui/coroutine/resume-live-across-yield.rs
index 45851411daaac..b67619ee70fb2 100644
--- a/tests/ui/coroutine/resume-live-across-yield.rs
+++ b/tests/ui/coroutine/resume-live-across-yield.rs
@@ -1,6 +1,6 @@
//@ run-pass
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::{Coroutine, CoroutineState};
use std::pin::Pin;
@@ -18,7 +18,8 @@ impl Drop for Dropper {
}
fn main() {
- let mut g = |mut _d| {
+ let mut g = #[coroutine]
+ |mut _d| {
_d = yield;
_d
};
diff --git a/tests/ui/coroutine/retain-resume-ref.rs b/tests/ui/coroutine/retain-resume-ref.rs
index c9f995ab0cf31..6e688c33979ac 100644
--- a/tests/ui/coroutine/retain-resume-ref.rs
+++ b/tests/ui/coroutine/retain-resume-ref.rs
@@ -1,6 +1,6 @@
//! This test ensures that a mutable reference cannot be passed as a resume argument twice.
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::marker::Unpin;
use std::ops::{
@@ -12,7 +12,8 @@ use std::pin::Pin;
fn main() {
let mut thing = String::from("hello");
- let mut gen = |r| {
+ let mut gen = #[coroutine]
+ |r| {
if false {
yield r;
}
diff --git a/tests/ui/coroutine/retain-resume-ref.stderr b/tests/ui/coroutine/retain-resume-ref.stderr
index eb8b78df6c998..e23023c6e23f3 100644
--- a/tests/ui/coroutine/retain-resume-ref.stderr
+++ b/tests/ui/coroutine/retain-resume-ref.stderr
@@ -1,5 +1,5 @@
error[E0499]: cannot borrow `thing` as mutable more than once at a time
- --> $DIR/retain-resume-ref.rs:23:25
+ --> $DIR/retain-resume-ref.rs:24:25
|
LL | gen.as_mut().resume(&mut thing);
| ---------- first mutable borrow occurs here
diff --git a/tests/ui/coroutine/size-moved-locals.rs b/tests/ui/coroutine/size-moved-locals.rs
index eb5210087a0e6..0f800de84544d 100644
--- a/tests/ui/coroutine/size-moved-locals.rs
+++ b/tests/ui/coroutine/size-moved-locals.rs
@@ -24,6 +24,7 @@ impl Drop for Foo {
}
fn move_before_yield() -> impl Coroutine<Yield = (), Return = ()> {
+ #[coroutine]
static || {
let first = Foo([0; FOO_SIZE]);
let _second = first;
@@ -35,6 +36,7 @@ fn move_before_yield() -> impl Coroutine<Yield = (), Return = ()> {
fn noop() {}
fn move_before_yield_with_noop() -> impl Coroutine<Yield = (), Return = ()> {
+ #[coroutine]
static || {
let first = Foo([0; FOO_SIZE]);
noop();
@@ -47,6 +49,7 @@ fn move_before_yield_with_noop() -> impl Coroutine<Yield = (), Return = ()> {
// Today we don't have NRVO (we allocate space for both `first` and `second`,)
// but we can overlap `first` with `_third`.
fn overlap_move_points() -> impl Coroutine<Yield = (), Return = ()> {
+ #[coroutine]
static || {
let first = Foo([0; FOO_SIZE]);
yield;
@@ -58,6 +61,7 @@ fn overlap_move_points() -> impl Coroutine<Yield = (), Return = ()> {
}
fn overlap_x_and_y() -> impl Coroutine<Yield = (), Return = ()> {
+ #[coroutine]
static || {
let x = Foo([0; FOO_SIZE]);
yield;
diff --git a/tests/ui/coroutine/sized-yield.rs b/tests/ui/coroutine/sized-yield.rs
index 1368c88b5227d..a4c91fafe6ca5 100644
--- a/tests/ui/coroutine/sized-yield.rs
+++ b/tests/ui/coroutine/sized-yield.rs
@@ -1,11 +1,12 @@
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
use std::pin::Pin;
fn main() {
let s = String::from("foo");
- let mut gen = move || {
+ let mut gen = #[coroutine]
+ move || {
//~^ ERROR the size for values of type
yield s[..];
};
diff --git a/tests/ui/coroutine/sized-yield.stderr b/tests/ui/coroutine/sized-yield.stderr
index 4e8dc13201de3..5d5dd6803c899 100644
--- a/tests/ui/coroutine/sized-yield.stderr
+++ b/tests/ui/coroutine/sized-yield.stderr
@@ -1,8 +1,7 @@
error[E0277]: the size for values of type `str` cannot be known at compilation time
- --> $DIR/sized-yield.rs:8:19
+ --> $DIR/sized-yield.rs:9:5
|
-LL | let mut gen = move || {
- | ___________________^
+LL | / move || {
LL | |
LL | | yield s[..];
LL | | };
@@ -12,7 +11,7 @@ LL | | };
= note: the yield type of a coroutine must have a statically known size
error[E0277]: the size for values of type `str` cannot be known at compilation time
- --> $DIR/sized-yield.rs:12:24
+ --> $DIR/sized-yield.rs:13:24
|
LL | Pin::new(&mut gen).resume(());
| ^^^^^^ doesn't have a size known at compile-time
diff --git a/tests/ui/coroutine/smoke-resume-args.rs b/tests/ui/coroutine/smoke-resume-args.rs
index 7d20cd2293d6b..209c481400189 100644
--- a/tests/ui/coroutine/smoke-resume-args.rs
+++ b/tests/ui/coroutine/smoke-resume-args.rs
@@ -3,7 +3,7 @@
//@ revisions: default nomiropt
//@[nomiropt]compile-flags: -Z mir-opt-level=0
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::fmt::Debug;
use std::ops::{
@@ -50,7 +50,7 @@ fn expect_drops<T>(expected_drops: usize, f: impl FnOnce() -> T) -> T {
fn main() {
drain(
- &mut |mut b| {
+ &mut #[coroutine] |mut b| {
while b != 0 {
b = yield (b + 1);
}
@@ -59,21 +59,24 @@ fn main() {
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))],
@@ -83,7 +86,7 @@ fn main() {
expect_drops(4, || {
drain(
#[allow(unused_assignments, unused_variables)]
- &mut |mut a: DropMe| {
+ &mut #[coroutine] |mut a: DropMe| {
a = yield;
a = yield;
a = yield;
diff --git a/tests/ui/coroutine/smoke.rs b/tests/ui/coroutine/smoke.rs
index 17d98a52a1c49..bfb183fde9368 100644
--- a/tests/ui/coroutine/smoke.rs
+++ b/tests/ui/coroutine/smoke.rs
@@ -6,7 +6,7 @@
//@ needs-threads
//@ compile-flags: --test
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::{CoroutineState, Coroutine};
use std::pin::Pin;
@@ -14,7 +14,7 @@ use std::thread;
#[test]
fn simple() {
- let mut foo = || {
+ let mut foo = #[coroutine] || {
if false {
yield;
}
@@ -29,7 +29,7 @@ fn simple() {
#[test]
fn return_capture() {
let a = String::from("foo");
- let mut foo = || {
+ let mut foo = #[coroutine] || {
if false {
yield;
}
@@ -44,7 +44,7 @@ fn return_capture() {
#[test]
fn simple_yield() {
- let mut foo = || {
+ let mut foo = #[coroutine] || {
yield;
};
@@ -61,7 +61,7 @@ fn simple_yield() {
#[test]
fn yield_capture() {
let b = String::from("foo");
- let mut foo = || {
+ let mut foo = #[coroutine] || {
yield b;
};
@@ -77,7 +77,7 @@ fn yield_capture() {
#[test]
fn simple_yield_value() {
- let mut foo = || {
+ let mut foo = #[coroutine] || {
yield String::from("bar");
return String::from("foo")
};
@@ -95,7 +95,7 @@ fn simple_yield_value() {
#[test]
fn return_after_yield() {
let a = String::from("foo");
- let mut foo = || {
+ let mut foo = #[coroutine] || {
yield;
return a
};
@@ -112,34 +112,34 @@ fn return_after_yield() {
#[test]
fn send_and_sync() {
- assert_send_sync(|| {
+ assert_send_sync(#[coroutine] || {
yield
});
- assert_send_sync(|| {
+ assert_send_sync(#[coroutine] || {
yield String::from("foo");
});
- assert_send_sync(|| {
+ assert_send_sync(#[coroutine] || {
yield;
return String::from("foo");
});
let a = 3;
- assert_send_sync(|| {
+ assert_send_sync(#[coroutine] || {
yield a;
return
});
let a = 3;
- assert_send_sync(move || {
+ assert_send_sync(#[coroutine] move || {
yield a;
return
});
let a = String::from("a");
- assert_send_sync(|| {
+ assert_send_sync(#[coroutine] || {
yield ;
drop(a);
return
});
let a = String::from("a");
- assert_send_sync(move || {
+ assert_send_sync(#[coroutine] move || {
yield ;
drop(a);
return
@@ -150,7 +150,7 @@ fn send_and_sync() {
#[test]
fn send_over_threads() {
- let mut foo = || { yield };
+ let mut foo = #[coroutine] || { yield };
thread::spawn(move || {
match Pin::new(&mut foo).resume(()) {
CoroutineState::Yielded(()) => {}
@@ -163,7 +163,7 @@ fn send_over_threads() {
}).join().unwrap();
let a = String::from("a");
- let mut foo = || { yield a };
+ let mut foo = #[coroutine] || { yield a };
thread::spawn(move || {
match Pin::new(&mut foo).resume(()) {
CoroutineState::Yielded(ref s) if *s == "a" => {}
diff --git a/tests/ui/coroutine/static-coroutine.rs b/tests/ui/coroutine/static-coroutine.rs
index 9beaef3e4de31..eba6336d342fe 100644
--- a/tests/ui/coroutine/static-coroutine.rs
+++ b/tests/ui/coroutine/static-coroutine.rs
@@ -1,12 +1,13 @@
//@ run-pass
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
-use std::pin::Pin;
use std::ops::{Coroutine, CoroutineState};
+use std::pin::Pin;
fn main() {
- let mut coroutine = static || {
+ let mut coroutine = #[coroutine]
+ static || {
let a = true;
let b = &a;
yield;
diff --git a/tests/ui/coroutine/static-mut-reference-across-yield.rs b/tests/ui/coroutine/static-mut-reference-across-yield.rs
index 0d8042ed8526b..40d5fdf2d5736 100644
--- a/tests/ui/coroutine/static-mut-reference-across-yield.rs
+++ b/tests/ui/coroutine/static-mut-reference-across-yield.rs
@@ -1,6 +1,6 @@
//@ build-pass
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
static mut A: [i32; 5] = [1, 2, 3, 4, 5];
@@ -8,13 +8,15 @@ fn is_send_sync<T: Send + Sync>(_: T) {}
fn main() {
unsafe {
- let gen_index = static || {
+ let gen_index = #[coroutine]
+ static || {
let u = A[{
yield;
1
}];
};
- let gen_match = static || match A {
+ let gen_match = #[coroutine]
+ static || match A {
i if {
yield;
true
diff --git a/tests/ui/coroutine/static-not-unpin.current.stderr b/tests/ui/coroutine/static-not-unpin.current.stderr
index 518abdd62c790..7d6260ac569e8 100644
--- a/tests/ui/coroutine/static-not-unpin.current.stderr
+++ b/tests/ui/coroutine/static-not-unpin.current.stderr
@@ -1,8 +1,8 @@
-error[E0277]: `{static coroutine@$DIR/static-not-unpin.rs:15:25: 15:34}` cannot be unpinned
+error[E0277]: `{static coroutine@$DIR/static-not-unpin.rs:15:5: 15:14}` cannot be unpinned
--> $DIR/static-not-unpin.rs:18:18
|
LL | assert_unpin(coroutine);
- | ------------ ^^^^^^^^^ the trait `Unpin` is not implemented for `{static coroutine@$DIR/static-not-unpin.rs:15:25: 15:34}`
+ | ------------ ^^^^^^^^^ the trait `Unpin` is not implemented for `{static coroutine@$DIR/static-not-unpin.rs:15:5: 15:14}`
| |
| required by a bound introduced by this call
|
@@ -11,7 +11,7 @@ LL | assert_unpin(coroutine);
note: required by a bound in `assert_unpin`
--> $DIR/static-not-unpin.rs:11:20
|
-LL | fn assert_unpin<T: Unpin>(_: T) {
+LL | fn assert_unpin<T: Unpin>(_: T) {}
| ^^^^^ required by this bound in `assert_unpin`
error: aborting due to 1 previous error
diff --git a/tests/ui/coroutine/static-not-unpin.next.stderr b/tests/ui/coroutine/static-not-unpin.next.stderr
index 518abdd62c790..7d6260ac569e8 100644
--- a/tests/ui/coroutine/static-not-unpin.next.stderr
+++ b/tests/ui/coroutine/static-not-unpin.next.stderr
@@ -1,8 +1,8 @@
-error[E0277]: `{static coroutine@$DIR/static-not-unpin.rs:15:25: 15:34}` cannot be unpinned
+error[E0277]: `{static coroutine@$DIR/static-not-unpin.rs:15:5: 15:14}` cannot be unpinned
--> $DIR/static-not-unpin.rs:18:18
|
LL | assert_unpin(coroutine);
- | ------------ ^^^^^^^^^ the trait `Unpin` is not implemented for `{static coroutine@$DIR/static-not-unpin.rs:15:25: 15:34}`
+ | ------------ ^^^^^^^^^ the trait `Unpin` is not implemented for `{static coroutine@$DIR/static-not-unpin.rs:15:5: 15:14}`
| |
| required by a bound introduced by this call
|
@@ -11,7 +11,7 @@ LL | assert_unpin(coroutine);
note: required by a bound in `assert_unpin`
--> $DIR/static-not-unpin.rs:11:20
|
-LL | fn assert_unpin<T: Unpin>(_: T) {
+LL | fn assert_unpin<T: Unpin>(_: T) {}
| ^^^^^ required by this bound in `assert_unpin`
error: aborting due to 1 previous error
diff --git a/tests/ui/coroutine/static-not-unpin.rs b/tests/ui/coroutine/static-not-unpin.rs
index 3704cca772977..2bc25e3796d45 100644
--- a/tests/ui/coroutine/static-not-unpin.rs
+++ b/tests/ui/coroutine/static-not-unpin.rs
@@ -2,17 +2,17 @@
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
//@ normalize-stderr-test "std::pin::Unpin" -> "std::marker::Unpin"
use std::marker::Unpin;
-fn assert_unpin<T: Unpin>(_: T) {
-}
+fn assert_unpin<T: Unpin>(_: T) {}
fn main() {
- let mut coroutine = static || {
+ let mut coroutine = #[coroutine]
+ static || {
yield;
};
assert_unpin(coroutine); //~ ERROR E0277
diff --git a/tests/ui/coroutine/static-reference-across-yield.rs b/tests/ui/coroutine/static-reference-across-yield.rs
index cf19ccb54d535..e7ff658ebf643 100644
--- a/tests/ui/coroutine/static-reference-across-yield.rs
+++ b/tests/ui/coroutine/static-reference-across-yield.rs
@@ -4,10 +4,10 @@
static A: [i32; 5] = [1, 2, 3, 4, 5];
fn main() {
- static || {
+ #[coroutine] static || {
let u = A[{yield; 1}];
};
- static || {
+ #[coroutine] static || {
match A {
i if { yield; true } => (),
_ => (),
diff --git a/tests/ui/coroutine/too-live-local-in-immovable-gen.rs b/tests/ui/coroutine/too-live-local-in-immovable-gen.rs
index 382e7ff38143d..1c689ef7cefc4 100644
--- a/tests/ui/coroutine/too-live-local-in-immovable-gen.rs
+++ b/tests/ui/coroutine/too-live-local-in-immovable-gen.rs
@@ -5,7 +5,7 @@
fn main() {
unsafe {
- static move || { //~ WARN unused coroutine that must be used
+ #[coroutine] static move || { //~ WARN unused coroutine that must be used
// Tests that the coroutine transformation finds out that `a` is not live
// during the yield expression. Type checking will also compute liveness
// and it should also find out that `a` is not live.
diff --git a/tests/ui/coroutine/too-live-local-in-immovable-gen.stderr b/tests/ui/coroutine/too-live-local-in-immovable-gen.stderr
index 4a67dbe71e19b..48df5c5beacd7 100644
--- a/tests/ui/coroutine/too-live-local-in-immovable-gen.stderr
+++ b/tests/ui/coroutine/too-live-local-in-immovable-gen.stderr
@@ -1,7 +1,8 @@
warning: unused coroutine that must be used
- --> $DIR/too-live-local-in-immovable-gen.rs:8:9
+ --> $DIR/too-live-local-in-immovable-gen.rs:8:22
|
-LL | / static move || {
+LL | #[coroutine] static move || {
+ | ______________________^
LL | | // Tests that the coroutine transformation finds out that `a` is not live
LL | | // during the yield expression. Type checking will also compute liveness
LL | | // and it should also find out that `a` is not live.
diff --git a/tests/ui/coroutine/too-many-parameters.rs b/tests/ui/coroutine/too-many-parameters.rs
index 377d80c7b22e2..3baaf0623479d 100644
--- a/tests/ui/coroutine/too-many-parameters.rs
+++ b/tests/ui/coroutine/too-many-parameters.rs
@@ -1,6 +1,7 @@
#![feature(coroutines)]
fn main() {
+ #[coroutine]
|(), ()| {
//~^ error: too many parameters for a coroutine
yield;
diff --git a/tests/ui/coroutine/too-many-parameters.stderr b/tests/ui/coroutine/too-many-parameters.stderr
index c0917c7225ba4..45dad8e349e25 100644
--- a/tests/ui/coroutine/too-many-parameters.stderr
+++ b/tests/ui/coroutine/too-many-parameters.stderr
@@ -1,5 +1,5 @@
error[E0628]: too many parameters for a coroutine (expected 0 or 1 parameters)
- --> $DIR/too-many-parameters.rs:4:5
+ --> $DIR/too-many-parameters.rs:5:5
|
LL | |(), ()| {
| ^^^^^^^^
diff --git a/tests/ui/coroutine/type-mismatch-error.rs b/tests/ui/coroutine/type-mismatch-error.rs
index 0d04c21484cbe..ee4e27c20da18 100644
--- a/tests/ui/coroutine/type-mismatch-error.rs
+++ b/tests/ui/coroutine/type-mismatch-error.rs
@@ -1,7 +1,7 @@
//! Test that we get the expected type mismatch error instead of "closure is expected to take 0
//! arguments" (which got introduced after implementing resume arguments).
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::Coroutine;
@@ -9,6 +9,7 @@ fn f<G: Coroutine>(_: G, _: G::Return) {}
fn main() {
f(
+ #[coroutine]
|a: u8| {
if false {
yield ();
diff --git a/tests/ui/coroutine/type-mismatch-error.stderr b/tests/ui/coroutine/type-mismatch-error.stderr
index 737d9afdd79a9..f10c30e259072 100644
--- a/tests/ui/coroutine/type-mismatch-error.stderr
+++ b/tests/ui/coroutine/type-mismatch-error.stderr
@@ -1,5 +1,5 @@
error[E0308]: `if` and `else` have incompatible types
- --> $DIR/type-mismatch-error.rs:16:17
+ --> $DIR/type-mismatch-error.rs:17:17
|
LL | / if false {
LL | | yield ();
diff --git a/tests/ui/coroutine/type-mismatch-signature-deduction.rs b/tests/ui/coroutine/type-mismatch-signature-deduction.rs
index d4ca622e80f53..5b04b3efaaa46 100644
--- a/tests/ui/coroutine/type-mismatch-signature-deduction.rs
+++ b/tests/ui/coroutine/type-mismatch-signature-deduction.rs
@@ -4,6 +4,7 @@ use std::ops::Coroutine;
fn foo() -> impl Coroutine<Return = i32> {
//~^ ERROR type mismatch
+ #[coroutine]
|| {
if false {
return Ok(6);
diff --git a/tests/ui/coroutine/type-mismatch-signature-deduction.stderr b/tests/ui/coroutine/type-mismatch-signature-deduction.stderr
index f26e30a8e7435..0892719603752 100644
--- a/tests/ui/coroutine/type-mismatch-signature-deduction.stderr
+++ b/tests/ui/coroutine/type-mismatch-signature-deduction.stderr
@@ -1,5 +1,5 @@
error[E0308]: mismatched types
- --> $DIR/type-mismatch-signature-deduction.rs:14:9
+ --> $DIR/type-mismatch-signature-deduction.rs:15:9
|
LL | 5
| ^ expected `Result<{integer}, _>`, found integer
@@ -7,7 +7,7 @@ LL | 5
= note: expected enum `Result<{integer}, _>`
found type `{integer}`
note: return type inferred to be `Result<{integer}, _>` here
- --> $DIR/type-mismatch-signature-deduction.rs:9:20
+ --> $DIR/type-mismatch-signature-deduction.rs:10:20
|
LL | return Ok(6);
| ^^^^^
@@ -18,7 +18,7 @@ LL | Ok(5)
LL | Err(5)
| ++++ +
-error[E0271]: type mismatch resolving `<{coroutine@$DIR/type-mismatch-signature-deduction.rs:7:5: 7:7} as Coroutine>::Return == i32`
+error[E0271]: type mismatch resolving `<{coroutine@$DIR/type-mismatch-signature-deduction.rs:8:5: 8:7} as Coroutine>::Return == i32`
--> $DIR/type-mismatch-signature-deduction.rs:5:13
|
LL | fn foo() -> impl Coroutine<Return = i32> {
diff --git a/tests/ui/coroutine/uninhabited-field.rs b/tests/ui/coroutine/uninhabited-field.rs
index 79776d653b1f7..d6ada07ce0cbc 100644
--- a/tests/ui/coroutine/uninhabited-field.rs
+++ b/tests/ui/coroutine/uninhabited-field.rs
@@ -3,7 +3,7 @@
#![allow(unused)]
#![feature(assert_matches)]
#![feature(coroutine_trait)]
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
#![feature(never_type)]
use std::assert_matches::assert_matches;
use std::ops::Coroutine;
@@ -13,7 +13,7 @@ use std::pin::Pin;
fn conjure<T>() -> T { loop {} }
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/ui/coroutine/unsized-capture-across-yield.rs b/tests/ui/coroutine/unsized-capture-across-yield.rs
index ef9cbc1d677da..c86b1823aafff 100644
--- a/tests/ui/coroutine/unsized-capture-across-yield.rs
+++ b/tests/ui/coroutine/unsized-capture-across-yield.rs
@@ -7,6 +7,7 @@ use std::ops::Coroutine;
fn capture() -> impl Coroutine {
let b: [u8] = *(Box::new([]) as Box<[u8]>);
+ #[coroutine]
move || {
println!("{:?}", &b);
//~^ ERROR the size for values of type `[u8]` cannot be known at compilation time
diff --git a/tests/ui/coroutine/unsized-capture-across-yield.stderr b/tests/ui/coroutine/unsized-capture-across-yield.stderr
index 436f0901a9776..03551f1bbff51 100644
--- a/tests/ui/coroutine/unsized-capture-across-yield.stderr
+++ b/tests/ui/coroutine/unsized-capture-across-yield.stderr
@@ -8,7 +8,7 @@ LL | #![feature(unsized_locals)]
= note: `#[warn(incomplete_features)]` on by default
error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
- --> $DIR/unsized-capture-across-yield.rs:11:27
+ --> $DIR/unsized-capture-across-yield.rs:12:27
|
LL | move || {
| -- this closure captures all values by move
diff --git a/tests/ui/coroutine/unsized-local-across-yield.rs b/tests/ui/coroutine/unsized-local-across-yield.rs
index 7a8ed60e46ae4..cb8ced13a111a 100644
--- a/tests/ui/coroutine/unsized-local-across-yield.rs
+++ b/tests/ui/coroutine/unsized-local-across-yield.rs
@@ -6,6 +6,7 @@
use std::ops::Coroutine;
fn across() -> impl Coroutine {
+ #[coroutine]
move || {
let b: [u8] = *(Box::new([]) as Box<[u8]>);
//~^ ERROR the size for values of type `[u8]` cannot be known at compilation time
diff --git a/tests/ui/coroutine/unsized-local-across-yield.stderr b/tests/ui/coroutine/unsized-local-across-yield.stderr
index c4c3be77ac2bd..4fe0f135a9d62 100644
--- a/tests/ui/coroutine/unsized-local-across-yield.stderr
+++ b/tests/ui/coroutine/unsized-local-across-yield.stderr
@@ -8,7 +8,7 @@ LL | #![feature(unsized_locals)]
= note: `#[warn(incomplete_features)]` on by default
error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
- --> $DIR/unsized-local-across-yield.rs:10:13
+ --> $DIR/unsized-local-across-yield.rs:11:13
|
LL | let b: [u8] = *(Box::new([]) as Box<[u8]>);
| ^ doesn't have a size known at compile-time
diff --git a/tests/ui/coroutine/yield-in-args-rev.rs b/tests/ui/coroutine/yield-in-args-rev.rs
index b074e2bc93987..29d79df25fbab 100644
--- a/tests/ui/coroutine/yield-in-args-rev.rs
+++ b/tests/ui/coroutine/yield-in-args-rev.rs
@@ -10,7 +10,7 @@
fn foo(_a: (), _b: &bool) {}
fn bar() {
- || { //~ WARN unused coroutine that must be used
+ #[coroutine] || { //~ WARN unused coroutine that must be used
let b = true;
foo(yield, &b);
};
diff --git a/tests/ui/coroutine/yield-in-args-rev.stderr b/tests/ui/coroutine/yield-in-args-rev.stderr
index dbf46739e8bf1..10829d661854d 100644
--- a/tests/ui/coroutine/yield-in-args-rev.stderr
+++ b/tests/ui/coroutine/yield-in-args-rev.stderr
@@ -1,7 +1,8 @@
warning: unused coroutine that must be used
- --> $DIR/yield-in-args-rev.rs:13:5
+ --> $DIR/yield-in-args-rev.rs:13:18
|
-LL | / || {
+LL | #[coroutine] || {
+ | __________________^
LL | | let b = true;
LL | | foo(yield, &b);
LL | | };
diff --git a/tests/ui/coroutine/yield-in-args.rs b/tests/ui/coroutine/yield-in-args.rs
index b2827148d771a..bc9909b310c3f 100644
--- a/tests/ui/coroutine/yield-in-args.rs
+++ b/tests/ui/coroutine/yield-in-args.rs
@@ -3,6 +3,7 @@
fn foo(_b: &bool, _a: ()) {}
fn main() {
+ #[coroutine]
|| {
let b = true;
foo(&b, yield); //~ ERROR
diff --git a/tests/ui/coroutine/yield-in-args.stderr b/tests/ui/coroutine/yield-in-args.stderr
index 7233f47884b7b..1d2c54f9bdbfa 100644
--- a/tests/ui/coroutine/yield-in-args.stderr
+++ b/tests/ui/coroutine/yield-in-args.stderr
@@ -1,5 +1,5 @@
error[E0626]: borrow may still be in use when coroutine yields
- --> $DIR/yield-in-args.rs:8:13
+ --> $DIR/yield-in-args.rs:9:13
|
LL | foo(&b, yield);
| ^^ ----- possible yield occurs here
diff --git a/tests/ui/coroutine/yield-in-const.rs b/tests/ui/coroutine/yield-in-const.rs
index 22651f32cf85a..dc1b30155b9ff 100644
--- a/tests/ui/coroutine/yield-in-const.rs
+++ b/tests/ui/coroutine/yield-in-const.rs
@@ -2,5 +2,6 @@
const A: u8 = { yield 3u8; 3u8};
//~^ ERROR yield expression outside
+//~| ERROR `yield` can only be used in
fn main() {}
diff --git a/tests/ui/coroutine/yield-in-const.stderr b/tests/ui/coroutine/yield-in-const.stderr
index d5748b0533753..f02729412ccd5 100644
--- a/tests/ui/coroutine/yield-in-const.stderr
+++ b/tests/ui/coroutine/yield-in-const.stderr
@@ -1,9 +1,15 @@
+error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+ --> $DIR/yield-in-const.rs:3:17
+ |
+LL | const A: u8 = { yield 3u8; 3u8};
+ | ^^^^^^^^^
+
error[E0627]: yield expression outside of coroutine literal
--> $DIR/yield-in-const.rs:3:17
|
LL | const A: u8 = { yield 3u8; 3u8};
| ^^^^^^^^^
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0627`.
diff --git a/tests/ui/coroutine/yield-in-function.rs b/tests/ui/coroutine/yield-in-function.rs
index a99312043bdb9..427c5d0e7f5e5 100644
--- a/tests/ui/coroutine/yield-in-function.rs
+++ b/tests/ui/coroutine/yield-in-function.rs
@@ -2,3 +2,4 @@
fn main() { yield; }
//~^ ERROR yield expression outside
+//~| ERROR `yield` can only be used in
diff --git a/tests/ui/coroutine/yield-in-function.stderr b/tests/ui/coroutine/yield-in-function.stderr
index b9d4708bb8d86..dbebf310b04ff 100644
--- a/tests/ui/coroutine/yield-in-function.stderr
+++ b/tests/ui/coroutine/yield-in-function.stderr
@@ -1,9 +1,20 @@
+error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+ --> $DIR/yield-in-function.rs:3:13
+ |
+LL | fn main() { yield; }
+ | ^^^^^
+ |
+help: use `#[coroutine]` to make this closure a coroutine
+ |
+LL | #[coroutine] fn main() { yield; }
+ | ++++++++++++
+
error[E0627]: yield expression outside of coroutine literal
--> $DIR/yield-in-function.rs:3:13
|
LL | fn main() { yield; }
| ^^^^^
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0627`.
diff --git a/tests/ui/coroutine/yield-in-initializer.rs b/tests/ui/coroutine/yield-in-initializer.rs
index 19218926b8a0d..3caefac013ef2 100644
--- a/tests/ui/coroutine/yield-in-initializer.rs
+++ b/tests/ui/coroutine/yield-in-initializer.rs
@@ -3,7 +3,7 @@
#![feature(coroutines)]
fn main() {
- static || { //~ WARN unused coroutine that must be used
+ #[coroutine] static || { //~ WARN unused coroutine that must be used
loop {
// Test that `opt` is not live across the yield, even when borrowed in a loop
// See https://github.com/rust-lang/rust/issues/52792
diff --git a/tests/ui/coroutine/yield-in-initializer.stderr b/tests/ui/coroutine/yield-in-initializer.stderr
index 614df43f2f58f..1e22b7876687f 100644
--- a/tests/ui/coroutine/yield-in-initializer.stderr
+++ b/tests/ui/coroutine/yield-in-initializer.stderr
@@ -1,7 +1,8 @@
warning: unused coroutine that must be used
- --> $DIR/yield-in-initializer.rs:6:5
+ --> $DIR/yield-in-initializer.rs:6:18
|
-LL | / static || {
+LL | #[coroutine] static || {
+ | __________________^
LL | | loop {
LL | | // Test that `opt` is not live across the yield, even when borrowed in a loop
LL | | // See https://github.com/rust-lang/rust/issues/52792
diff --git a/tests/ui/coroutine/yield-in-static.rs b/tests/ui/coroutine/yield-in-static.rs
index 45e0380d46d9f..99d08913e64ce 100644
--- a/tests/ui/coroutine/yield-in-static.rs
+++ b/tests/ui/coroutine/yield-in-static.rs
@@ -2,5 +2,6 @@
static B: u8 = { yield 3u8; 3u8};
//~^ ERROR yield expression outside
+//~| ERROR `yield` can only be used in
fn main() {}
diff --git a/tests/ui/coroutine/yield-in-static.stderr b/tests/ui/coroutine/yield-in-static.stderr
index b56283cab6690..d1fd4eab0fc3c 100644
--- a/tests/ui/coroutine/yield-in-static.stderr
+++ b/tests/ui/coroutine/yield-in-static.stderr
@@ -1,9 +1,15 @@
+error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+ --> $DIR/yield-in-static.rs:3:18
+ |
+LL | static B: u8 = { yield 3u8; 3u8};
+ | ^^^^^^^^^
+
error[E0627]: yield expression outside of coroutine literal
--> $DIR/yield-in-static.rs:3:18
|
LL | static B: u8 = { yield 3u8; 3u8};
| ^^^^^^^^^
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0627`.
diff --git a/tests/ui/coroutine/yield-outside-coroutine-issue-78653.rs b/tests/ui/coroutine/yield-outside-coroutine-issue-78653.rs
index 31025c33b1a26..6833bc9901212 100644
--- a/tests/ui/coroutine/yield-outside-coroutine-issue-78653.rs
+++ b/tests/ui/coroutine/yield-outside-coroutine-issue-78653.rs
@@ -4,4 +4,5 @@ fn main() {
yield || for i in 0 { }
//~^ ERROR yield expression outside of coroutine literal
//~| ERROR `{integer}` is not an iterator
+ //~| ERROR `yield` can only be used in
}
diff --git a/tests/ui/coroutine/yield-outside-coroutine-issue-78653.stderr b/tests/ui/coroutine/yield-outside-coroutine-issue-78653.stderr
index 8f8bec9945847..921e8d5d47a0d 100644
--- a/tests/ui/coroutine/yield-outside-coroutine-issue-78653.stderr
+++ b/tests/ui/coroutine/yield-outside-coroutine-issue-78653.stderr
@@ -1,3 +1,14 @@
+error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+ --> $DIR/yield-outside-coroutine-issue-78653.rs:4:5
+ |
+LL | yield || for i in 0 { }
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: use `#[coroutine]` to make this closure a coroutine
+ |
+LL | #[coroutine] fn main() {
+ | ++++++++++++
+
error[E0627]: yield expression outside of coroutine literal
--> $DIR/yield-outside-coroutine-issue-78653.rs:4:5
|
@@ -14,7 +25,7 @@ LL | yield || for i in 0 { }
= note: if you want to iterate between `start` until a value `end`, use the exclusive range syntax `start..end` or the inclusive range syntax `start..=end`
= note: required for `{integer}` to implement `IntoIterator`
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
Some errors have detailed explanations: E0277, E0627.
For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/coroutine/yield-subtype.rs b/tests/ui/coroutine/yield-subtype.rs
index 271f8362f17ed..adee5075e8324 100644
--- a/tests/ui/coroutine/yield-subtype.rs
+++ b/tests/ui/coroutine/yield-subtype.rs
@@ -8,7 +8,7 @@ fn bar<'a>() {
let a: &'static str = "hi";
let b: &'a str = a;
- || { //~ WARN unused coroutine that must be used
+ #[coroutine] || { //~ WARN unused coroutine that must be used
yield a;
yield b;
};
diff --git a/tests/ui/coroutine/yield-subtype.stderr b/tests/ui/coroutine/yield-subtype.stderr
index 5e7ae9f581eb1..973415327a5d8 100644
--- a/tests/ui/coroutine/yield-subtype.stderr
+++ b/tests/ui/coroutine/yield-subtype.stderr
@@ -1,7 +1,8 @@
warning: unused coroutine that must be used
- --> $DIR/yield-subtype.rs:11:5
+ --> $DIR/yield-subtype.rs:11:18
|
-LL | / || {
+LL | #[coroutine] || {
+ | __________________^
LL | | yield a;
LL | | yield b;
LL | | };
diff --git a/tests/ui/coroutine/yield-while-iterating.rs b/tests/ui/coroutine/yield-while-iterating.rs
index 66ac6d3922a9c..77f601e4f2c5b 100644
--- a/tests/ui/coroutine/yield-while-iterating.rs
+++ b/tests/ui/coroutine/yield-while-iterating.rs
@@ -1,4 +1,4 @@
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::ops::{CoroutineState, Coroutine};
use std::cell::Cell;
@@ -9,7 +9,7 @@ fn yield_during_iter_owned_data(x: Vec<i32>) {
// reference to it. This winds up becoming a rather confusing
// regionck error -- in particular, we would freeze with the
// reference in scope, and it doesn't live long enough.
- let _b = move || {
+ let _b =#[coroutine] move || {
for p in &x { //~ ERROR
yield();
}
@@ -17,7 +17,7 @@ fn yield_during_iter_owned_data(x: Vec<i32>) {
}
fn yield_during_iter_borrowed_slice(x: &[i32]) {
- let _b = move || {
+ let _b = #[coroutine] move || {
for p in x {
yield();
}
@@ -26,7 +26,7 @@ fn yield_during_iter_borrowed_slice(x: &[i32]) {
fn yield_during_iter_borrowed_slice_2() {
let mut x = vec![22_i32];
- let _b = || {
+ let _b = #[coroutine] || {
for p in &x {
yield();
}
@@ -38,7 +38,7 @@ fn yield_during_iter_borrowed_slice_3() {
// OK to take a mutable ref to `x` and yield
// up pointers from it:
let mut x = vec![22_i32];
- let mut b = || {
+ let mut b = #[coroutine] || {
for p in &mut x {
yield p;
}
@@ -50,7 +50,7 @@ fn yield_during_iter_borrowed_slice_4() {
// ...but not OK to do that while reading
// from `x` too
let mut x = vec![22_i32];
- let mut b = || {
+ let mut b = #[coroutine] || {
for p in &mut x {
yield p;
}
@@ -61,7 +61,7 @@ fn yield_during_iter_borrowed_slice_4() {
fn yield_during_range_iter() {
// Should be OK.
- let mut b = || {
+ let mut b = #[coroutine] || {
let v = vec![1,2,3];
let len = v.len();
for i in 0..len {
diff --git a/tests/ui/coroutine/yield-while-iterating.stderr b/tests/ui/coroutine/yield-while-iterating.stderr
index 5330121f3728f..f81c914c4bd49 100644
--- a/tests/ui/coroutine/yield-while-iterating.stderr
+++ b/tests/ui/coroutine/yield-while-iterating.stderr
@@ -9,8 +9,8 @@ LL | yield();
error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable
--> $DIR/yield-while-iterating.rs:58:20
|
-LL | let mut b = || {
- | -- mutable borrow occurs here
+LL | let mut b = #[coroutine] || {
+ | -- mutable borrow occurs here
LL | for p in &mut x {
| - first borrow occurs due to use of `x` in coroutine
...
diff --git a/tests/ui/coroutine/yield-while-local-borrowed.rs b/tests/ui/coroutine/yield-while-local-borrowed.rs
index 7f8d1d4543d89..3db30c36712f0 100644
--- a/tests/ui/coroutine/yield-while-local-borrowed.rs
+++ b/tests/ui/coroutine/yield-while-local-borrowed.rs
@@ -1,4 +1,4 @@
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
use std::cell::Cell;
use std::ops::{Coroutine, CoroutineState};
@@ -9,7 +9,7 @@ fn borrow_local_inline() {
//
// (This error occurs because the region shows up in the type of
// `b` and gets extended by region inference.)
- let mut b = move || {
+ let mut b = #[coroutine] move || {
let a = &mut 3;
//~^ ERROR borrow may still be in use when coroutine yields
yield ();
@@ -20,7 +20,7 @@ fn borrow_local_inline() {
fn borrow_local_inline_done() {
// No error here -- `a` is not in scope at the point of `yield`.
- let mut b = move || {
+ let mut b = #[coroutine] move || {
{
let a = &mut 3;
}
@@ -34,7 +34,7 @@ fn borrow_local() {
//
// (This error occurs because the region shows up in the type of
// `b` and gets extended by region inference.)
- let mut b = move || {
+ let mut b = #[coroutine] move || {
let a = 3;
{
let b = &a;
diff --git a/tests/ui/coroutine/yield-while-ref-reborrowed.rs b/tests/ui/coroutine/yield-while-ref-reborrowed.rs
index 07c591758586b..2600d0b4124b1 100644
--- a/tests/ui/coroutine/yield-while-ref-reborrowed.rs
+++ b/tests/ui/coroutine/yield-while-ref-reborrowed.rs
@@ -1,15 +1,16 @@
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
-use std::ops::{CoroutineState, Coroutine};
use std::cell::Cell;
+use std::ops::{Coroutine, CoroutineState};
use std::pin::Pin;
fn reborrow_shared_ref(x: &i32) {
// This is OK -- we have a borrow live over the yield, but it's of
// data that outlives the coroutine.
- let mut b = move || {
+ let mut b = #[coroutine]
+ move || {
let a = &*x;
- yield();
+ yield ();
println!("{}", a);
};
Pin::new(&mut b).resume(());
@@ -18,9 +19,10 @@ fn reborrow_shared_ref(x: &i32) {
fn reborrow_mutable_ref(x: &mut i32) {
// This is OK -- we have a borrow live over the yield, but it's of
// data that outlives the coroutine.
- let mut b = move || {
+ let mut b = #[coroutine]
+ move || {
let a = &mut *x;
- yield();
+ yield ();
println!("{}", a);
};
Pin::new(&mut b).resume(());
@@ -28,13 +30,14 @@ fn reborrow_mutable_ref(x: &mut i32) {
fn reborrow_mutable_ref_2(x: &mut i32) {
// ...but not OK to go on using `x`.
- let mut b = || {
+ let mut b = #[coroutine]
+ || {
let a = &mut *x;
- yield();
+ yield ();
println!("{}", a);
};
println!("{}", x); //~ ERROR
Pin::new(&mut b).resume(());
}
-fn main() { }
+fn main() {}
diff --git a/tests/ui/coroutine/yield-while-ref-reborrowed.stderr b/tests/ui/coroutine/yield-while-ref-reborrowed.stderr
index 62ac02653112e..7c9b766457dbf 100644
--- a/tests/ui/coroutine/yield-while-ref-reborrowed.stderr
+++ b/tests/ui/coroutine/yield-while-ref-reborrowed.stderr
@@ -1,8 +1,8 @@
error[E0501]: cannot borrow `x` as immutable because previous closure requires unique access
- --> $DIR/yield-while-ref-reborrowed.rs:36:20
+ --> $DIR/yield-while-ref-reborrowed.rs:39:20
|
-LL | let mut b = || {
- | -- coroutine construction occurs here
+LL | || {
+ | -- coroutine construction occurs here
LL | let a = &mut *x;
| -- first borrow occurs due to use of `x` in coroutine
...
diff --git a/tests/ui/drop/dynamic-drop.rs b/tests/ui/drop/dynamic-drop.rs
index f848a1a340b29..b695b5702d943 100644
--- a/tests/ui/drop/dynamic-drop.rs
+++ b/tests/ui/drop/dynamic-drop.rs
@@ -1,7 +1,7 @@
//@ run-pass
//@ needs-unwind
-#![feature(coroutines, coroutine_trait)]
+#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
#![feature(if_let_guard)]
#![allow(unused_assignments)]
@@ -176,7 +176,7 @@ fn vec_simple(a: &Allocator) {
fn coroutine(a: &Allocator, run_count: usize) {
assert!(run_count < 4);
- let mut gen = || {
+ let mut gen = #[coroutine] || {
(a.alloc(),
yield a.alloc(),
a.alloc(),
diff --git a/tests/ui/feature-gates/feature-gate-closure_track_caller.rs b/tests/ui/feature-gates/feature-gate-closure_track_caller.rs
index 93bf83ecf53c8..d90fb765a237a 100644
--- a/tests/ui/feature-gates/feature-gate-closure_track_caller.rs
+++ b/tests/ui/feature-gates/feature-gate-closure_track_caller.rs
@@ -4,6 +4,6 @@
fn main() {
let _closure = #[track_caller] || {}; //~ `#[track_caller]` on closures
- let _coroutine = #[track_caller] || { yield; }; //~ `#[track_caller]` on closures
+ let _coroutine = #[coroutine] #[track_caller] || { yield; }; //~ `#[track_caller]` on closures
let _future = #[track_caller] async {}; //~ `#[track_caller]` on closures
}
diff --git a/tests/ui/feature-gates/feature-gate-closure_track_caller.stderr b/tests/ui/feature-gates/feature-gate-closure_track_caller.stderr
index 17b5e6016a461..0b12b73fd1fff 100644
--- a/tests/ui/feature-gates/feature-gate-closure_track_caller.stderr
+++ b/tests/ui/feature-gates/feature-gate-closure_track_caller.stderr
@@ -9,10 +9,10 @@ LL | let _closure = #[track_caller] || {};
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: `#[track_caller]` on closures is currently unstable
- --> $DIR/feature-gate-closure_track_caller.rs:7:22
+ --> $DIR/feature-gate-closure_track_caller.rs:7:35
|
-LL | let _coroutine = #[track_caller] || { yield; };
- | ^^^^^^^^^^^^^^^
+LL | let _coroutine = #[coroutine] #[track_caller] || { yield; };
+ | ^^^^^^^^^^^^^^^
|
= note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
= help: add `#![feature(closure_track_caller)]` to the crate attributes to enable
diff --git a/tests/ui/feature-gates/feature-gate-coroutines.e2024.stderr b/tests/ui/feature-gates/feature-gate-coroutines.e2024.stderr
index 1cef163cef5c2..3bb48e4a37a4a 100644
--- a/tests/ui/feature-gates/feature-gate-coroutines.e2024.stderr
+++ b/tests/ui/feature-gates/feature-gate-coroutines.e2024.stderr
@@ -8,8 +8,19 @@ LL | yield true;
= help: add `#![feature(coroutines)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+ --> $DIR/feature-gate-coroutines.rs:5:5
+ |
+LL | yield true;
+ | ^^^^^^^^^^
+ |
+help: use `#[coroutine]` to make this closure a coroutine
+ |
+LL | #[coroutine] fn main() {
+ | ++++++++++++
+
error[E0658]: yield syntax is experimental
- --> $DIR/feature-gate-coroutines.rs:9:16
+ --> $DIR/feature-gate-coroutines.rs:10:16
|
LL | let _ = || yield true;
| ^^^^^^^^^^
@@ -18,13 +29,24 @@ LL | let _ = || yield true;
= help: add `#![feature(coroutines)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+ --> $DIR/feature-gate-coroutines.rs:10:16
+ |
+LL | let _ = || yield true;
+ | ^^^^^^^^^^
+ |
+help: use `#[coroutine]` to make this closure a coroutine
+ |
+LL | let _ = #[coroutine] || yield true;
+ | ++++++++++++
+
error[E0627]: yield expression outside of coroutine literal
--> $DIR/feature-gate-coroutines.rs:5:5
|
LL | yield true;
| ^^^^^^^^^^
-error: aborting due to 3 previous errors
+error: aborting due to 5 previous errors
Some errors have detailed explanations: E0627, E0658.
For more information about an error, try `rustc --explain E0627`.
diff --git a/tests/ui/feature-gates/feature-gate-coroutines.none.stderr b/tests/ui/feature-gates/feature-gate-coroutines.none.stderr
index 403f0549aef27..65e7737ef84d5 100644
--- a/tests/ui/feature-gates/feature-gate-coroutines.none.stderr
+++ b/tests/ui/feature-gates/feature-gate-coroutines.none.stderr
@@ -9,7 +9,7 @@ LL | yield true;
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: yield syntax is experimental
- --> $DIR/feature-gate-coroutines.rs:9:16
+ --> $DIR/feature-gate-coroutines.rs:10:16
|
LL | let _ = || yield true;
| ^^^^^^^^^^
@@ -19,7 +19,7 @@ LL | let _ = || yield true;
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: yield syntax is experimental
- --> $DIR/feature-gate-coroutines.rs:16:5
+ --> $DIR/feature-gate-coroutines.rs:18:5
|
LL | yield;
| ^^^^^
@@ -29,7 +29,7 @@ LL | yield;
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: yield syntax is experimental
- --> $DIR/feature-gate-coroutines.rs:17:5
+ --> $DIR/feature-gate-coroutines.rs:19:5
|
LL | yield 0;
| ^^^^^^^
@@ -49,8 +49,19 @@ LL | yield true;
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+ --> $DIR/feature-gate-coroutines.rs:5:5
+ |
+LL | yield true;
+ | ^^^^^^^^^^
+ |
+help: use `#[coroutine]` to make this closure a coroutine
+ |
+LL | #[coroutine] fn main() {
+ | ++++++++++++
+
error[E0658]: yield syntax is experimental
- --> $DIR/feature-gate-coroutines.rs:9:16
+ --> $DIR/feature-gate-coroutines.rs:10:16
|
LL | let _ = || yield true;
| ^^^^^^^^^^
@@ -60,13 +71,24 @@ LL | let _ = || yield true;
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+ --> $DIR/feature-gate-coroutines.rs:10:16
+ |
+LL | let _ = || yield true;
+ | ^^^^^^^^^^
+ |
+help: use `#[coroutine]` to make this closure a coroutine
+ |
+LL | let _ = #[coroutine] || yield true;
+ | ++++++++++++
+
error[E0627]: yield expression outside of coroutine literal
--> $DIR/feature-gate-coroutines.rs:5:5
|
LL | yield true;
| ^^^^^^^^^^
-error: aborting due to 7 previous errors
+error: aborting due to 9 previous errors
Some errors have detailed explanations: E0627, E0658.
For more information about an error, try `rustc --explain E0627`.
diff --git a/tests/ui/feature-gates/feature-gate-coroutines.rs b/tests/ui/feature-gates/feature-gate-coroutines.rs
index b3df2351b680b..28dce8596d396 100644
--- a/tests/ui/feature-gates/feature-gate-coroutines.rs
+++ b/tests/ui/feature-gates/feature-gate-coroutines.rs
@@ -5,9 +5,11 @@ fn main() {
yield true; //~ ERROR yield syntax is experimental
//~^ ERROR yield expression outside of coroutine literal
//[none]~^^ ERROR yield syntax is experimental
+ //~^^^ ERROR `yield` can only be used
let _ = || yield true; //~ ERROR yield syntax is experimental
//[none]~^ ERROR yield syntax is experimental
+ //~^^ ERROR `yield` can only be used
}
#[cfg(FALSE)]
diff --git a/tests/ui/feature-gates/feature-gate-inline_const.rs b/tests/ui/feature-gates/feature-gate-inline_const.rs
deleted file mode 100644
index 43ff90d234cb7..0000000000000
--- a/tests/ui/feature-gates/feature-gate-inline_const.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-fn main() {
- let _ = const {
- //~^ ERROR inline-const is experimental [E0658]
- true
- };
-}
diff --git a/tests/ui/feature-gates/feature-gate-inline_const.stderr b/tests/ui/feature-gates/feature-gate-inline_const.stderr
deleted file mode 100644
index 6cf675065f34d..0000000000000
--- a/tests/ui/feature-gates/feature-gate-inline_const.stderr
+++ /dev/null
@@ -1,13 +0,0 @@
-error[E0658]: inline-const is experimental
- --> $DIR/feature-gate-inline_const.rs:2:13
- |
-LL | let _ = const {
- | ^^^^^
- |
- = note: see issue #76001 <https://github.com/rust-lang/rust/issues/76001> for more information
- = help: add `#![feature(inline_const)]` to the crate attributes to enable
- = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/impl-trait/issues/issue-58504.rs b/tests/ui/impl-trait/issues/issue-58504.rs
index 4f7a35e81b80b..856e1297e58b8 100644
--- a/tests/ui/impl-trait/issues/issue-58504.rs
+++ b/tests/ui/impl-trait/issues/issue-58504.rs
@@ -3,7 +3,7 @@
use std::ops::Coroutine;
fn mk_gen() -> impl Coroutine<Return=!, Yield=()> {
- || { loop { yield; } }
+ #[coroutine] || { loop { yield; } }
}
fn main() {
diff --git a/tests/ui/impl-trait/lifetimes.rs b/tests/ui/impl-trait/lifetimes.rs
index 93a4801fa40ef..df64b685eab85 100644
--- a/tests/ui/impl-trait/lifetimes.rs
+++ b/tests/ui/impl-trait/lifetimes.rs
@@ -115,7 +115,7 @@ impl<'unnecessary_lifetime> MyVec {
}
fn coroutine_doesnt_capture_unnecessary_lifetime<'s: 's>() -> impl Sized {
- || yield
+ #[coroutine] || yield
}
}
diff --git a/tests/ui/impl-trait/normalize-tait-in-const.rs b/tests/ui/impl-trait/normalize-tait-in-const.rs
index ccd073b807094..422c2e439cf0b 100644
--- a/tests/ui/impl-trait/normalize-tait-in-const.rs
+++ b/tests/ui/impl-trait/normalize-tait-in-const.rs
@@ -3,7 +3,6 @@
#![feature(type_alias_impl_trait)]
#![feature(const_trait_impl)]
#![feature(const_refs_to_cell)]
-#![feature(inline_const)]
use std::marker::Destruct;
diff --git a/tests/ui/impl-trait/normalize-tait-in-const.stderr b/tests/ui/impl-trait/normalize-tait-in-const.stderr
index 7ae8306d74d5d..fbd41b61730e6 100644
--- a/tests/ui/impl-trait/normalize-tait-in-const.stderr
+++ b/tests/ui/impl-trait/normalize-tait-in-const.stderr
@@ -1,11 +1,11 @@
error: `~const` can only be applied to `#[const_trait]` traits
- --> $DIR/normalize-tait-in-const.rs:25:42
+ --> $DIR/normalize-tait-in-const.rs:24:42
|
LL | const fn with_positive<F: ~const for<'a> Fn(&'a Alias<'a>) + ~const Destruct>(fun: F) {
| ^^^^^^^^^^^^^^^^^
error[E0015]: cannot call non-const closure in constant functions
- --> $DIR/normalize-tait-in-const.rs:26:5
+ --> $DIR/normalize-tait-in-const.rs:25:5
|
LL | fun(filter_positive());
| ^^^^^^^^^^^^^^^^^^^^^^
@@ -21,7 +21,7 @@ LL + #![feature(effects)]
|
error[E0493]: destructor of `F` cannot be evaluated at compile-time
- --> $DIR/normalize-tait-in-const.rs:25:79
+ --> $DIR/normalize-tait-in-const.rs:24:79
|
LL | const fn with_positive<F: ~const for<'a> Fn(&'a Alias<'a>) + ~const Destruct>(fun: F) {
| ^^^ the destructor for this type cannot be evaluated in constant functions
diff --git a/tests/ui/impl-trait/recursive-coroutine-boxed.next.stderr b/tests/ui/impl-trait/recursive-coroutine-boxed.next.stderr
index c0b399746eaf9..96db2030a405c 100644
--- a/tests/ui/impl-trait/recursive-coroutine-boxed.next.stderr
+++ b/tests/ui/impl-trait/recursive-coroutine-boxed.next.stderr
@@ -1,5 +1,5 @@
error[E0282]: type annotations needed
- --> $DIR/recursive-coroutine-boxed.rs:14:23
+ --> $DIR/recursive-coroutine-boxed.rs:15:23
|
LL | let mut gen = Box::pin(foo());
| ^^^^^^^^ cannot infer type of the type parameter `T` declared on the struct `Box`
@@ -13,7 +13,7 @@ LL | let mut gen = Box::<T>::pin(foo());
| +++++
error[E0308]: mismatched types
- --> $DIR/recursive-coroutine-boxed.rs:13:5
+ --> $DIR/recursive-coroutine-boxed.rs:14:18
|
LL | fn foo() -> impl Coroutine<Yield = (), Return = ()> {
| ---------------------------------------
@@ -21,7 +21,8 @@ LL | fn foo() -> impl Coroutine<Yield = (), Return = ()> {
| the expected opaque type
| expected `impl Coroutine<Yield = (), Return = ()>` because of return type
...
-LL | / || {
+LL | #[coroutine] || {
+ | __________________^
LL | | let mut gen = Box::pin(foo());
LL | |
LL | | let mut r = gen.as_mut().resume(());
@@ -31,7 +32,7 @@ LL | | }
| |_____^ types differ
|
= note: expected opaque type `impl Coroutine<Yield = (), Return = ()>`
- found coroutine `{coroutine@$DIR/recursive-coroutine-boxed.rs:13:5: 13:7}`
+ found coroutine `{coroutine@$DIR/recursive-coroutine-boxed.rs:14:18: 14:20}`
error: aborting due to 2 previous errors
diff --git a/tests/ui/impl-trait/recursive-coroutine-boxed.rs b/tests/ui/impl-trait/recursive-coroutine-boxed.rs
index 02c75be0f3aa0..24a77d7311419 100644
--- a/tests/ui/impl-trait/recursive-coroutine-boxed.rs
+++ b/tests/ui/impl-trait/recursive-coroutine-boxed.rs
@@ -10,7 +10,8 @@ fn foo() -> impl Coroutine<Yield = (), Return = ()> {
// FIXME(-Znext-solver): this fails with a mismatched types as the
// hidden type of the opaque ends up as {type error}. We should not
// emit errors for such goals.
- || { //[next]~ ERROR mismatched types
+
+ #[coroutine] || { //[next]~ ERROR mismatched types
let mut gen = Box::pin(foo());
//[next]~^ ERROR type annotations needed
let mut r = gen.as_mut().resume(());
diff --git a/tests/ui/impl-trait/recursive-coroutine-indirect.current.stderr b/tests/ui/impl-trait/recursive-coroutine-indirect.current.stderr
index ee87c483d0d03..9814187e179ef 100644
--- a/tests/ui/impl-trait/recursive-coroutine-indirect.current.stderr
+++ b/tests/ui/impl-trait/recursive-coroutine-indirect.current.stderr
@@ -1,8 +1,8 @@
error[E0733]: recursion in a coroutine requires boxing
- --> $DIR/recursive-coroutine-indirect.rs:11:5
+ --> $DIR/recursive-coroutine-indirect.rs:11:18
|
-LL | move || {
- | ^^^^^^^
+LL | #[coroutine] move || {
+ | ^^^^^^^
LL | let x = coroutine_hold();
| - recursive call here
diff --git a/tests/ui/impl-trait/recursive-coroutine-indirect.next.stderr b/tests/ui/impl-trait/recursive-coroutine-indirect.next.stderr
index ee87c483d0d03..9814187e179ef 100644
--- a/tests/ui/impl-trait/recursive-coroutine-indirect.next.stderr
+++ b/tests/ui/impl-trait/recursive-coroutine-indirect.next.stderr
@@ -1,8 +1,8 @@
error[E0733]: recursion in a coroutine requires boxing
- --> $DIR/recursive-coroutine-indirect.rs:11:5
+ --> $DIR/recursive-coroutine-indirect.rs:11:18
|
-LL | move || {
- | ^^^^^^^
+LL | #[coroutine] move || {
+ | ^^^^^^^
LL | let x = coroutine_hold();
| - recursive call here
diff --git a/tests/ui/impl-trait/recursive-coroutine-indirect.rs b/tests/ui/impl-trait/recursive-coroutine-indirect.rs
index bba9792fe3cfa..cec2176049b87 100644
--- a/tests/ui/impl-trait/recursive-coroutine-indirect.rs
+++ b/tests/ui/impl-trait/recursive-coroutine-indirect.rs
@@ -8,7 +8,7 @@
#![feature(coroutines)]
#![allow(unconditional_recursion)]
fn coroutine_hold() -> impl Sized {
- move || { //~ ERROR recursion in a coroutine requires boxing
+ #[coroutine] move || { //~ ERROR recursion in a coroutine requires boxing
let x = coroutine_hold();
yield;
x;
diff --git a/tests/ui/impl-trait/recursive-impl-trait-type-indirect.rs b/tests/ui/impl-trait/recursive-impl-trait-type-indirect.rs
index 432f80a1763e5..8b9dac0e29b0b 100644
--- a/tests/ui/impl-trait/recursive-impl-trait-type-indirect.rs
+++ b/tests/ui/impl-trait/recursive-impl-trait-type-indirect.rs
@@ -57,6 +57,8 @@ fn coroutine_sig() -> impl Sized {
fn coroutine_capture() -> impl Sized {
//~^ ERROR
let x = coroutine_capture();
+
+ #[coroutine]
move || {
yield;
x;
diff --git a/tests/ui/impl-trait/recursive-impl-trait-type-indirect.stderr b/tests/ui/impl-trait/recursive-impl-trait-type-indirect.stderr
index d5b8c531fd6e0..2d2731e4368f5 100644
--- a/tests/ui/impl-trait/recursive-impl-trait-type-indirect.stderr
+++ b/tests/ui/impl-trait/recursive-impl-trait-type-indirect.stderr
@@ -98,10 +98,10 @@ LL | | yield;
LL | | x;
| | - coroutine captures itself here
LL | | }
- | |_____- returning here with type `{coroutine@$DIR/recursive-impl-trait-type-indirect.rs:60:5: 60:12}`
+ | |_____- returning here with type `{coroutine@$DIR/recursive-impl-trait-type-indirect.rs:62:5: 62:12}`
error[E0720]: cannot resolve opaque type
- --> $DIR/recursive-impl-trait-type-indirect.rs:66:35
+ --> $DIR/recursive-impl-trait-type-indirect.rs:68:35
|
LL | fn substs_change<T: 'static>() -> impl Sized {
| ^^^^^^^^^^ recursive opaque type
@@ -110,7 +110,7 @@ LL | (substs_change::<&T>(),)
| ------------------------ returning here with type `(impl Sized,)`
error[E0720]: cannot resolve opaque type
- --> $DIR/recursive-impl-trait-type-indirect.rs:76:26
+ --> $DIR/recursive-impl-trait-type-indirect.rs:78:26
|
LL | fn mutual_recursion() -> impl Sync {
| ^^^^^^^^^ recursive opaque type
@@ -122,7 +122,7 @@ LL | fn mutual_recursion_b() -> impl Sized {
| ---------- returning this opaque type `impl Sized`
error[E0720]: cannot resolve opaque type
- --> $DIR/recursive-impl-trait-type-indirect.rs:81:28
+ --> $DIR/recursive-impl-trait-type-indirect.rs:83:28
|
LL | fn mutual_recursion() -> impl Sync {
| --------- returning this opaque type `impl Sync`
diff --git a/tests/ui/inline-const/const-expr-array-init.rs b/tests/ui/inline-const/const-expr-array-init.rs
index 075c27c1cc92d..eb126b61f2dfe 100644
--- a/tests/ui/inline-const/const-expr-array-init.rs
+++ b/tests/ui/inline-const/const-expr-array-init.rs
@@ -1,7 +1,5 @@
//@ build-pass
-#![feature(inline_const)]
-
use std::cell::Cell;
fn main() {
diff --git a/tests/ui/inline-const/const-expr-basic.rs b/tests/ui/inline-const/const-expr-basic.rs
index 6a19cc656d02f..7f769d2b5c337 100644
--- a/tests/ui/inline-const/const-expr-basic.rs
+++ b/tests/ui/inline-const/const-expr-basic.rs
@@ -1,7 +1,5 @@
//@ run-pass
-#![feature(inline_const)]
-
fn foo() -> i32 {
const {
let x = 5 + 10;
diff --git a/tests/ui/inline-const/const-expr-generic-err.rs b/tests/ui/inline-const/const-expr-generic-err.rs
index 3c4bbcb3dc9a6..3249e826a96be 100644
--- a/tests/ui/inline-const/const-expr-generic-err.rs
+++ b/tests/ui/inline-const/const-expr-generic-err.rs
@@ -1,5 +1,4 @@
//@ build-fail
-#![feature(inline_const)]
fn foo<T>() {
const { assert!(std::mem::size_of::<T>() == 0); } //~ ERROR E0080
diff --git a/tests/ui/inline-const/const-expr-generic-err.stderr b/tests/ui/inline-const/const-expr-generic-err.stderr
index 7331c7f18e976..dcd6b62bbfc1d 100644
--- a/tests/ui/inline-const/const-expr-generic-err.stderr
+++ b/tests/ui/inline-const/const-expr-generic-err.stderr
@@ -1,37 +1,37 @@
error[E0080]: evaluation of `foo::<i32>::{constant#0}` failed
- --> $DIR/const-expr-generic-err.rs:5:13
+ --> $DIR/const-expr-generic-err.rs:4:13
|
LL | const { assert!(std::mem::size_of::<T>() == 0); }
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: std::mem::size_of::<T>() == 0', $DIR/const-expr-generic-err.rs:5:13
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: std::mem::size_of::<T>() == 0', $DIR/const-expr-generic-err.rs:4:13
|
= note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
note: erroneous constant encountered
- --> $DIR/const-expr-generic-err.rs:5:5
+ --> $DIR/const-expr-generic-err.rs:4:5
|
LL | const { assert!(std::mem::size_of::<T>() == 0); }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: the above error was encountered while instantiating `fn foo::<i32>`
- --> $DIR/const-expr-generic-err.rs:13:5
+ --> $DIR/const-expr-generic-err.rs:12:5
|
LL | foo::<i32>();
| ^^^^^^^^^^^^
error[E0080]: evaluation of `bar::<0>::{constant#0}` failed
- --> $DIR/const-expr-generic-err.rs:9:13
+ --> $DIR/const-expr-generic-err.rs:8:13
|
LL | const { N - 1 }
| ^^^^^ attempt to compute `0_usize - 1_usize`, which would overflow
note: erroneous constant encountered
- --> $DIR/const-expr-generic-err.rs:9:5
+ --> $DIR/const-expr-generic-err.rs:8:5
|
LL | const { N - 1 }
| ^^^^^^^^^^^^^^^
note: erroneous constant encountered
- --> $DIR/const-expr-generic-err.rs:9:5
+ --> $DIR/const-expr-generic-err.rs:8:5
|
LL | const { N - 1 }
| ^^^^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL | const { N - 1 }
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
note: the above error was encountered while instantiating `fn bar::<0>`
- --> $DIR/const-expr-generic-err.rs:14:5
+ --> $DIR/const-expr-generic-err.rs:13:5
|
LL | bar::<0>();
| ^^^^^^^^^^
diff --git a/tests/ui/inline-const/const-expr-generic-err2.rs b/tests/ui/inline-const/const-expr-generic-err2.rs
index e097cbe9dd6d1..49cbdbfda5da8 100644
--- a/tests/ui/inline-const/const-expr-generic-err2.rs
+++ b/tests/ui/inline-const/const-expr-generic-err2.rs
@@ -1,5 +1,3 @@
-#![feature(inline_const)]
-
fn foo<T>() {
let _ = [0u8; const { std::mem::size_of::<T>() }];
//~^ ERROR: constant expression depends on a generic parameter
diff --git a/tests/ui/inline-const/const-expr-generic-err2.stderr b/tests/ui/inline-const/const-expr-generic-err2.stderr
index 5876a6c9e198d..c6d77593c46ff 100644
--- a/tests/ui/inline-const/const-expr-generic-err2.stderr
+++ b/tests/ui/inline-const/const-expr-generic-err2.stderr
@@ -1,5 +1,5 @@
error: constant expression depends on a generic parameter
- --> $DIR/const-expr-generic-err2.rs:4:19
+ --> $DIR/const-expr-generic-err2.rs:2:19
|
LL | let _ = [0u8; const { std::mem::size_of::<T>() }];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/inline-const/const-expr-generic.rs b/tests/ui/inline-const/const-expr-generic.rs
index e634e1d4a47f1..0c33b02d3a2e7 100644
--- a/tests/ui/inline-const/const-expr-generic.rs
+++ b/tests/ui/inline-const/const-expr-generic.rs
@@ -1,5 +1,4 @@
//@ check-pass
-#![feature(inline_const)]
fn foo<T>() -> usize {
const { std::mem::size_of::<T>() }
diff --git a/tests/ui/inline-const/const-expr-inference.rs b/tests/ui/inline-const/const-expr-inference.rs
index f3b97d3430efa..99cea3204a194 100644
--- a/tests/ui/inline-const/const-expr-inference.rs
+++ b/tests/ui/inline-const/const-expr-inference.rs
@@ -1,7 +1,5 @@
//@ check-pass
-#![feature(inline_const)]
-
pub fn todo<T>() -> T {
const { todo!() }
}
diff --git a/tests/ui/inline-const/const-expr-lifetime-err.rs b/tests/ui/inline-const/const-expr-lifetime-err.rs
index 0a032a7338ad0..df1e5fcb47352 100644
--- a/tests/ui/inline-const/const-expr-lifetime-err.rs
+++ b/tests/ui/inline-const/const-expr-lifetime-err.rs
@@ -1,5 +1,4 @@
#![feature(const_mut_refs)]
-#![feature(inline_const)]
use std::marker::PhantomData;
diff --git a/tests/ui/inline-const/const-expr-lifetime-err.stderr b/tests/ui/inline-const/const-expr-lifetime-err.stderr
index 75877bc093a79..f97e2d25e6c25 100644
--- a/tests/ui/inline-const/const-expr-lifetime-err.stderr
+++ b/tests/ui/inline-const/const-expr-lifetime-err.stderr
@@ -1,5 +1,5 @@
error[E0597]: `y` does not live long enough
- --> $DIR/const-expr-lifetime-err.rs:23:30
+ --> $DIR/const-expr-lifetime-err.rs:22:30
|
LL | fn foo<'a>() {
| -- lifetime `'a` defined here
diff --git a/tests/ui/inline-const/const-expr-lifetime.rs b/tests/ui/inline-const/const-expr-lifetime.rs
index 5dac17645d7a8..071e724a0faa3 100644
--- a/tests/ui/inline-const/const-expr-lifetime.rs
+++ b/tests/ui/inline-const/const-expr-lifetime.rs
@@ -1,7 +1,6 @@
//@ run-pass
#![feature(const_mut_refs)]
-#![feature(inline_const)]
use std::marker::PhantomData;
diff --git a/tests/ui/inline-const/const-expr-macro.rs b/tests/ui/inline-const/const-expr-macro.rs
index bf3cb3c3320fb..cf07eb12f5a94 100644
--- a/tests/ui/inline-const/const-expr-macro.rs
+++ b/tests/ui/inline-const/const-expr-macro.rs
@@ -1,7 +1,5 @@
//@ run-pass
-#![feature(inline_const)]
-
macro_rules! do_const_block{
($val:block) => { const $val }
}
diff --git a/tests/ui/inline-const/const-expr-reference.rs b/tests/ui/inline-const/const-expr-reference.rs
index b3753b0d371af..208271e37c311 100644
--- a/tests/ui/inline-const/const-expr-reference.rs
+++ b/tests/ui/inline-const/const-expr-reference.rs
@@ -1,7 +1,5 @@
//@ run-pass
-#![feature(inline_const)]
-
const fn bar() -> i32 {
const {
2 + 3
diff --git a/tests/ui/inline-const/const-match-pat-lifetime.rs b/tests/ui/inline-const/const-match-pat-lifetime.rs
index f909e68e7be51..590c426c77379 100644
--- a/tests/ui/inline-const/const-match-pat-lifetime.rs
+++ b/tests/ui/inline-const/const-match-pat-lifetime.rs
@@ -1,7 +1,6 @@
//@ run-pass
#![feature(const_mut_refs)]
-#![feature(inline_const)]
#![feature(inline_const_pat)]
use std::marker::PhantomData;
diff --git a/tests/ui/inline-const/elided-lifetime-being-infer-vars.rs b/tests/ui/inline-const/elided-lifetime-being-infer-vars.rs
index a1c3c61484ae6..e0a889ac34710 100644
--- a/tests/ui/inline-const/elided-lifetime-being-infer-vars.rs
+++ b/tests/ui/inline-const/elided-lifetime-being-infer-vars.rs
@@ -1,7 +1,5 @@
//@ check-pass
-#![feature(inline_const)]
-
fn main() {
let _my_usize = const {
let a = 10_usize;
diff --git a/tests/ui/inline-const/expr-unsafe-err.rs b/tests/ui/inline-const/expr-unsafe-err.rs
index a05a294516833..d53d84b944f0b 100644
--- a/tests/ui/inline-const/expr-unsafe-err.rs
+++ b/tests/ui/inline-const/expr-unsafe-err.rs
@@ -1,4 +1,3 @@
-#![feature(inline_const)]
const unsafe fn require_unsafe() -> usize {
1
}
diff --git a/tests/ui/inline-const/expr-unsafe-err.stderr b/tests/ui/inline-const/expr-unsafe-err.stderr
index 45f850d1f99bf..13a408b971c8c 100644
--- a/tests/ui/inline-const/expr-unsafe-err.stderr
+++ b/tests/ui/inline-const/expr-unsafe-err.stderr
@@ -1,5 +1,5 @@
error[E0133]: call to unsafe function `require_unsafe` is unsafe and requires unsafe function or block
- --> $DIR/expr-unsafe-err.rs:8:9
+ --> $DIR/expr-unsafe-err.rs:7:9
|
LL | require_unsafe();
| ^^^^^^^^^^^^^^^^ call to unsafe function
diff --git a/tests/ui/inline-const/expr-unsafe.rs b/tests/ui/inline-const/expr-unsafe.rs
index f9d1450503e2a..cdd101f3e0884 100644
--- a/tests/ui/inline-const/expr-unsafe.rs
+++ b/tests/ui/inline-const/expr-unsafe.rs
@@ -1,7 +1,7 @@
//@ check-pass
#![warn(unused_unsafe)]
-#![feature(inline_const)]
+
const unsafe fn require_unsafe() -> usize { 1 }
fn main() {
diff --git a/tests/ui/inline-const/expr-with-block-err.rs b/tests/ui/inline-const/expr-with-block-err.rs
index f7547742ddcbe..6f85075755888 100644
--- a/tests/ui/inline-const/expr-with-block-err.rs
+++ b/tests/ui/inline-const/expr-with-block-err.rs
@@ -1,5 +1,3 @@
-#![feature(inline_const)]
-
fn main() {
const { 2 } - const { 1 };
//~^ ERROR mismatched types
diff --git a/tests/ui/inline-const/expr-with-block-err.stderr b/tests/ui/inline-const/expr-with-block-err.stderr
index a46d739504582..f127c11e9b7a5 100644
--- a/tests/ui/inline-const/expr-with-block-err.stderr
+++ b/tests/ui/inline-const/expr-with-block-err.stderr
@@ -1,5 +1,5 @@
error[E0308]: mismatched types
- --> $DIR/expr-with-block-err.rs:4:13
+ --> $DIR/expr-with-block-err.rs:2:13
|
LL | const { 2 } - const { 1 };
| ^ expected `()`, found integer
diff --git a/tests/ui/inline-const/expr-with-block.rs b/tests/ui/inline-const/expr-with-block.rs
index 07a1c9a10f5c2..a32afbcffaddd 100644
--- a/tests/ui/inline-const/expr-with-block.rs
+++ b/tests/ui/inline-const/expr-with-block.rs
@@ -1,5 +1,5 @@
//@ check-pass
-#![feature(inline_const)]
+
fn main() {
match true {
true => const {}
diff --git a/tests/ui/inline-const/instance-doesnt-depend-on-type.rs b/tests/ui/inline-const/instance-doesnt-depend-on-type.rs
index e69106a43af49..c53aab60b06fa 100644
--- a/tests/ui/inline-const/instance-doesnt-depend-on-type.rs
+++ b/tests/ui/inline-const/instance-doesnt-depend-on-type.rs
@@ -1,8 +1,6 @@
//@ check-pass
// issue: 114660
-#![feature(inline_const)]
-
fn main() {
const { core::mem::transmute::<u8, u8> };
// Don't resolve the instance of this inline constant to be an intrinsic,
diff --git a/tests/ui/inline-const/interpolated.rs b/tests/ui/inline-const/interpolated.rs
index 582900e7aa012..38ed2a042e090 100644
--- a/tests/ui/inline-const/interpolated.rs
+++ b/tests/ui/inline-const/interpolated.rs
@@ -1,7 +1,5 @@
//@ check-pass
-#![feature(inline_const)]
-
// This used to be unsupported since the parser first tries to check if we have
// any nested items, and then checks for statements (and expressions). The heuristic
// that we were using to detect the beginning of a const item was incorrect, so
diff --git a/tests/ui/inline-const/promotion.rs b/tests/ui/inline-const/promotion.rs
index 242959c6b5164..2cfb8a0d19fc3 100644
--- a/tests/ui/inline-const/promotion.rs
+++ b/tests/ui/inline-const/promotion.rs
@@ -1,4 +1,3 @@
-#![feature(inline_const)]
#![allow(arithmetic_overflow, unconditional_panic)]
// The only way to have promoteds that fail is in `const fn` called from `const`/`static`.
diff --git a/tests/ui/inline-const/promotion.stderr b/tests/ui/inline-const/promotion.stderr
index 7f06b97818bf5..4e914c9e08728 100644
--- a/tests/ui/inline-const/promotion.stderr
+++ b/tests/ui/inline-const/promotion.stderr
@@ -1,5 +1,5 @@
error[E0716]: temporary value dropped while borrowed
- --> $DIR/promotion.rs:17:37
+ --> $DIR/promotion.rs:16:37
|
LL | let _x: &'static i32 = &div_by_zero();
| ------------ ^^^^^^^^^^^^^ creates a temporary value which is freed while still in use
diff --git a/tests/ui/inline-const/required-const.rs b/tests/ui/inline-const/required-const.rs
index 3de0ab2a0c06c..8f640e933d019 100644
--- a/tests/ui/inline-const/required-const.rs
+++ b/tests/ui/inline-const/required-const.rs
@@ -1,6 +1,5 @@
//@ build-fail
//@ compile-flags: -Zmir-opt-level=3
-#![feature(inline_const)]
fn foo<T>() {
if false {
diff --git a/tests/ui/inline-const/required-const.stderr b/tests/ui/inline-const/required-const.stderr
index 2a13d18547c54..6ca4c250223e6 100644
--- a/tests/ui/inline-const/required-const.stderr
+++ b/tests/ui/inline-const/required-const.stderr
@@ -1,13 +1,13 @@
error[E0080]: evaluation of `foo::<i32>::{constant#0}` failed
- --> $DIR/required-const.rs:7:17
+ --> $DIR/required-const.rs:6:17
|
LL | const { panic!() }
- | ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/required-const.rs:7:17
+ | ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/required-const.rs:6:17
|
= note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
note: erroneous constant encountered
- --> $DIR/required-const.rs:7:9
+ --> $DIR/required-const.rs:6:9
|
LL | const { panic!() }
| ^^^^^^^^^^^^^^^^^^
diff --git a/tests/crashes/124031.rs b/tests/ui/layout/ice-type-error-in-tail-124031.rs
similarity index 54%
rename from tests/crashes/124031.rs
rename to tests/ui/layout/ice-type-error-in-tail-124031.rs
index bdc66fbafe4ca..0a2be11740358 100644
--- a/tests/crashes/124031.rs
+++ b/tests/ui/layout/ice-type-error-in-tail-124031.rs
@@ -1,10 +1,13 @@
-//@ known-bug: #124031
+// Regression test for issue #124031
+// Checks that we don't ICE when the tail
+// of an ADT has a type error
trait Trait {
type RefTarget;
}
impl Trait for () {}
+//~^ ERROR not all trait items implemented, missing: `RefTarget`
struct Other {
data: <() as Trait>::RefTarget,
diff --git a/tests/ui/layout/ice-type-error-in-tail-124031.stderr b/tests/ui/layout/ice-type-error-in-tail-124031.stderr
new file mode 100644
index 0000000000000..57dc83f92dfda
--- /dev/null
+++ b/tests/ui/layout/ice-type-error-in-tail-124031.stderr
@@ -0,0 +1,12 @@
+error[E0046]: not all trait items implemented, missing: `RefTarget`
+ --> $DIR/ice-type-error-in-tail-124031.rs:9:1
+ |
+LL | type RefTarget;
+ | -------------- `RefTarget` from trait
+...
+LL | impl Trait for () {}
+ | ^^^^^^^^^^^^^^^^^ missing `RefTarget` in implementation
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/lifetimes/unusual-rib-combinations.rs b/tests/ui/lifetimes/unusual-rib-combinations.rs
index a2461cff93265..3bc87b9d480b4 100644
--- a/tests/ui/lifetimes/unusual-rib-combinations.rs
+++ b/tests/ui/lifetimes/unusual-rib-combinations.rs
@@ -1,5 +1,3 @@
-#![feature(inline_const)]
-
struct S<'a>(&'a u8);
fn foo() {}
diff --git a/tests/ui/lifetimes/unusual-rib-combinations.stderr b/tests/ui/lifetimes/unusual-rib-combinations.stderr
index 320e64a2f7744..2857fc72ea140 100644
--- a/tests/ui/lifetimes/unusual-rib-combinations.stderr
+++ b/tests/ui/lifetimes/unusual-rib-combinations.stderr
@@ -1,11 +1,11 @@
error[E0106]: missing lifetime specifier
- --> $DIR/unusual-rib-combinations.rs:24:15
+ --> $DIR/unusual-rib-combinations.rs:22:15
|
LL | fn d<const C: S>() {}
| ^ expected named lifetime parameter
error[E0770]: the type of const parameters must not depend on other generic parameters
- --> $DIR/unusual-rib-combinations.rs:29:22
+ --> $DIR/unusual-rib-combinations.rs:27:22
|
LL | struct Bar<const N: &'a (dyn for<'a> Foo<'a>)>;
| ^^ the type must not depend on the parameter `'a`
@@ -13,25 +13,25 @@ LL | struct Bar<const N: &'a (dyn for<'a> Foo<'a>)>;
= note: lifetime parameters may not be used in the type of const parameters
error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
- --> $DIR/unusual-rib-combinations.rs:7:16
+ --> $DIR/unusual-rib-combinations.rs:5:16
|
LL | fn a() -> [u8; foo::()] {
| ^^^^^^^ only `Fn` traits may use parentheses
error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
- --> $DIR/unusual-rib-combinations.rs:14:15
+ --> $DIR/unusual-rib-combinations.rs:12:15
|
LL | fn b<const C: u8()>() {}
| ^^^^ only `Fn` traits may use parentheses
error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
- --> $DIR/unusual-rib-combinations.rs:18:10
+ --> $DIR/unusual-rib-combinations.rs:16:10
|
LL | fn c<T = u8()>() {}
| ^^^^ only `Fn` traits may use parentheses
error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
- --> $DIR/unusual-rib-combinations.rs:18:6
+ --> $DIR/unusual-rib-combinations.rs:16:6
|
LL | fn c<T = u8()>() {}
| ^^^^^^^^
@@ -41,7 +41,7 @@ LL | fn c<T = u8()>() {}
= note: `#[deny(invalid_type_param_default)]` on by default
error[E0308]: mismatched types
- --> $DIR/unusual-rib-combinations.rs:7:16
+ --> $DIR/unusual-rib-combinations.rs:5:16
|
LL | fn a() -> [u8; foo::()] {
| ^^^^^^^ expected `usize`, found fn item
@@ -50,7 +50,7 @@ LL | fn a() -> [u8; foo::()] {
found fn item `fn() {foo}`
error: `S<'_>` is forbidden as the type of a const generic parameter
- --> $DIR/unusual-rib-combinations.rs:24:15
+ --> $DIR/unusual-rib-combinations.rs:22:15
|
LL | fn d<const C: S>() {}
| ^
diff --git a/tests/ui/lint/invalid_from_utf8.rs b/tests/ui/lint/invalid_from_utf8.rs
index e87afe9094cab..2d1822a54ac33 100644
--- a/tests/ui/lint/invalid_from_utf8.rs
+++ b/tests/ui/lint/invalid_from_utf8.rs
@@ -1,6 +1,5 @@
//@ check-pass
-#![feature(inline_const)]
#![feature(concat_bytes)]
#![warn(invalid_from_utf8_unchecked)]
diff --git a/tests/ui/lint/invalid_from_utf8.stderr b/tests/ui/lint/invalid_from_utf8.stderr
index 884165d4f123c..07616e118010b 100644
--- a/tests/ui/lint/invalid_from_utf8.stderr
+++ b/tests/ui/lint/invalid_from_utf8.stderr
@@ -1,5 +1,5 @@
warning: calls to `std::str::from_utf8_unchecked_mut` with a invalid literal are undefined behavior
- --> $DIR/invalid_from_utf8.rs:21:9
+ --> $DIR/invalid_from_utf8.rs:20:9
|
LL | std::str::from_utf8_unchecked_mut(&mut [99, 108, 130, 105, 112, 112, 121]);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------------------------^
@@ -7,13 +7,13 @@ LL | std::str::from_utf8_unchecked_mut(&mut [99, 108, 130, 105, 112, 112
| the literal was valid UTF-8 up to the 2 bytes
|
note: the lint level is defined here
- --> $DIR/invalid_from_utf8.rs:6:9
+ --> $DIR/invalid_from_utf8.rs:5:9
|
LL | #![warn(invalid_from_utf8_unchecked)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: calls to `std::str::from_utf8_unchecked_mut` with a invalid literal are undefined behavior
- --> $DIR/invalid_from_utf8.rs:23:9
+ --> $DIR/invalid_from_utf8.rs:22:9
|
LL | std::str::from_utf8_unchecked_mut(&mut [b'c', b'l', b'\x82', b'i', b'p', b'p', b'y']);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---------------------------------------------^
@@ -21,7 +21,7 @@ LL | std::str::from_utf8_unchecked_mut(&mut [b'c', b'l', b'\x82', b'i',
| the literal was valid UTF-8 up to the 2 bytes
warning: calls to `std::str::from_utf8_unchecked` with a invalid literal are undefined behavior
- --> $DIR/invalid_from_utf8.rs:41:9
+ --> $DIR/invalid_from_utf8.rs:40:9
|
LL | std::str::from_utf8_unchecked(&[99, 108, 130, 105, 112, 112, 121]);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------------------------^
@@ -29,7 +29,7 @@ LL | std::str::from_utf8_unchecked(&[99, 108, 130, 105, 112, 112, 121]);
| the literal was valid UTF-8 up to the 2 bytes
warning: calls to `std::str::from_utf8_unchecked` with a invalid literal are undefined behavior
- --> $DIR/invalid_from_utf8.rs:43:9
+ --> $DIR/invalid_from_utf8.rs:42:9
|
LL | std::str::from_utf8_unchecked(&[b'c', b'l', b'\x82', b'i', b'p', b'p', b'y']);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---------------------------------------------^
@@ -37,7 +37,7 @@ LL | std::str::from_utf8_unchecked(&[b'c', b'l', b'\x82', b'i', b'p', b'
| the literal was valid UTF-8 up to the 2 bytes
warning: calls to `std::str::from_utf8_unchecked` with a invalid literal are undefined behavior
- --> $DIR/invalid_from_utf8.rs:45:9
+ --> $DIR/invalid_from_utf8.rs:44:9
|
LL | std::str::from_utf8_unchecked(b"cl\x82ippy");
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-------------^
@@ -45,7 +45,7 @@ LL | std::str::from_utf8_unchecked(b"cl\x82ippy");
| the literal was valid UTF-8 up to the 2 bytes
warning: calls to `std::str::from_utf8_unchecked` with a invalid literal are undefined behavior
- --> $DIR/invalid_from_utf8.rs:47:9
+ --> $DIR/invalid_from_utf8.rs:46:9
|
LL | std::str::from_utf8_unchecked(concat_bytes!(b"cl", b"\x82ippy"));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---------------------------------^
@@ -53,7 +53,7 @@ LL | std::str::from_utf8_unchecked(concat_bytes!(b"cl", b"\x82ippy"));
| the literal was valid UTF-8 up to the 2 bytes
warning: calls to `std::str::from_utf8_mut` with a invalid literal always return an error
- --> $DIR/invalid_from_utf8.rs:64:9
+ --> $DIR/invalid_from_utf8.rs:63:9
|
LL | std::str::from_utf8_mut(&mut [99, 108, 130, 105, 112, 112, 121]);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------------------------^
@@ -61,13 +61,13 @@ LL | std::str::from_utf8_mut(&mut [99, 108, 130, 105, 112, 112, 121]);
| the literal was valid UTF-8 up to the 2 bytes
|
note: the lint level is defined here
- --> $DIR/invalid_from_utf8.rs:7:9
+ --> $DIR/invalid_from_utf8.rs:6:9
|
LL | #![warn(invalid_from_utf8)]
| ^^^^^^^^^^^^^^^^^
warning: calls to `std::str::from_utf8_mut` with a invalid literal always return an error
- --> $DIR/invalid_from_utf8.rs:66:9
+ --> $DIR/invalid_from_utf8.rs:65:9
|
LL | std::str::from_utf8_mut(&mut [b'c', b'l', b'\x82', b'i', b'p', b'p', b'y']);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---------------------------------------------^
@@ -75,7 +75,7 @@ LL | std::str::from_utf8_mut(&mut [b'c', b'l', b'\x82', b'i', b'p', b'p'
| the literal was valid UTF-8 up to the 2 bytes
warning: calls to `std::str::from_utf8` with a invalid literal always return an error
- --> $DIR/invalid_from_utf8.rs:84:9
+ --> $DIR/invalid_from_utf8.rs:83:9
|
LL | std::str::from_utf8(&[99, 108, 130, 105, 112, 112, 121]);
| ^^^^^^^^^^^^^^^^^^^^^----------------------------------^
@@ -83,7 +83,7 @@ LL | std::str::from_utf8(&[99, 108, 130, 105, 112, 112, 121]);
| the literal was valid UTF-8 up to the 2 bytes
warning: calls to `std::str::from_utf8` with a invalid literal always return an error
- --> $DIR/invalid_from_utf8.rs:86:9
+ --> $DIR/invalid_from_utf8.rs:85:9
|
LL | std::str::from_utf8(&[b'c', b'l', b'\x82', b'i', b'p', b'p', b'y']);
| ^^^^^^^^^^^^^^^^^^^^^---------------------------------------------^
@@ -91,7 +91,7 @@ LL | std::str::from_utf8(&[b'c', b'l', b'\x82', b'i', b'p', b'p', b'y'])
| the literal was valid UTF-8 up to the 2 bytes
warning: calls to `std::str::from_utf8` with a invalid literal always return an error
- --> $DIR/invalid_from_utf8.rs:88:9
+ --> $DIR/invalid_from_utf8.rs:87:9
|
LL | std::str::from_utf8(b"cl\x82ippy");
| ^^^^^^^^^^^^^^^^^^^^-------------^
@@ -99,7 +99,7 @@ LL | std::str::from_utf8(b"cl\x82ippy");
| the literal was valid UTF-8 up to the 2 bytes
warning: calls to `std::str::from_utf8` with a invalid literal always return an error
- --> $DIR/invalid_from_utf8.rs:90:9
+ --> $DIR/invalid_from_utf8.rs:89:9
|
LL | std::str::from_utf8(concat_bytes!(b"cl", b"\x82ippy"));
| ^^^^^^^^^^^^^^^^^^^^---------------------------------^
@@ -107,7 +107,7 @@ LL | std::str::from_utf8(concat_bytes!(b"cl", b"\x82ippy"));
| the literal was valid UTF-8 up to the 2 bytes
warning: calls to `std::str::from_utf8_mut` with a invalid literal always return an error
- --> $DIR/invalid_from_utf8.rs:97:5
+ --> $DIR/invalid_from_utf8.rs:96:5
|
LL | let mut a = [99, 108, 130, 105, 112, 112, 121];
| ---------------------------------- the literal was valid UTF-8 up to the 2 bytes
@@ -115,7 +115,7 @@ LL | std::str::from_utf8_mut(&mut a);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: calls to `std::str::from_utf8_mut` with a invalid literal always return an error
- --> $DIR/invalid_from_utf8.rs:101:5
+ --> $DIR/invalid_from_utf8.rs:100:5
|
LL | let mut a = [99, 108, 130, 105, 112, 112, 121];
| ---------------------------------- the literal was valid UTF-8 up to the 2 bytes
@@ -124,7 +124,7 @@ LL | std::str::from_utf8_mut(c);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: calls to `std::str::from_utf8` with a invalid literal always return an error
- --> $DIR/invalid_from_utf8.rs:104:5
+ --> $DIR/invalid_from_utf8.rs:103:5
|
LL | let mut c = &[99, 108, 130, 105, 112, 112, 121];
| ---------------------------------- the literal was valid UTF-8 up to the 2 bytes
@@ -132,7 +132,7 @@ LL | std::str::from_utf8(c);
| ^^^^^^^^^^^^^^^^^^^^^^
warning: calls to `std::str::from_utf8` with a invalid literal always return an error
- --> $DIR/invalid_from_utf8.rs:107:5
+ --> $DIR/invalid_from_utf8.rs:106:5
|
LL | const INVALID_1: [u8; 7] = [99, 108, 130, 105, 112, 112, 121];
| ---------------------------------- the literal was valid UTF-8 up to the 2 bytes
@@ -140,7 +140,7 @@ LL | std::str::from_utf8(&INVALID_1);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: calls to `std::str::from_utf8` with a invalid literal always return an error
- --> $DIR/invalid_from_utf8.rs:110:5
+ --> $DIR/invalid_from_utf8.rs:109:5
|
LL | static INVALID_2: [u8; 7] = [99, 108, 130, 105, 112, 112, 121];
| ---------------------------------- the literal was valid UTF-8 up to the 2 bytes
@@ -148,7 +148,7 @@ LL | std::str::from_utf8(&INVALID_2);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: calls to `std::str::from_utf8` with a invalid literal always return an error
- --> $DIR/invalid_from_utf8.rs:113:5
+ --> $DIR/invalid_from_utf8.rs:112:5
|
LL | const INVALID_3: &'static [u8; 7] = &[99, 108, 130, 105, 112, 112, 121];
| ---------------------------------- the literal was valid UTF-8 up to the 2 bytes
@@ -156,7 +156,7 @@ LL | std::str::from_utf8(INVALID_3);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: calls to `std::str::from_utf8` with a invalid literal always return an error
- --> $DIR/invalid_from_utf8.rs:116:5
+ --> $DIR/invalid_from_utf8.rs:115:5
|
LL | const INVALID_4: &'static [u8; 7] = { &[99, 108, 130, 105, 112, 112, 121] };
| ---------------------------------- the literal was valid UTF-8 up to the 2 bytes
diff --git a/tests/ui/lint/must_not_suspend/tuple-mismatch.rs b/tests/ui/lint/must_not_suspend/tuple-mismatch.rs
index 2f3c5d9ea294d..ec409925d7248 100644
--- a/tests/ui/lint/must_not_suspend/tuple-mismatch.rs
+++ b/tests/ui/lint/must_not_suspend/tuple-mismatch.rs
@@ -1,7 +1,8 @@
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
fn main() {
- let _coroutine = || {
+ let _coroutine = #[coroutine]
+ || {
yield ((), ((), ()));
yield ((), ());
//~^ ERROR mismatched types
diff --git a/tests/ui/lint/must_not_suspend/tuple-mismatch.stderr b/tests/ui/lint/must_not_suspend/tuple-mismatch.stderr
index 3adf26cfee229..102eadd7affd4 100644
--- a/tests/ui/lint/must_not_suspend/tuple-mismatch.stderr
+++ b/tests/ui/lint/must_not_suspend/tuple-mismatch.stderr
@@ -1,5 +1,5 @@
error[E0308]: mismatched types
- --> $DIR/tuple-mismatch.rs:6:20
+ --> $DIR/tuple-mismatch.rs:7:20
|
LL | yield ((), ());
| ^^ expected `((), ())`, found `()`
diff --git a/tests/ui/lint/non-local-defs/consts.rs b/tests/ui/lint/non-local-defs/consts.rs
index 2652447dcf59b..d8a497e43e502 100644
--- a/tests/ui/lint/non-local-defs/consts.rs
+++ b/tests/ui/lint/non-local-defs/consts.rs
@@ -2,8 +2,6 @@
//@ edition:2021
//@ rustc-env:CARGO_CRATE_NAME=non_local_def
-#![feature(inline_const)]
-
struct Test;
trait Uto {}
diff --git a/tests/ui/lint/non-local-defs/consts.stderr b/tests/ui/lint/non-local-defs/consts.stderr
index 5563ea9d93f06..d15b452b004e9 100644
--- a/tests/ui/lint/non-local-defs/consts.stderr
+++ b/tests/ui/lint/non-local-defs/consts.stderr
@@ -1,5 +1,5 @@
warning: non-local `impl` definition, they should be avoided as they go against expectation
- --> $DIR/consts.rs:15:5
+ --> $DIR/consts.rs:13:5
|
LL | const Z: () = {
| - help: use a const-anon item to suppress this lint: `_`
@@ -14,7 +14,7 @@ LL | impl Uto for &Test {}
= note: `#[warn(non_local_definitions)]` on by default
warning: non-local `impl` definition, they should be avoided as they go against expectation
- --> $DIR/consts.rs:26:5
+ --> $DIR/consts.rs:24:5
|
LL | impl Uto2 for Test {}
| ^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL | impl Uto2 for Test {}
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, they should be avoided as they go against expectation
- --> $DIR/consts.rs:34:5
+ --> $DIR/consts.rs:32:5
|
LL | impl Uto3 for Test {}
| ^^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL | impl Uto3 for Test {}
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, they should be avoided as they go against expectation
- --> $DIR/consts.rs:45:5
+ --> $DIR/consts.rs:43:5
|
LL | / impl Test {
LL | |
@@ -50,7 +50,7 @@ LL | | }
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, they should be avoided as they go against expectation
- --> $DIR/consts.rs:52:9
+ --> $DIR/consts.rs:50:9
|
LL | / impl Test {
LL | |
@@ -64,7 +64,7 @@ LL | | }
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, they should be avoided as they go against expectation
- --> $DIR/consts.rs:61:9
+ --> $DIR/consts.rs:59:9
|
LL | / impl Test {
LL | |
@@ -78,7 +78,7 @@ LL | | }
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, they should be avoided as they go against expectation
- --> $DIR/consts.rs:74:9
+ --> $DIR/consts.rs:72:9
|
LL | impl Uto9 for Test {}
| ^^^^^^^^^^^^^^^^^^^^^
@@ -89,7 +89,7 @@ LL | impl Uto9 for Test {}
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, they should be avoided as they go against expectation
- --> $DIR/consts.rs:81:9
+ --> $DIR/consts.rs:79:9
|
LL | impl Uto10 for Test {}
| ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/lint/non-local-defs/from-local-for-global.rs b/tests/ui/lint/non-local-defs/from-local-for-global.rs
index 0ab3a6b198874..fea9679d7375d 100644
--- a/tests/ui/lint/non-local-defs/from-local-for-global.rs
+++ b/tests/ui/lint/non-local-defs/from-local-for-global.rs
@@ -1,8 +1,6 @@
//@ check-pass
//@ edition:2021
-#![feature(inline_const)]
-
struct Cat;
struct Wrap<T>(T);
diff --git a/tests/ui/lint/non-local-defs/from-local-for-global.stderr b/tests/ui/lint/non-local-defs/from-local-for-global.stderr
index bd592a721572e..0cd385049aa6e 100644
--- a/tests/ui/lint/non-local-defs/from-local-for-global.stderr
+++ b/tests/ui/lint/non-local-defs/from-local-for-global.stderr
@@ -1,5 +1,5 @@
warning: non-local `impl` definition, they should be avoided as they go against expectation
- --> $DIR/from-local-for-global.rs:10:5
+ --> $DIR/from-local-for-global.rs:8:5
|
LL | / impl From<Cat> for () {
LL | |
@@ -16,7 +16,7 @@ LL | | }
= note: `#[warn(non_local_definitions)]` on by default
warning: non-local `impl` definition, they should be avoided as they go against expectation
- --> $DIR/from-local-for-global.rs:20:5
+ --> $DIR/from-local-for-global.rs:18:5
|
LL | / impl From<Wrap<Wrap<Elephant>>> for () {
LL | |
@@ -32,7 +32,7 @@ LL | | }
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, they should be avoided as they go against expectation
- --> $DIR/from-local-for-global.rs:34:5
+ --> $DIR/from-local-for-global.rs:32:5
|
LL | impl StillNonLocal for &Foo {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -43,7 +43,7 @@ LL | impl StillNonLocal for &Foo {}
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, they should be avoided as they go against expectation
- --> $DIR/from-local-for-global.rs:42:5
+ --> $DIR/from-local-for-global.rs:40:5
|
LL | / impl From<Local1> for GlobalSameFunction {
LL | |
@@ -59,7 +59,7 @@ LL | | }
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, they should be avoided as they go against expectation
- --> $DIR/from-local-for-global.rs:50:5
+ --> $DIR/from-local-for-global.rs:48:5
|
LL | / impl From<Local2> for GlobalSameFunction {
LL | |
diff --git a/tests/ui/lint/unused/issue-74883-unused-paren-baren-yield.rs b/tests/ui/lint/unused/issue-74883-unused-paren-baren-yield.rs
index c5dd281cb4e5f..12e2bcb898cad 100644
--- a/tests/ui/lint/unused/issue-74883-unused-paren-baren-yield.rs
+++ b/tests/ui/lint/unused/issue-74883-unused-paren-baren-yield.rs
@@ -1,12 +1,12 @@
#![feature(coroutine_trait)]
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
#![deny(unused_braces, unused_parens)]
use std::ops::Coroutine;
use std::pin::Pin;
fn main() {
- let mut x = |_| {
+ let mut x = #[coroutine] |_| {
while let Some(_) = (yield) {}
while let Some(_) = {yield} {}
diff --git a/tests/ui/lint/unused/unused-closure.rs b/tests/ui/lint/unused/unused-closure.rs
index 9106edee65380..4633038cc9bb3 100644
--- a/tests/ui/lint/unused/unused-closure.rs
+++ b/tests/ui/lint/unused/unused-closure.rs
@@ -2,7 +2,7 @@
//@ edition:2018
#![feature(async_closure)]
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
#![deny(unused_must_use)]
fn unused() {
@@ -26,7 +26,7 @@ fn unused() {
fn ignored() {
let _ = || {};
- let _ = || yield 42;
+ let _ = #[coroutine] || yield 42;
}
fn main() {
diff --git a/tests/ui/liveness/liveness-upvars.rs b/tests/ui/liveness/liveness-upvars.rs
index 7898b97888230..f76efba3e6b3a 100644
--- a/tests/ui/liveness/liveness-upvars.rs
+++ b/tests/ui/liveness/liveness-upvars.rs
@@ -1,6 +1,6 @@
//@ edition:2018
//@ check-pass
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
#![warn(unused)]
#![allow(unreachable_code)]
@@ -131,7 +131,7 @@ pub fn async_coroutine() {
pub fn coroutine() {
let mut s: u32 = 0;
- let _ = |_| {
+ let _ = #[coroutine] |_| {
s = 0;
yield ();
s = 1; //~ WARN value assigned to `s` is never read
diff --git a/tests/ui/loops/dont-suggest-break-thru-item.rs b/tests/ui/loops/dont-suggest-break-thru-item.rs
index 34a9a57bfed05..b4262ec02bf47 100644
--- a/tests/ui/loops/dont-suggest-break-thru-item.rs
+++ b/tests/ui/loops/dont-suggest-break-thru-item.rs
@@ -1,7 +1,5 @@
//@ edition:2021
-#![feature(inline_const)]
-
fn closure() {
loop {
let closure = || {
diff --git a/tests/ui/loops/dont-suggest-break-thru-item.stderr b/tests/ui/loops/dont-suggest-break-thru-item.stderr
index c84a98198f55a..642578ade60bf 100644
--- a/tests/ui/loops/dont-suggest-break-thru-item.stderr
+++ b/tests/ui/loops/dont-suggest-break-thru-item.stderr
@@ -1,5 +1,5 @@
error[E0308]: mismatched types
- --> $DIR/dont-suggest-break-thru-item.rs:9:17
+ --> $DIR/dont-suggest-break-thru-item.rs:7:17
|
LL | / if true {
LL | | Err(1)
@@ -17,7 +17,7 @@ LL | return Err(1);
| ++++++ +
error[E0308]: mismatched types
- --> $DIR/dont-suggest-break-thru-item.rs:23:17
+ --> $DIR/dont-suggest-break-thru-item.rs:21:17
|
LL | / if true {
LL | | Err(1)
@@ -35,7 +35,7 @@ LL | return Err(1);
| ++++++ +
error[E0308]: mismatched types
- --> $DIR/dont-suggest-break-thru-item.rs:37:17
+ --> $DIR/dont-suggest-break-thru-item.rs:35:17
|
LL | / if true {
LL | | Err(1)
@@ -48,7 +48,7 @@ LL | | }
found enum `Result<_, {integer}>`
error[E0308]: mismatched types
- --> $DIR/dont-suggest-break-thru-item.rs:49:17
+ --> $DIR/dont-suggest-break-thru-item.rs:47:17
|
LL | / if true {
LL | | Err(1)
diff --git a/tests/ui/nll/coroutine-distinct-lifetime.rs b/tests/ui/nll/coroutine-distinct-lifetime.rs
index ff94a3d54b76b..471fad686c4c3 100644
--- a/tests/ui/nll/coroutine-distinct-lifetime.rs
+++ b/tests/ui/nll/coroutine-distinct-lifetime.rs
@@ -9,6 +9,7 @@
//@ check-pass
fn foo(x: &mut u32) {
+ #[coroutine]
move || {
let s = &mut *x;
yield;
diff --git a/tests/ui/nll/coroutine-upvar-mutability.rs b/tests/ui/nll/coroutine-upvar-mutability.rs
index 12853b16b9b75..a7d14173fb9fc 100644
--- a/tests/ui/nll/coroutine-upvar-mutability.rs
+++ b/tests/ui/nll/coroutine-upvar-mutability.rs
@@ -4,6 +4,8 @@
fn mutate_upvar() {
let x = 0;
+
+ #[coroutine]
move || {
x = 1;
//~^ ERROR
diff --git a/tests/ui/nll/coroutine-upvar-mutability.stderr b/tests/ui/nll/coroutine-upvar-mutability.stderr
index 8922eae315188..8b9be877c8f39 100644
--- a/tests/ui/nll/coroutine-upvar-mutability.stderr
+++ b/tests/ui/nll/coroutine-upvar-mutability.stderr
@@ -1,9 +1,9 @@
error[E0594]: cannot assign to `x`, as it is not declared as mutable
- --> $DIR/coroutine-upvar-mutability.rs:8:9
+ --> $DIR/coroutine-upvar-mutability.rs:10:9
|
LL | let x = 0;
| - help: consider changing this to be mutable: `mut x`
-LL | move || {
+...
LL | x = 1;
| ^^^^^ cannot assign
diff --git a/tests/ui/nll/extra-unused-mut.rs b/tests/ui/nll/extra-unused-mut.rs
index 786ba98508fb6..b040dcc6e5db9 100644
--- a/tests/ui/nll/extra-unused-mut.rs
+++ b/tests/ui/nll/extra-unused-mut.rs
@@ -18,6 +18,8 @@ fn mutable_upvar() {
// #50897
fn coroutine_mutable_upvar() {
let mut x = 0;
+
+ #[coroutine]
move || {
x = 1;
yield;
@@ -36,13 +38,13 @@ struct Expr {
// #51904
fn parse_dot_or_call_expr_with(mut attrs: Vec<u32>) {
let x = Expr { attrs: vec![] };
- Some(Some(x)).map(|expr|
+ Some(Some(x)).map(|expr| {
expr.map(|mut expr| {
attrs.push(666);
expr.attrs = attrs;
expr
})
- );
+ });
}
// Found when trying to bootstrap rustc
diff --git a/tests/ui/nll/issue-48623-coroutine.rs b/tests/ui/nll/issue-48623-coroutine.rs
index 3a4a27855d99d..63348a2047c07 100644
--- a/tests/ui/nll/issue-48623-coroutine.rs
+++ b/tests/ui/nll/issue-48623-coroutine.rs
@@ -12,7 +12,7 @@ impl Drop for WithDrop {
fn reborrow_from_coroutine(r: &mut ()) {
let d = WithDrop;
- move || { d; yield; &mut *r }; //~ WARN unused coroutine that must be used
+ #[coroutine] move || { d; yield; &mut *r }; //~ WARN unused coroutine that must be used
}
fn main() {}
diff --git a/tests/ui/nll/issue-48623-coroutine.stderr b/tests/ui/nll/issue-48623-coroutine.stderr
index 1b7b1735aacb1..4e4cd28ef2ae9 100644
--- a/tests/ui/nll/issue-48623-coroutine.stderr
+++ b/tests/ui/nll/issue-48623-coroutine.stderr
@@ -1,8 +1,8 @@
warning: unused coroutine that must be used
- --> $DIR/issue-48623-coroutine.rs:15:5
+ --> $DIR/issue-48623-coroutine.rs:15:18
|
-LL | move || { d; yield; &mut *r };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #[coroutine] move || { d; yield; &mut *r };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: coroutines are lazy and do nothing unless resumed
= note: `#[warn(unused_must_use)]` on by default
diff --git a/tests/ui/nll/issue-55850.rs b/tests/ui/nll/issue-55850.rs
index fc873af94638b..bf1e2e7caef6d 100644
--- a/tests/ui/nll/issue-55850.rs
+++ b/tests/ui/nll/issue-55850.rs
@@ -23,7 +23,7 @@ where
}
fn bug<'a>() -> impl Iterator<Item = &'a str> {
- GenIter(move || {
+ GenIter(#[coroutine] move || {
let mut s = String::new();
yield &s[..] //~ ERROR cannot yield value referencing local variable `s` [E0515]
//~| ERROR borrow may still be in use when coroutine yields
diff --git a/tests/ui/packed/packed-struct-drop-aligned.rs b/tests/ui/packed/packed-struct-drop-aligned.rs
index 037b8cb78b721..ba3dcb10c61e5 100644
--- a/tests/ui/packed/packed-struct-drop-aligned.rs
+++ b/tests/ui/packed/packed-struct-drop-aligned.rs
@@ -1,5 +1,5 @@
//@ run-pass
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
#![feature(coroutine_trait)]
use std::cell::Cell;
use std::mem;
@@ -7,13 +7,12 @@ use std::ops::Coroutine;
use std::pin::Pin;
struct Aligned<'a> {
- drop_count: &'a Cell<usize>
+ drop_count: &'a Cell<usize>,
}
#[inline(never)]
fn check_align(ptr: *const Aligned) {
- assert_eq!(ptr as usize % mem::align_of::<Aligned>(),
- 0);
+ assert_eq!(ptr as usize % mem::align_of::<Aligned>(), 0);
}
impl<'a> Drop for Aligned<'a> {
@@ -39,7 +38,8 @@ fn main() {
assert_eq!(drop_count.get(), 2);
let drop_count = &Cell::new(0);
- let mut g = || {
+ let mut g = #[coroutine]
+ || {
let mut p = Packed(NotCopy(0), Aligned { drop_count });
let _ = &p;
p.1 = Aligned { drop_count };
diff --git a/tests/ui/parser/bad-let-else-statement.rs b/tests/ui/parser/bad-let-else-statement.rs
index c3126a493e546..de41a07568fb1 100644
--- a/tests/ui/parser/bad-let-else-statement.rs
+++ b/tests/ui/parser/bad-let-else-statement.rs
@@ -1,4 +1,3 @@
-#![feature(inline_const)]
#![feature(yeet_expr)]
#![allow(incomplete_features)] // Necessary for now, while explicit_tail_calls is incomplete
#![feature(explicit_tail_calls)]
diff --git a/tests/ui/parser/bad-let-else-statement.stderr b/tests/ui/parser/bad-let-else-statement.stderr
index 12df8f849abd2..3f7e176b3e31f 100644
--- a/tests/ui/parser/bad-let-else-statement.stderr
+++ b/tests/ui/parser/bad-let-else-statement.stderr
@@ -1,5 +1,5 @@
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:10:5
+ --> $DIR/bad-let-else-statement.rs:9:5
|
LL | } else {
| ^
@@ -13,7 +13,7 @@ LL ~ }) else {
|
error: `for...else` loops are not supported
- --> $DIR/bad-let-else-statement.rs:19:7
+ --> $DIR/bad-let-else-statement.rs:18:7
|
LL | let foo = for i in 1..2 {
| --- `else` is attached to this loop
@@ -28,7 +28,7 @@ LL | | };
= note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:31:5
+ --> $DIR/bad-let-else-statement.rs:30:5
|
LL | } else {
| ^
@@ -43,7 +43,7 @@ LL ~ }) else {
|
error: `loop...else` loops are not supported
- --> $DIR/bad-let-else-statement.rs:40:7
+ --> $DIR/bad-let-else-statement.rs:39:7
|
LL | let foo = loop {
| ---- `else` is attached to this loop
@@ -58,7 +58,7 @@ LL | | };
= note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:51:5
+ --> $DIR/bad-let-else-statement.rs:50:5
|
LL | } else {
| ^
@@ -73,7 +73,7 @@ LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:62:5
+ --> $DIR/bad-let-else-statement.rs:61:5
|
LL | } else {
| ^
@@ -87,7 +87,7 @@ LL ~ }) else {
|
error: `while...else` loops are not supported
- --> $DIR/bad-let-else-statement.rs:71:7
+ --> $DIR/bad-let-else-statement.rs:70:7
|
LL | let foo = while false {
| ----- `else` is attached to this loop
@@ -102,7 +102,7 @@ LL | | };
= note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:81:5
+ --> $DIR/bad-let-else-statement.rs:80:5
|
LL | } else {
| ^
@@ -116,7 +116,7 @@ LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:91:5
+ --> $DIR/bad-let-else-statement.rs:90:5
|
LL | } else {
| ^
@@ -130,7 +130,7 @@ LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:102:5
+ --> $DIR/bad-let-else-statement.rs:101:5
|
LL | } else {
| ^
@@ -144,7 +144,7 @@ LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:112:5
+ --> $DIR/bad-let-else-statement.rs:111:5
|
LL | } else {
| ^
@@ -158,7 +158,7 @@ LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:122:5
+ --> $DIR/bad-let-else-statement.rs:121:5
|
LL | } else {
| ^
@@ -172,7 +172,7 @@ LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:132:5
+ --> $DIR/bad-let-else-statement.rs:131:5
|
LL | } else {
| ^
@@ -186,7 +186,7 @@ LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:142:5
+ --> $DIR/bad-let-else-statement.rs:141:5
|
LL | } else {
| ^
@@ -200,7 +200,7 @@ LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:152:5
+ --> $DIR/bad-let-else-statement.rs:151:5
|
LL | } else {
| ^
@@ -214,7 +214,7 @@ LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:162:5
+ --> $DIR/bad-let-else-statement.rs:161:5
|
LL | } else {
| ^
@@ -228,7 +228,7 @@ LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:172:5
+ --> $DIR/bad-let-else-statement.rs:171:5
|
LL | } else {
| ^
@@ -242,7 +242,7 @@ LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:182:31
+ --> $DIR/bad-let-else-statement.rs:181:31
|
LL | let bad = format_args! {""} else { return; };
| ^
@@ -253,7 +253,7 @@ LL | let bad = format_args! ("") else { return; };
| ~ ~
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:199:25
+ --> $DIR/bad-let-else-statement.rs:198:25
|
LL | let x = a! {} else { return; };
| ^
@@ -268,7 +268,7 @@ LL | let x = a! () else { return; };
| ~~
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:7:5
+ --> $DIR/bad-let-else-statement.rs:6:5
|
LL | / let foo = {
LL | |
@@ -281,7 +281,7 @@ LL | | } else {
= note: `#[warn(irrefutable_let_patterns)]` on by default
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:26:5
+ --> $DIR/bad-let-else-statement.rs:25:5
|
LL | / let foo = if true {
LL | |
@@ -295,7 +295,7 @@ LL | | } else {
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:47:5
+ --> $DIR/bad-let-else-statement.rs:46:5
|
LL | / let foo = match true {
LL | |
@@ -308,7 +308,7 @@ LL | | } else {
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:59:5
+ --> $DIR/bad-let-else-statement.rs:58:5
|
LL | / let foo = X {
LL | |
@@ -320,7 +320,7 @@ LL | | } else {
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:78:5
+ --> $DIR/bad-let-else-statement.rs:77:5
|
LL | / let foo = const {
LL | |
@@ -332,7 +332,7 @@ LL | | } else {
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:88:5
+ --> $DIR/bad-let-else-statement.rs:87:5
|
LL | / let foo = &{
LL | |
@@ -344,7 +344,7 @@ LL | | } else {
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:99:5
+ --> $DIR/bad-let-else-statement.rs:98:5
|
LL | / let foo = bar = {
LL | |
@@ -356,7 +356,7 @@ LL | | } else {
= help: consider removing the `else` clause
error[E0384]: cannot assign twice to immutable variable `bar`
- --> $DIR/bad-let-else-statement.rs:99:15
+ --> $DIR/bad-let-else-statement.rs:98:15
|
LL | let bar = 0;
| ---
@@ -371,7 +371,7 @@ LL | | } else {
| |_____^ cannot assign twice to immutable variable
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:109:5
+ --> $DIR/bad-let-else-statement.rs:108:5
|
LL | / let foo = 1 + {
LL | |
@@ -383,7 +383,7 @@ LL | | } else {
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:119:5
+ --> $DIR/bad-let-else-statement.rs:118:5
|
LL | / let foo = 1..{
LL | |
@@ -395,7 +395,7 @@ LL | | } else {
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:129:5
+ --> $DIR/bad-let-else-statement.rs:128:5
|
LL | / let foo = return {
LL | |
@@ -407,7 +407,7 @@ LL | | } else {
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:139:5
+ --> $DIR/bad-let-else-statement.rs:138:5
|
LL | / let foo = -{
LL | |
@@ -419,7 +419,7 @@ LL | | } else {
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:149:5
+ --> $DIR/bad-let-else-statement.rs:148:5
|
LL | / let foo = do yeet {
LL | |
@@ -431,7 +431,7 @@ LL | | } else {
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:159:5
+ --> $DIR/bad-let-else-statement.rs:158:5
|
LL | / let foo = become {
LL | |
@@ -443,7 +443,7 @@ LL | | } else {
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:169:5
+ --> $DIR/bad-let-else-statement.rs:168:5
|
LL | / let foo = |x: i32| {
LL | |
@@ -455,7 +455,7 @@ LL | | } else {
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:179:5
+ --> $DIR/bad-let-else-statement.rs:178:5
|
LL | let ok = format_args!("") else { return; };
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -464,7 +464,7 @@ LL | let ok = format_args!("") else { return; };
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:182:5
+ --> $DIR/bad-let-else-statement.rs:181:5
|
LL | let bad = format_args! {""} else { return; };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -473,7 +473,7 @@ LL | let bad = format_args! {""} else { return; };
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:189:19
+ --> $DIR/bad-let-else-statement.rs:188:19
|
LL | () => { {} }
| ___________________^
@@ -493,7 +493,7 @@ LL | b!(1); b!(2);
= note: this warning originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:189:19
+ --> $DIR/bad-let-else-statement.rs:188:19
|
LL | () => { {} }
| ___________________^
diff --git a/tests/ui/polymorphization/coroutine.rs b/tests/ui/polymorphization/coroutine.rs
index a989947f78738..22ceadfb194d9 100644
--- a/tests/ui/polymorphization/coroutine.rs
+++ b/tests/ui/polymorphization/coroutine.rs
@@ -32,6 +32,7 @@ where
#[rustc_polymorphize_error]
pub fn unused_type<T>() -> impl Coroutine<(), Yield = u32, Return = u32> + Unpin {
+ #[coroutine]
|| {
//~^ ERROR item has unused generic parameters
yield 1;
@@ -41,6 +42,7 @@ pub fn unused_type<T>() -> impl Coroutine<(), Yield = u32, Return = u32> + Unpin
#[rustc_polymorphize_error]
pub fn used_type_in_yield<Y: Default>() -> impl Coroutine<(), Yield = Y, Return = u32> + Unpin {
+ #[coroutine]
|| {
yield Y::default();
2
@@ -49,6 +51,7 @@ pub fn used_type_in_yield<Y: Default>() -> impl Coroutine<(), Yield = Y, Return
#[rustc_polymorphize_error]
pub fn used_type_in_return<R: Default>() -> impl Coroutine<(), Yield = u32, Return = R> + Unpin {
+ #[coroutine]
|| {
yield 3;
R::default()
@@ -57,6 +60,7 @@ pub fn used_type_in_return<R: Default>() -> impl Coroutine<(), Yield = u32, Retu
#[rustc_polymorphize_error]
pub fn unused_const<const T: u32>() -> impl Coroutine<(), Yield = u32, Return = u32> + Unpin {
+ #[coroutine]
|| {
//~^ ERROR item has unused generic parameters
yield 1;
@@ -67,6 +71,7 @@ pub fn unused_const<const T: u32>() -> impl Coroutine<(), Yield = u32, Return =
#[rustc_polymorphize_error]
pub fn used_const_in_yield<const Y: u32>() -> impl Coroutine<(), Yield = u32, Return = u32> + Unpin
{
+ #[coroutine]
|| {
yield Y;
2
@@ -76,6 +81,7 @@ pub fn used_const_in_yield<const Y: u32>() -> impl Coroutine<(), Yield = u32, Re
#[rustc_polymorphize_error]
pub fn used_const_in_return<const R: u32>() -> impl Coroutine<(), Yield = u32, Return = u32> + Unpin
{
+ #[coroutine]
|| {
yield 4;
R
diff --git a/tests/ui/polymorphization/coroutine.stderr b/tests/ui/polymorphization/coroutine.stderr
index 67b55a5988317..07e29184226d9 100644
--- a/tests/ui/polymorphization/coroutine.stderr
+++ b/tests/ui/polymorphization/coroutine.stderr
@@ -8,18 +8,20 @@ LL | #![feature(generic_const_exprs, coroutines, coroutine_trait, rustc_attrs)]
= note: `#[warn(incomplete_features)]` on by default
error: item has unused generic parameters
- --> $DIR/coroutine.rs:35:5
+ --> $DIR/coroutine.rs:36:5
|
LL | pub fn unused_type<T>() -> impl Coroutine<(), Yield = u32, Return = u32> + Unpin {
| - generic parameter `T` is unused
+LL | #[coroutine]
LL | || {
| ^^
error: item has unused generic parameters
- --> $DIR/coroutine.rs:60:5
+ --> $DIR/coroutine.rs:64:5
|
LL | pub fn unused_const<const T: u32>() -> impl Coroutine<(), Yield = u32, Return = u32> + Unpin {
| ------------ generic parameter `T` is unused
+LL | #[coroutine]
LL | || {
| ^^
diff --git a/tests/ui/print_type_sizes/coroutine.rs b/tests/ui/print_type_sizes/coroutine.rs
index 61488c51f0530..1533578878944 100644
--- a/tests/ui/print_type_sizes/coroutine.rs
+++ b/tests/ui/print_type_sizes/coroutine.rs
@@ -7,6 +7,7 @@
use std::ops::Coroutine;
fn coroutine<const C: usize>(array: [u8; C]) -> impl Coroutine<Yield = (), Return = ()> {
+ #[coroutine]
move |()| {
yield ();
let _ = array;
diff --git a/tests/ui/print_type_sizes/coroutine.stdout b/tests/ui/print_type_sizes/coroutine.stdout
index 5d51339558caf..339bbddfc2a93 100644
--- a/tests/ui/print_type_sizes/coroutine.stdout
+++ b/tests/ui/print_type_sizes/coroutine.stdout
@@ -1,4 +1,4 @@
-print-type-size type: `{coroutine@$DIR/coroutine.rs:10:5: 10:14}`: 8193 bytes, alignment: 1 bytes
+print-type-size type: `{coroutine@$DIR/coroutine.rs:11:5: 11:14}`: 8193 bytes, alignment: 1 bytes
print-type-size discriminant: 1 bytes
print-type-size variant `Unresumed`: 8192 bytes
print-type-size upvar `.array`: 8192 bytes
diff --git a/tests/ui/print_type_sizes/coroutine_discr_placement.rs b/tests/ui/print_type_sizes/coroutine_discr_placement.rs
index 4b9f67a79997f..d97b0b28ed0fe 100644
--- a/tests/ui/print_type_sizes/coroutine_discr_placement.rs
+++ b/tests/ui/print_type_sizes/coroutine_discr_placement.rs
@@ -5,11 +5,12 @@
// Tests a coroutine that has its discriminant as the *final* field.
// Avoid emitting panic handlers, like the rest of these tests...
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
#![allow(dropping_copy_types)]
pub fn foo() {
- let a = || {
+ let a = #[coroutine]
+ || {
{
let w: i32 = 4;
yield;
diff --git a/tests/ui/print_type_sizes/coroutine_discr_placement.stdout b/tests/ui/print_type_sizes/coroutine_discr_placement.stdout
index 71a7f3c63815c..4ce1ce46f6e82 100644
--- a/tests/ui/print_type_sizes/coroutine_discr_placement.stdout
+++ b/tests/ui/print_type_sizes/coroutine_discr_placement.stdout
@@ -1,4 +1,4 @@
-print-type-size type: `{coroutine@$DIR/coroutine_discr_placement.rs:12:13: 12:15}`: 8 bytes, alignment: 4 bytes
+print-type-size type: `{coroutine@$DIR/coroutine_discr_placement.rs:13:5: 13:7}`: 8 bytes, alignment: 4 bytes
print-type-size discriminant: 1 bytes
print-type-size variant `Unresumed`: 0 bytes
print-type-size variant `Suspend0`: 7 bytes
diff --git a/tests/ui/rfcs/rfc-2091-track-caller/tracked-closure.rs b/tests/ui/rfcs/rfc-2091-track-caller/tracked-closure.rs
index d5c8a529e1e37..9fdceefbf9b92 100644
--- a/tests/ui/rfcs/rfc-2091-track-caller/tracked-closure.rs
+++ b/tests/ui/rfcs/rfc-2091-track-caller/tracked-closure.rs
@@ -113,7 +113,7 @@ fn dyn_coroutine(
}
fn test_coroutine() {
- 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());
};
@@ -136,7 +136,7 @@ fn test_coroutine() {
assert_eq!(mono_loc.line(), mono_line);
assert_eq!(mono_loc.column(), 42);
- 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,
@@ -144,7 +144,7 @@ fn test_coroutine() {
};
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);
}
diff --git a/tests/ui/sanitizer/cfi-coroutine.rs b/tests/ui/sanitizer/cfi-coroutine.rs
index 5c6a489a7e89e..ad994fcf73700 100644
--- a/tests/ui/sanitizer/cfi-coroutine.rs
+++ b/tests/ui/sanitizer/cfi-coroutine.rs
@@ -14,7 +14,7 @@
//@ compile-flags: --test -Z unstable-options
//@ run-pass
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
#![feature(coroutine_trait)]
#![feature(noop_waker)]
#![feature(gen_blocks)]
@@ -27,7 +27,7 @@ use std::async_iter::AsyncIterator;
#[test]
fn general_coroutine() {
- let mut coro = |x: i32| {
+ let mut coro = #[coroutine] |x: i32| {
yield x;
"done"
};
diff --git a/tests/ui/simd/const-err-trumps-simd-err.rs b/tests/ui/simd/const-err-trumps-simd-err.rs
index 06a747273ab7f..fda044344517d 100644
--- a/tests/ui/simd/const-err-trumps-simd-err.rs
+++ b/tests/ui/simd/const-err-trumps-simd-err.rs
@@ -5,7 +5,7 @@
#![feature(generic_arg_infer)]
#![feature(core_intrinsics)]
#![feature(repr_simd)]
-#![feature(inline_const)]
+
use std::intrinsics::simd::*;
#[repr(simd)]
diff --git a/tests/ui/simd/intrinsic/generic-elements-pass.rs b/tests/ui/simd/intrinsic/generic-elements-pass.rs
index 7300308781932..a81d8ebdf50c2 100644
--- a/tests/ui/simd/intrinsic/generic-elements-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-elements-pass.rs
@@ -2,7 +2,6 @@
//@ ignore-emscripten FIXME(#45351) hits an LLVM assert
#![feature(repr_simd, intrinsics)]
-#![feature(inline_const)]
#[repr(simd)]
#[derive(Copy, Clone, Debug, PartialEq)]
diff --git a/tests/ui/suggestions/issue-84973-blacklist.rs b/tests/ui/suggestions/issue-84973-blacklist.rs
index 6a35d779c1cda..edc0637636b57 100644
--- a/tests/ui/suggestions/issue-84973-blacklist.rs
+++ b/tests/ui/suggestions/issue-84973-blacklist.rs
@@ -14,7 +14,7 @@ struct S;
fn main() {
f_copy("".to_string()); //~ ERROR: the trait bound `String: Copy` is not satisfied [E0277]
f_clone(S); //~ ERROR: the trait bound `S: Clone` is not satisfied [E0277]
- f_unpin(static || { yield; });
+ f_unpin(#[coroutine] static || { yield; });
//~^ ERROR: cannot be unpinned [E0277]
let cl = || ();
diff --git a/tests/ui/suggestions/issue-84973-blacklist.stderr b/tests/ui/suggestions/issue-84973-blacklist.stderr
index 3333822832856..4fd063e46926a 100644
--- a/tests/ui/suggestions/issue-84973-blacklist.stderr
+++ b/tests/ui/suggestions/issue-84973-blacklist.stderr
@@ -36,11 +36,11 @@ LL + #[derive(Clone)]
LL | struct S;
|
-error[E0277]: `{static coroutine@$DIR/issue-84973-blacklist.rs:17:13: 17:22}` cannot be unpinned
- --> $DIR/issue-84973-blacklist.rs:17:13
+error[E0277]: `{static coroutine@$DIR/issue-84973-blacklist.rs:17:26: 17:35}` cannot be unpinned
+ --> $DIR/issue-84973-blacklist.rs:17:26
|
-LL | f_unpin(static || { yield; });
- | ------- ^^^^^^^^^^^^^^^^^^^^ the trait `Unpin` is not implemented for `{static coroutine@$DIR/issue-84973-blacklist.rs:17:13: 17:22}`
+LL | f_unpin(#[coroutine] static || { yield; });
+ | ------- ^^^^^^^^^^^^^^^^^^^^ the trait `Unpin` is not implemented for `{static coroutine@$DIR/issue-84973-blacklist.rs:17:26: 17:35}`
| |
| required by a bound introduced by this call
|
diff --git a/tests/ui/suggestions/unnamable-types.rs b/tests/ui/suggestions/unnamable-types.rs
index a4e32d7c80654..dd2c3536eb92e 100644
--- a/tests/ui/suggestions/unnamable-types.rs
+++ b/tests/ui/suggestions/unnamable-types.rs
@@ -1,7 +1,7 @@
// Test that we do not suggest to add type annotations for unnamable types.
#![crate_type="lib"]
-#![feature(coroutines)]
+#![feature(coroutines, stmt_expr_attributes)]
const A = 5;
//~^ ERROR: missing type for `const` item
@@ -34,6 +34,6 @@ const F = S { t: foo };
//~| HELP: provide a type for the constant
-const G = || -> i32 { yield 0; return 1; };
+const G = #[coroutine] || -> i32 { yield 0; return 1; };
//~^ ERROR: missing type for `const` item
//~| NOTE: however, the inferred type
diff --git a/tests/ui/suggestions/unnamable-types.stderr b/tests/ui/suggestions/unnamable-types.stderr
index d003b91691c0f..6623678fd0c2d 100644
--- a/tests/ui/suggestions/unnamable-types.stderr
+++ b/tests/ui/suggestions/unnamable-types.stderr
@@ -52,14 +52,14 @@ LL | const F = S { t: foo };
error: missing type for `const` item
--> $DIR/unnamable-types.rs:37:8
|
-LL | const G = || -> i32 { yield 0; return 1; };
+LL | const G = #[coroutine] || -> i32 { yield 0; return 1; };
| ^
|
-note: however, the inferred type `{coroutine@$DIR/unnamable-types.rs:37:11: 37:20}` cannot be named
- --> $DIR/unnamable-types.rs:37:11
+note: however, the inferred type `{coroutine@$DIR/unnamable-types.rs:37:24: 37:33}` cannot be named
+ --> $DIR/unnamable-types.rs:37:24
|
-LL | const G = || -> i32 { yield 0; return 1; };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | const G = #[coroutine] || -> i32 { yield 0; return 1; };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 7 previous errors
diff --git a/tests/ui/traits/next-solver/coroutine.fail.stderr b/tests/ui/traits/next-solver/coroutine.fail.stderr
index 14e67727d0ba7..e880d05a4dd34 100644
--- a/tests/ui/traits/next-solver/coroutine.fail.stderr
+++ b/tests/ui/traits/next-solver/coroutine.fail.stderr
@@ -1,16 +1,16 @@
-error[E0277]: the trait bound `{coroutine@$DIR/coroutine.rs:18:21: 18:23}: Coroutine<A>` is not satisfied
- --> $DIR/coroutine.rs:18:21
+error[E0277]: the trait bound `{coroutine@$DIR/coroutine.rs:20:9: 20:11}: Coroutine<A>` is not satisfied
+ --> $DIR/coroutine.rs:20:9
|
-LL | needs_coroutine(|| {
- | _____---------------_^
- | | |
- | | required by a bound introduced by this call
+LL | needs_coroutine(
+ | --------------- required by a bound introduced by this call
+LL | #[coroutine]
+LL | / || {
LL | |
LL | |
LL | |
-LL | | yield ();
-LL | | });
- | |_____^ the trait `Coroutine<A>` is not implemented for `{coroutine@$DIR/coroutine.rs:18:21: 18:23}`
+LL | | yield ();
+LL | | },
+ | |_________^ the trait `Coroutine<A>` is not implemented for `{coroutine@$DIR/coroutine.rs:20:9: 20:11}`
|
note: required by a bound in `needs_coroutine`
--> $DIR/coroutine.rs:14:28
@@ -18,19 +18,19 @@ note: required by a bound in `needs_coroutine`
LL | fn needs_coroutine(_: impl Coroutine<A, Yield = B, Return = C>) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `needs_coroutine`
-error[E0271]: type mismatch resolving `<{coroutine@$DIR/coroutine.rs:18:21: 18:23} as Coroutine<A>>::Yield == B`
- --> $DIR/coroutine.rs:18:21
+error[E0271]: type mismatch resolving `<{coroutine@$DIR/coroutine.rs:20:9: 20:11} as Coroutine<A>>::Yield == B`
+ --> $DIR/coroutine.rs:20:9
|
-LL | needs_coroutine(|| {
- | _____---------------_^
- | | |
- | | required by a bound introduced by this call
+LL | needs_coroutine(
+ | --------------- required by a bound introduced by this call
+LL | #[coroutine]
+LL | / || {
LL | |
LL | |
LL | |
-LL | | yield ();
-LL | | });
- | |_____^ types differ
+LL | | yield ();
+LL | | },
+ | |_________^ types differ
|
note: required by a bound in `needs_coroutine`
--> $DIR/coroutine.rs:14:41
@@ -38,19 +38,19 @@ note: required by a bound in `needs_coroutine`
LL | fn needs_coroutine(_: impl Coroutine<A, Yield = B, Return = C>) {}
| ^^^^^^^^^ required by this bound in `needs_coroutine`
-error[E0271]: type mismatch resolving `<{coroutine@$DIR/coroutine.rs:18:21: 18:23} as Coroutine<A>>::Return == C`
- --> $DIR/coroutine.rs:18:21
+error[E0271]: type mismatch resolving `<{coroutine@$DIR/coroutine.rs:20:9: 20:11} as Coroutine<A>>::Return == C`
+ --> $DIR/coroutine.rs:20:9
|
-LL | needs_coroutine(|| {
- | _____---------------_^
- | | |
- | | required by a bound introduced by this call
+LL | needs_coroutine(
+ | --------------- required by a bound introduced by this call
+LL | #[coroutine]
+LL | / || {
LL | |
LL | |
LL | |
-LL | | yield ();
-LL | | });
- | |_____^ types differ
+LL | | yield ();
+LL | | },
+ | |_________^ types differ
|
note: required by a bound in `needs_coroutine`
--> $DIR/coroutine.rs:14:52
diff --git a/tests/ui/traits/next-solver/coroutine.rs b/tests/ui/traits/next-solver/coroutine.rs
index 2b5bf01cefd7d..1882a62cf29cc 100644
--- a/tests/ui/traits/next-solver/coroutine.rs
+++ b/tests/ui/traits/next-solver/coroutine.rs
@@ -15,18 +15,24 @@ fn needs_coroutine(_: impl Coroutine<A, Yield = B, Return = C>) {}
#[cfg(fail)]
fn main() {
- needs_coroutine(|| {
- //[fail]~^ ERROR Coroutine<A>` is not satisfied
- //[fail]~| ERROR as Coroutine<A>>::Yield == B`
- //[fail]~| ERROR as Coroutine<A>>::Return == C`
- yield ();
- });
+ needs_coroutine(
+ #[coroutine]
+ || {
+ //[fail]~^ ERROR Coroutine<A>` is not satisfied
+ //[fail]~| ERROR as Coroutine<A>>::Yield == B`
+ //[fail]~| ERROR as Coroutine<A>>::Return == C`
+ yield ();
+ },
+ );
}
#[cfg(pass)]
fn main() {
- needs_coroutine(|_: A| {
- let _: A = yield B;
- C
- })
+ needs_coroutine(
+ #[coroutine]
+ |_: A| {
+ let _: A = yield B;
+ C
+ },
+ )
}
diff --git a/tests/ui/type-alias-impl-trait/issue-53678-coroutine-and-const-fn.rs b/tests/ui/type-alias-impl-trait/issue-53678-coroutine-and-const-fn.rs
index cd14bc1fd0985..0d9126d399334 100644
--- a/tests/ui/type-alias-impl-trait/issue-53678-coroutine-and-const-fn.rs
+++ b/tests/ui/type-alias-impl-trait/issue-53678-coroutine-and-const-fn.rs
@@ -9,6 +9,7 @@ mod gen {
pub type CoroOnce<Y, R> = impl Coroutine<Yield = Y, Return = R>;
pub const fn const_coroutine<Y, R>(yielding: Y, returning: R) -> CoroOnce<Y, R> {
+ #[coroutine]
move || {
yield yielding;
diff --git a/tests/ui/type-alias-impl-trait/issue-58662-coroutine-with-lifetime.rs b/tests/ui/type-alias-impl-trait/issue-58662-coroutine-with-lifetime.rs
index 78a1d5116bedb..899e81ed562fc 100644
--- a/tests/ui/type-alias-impl-trait/issue-58662-coroutine-with-lifetime.rs
+++ b/tests/ui/type-alias-impl-trait/issue-58662-coroutine-with-lifetime.rs
@@ -8,6 +8,7 @@ use std::pin::Pin;
type RandCoroutine<'a> = impl Coroutine<Return = (), Yield = u64> + 'a;
fn rand_coroutine<'a>(rng: &'a ()) -> RandCoroutine<'a> {
+ #[coroutine]
move || {
let _rng = rng;
loop {
@@ -19,6 +20,7 @@ fn rand_coroutine<'a>(rng: &'a ()) -> RandCoroutine<'a> {
pub type RandCoroutineWithIndirection<'c> = impl Coroutine<Return = (), Yield = u64> + 'c;
pub fn rand_coroutine_with_indirection<'a>(rng: &'a ()) -> RandCoroutineWithIndirection<'a> {
fn helper<'b>(rng: &'b ()) -> impl 'b + Coroutine<Return = (), Yield = u64> {
+ #[coroutine]
move || {
let _rng = rng;
loop {
diff --git a/tests/ui/type-alias-impl-trait/issue-94429.rs b/tests/ui/type-alias-impl-trait/issue-94429.rs
index 306e73003fa98..11beed06a20cd 100644
--- a/tests/ui/type-alias-impl-trait/issue-94429.rs
+++ b/tests/ui/type-alias-impl-trait/issue-94429.rs
@@ -14,6 +14,7 @@ impl Runnable for Implementor {
fn run(&mut self) -> Self::Coro {
//~^ ERROR: type mismatch resolving
+ #[coroutine]
move || {
yield 1;
}
diff --git a/tests/ui/type-alias-impl-trait/issue-94429.stderr b/tests/ui/type-alias-impl-trait/issue-94429.stderr
index 5d081e6b1eff5..4c2020becbe32 100644
--- a/tests/ui/type-alias-impl-trait/issue-94429.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-94429.stderr
@@ -1,4 +1,4 @@
-error[E0271]: type mismatch resolving `<{coroutine@$DIR/issue-94429.rs:17:9: 17:16} as Coroutine>::Yield == ()`
+error[E0271]: type mismatch resolving `<{coroutine@$DIR/issue-94429.rs:18:9: 18:16} as Coroutine>::Yield == ()`
--> $DIR/issue-94429.rs:15:26
|
LL | fn run(&mut self) -> Self::Coro {
diff --git a/tests/ui/weird-exprs.rs b/tests/ui/weird-exprs.rs
index 0009ed0e34c89..08b5517aae22f 100644
--- a/tests/ui/weird-exprs.rs
+++ b/tests/ui/weird-exprs.rs
@@ -152,6 +152,7 @@ fn r#match() {
}
fn i_yield() {
+ #[coroutine]
static || {
yield yield yield yield yield yield yield yield yield;
};