languages/rust
languages/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust synced 2024-10-04 15:50:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #108471 - clubby789:unbox-the-syntax, r=Nilstrieb,est31

Browse source 
Remove `box_syntax`

r? `@Nilstrieb`

This removes the feature `box_syntax`, which allows the use of `box <expr>` to create a Box, and finalises removing use of the feature from the compiler. `box_patterns` (allowing the use of `box <pat>` in a pattern) is unaffected.
It also removes `ast::ExprKind::Box` - the only way to create a 'box' expression now is with the rustc-internal `#[rustc_box]` attribute.
As a temporary measure to help users move away, `box <expr>` now parses the inner expression, and emits a `MachineApplicable` lint to replace it with `Box::new`

Closes #49733
This commit is contained in:
bors 2023-03-13 10:41:50 +00:00
parent d610b0c514 8b186dfdb7
commit f1b1ed7e18
110 changed files with 990 additions and 1065 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
compiler/rustc_ast/src/ast.rs
View file

@ -1230,7 +1230,6 @@ pub fn to_ty(&self) -> Option<P<Ty>> {
pub fn precedence(&self) -> ExprPrecedence {
match self.kind {
ExprKind::Box(_) => ExprPrecedence::Box,
ExprKind::Array(_) => ExprPrecedence::Array,
ExprKind::ConstBlock(_) => ExprPrecedence::ConstBlock,
ExprKind::Call(..) => ExprPrecedence::Call,
@ -1291,8 +1290,7 @@ pub fn take(&mut self) -> Self {
/// To a first-order approximation, is this a pattern?
pub fn is_approximately_pattern(&self) -> bool {
match &self.peel_parens().kind {
ExprKind::Box(_)
| ExprKind::Array(_)
ExprKind::Array(_)
| ExprKind::Call(_, _)
| ExprKind::Tup(_)
| ExprKind::Lit(_)
@ -1363,8 +1361,6 @@ pub struct StructExpr {
#[derive(Clone, Encodable, Decodable, Debug)]
pub enum ExprKind {
/// A `box x` expression.
Box(P<Expr>),
/// An array (`[a, b, c, d]`)
Array(ThinVec<P<Expr>>),
/// Allow anonymous constants from an inline `const` block

1
compiler/rustc_ast/src/mut_visit.rs
View file

@ -1316,7 +1316,6 @@ pub fn noop_visit_expr<T: MutVisitor>(
vis: &mut T,
) {
match kind {
ExprKind::Box(expr) => vis.visit_expr(expr),
ExprKind::Array(exprs) => visit_thin_exprs(exprs, vis),
ExprKind::ConstBlock(anon_const) => {
vis.visit_anon_const(anon_const);

1
compiler/rustc_ast/src/util/classify.rs
View file

@ -35,7 +35,6 @@ pub fn expr_trailing_brace(mut expr: &ast::Expr) -> Option<&ast::Expr> {
| Assign(_, e, _)
| AssignOp(_, _, e)
| Binary(_, _, e)
| Box(e)
| Break(_, Some(e))
| Let(_, e, _)
| Range(_, Some(e), _)

1
compiler/rustc_ast/src/visit.rs
View file

@ -772,7 +772,6 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) {
walk_list!(visitor, visit_attribute, expression.attrs.iter());
match &expression.kind {
ExprKind::Box(subexpression) => visitor.visit_expr(subexpression),
ExprKind::Array(subexpressions) => {
walk_list!(visitor, visit_expr, subexpressions);
}

1
compiler/rustc_ast_lowering/src/expr.rs
View file

@ -70,7 +70,6 @@ pub(super) fn lower_expr_mut(&mut self, e: &Expr) -> hir::Expr<'hir> {
self.lower_attrs(hir_id, &e.attrs);
let kind = match &e.kind {
ExprKind::Box(inner) => hir::ExprKind::Box(self.lower_expr(inner)),
ExprKind::Array(exprs) => hir::ExprKind::Array(self.lower_exprs(exprs)),
ExprKind::ConstBlock(anon_const) => {
let anon_const = self.lower_anon_const(anon_const);

9
compiler/rustc_ast_passes/src/feature_gate.rs
View file

@ -392,14 +392,6 @@ fn visit_stmt(&mut self, stmt: &'a ast::Stmt) {
fn visit_expr(&mut self, e: &'a ast::Expr) {
match e.kind {
ast::ExprKind::Box(_) => {
gate_feature_post!(
&self,
box_syntax,
e.span,
"box expression syntax is experimental; you can call `Box::new` instead"
);
}
ast::ExprKind::Type(..) => {
if self.sess.parse_sess.span_diagnostic.err_count() == 0 {
// To avoid noise about type ascription in common syntax errors,
@ -604,7 +596,6 @@ macro_rules! gate_all {
gate_all!(box_patterns, "box pattern syntax is experimental");
gate_all!(exclusive_range_pattern, "exclusive range pattern syntax is experimental");
gate_all!(try_blocks, "`try` blocks are unstable");
gate_all!(box_syntax, "box expression syntax is experimental; you can call `Box::new` instead");
gate_all!(type_ascription, "type ascription is experimental");
visit::walk_crate(&mut visitor, krate);

4
compiler/rustc_ast_pretty/src/pprust/state/expr.rs
View file

@ -296,10 +296,6 @@ pub(super) fn print_expr_outer_attr_style(&mut self, expr: &ast::Expr, is_inline
self.ibox(INDENT_UNIT);
self.ann.pre(self, AnnNode::Expr(expr));
match &expr.kind {
ast::ExprKind::Box(expr) => {
self.word_space("box");
self.print_expr_maybe_paren(expr, parser::PREC_PREFIX);
}
ast::ExprKind::Array(exprs) => {
self.print_expr_vec(exprs);
}

1
compiler/rustc_builtin_macros/src/assert/context.rs
View file

@ -290,7 +290,6 @@ fn manage_cond_expr(&mut self, expr: &mut P<Expr>) {
| ExprKind::Async(_, _, _)
| ExprKind::Await(_)
| ExprKind::Block(_, _)
| ExprKind::Box(_)
| ExprKind::Break(_, _)
| ExprKind::Closure(_)
| ExprKind::ConstBlock(_)

4
compiler/rustc_codegen_cranelift/example/alloc_example.rs
View file

@ -1,4 +1,4 @@
#![feature(start, core_intrinsics, alloc_error_handler, box_syntax)]
#![feature(start, core_intrinsics, alloc_error_handler)]
#![no_std]
extern crate alloc;
@ -29,7 +29,7 @@ fn alloc_error_handler(_: alloc::alloc::Layout) -> ! {
#[start]
fn main(_argc: isize, _argv: *const *const u8) -> isize {
let world: Box<&str> = box "Hello World!\0";
let world: Box<&str> = Box::new("Hello World!\0");
unsafe {
puts(*world as *const str as *const u8);
}

8
compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs
View file

@ -1,4 +1,4 @@
#![feature(no_core, lang_items, never_type, linkage, extern_types, thread_local, box_syntax)]
#![feature(no_core, lang_items, never_type, linkage, extern_types, thread_local)]
#![no_core]
#![allow(dead_code, non_camel_case_types)]
@ -178,7 +178,7 @@ fn main() {
let ptr: *const i8 = hello as *const [u8] as *const i8;
puts(ptr);
let world: Box<&str> = box "World!\0";
let world: Box<&str> = Box::new("World!\0");
puts(*world as *const str as *const i8);
world as Box<dyn SomeTrait>;
@ -238,10 +238,10 @@ unsafe fn uninitialized<T>() -> T {
}
}
let _ = box NoisyDrop {
let _ = Box::new(NoisyDrop {
text: "Boxed outer got dropped!\0",
inner: NoisyDropInner,
} as Box<dyn SomeTrait>;
}) as Box<dyn SomeTrait>;
const FUNC_REF: Option<fn()> = Some(main);
match FUNC_REF {

4
compiler/rustc_codegen_gcc/example/alloc_example.rs
View file

@ -1,4 +1,4 @@
#![feature(start, box_syntax, core_intrinsics, alloc_error_handler, lang_items)]
#![feature(start, core_intrinsics, alloc_error_handler, lang_items)]
#![no_std]
extern crate alloc;
@ -38,7 +38,7 @@ fn eh_personality() -> ! {
#[start]
fn main(_argc: isize, _argv: *const *const u8) -> isize {
let world: Box<&str> = box "Hello World!\0";
let world: Box<&str> = Box::new("Hello World!\0");
unsafe {
puts(*world as *const str as *const u8);
}

8
compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs
View file

@ -1,7 +1,7 @@
// Adapted from https://github.com/sunfishcode/mir2cranelift/blob/master/rust-examples/nocore-hello-world.rs
#![feature(
no_core, unboxed_closures, start, lang_items, box_syntax, never_type, linkage,
no_core, unboxed_closures, start, lang_items, never_type, linkage,
extern_types, thread_local
)]
#![no_core]
@ -163,7 +163,7 @@ fn main() {
let ptr: *const u8 = hello as *const [u8] as *const u8;
puts(ptr);
let world: Box<&str> = box "World!\0";
let world: Box<&str> = Box::new("World!\0");
puts(*world as *const str as *const u8);
world as Box<dyn SomeTrait>;
@ -223,10 +223,10 @@ unsafe fn uninitialized<T>() -> T {
}
}
let _ = box NoisyDrop {
let _ = Box::new(NoisyDrop {
text: "Boxed outer got dropped!\0",
inner: NoisyDropInner,
} as Box<dyn SomeTrait>;
}) as Box<dyn SomeTrait>;
const FUNC_REF: Option<fn()> = Some(main);
#[allow(unreachable_code)]

2
compiler/rustc_codegen_gcc/example/mod_bench.rs
View file

@ -1,4 +1,4 @@
#![feature(start, box_syntax, core_intrinsics, lang_items)]
#![feature(start, core_intrinsics, lang_items)]
#![no_std]
#[link(name = "c")]

4
compiler/rustc_error_codes/src/error_codes/E0010.md
View file

@ -5,7 +5,5 @@ the heap at runtime, and therefore cannot be done at compile time.
Erroneous code example:
```compile_fail,E0010
#![feature(box_syntax)]
const CON : Box<i32> = box 0;
const CON : Vec<i32> = vec![1, 2, 3];
```

2
compiler/rustc_feature/src/active.rs
View file

@ -200,8 +200,6 @@ pub fn set(&self, features: &mut Features, span: Span) {
(active, auto_traits, "1.50.0", Some(13231), None),
/// Allows using `box` in patterns (RFC 469).
(active, box_patterns, "1.0.0", Some(29641), None),
/// Allows using the `box $expr` syntax.
(active, box_syntax, "1.0.0", Some(49733), None),
/// Allows `#[doc(notable_trait)]`.
/// Renamed from `doc_spotlight`.
(active, doc_notable_trait, "1.52.0", Some(45040), None),

2
compiler/rustc_feature/src/removed.rs
View file

@ -52,6 +52,8 @@ macro_rules! declare_features {
(removed, allow_fail, "1.19.0", Some(46488), None, Some("removed due to no clear use cases")),
(removed, await_macro, "1.38.0", Some(50547), None,
Some("subsumed by `.await` syntax")),
/// Allows using the `box $expr` syntax.
(removed, box_syntax, "CURRENT_RUSTC_VERSION", Some(49733), None, Some("replaced with `#[rustc_box]`")),
/// Allows capturing disjoint fields in a closure/generator (RFC 2229).
(removed, capture_disjoint_fields, "1.49.0", Some(53488), None, Some("stabilized in Rust 2021")),
/// Allows comparing raw pointers during const eval.

4
compiler/rustc_hir_pretty/src/lib.rs
View file

@ -1367,8 +1367,8 @@ pub fn print_expr(&mut self, expr: &hir::Expr<'_>) {
self.ann.pre(self, AnnNode::Expr(expr));
match expr.kind {
hir::ExprKind::Box(expr) => {
self.word_space("box");
self.print_expr_maybe_paren(expr, parser::PREC_PREFIX);
self.word_space("Box::new");
self.print_call_post(std::slice::from_ref(expr));
}
hir::ExprKind::Array(exprs) => {
self.print_expr_vec(exprs);

1
compiler/rustc_lint/src/unused.rs
View file

@ -1371,7 +1371,6 @@ fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
impl<'tcx> LateLintPass<'tcx> for UnusedAllocation {
fn check_expr(&mut self, cx: &LateContext<'_>, e: &hir::Expr<'_>) {
match e.kind {
hir::ExprKind::Box(_) => {}
hir::ExprKind::Call(path_expr, [_])
if let hir::ExprKind::Path(qpath) = &path_expr.kind
&& let Some(did) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id()

45
compiler/rustc_mir_transform/src/large_enums.rs
View file

@ -158,10 +158,12 @@ fn optim<'tcx>(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
tmp_ty,
),
};
let rval = Rvalue::Use(Operand::Constant(box (constant_vals)));
let rval = Rvalue::Use(Operand::Constant(Box::new(constant_vals)));
let const_assign =
Statement { source_info, kind: StatementKind::Assign(box (place, rval)) };
let const_assign = Statement {
source_info,
kind: StatementKind::Assign(Box::new((place, rval))),
};
let discr_place = Place::from(
local_decls
@ -170,7 +172,10 @@ fn optim<'tcx>(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
let store_discr = Statement {
source_info,
kind: StatementKind::Assign(box (discr_place, Rvalue::Discriminant(*rhs))),
kind: StatementKind::Assign(Box::new((
discr_place,
Rvalue::Discriminant(*rhs),
))),
};
let discr_cast_place =
@ -178,14 +183,14 @@ fn optim<'tcx>(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
let cast_discr = Statement {
source_info,
kind: StatementKind::Assign(box (
kind: StatementKind::Assign(Box::new((
discr_cast_place,
Rvalue::Cast(
CastKind::IntToInt,
Operand::Copy(discr_place),
tcx.types.usize,
),
)),
))),
};
let size_place =
@ -193,14 +198,14 @@ fn optim<'tcx>(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
let store_size = Statement {
source_info,
kind: StatementKind::Assign(box (
kind: StatementKind::Assign(Box::new((
size_place,
Rvalue::Use(Operand::Copy(Place {
local: size_array_local,
projection: tcx
.mk_place_elems(&[PlaceElem::Index(discr_cast_place.local)]),
})),
)),
))),
};
let dst =
@ -208,10 +213,10 @@ fn optim<'tcx>(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
let dst_ptr = Statement {
source_info,
kind: StatementKind::Assign(box (
kind: StatementKind::Assign(Box::new((
dst,
Rvalue::AddressOf(Mutability::Mut, *lhs),
)),
))),
};
let dst_cast_ty = tcx.mk_mut_ptr(tcx.types.u8);
@ -220,10 +225,10 @@ fn optim<'tcx>(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
let dst_cast = Statement {
source_info,
kind: StatementKind::Assign(box (
kind: StatementKind::Assign(Box::new((
dst_cast_place,
Rvalue::Cast(CastKind::PtrToPtr, Operand::Copy(dst), dst_cast_ty),
)),
))),
};
let src =
@ -231,10 +236,10 @@ fn optim<'tcx>(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
let src_ptr = Statement {
source_info,
kind: StatementKind::Assign(box (
kind: StatementKind::Assign(Box::new((
src,
Rvalue::AddressOf(Mutability::Not, *rhs),
)),
))),
};
let src_cast_ty = tcx.mk_imm_ptr(tcx.types.u8);
@ -243,24 +248,24 @@ fn optim<'tcx>(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
let src_cast = Statement {
source_info,
kind: StatementKind::Assign(box (
kind: StatementKind::Assign(Box::new((
src_cast_place,
Rvalue::Cast(CastKind::PtrToPtr, Operand::Copy(src), src_cast_ty),
)),
))),
};
let deinit_old =
Statement { source_info, kind: StatementKind::Deinit(box dst) };
Statement { source_info, kind: StatementKind::Deinit(Box::new(dst)) };
let copy_bytes = Statement {
source_info,
kind: StatementKind::Intrinsic(
box NonDivergingIntrinsic::CopyNonOverlapping(CopyNonOverlapping {
kind: StatementKind::Intrinsic(Box::new(
NonDivergingIntrinsic::CopyNonOverlapping(CopyNonOverlapping {
src: Operand::Copy(src_cast_place),
dst: Operand::Copy(dst_cast_place),
count: Operand::Copy(size_place),
}),
),
)),
};
let store_dead = Statement {

1
compiler/rustc_mir_transform/src/lib.rs
View file

@ -1,7 +1,6 @@
#![allow(rustc::potential_query_instability)]
#![feature(box_patterns)]
#![feature(drain_filter)]
#![feature(box_syntax)]
#![feature(let_chains)]
#![feature(map_try_insert)]
#![feature(min_specialization)]

3
compiler/rustc_parse/messages.ftl
View file

@ -731,3 +731,6 @@ parse_unknown_start_of_token = unknown start of token: {$escaped}
[one] once more
*[other] {$repeats} more times
}
parse_box_syntax_removed = `box_syntax` has been removed
.suggestion = use `Box::new()` instead

13
compiler/rustc_parse/src/errors.rs
View file

@ -2300,3 +2300,16 @@ pub fn new() -> Self {
}
}
}
#[derive(Diagnostic)]
#[diag(parse_box_syntax_removed)]
pub struct BoxSyntaxRemoved<'a> {
#[primary_span]
#[suggestion(
code = "Box::new({code})",
applicability = "machine-applicable",
style = "verbose"
)]
pub span: Span,
pub code: &'a str,
}

24
compiler/rustc_parse/src/parser/expr.rs
View file

@ -8,6 +8,7 @@
use crate::errors;
use crate::maybe_recover_from_interpolated_ty_qpath;
use ast::{Path, PathSegment};
use core::mem;
use rustc_ast::ptr::P;
use rustc_ast::token::{self, Delimiter, Token, TokenKind};
@ -29,6 +30,7 @@
use rustc_session::lint::builtin::BREAK_WITH_LABEL_AND_LOOP;
use rustc_session::lint::BuiltinLintDiagnostics;
use rustc_span::source_map::{self, Span, Spanned};
use rustc_span::symbol::kw::PathRoot;
use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{BytePos, Pos};
use thin_vec::{thin_vec, ThinVec};
@ -636,11 +638,27 @@ fn recover_tilde_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> {
self.parse_expr_unary(lo, UnOp::Not)
}
/// Parse `box expr`.
/// Parse `box expr` - this syntax has been removed, but we still parse this
/// for now to provide an automated way to fix usages of it
fn parse_expr_box(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> {
let (span, expr) = self.parse_expr_prefix_common(lo)?;
self.sess.gated_spans.gate(sym::box_syntax, span);
Ok((span, ExprKind::Box(expr)))
let code = self.sess.source_map().span_to_snippet(span.with_lo(lo.hi())).unwrap();
self.sess.emit_err(errors::BoxSyntaxRemoved { span, code: code.trim() });
// So typechecking works, parse `box <expr>` as `::std::boxed::Box::new(expr)`
let path = Path {
span,
segments: [
PathSegment::from_ident(Ident::with_dummy_span(PathRoot)),
PathSegment::from_ident(Ident::with_dummy_span(sym::std)),
PathSegment::from_ident(Ident::from_str("boxed")),
PathSegment::from_ident(Ident::from_str("Box")),
PathSegment::from_ident(Ident::with_dummy_span(sym::new)),
]
.into(),
tokens: None,
};
let path = self.mk_expr(span, ExprKind::Path(None, path));
Ok((span, self.mk_call(path, ThinVec::from([expr]))))
}
fn is_mistaken_not_ident_negation(&self) -> bool {

2
compiler/rustc_passes/src/hir_stats.rs
View file

@ -565,7 +565,7 @@ fn visit_expr(&mut self, e: &'v ast::Expr) {
record_variants!(
(self, e, e.kind, Id::None, ast, Expr, ExprKind),
[
Box, Array, ConstBlock, Call, MethodCall, Tup, Binary, Unary, Lit, Cast, Type, Let,
Array, ConstBlock, Call, MethodCall, Tup, Binary, Unary, Lit, Cast, Type, Let,
If, While, ForLoop, Loop, Match, Closure, Block, Async, Await, TryBlock, Assign,
AssignOp, Field, Index, Range, Underscore, Path, AddrOf, Break, Continue, Ret,
InlineAsm, FormatArgs, MacCall, Struct, Repeat, Paren, Try, Yield, Yeet, IncludedBytes, Err

2
src/doc/unstable-book/src/language-features/box-patterns.md
View file

@ -4,8 +4,6 @@ The tracking issue for this feature is: [#29641]
[#29641]: https://github.com/rust-lang/rust/issues/29641
See also [`box_syntax`](box-syntax.md)
------------------------
Box patterns let you match on `Box<T>`s:

22
src/doc/unstable-book/src/language-features/box-syntax.md
View file

@ -1,22 +0,0 @@
# `box_syntax`
The tracking issue for this feature is: [#49733]
[#49733]: https://github.com/rust-lang/rust/issues/49733
See also [`box_patterns`](box-patterns.md)
------------------------
Currently the only stable way to create a `Box` is via the `Box::new` method.
Also it is not possible in stable Rust to destructure a `Box` in a match
pattern. The unstable `box` keyword can be used to create a `Box`. An example
usage would be:
```rust
#![feature(box_syntax)]
fn main() {
let b = box 5;
}
```

23
src/doc/unstable-book/src/the-unstable-book.md
View file

@ -5,16 +5,31 @@ 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(box_syntax)]
#![feature(generators, generator_trait)]
use std::ops::{Generator, GeneratorState};
use std::pin::Pin;
fn main() {
let five = box 5;
let mut generator = || {
yield 1;
return "foo"
};
match Pin::new(&mut generator).resume(()) {
GeneratorState::Yielded(1) => {}
_ => panic!("unexpected value from resume"),
}
match Pin::new(&mut generator).resume(()) {
GeneratorState::Complete("foo") => {}
_ => panic!("unexpected value from resume"),
}
}
```
The `box_syntax` feature [has a chapter][box] describing how to use it.
The `generators` feature [has a chapter][generators] describing how to use it.
[box]: language-features/box-syntax.md
[generators]: language-features/generators.md
Because this documentation relates to unstable features, we make no guarantees
that what is contained here is accurate or up to date. It's developed on a

3
src/tools/clippy/clippy_lints/src/suspicious_operation_groupings.rs
View file

@ -596,8 +596,7 @@ fn ident_difference_expr_with_base_location(
| (MethodCall(_), MethodCall(_))
| (Call(_, _), Call(_, _))
| (ConstBlock(_), ConstBlock(_))
| (Array(_), Array(_))
| (Box(_), Box(_)) => {
| (Array(_), Array(_)) => {
// keep going
},
_ => {

2
src/tools/clippy/clippy_utils/src/ast_utils.rs
View file

@ -143,7 +143,7 @@ pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
(Paren(l), _) => eq_expr(l, r),
(_, Paren(r)) => eq_expr(l, r),
(Err, Err) => true,
(Box(l), Box(r)) | (Try(l), Try(r)) | (Await(l), Await(r)) => eq_expr(l, r),
(Try(l), Try(r)) | (Await(l), Await(r)) => eq_expr(l, r),
(Array(l), Array(r)) => over(l, r, |l, r| eq_expr(l, r)),
(Tup(l), Tup(r)) => over(l, r, |l, r| eq_expr(l, r)),
(Repeat(le, ls), Repeat(re, rs)) => eq_expr(le, re) && eq_expr(&ls.value, &rs.value),

1
src/tools/clippy/clippy_utils/src/sugg.rs
View file

@ -188,7 +188,6 @@ pub fn ast(
match expr.kind {
_ if expr.span.ctxt() != ctxt => Sugg::NonParen(snippet_with_context(cx, expr.span, ctxt, default, app).0),
ast::ExprKind::AddrOf(..)
| ast::ExprKind::Box(..)
| ast::ExprKind::Closure { .. }
| ast::ExprKind::If(..)
| ast::ExprKind::Let(..)

35
src/tools/clippy/tests/ui/boxed_local.rs
View file

@ -1,4 +1,3 @@
#![feature(box_syntax)]
#![feature(lint_reasons)]
#![allow(
clippy::borrowed_box,
@ -34,7 +33,7 @@ fn ok_box_trait(boxed_trait: &Box<dyn Z>) {
}
fn warn_call() {
let x = box A;
let x = Box::new(A);
x.foo();
}
@ -43,41 +42,41 @@ fn warn_arg(x: Box<A>) {
}
fn nowarn_closure_arg() {
let x = Some(box A);
let x = Some(Box::new(A));
x.map_or((), |x| take_ref(&x));
}
fn warn_rename_call() {
let x = box A;
let x = Box::new(A);
let y = x;
y.foo(); // via autoderef
}
fn warn_notuse() {
let bz = box A;
let bz = Box::new(A);
}
fn warn_pass() {
let bz = box A;
let bz = Box::new(A);
take_ref(&bz); // via deref coercion
}
fn nowarn_return() -> Box<A> {
box A // moved out, "escapes"
Box::new(A) // moved out, "escapes"
}
fn nowarn_move() {
let bx = box A;
let bx = Box::new(A);
drop(bx) // moved in, "escapes"
}
fn nowarn_call() {
let bx = box A;
let bx = Box::new(A);
bx.clone(); // method only available to Box, not via autoderef
}
fn nowarn_pass() {
let bx = box A;
let bx = Box::new(A);
take_box(&bx); // fn needs &Box
}
@ -86,30 +85,20 @@ fn take_ref(x: &A) {}
fn nowarn_ref_take() {
// false positive, should actually warn
let x = box A;
let x = Box::new(A);
let y = &x;
take_box(y);
}
fn nowarn_match() {
let x = box A; // moved into a match
let x = Box::new(A); // moved into a match
match x {
y => drop(y),
}
}
fn warn_match() {
let x = box A;
match &x {
// not moved
y => (),
}
}
fn nowarn_large_array() {
// should not warn, is large array
// and should not be on stack
let x = box [1; 10000];
let x = Box::new(A);
match &x {
// not moved
y => (),

8
src/tools/clippy/tests/ui/boxed_local.stderr
View file

@ -1,5 +1,5 @@
error: local variable doesn't need to be boxed here
--> $DIR/boxed_local.rs:41:13
--> $DIR/boxed_local.rs:40:13
|
LL | fn warn_arg(x: Box<A>) {
| ^
@ -7,19 +7,19 @@ LL | fn warn_arg(x: Box<A>) {
= note: `-D clippy::boxed-local` implied by `-D warnings`
error: local variable doesn't need to be boxed here
--> $DIR/boxed_local.rs:132:12
--> $DIR/boxed_local.rs:121:12
|
LL | pub fn new(_needs_name: Box<PeekableSeekable<&()>>) -> () {}
| ^^^^^^^^^^^
error: local variable doesn't need to be boxed here
--> $DIR/boxed_local.rs:196:44
--> $DIR/boxed_local.rs:185:44
|
LL | fn default_impl_x(self: Box<Self>, x: Box<u32>) -> u32 {
| ^
error: local variable doesn't need to be boxed here
--> $DIR/boxed_local.rs:203:16
--> $DIR/boxed_local.rs:192:16
|
LL | fn foo(x: Box<u32>) {}
| ^

3
src/tools/clippy/tests/ui/no_effect.rs
View file

@ -1,4 +1,4 @@
#![feature(box_syntax, fn_traits, unboxed_closures)]
#![feature(fn_traits, unboxed_closures)]
#![warn(clippy::no_effect_underscore_binding)]
#![allow(dead_code, path_statements)]
#![allow(clippy::deref_addrof, clippy::redundant_field_names, clippy::uninlined_format_args)]
@ -102,7 +102,6 @@ fn main() {
*&42;
&6;
(5, 6, 7);
box 42;
..;
5..;
..5;

38
src/tools/clippy/tests/ui/no_effect.stderr
View file

@ -81,83 +81,77 @@ LL | (5, 6, 7);
error: statement with no effect
--> $DIR/no_effect.rs:105:5
|
LL | box 42;
| ^^^^^^^
error: statement with no effect
--> $DIR/no_effect.rs:106:5
|
LL | ..;
| ^^^
error: statement with no effect
--> $DIR/no_effect.rs:107:5
--> $DIR/no_effect.rs:106:5
|
LL | 5..;
| ^^^^
error: statement with no effect
--> $DIR/no_effect.rs:108:5
--> $DIR/no_effect.rs:107:5
|
LL | ..5;
| ^^^^
error: statement with no effect
--> $DIR/no_effect.rs:109:5
--> $DIR/no_effect.rs:108:5
|
LL | 5..6;
| ^^^^^
error: statement with no effect
--> $DIR/no_effect.rs:110:5
--> $DIR/no_effect.rs:109:5
|
LL | 5..=6;
| ^^^^^^
error: statement with no effect
--> $DIR/no_effect.rs:111:5
--> $DIR/no_effect.rs:110:5
|
LL | [42, 55];
| ^^^^^^^^^
error: statement with no effect
--> $DIR/no_effect.rs:112:5
--> $DIR/no_effect.rs:111:5
|
LL | [42, 55][1];
| ^^^^^^^^^^^^
error: statement with no effect
--> $DIR/no_effect.rs:113:5
--> $DIR/no_effect.rs:112:5
|
LL | (42, 55).1;
| ^^^^^^^^^^^
error: statement with no effect
--> $DIR/no_effect.rs:114:5
--> $DIR/no_effect.rs:113:5
|
LL | [42; 55];
| ^^^^^^^^^
error: statement with no effect
--> $DIR/no_effect.rs:115:5
--> $DIR/no_effect.rs:114:5
|
LL | [42; 55][13];
| ^^^^^^^^^^^^^
error: statement with no effect
--> $DIR/no_effect.rs:117:5
--> $DIR/no_effect.rs:116:5
|
LL | || x += 5;
| ^^^^^^^^^^
error: statement with no effect
--> $DIR/no_effect.rs:119:5
--> $DIR/no_effect.rs:118:5
|
LL | FooString { s: s };
| ^^^^^^^^^^^^^^^^^^^
error: binding to `_` prefixed variable with no side-effect
--> $DIR/no_effect.rs:120:5
--> $DIR/no_effect.rs:119:5
|
LL | let _unused = 1;
| ^^^^^^^^^^^^^^^^
@ -165,22 +159,22 @@ LL | let _unused = 1;
= note: `-D clippy::no-effect-underscore-binding` implied by `-D warnings`
error: binding to `_` prefixed variable with no side-effect
--> $DIR/no_effect.rs:121:5
--> $DIR/no_effect.rs:120:5
|
LL | let _penguin = || println!("Some helpful closure");
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: binding to `_` prefixed variable with no side-effect
--> $DIR/no_effect.rs:122:5
--> $DIR/no_effect.rs:121:5
|
LL | let _duck = Struct { field: 0 };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: binding to `_` prefixed variable with no side-effect
--> $DIR/no_effect.rs:123:5
--> $DIR/no_effect.rs:122:5
|
LL | let _cat = [2, 4, 6, 8][2];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 30 previous errors
error: aborting due to 29 previous errors

2
src/tools/clippy/tests/ui/unnecessary_operation.fixed
View file

@ -1,6 +1,5 @@
// run-rustfix
#![feature(box_syntax)]
#![allow(clippy::deref_addrof, dead_code, unused, clippy::no_effect)]
#![warn(clippy::unnecessary_operation)]
@ -59,7 +58,6 @@ fn main() {
5;6;get_number();
get_number();
get_number();
get_number();
5;get_number();
42;get_number();
assert!([42, 55].len() > get_usize());

2
src/tools/clippy/tests/ui/unnecessary_operation.rs
View file

@ -1,6 +1,5 @@
// run-rustfix
#![feature(box_syntax)]
#![allow(clippy::deref_addrof, dead_code, unused, clippy::no_effect)]
#![warn(clippy::unnecessary_operation)]
@ -57,7 +56,6 @@ fn main() {
*&get_number();
&get_number();
(5, 6, get_number());
box get_number();
get_number()..;
..get_number();
5..get_number();

46
src/tools/clippy/tests/ui/unnecessary_operation.stderr
View file

@ -1,5 +1,5 @@
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:51:5
--> $DIR/unnecessary_operation.rs:50:5
|
LL | Tuple(get_number());
| ^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
@ -7,109 +7,103 @@ LL | Tuple(get_number());
= note: `-D clippy::unnecessary-operation` implied by `-D warnings`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:52:5
--> $DIR/unnecessary_operation.rs:51:5
|
LL | Struct { field: get_number() };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:53:5
--> $DIR/unnecessary_operation.rs:52:5
|
LL | Struct { ..get_struct() };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_struct();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:54:5
--> $DIR/unnecessary_operation.rs:53:5
|
LL | Enum::Tuple(get_number());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:55:5
--> $DIR/unnecessary_operation.rs:54:5
|
LL | Enum::Struct { field: get_number() };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:56:5
--> $DIR/unnecessary_operation.rs:55:5
|
LL | 5 + get_number();
| ^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;get_number();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:57:5
--> $DIR/unnecessary_operation.rs:56:5
|
LL | *&get_number();
| ^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:58:5
--> $DIR/unnecessary_operation.rs:57:5
|
LL | &get_number();
| ^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:59:5
--> $DIR/unnecessary_operation.rs:58:5
|
LL | (5, 6, get_number());
| ^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;6;get_number();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:60:5
|
LL | box get_number();
| ^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:61:5
--> $DIR/unnecessary_operation.rs:59:5
|
LL | get_number()..;
| ^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:62:5
--> $DIR/unnecessary_operation.rs:60:5
|
LL | ..get_number();
| ^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:63:5
--> $DIR/unnecessary_operation.rs:61:5
|
LL | 5..get_number();
| ^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;get_number();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:64:5
--> $DIR/unnecessary_operation.rs:62:5
|
LL | [42, get_number()];
| ^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `42;get_number();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:65:5
--> $DIR/unnecessary_operation.rs:63:5
|
LL | [42, 55][get_usize()];
| ^^^^^^^^^^^^^^^^^^^^^^ help: statement can be written as: `assert!([42, 55].len() > get_usize());`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:66:5
--> $DIR/unnecessary_operation.rs:64:5
|
LL | (42, get_number()).1;
| ^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `42;get_number();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:67:5
--> $DIR/unnecessary_operation.rs:65:5
|
LL | [get_number(); 55];
| ^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:68:5
--> $DIR/unnecessary_operation.rs:66:5
|
LL | [42; 55][get_usize()];
| ^^^^^^^^^^^^^^^^^^^^^^ help: statement can be written as: `assert!([42; 55].len() > get_usize());`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:69:5
--> $DIR/unnecessary_operation.rs:67:5
|
LL | / {
LL | | get_number()
@ -117,12 +111,12 @@ LL | | };
| |______^ help: statement can be reduced to: `get_number();`
error: unnecessary operation
--> $DIR/unnecessary_operation.rs:72:5
--> $DIR/unnecessary_operation.rs:70:5
|
LL | / FooString {
LL | | s: String::from("blah"),
LL | | };
| |______^ help: statement can be reduced to: `String::from("blah");`
error: aborting due to 20 previous errors
error: aborting due to 19 previous errors

4
src/tools/miri/tests/fail/function_pointers/execute_memory.rs
View file

@ -1,10 +1,8 @@
// Validation makes this fail in the wrong place
//@compile-flags: -Zmiri-disable-validation
#![feature(box_syntax)]
fn main() {
let x = box 42;
let x = Box::new(42);
unsafe {
let f = std::mem::transmute::<Box<i32>, fn()>(x);
f() //~ ERROR: function pointer but it does not point to a function

4
src/tools/miri/tests/pass/drop_empty_slice.rs
View file

@ -1,7 +1,5 @@
#![feature(box_syntax)]
fn main() {
// With the nested Vec, this is calling Offset(Unique::empty(), 0) on drop.
let args: Vec<Vec<i32>> = Vec::new();
let _val = box args;
let _val = Box::new(args);
}

6
src/tools/miri/tests/pass/dst-struct.rs
View file

@ -1,5 +1,3 @@
#![feature(box_syntax)]
struct Fat<T: ?Sized> {
f1: isize,
f2: &'static str,
@ -109,7 +107,7 @@ pub fn main() {
assert_eq!((*f2)[1], 2);
// Nested Box.
let f1: Box<Fat<[isize; 3]>> = box Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
let f1: Box<Fat<[isize; 3]>> = Box::new(Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] });
foo(&*f1);
let f2: Box<Fat<[isize]>> = f1;
foo(&*f2);
@ -117,6 +115,6 @@ pub fn main() {
let f3: Box<Fat<[isize]>> =
Box::<Fat<[_; 3]>>::new(Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] });
foo(&*f3);
let f4: Box<Fat<[isize]>> = box Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
let f4: Box<Fat<[isize]>> = Box::new(Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] });
foo(&*f4);
}

7
src/tools/miri/tests/pass/heap.rs
View file

@ -1,13 +1,7 @@
#![feature(box_syntax)]
fn make_box() -> Box<(i16, i16)> {
Box::new((1, 2))
}
fn make_box_syntax() -> Box<(i16, i16)> {
box (1, 2)
}
fn allocate_reallocate() {
let mut s = String::new();
@ -29,6 +23,5 @@ fn allocate_reallocate() {
fn main() {
assert_eq!(*make_box(), (1, 2));
assert_eq!(*make_box_syntax(), (1, 2));
allocate_reallocate();
}

4
src/tools/miri/tests/pass/issues/issue-3794.rs
View file

@ -1,5 +1,3 @@
#![feature(box_syntax)]
trait T {
fn print(&self);
}
@ -25,7 +23,7 @@ fn print_s(s: &S) {
}
pub fn main() {
let s: Box<S> = box S { s: 5 };
let s: Box<S> = Box::new(S { s: 5 });
print_s(&*s);
let t: Box<dyn T> = s as Box<dyn T>;
print_t(&*t);

4
src/tools/miri/tests/pass/move-arg-2-unique.rs
View file

@ -1,11 +1,9 @@
#![feature(box_syntax)]
fn test(foo: Box<Vec<isize>>) {
assert_eq!((*foo)[0], 10);
}
pub fn main() {
let x = box vec![10];
let x = Box::new(vec![10]);
// Test forgetting a local by move-in
test(x);
}

4
src/tools/miri/tests/pass/move-arg-3-unique.rs
View file

@ -1,7 +1,5 @@
#![feature(box_syntax)]
pub fn main() {
let x = box 10;
let x = Box::new(10);
let y = x;
assert_eq!(*y, 10);
}

14
src/tools/miri/tests/pass/mpsc.rs
View file

@ -1,15 +1,13 @@
#![feature(box_syntax)]
use std::sync::mpsc::channel;
pub fn main() {
let (tx, rx) = channel::<Box<_>>();
tx.send(box 100).unwrap();
tx.send(Box::new(100)).unwrap();
let v = rx.recv().unwrap();
assert_eq!(v, box 100);
assert_eq!(v, Box::new(100));
tx.send(box 101).unwrap();
tx.send(box 102).unwrap();
assert_eq!(rx.recv().unwrap(), box 101);
assert_eq!(rx.recv().unwrap(), box 102);
tx.send(Box::new(101)).unwrap();
tx.send(Box::new(102)).unwrap();
assert_eq!(rx.recv().unwrap(), Box::new(101));
assert_eq!(rx.recv().unwrap(), Box::new(102));
}

6
src/tools/miri/tests/pass/regions-lifetime-nonfree-late-bound.rs
View file

@ -12,8 +12,6 @@
// doing region-folding, when really all clients of the region-folding
// case only want to see *free* lifetime variables, not bound ones.
#![feature(box_syntax)]
pub fn main() {
fn explicit() {
fn test<F>(_x: Option<Box<F>>)
@ -21,7 +19,7 @@ fn test<F>(_x: Option<Box<F>>)
F: FnMut(Box<dyn for<'a> FnMut(&'a isize)>),
{
}
test(Some(box |_f: Box<dyn for<'a> FnMut(&'a isize)>| {}));
test(Some(Box::new(|_f: Box<dyn for<'a> FnMut(&'a isize)>| {})));
}
// The code below is shorthand for the code above (and more likely
@ -32,7 +30,7 @@ fn test<F>(_x: Option<Box<F>>)
F: FnMut(Box<dyn FnMut(&isize)>),
{
}
test(Some(box |_f: Box<dyn FnMut(&isize)>| {}));
test(Some(Box::new(|_f: Box<dyn FnMut(&isize)>| {})));
}
explicit();

4
src/tools/rust-analyzer/crates/ide-completion/src/tests/attribute.rs
View file

@ -857,9 +857,9 @@ fn lint_qualified() {
#[test]
fn lint_feature() {
check_edit(
"box_syntax",
"box_patterns",
r#"#[feature(box_$0)] struct Test;"#,
r#"#[feature(box_syntax)] struct Test;"#,
r#"#[feature(box_patterns)] struct Test;"#,
)
}

2
src/tools/rustfmt/src/closures.rs
View file

@ -195,7 +195,6 @@ fn allow_multi_line(expr: &ast::Expr) -> bool {
| ast::ExprKind::Struct(..) => true,
ast::ExprKind::AddrOf(_, _, ref expr)
| ast::ExprKind::Box(ref expr)
| ast::ExprKind::Try(ref expr)
| ast::ExprKind::Unary(_, ref expr)
| ast::ExprKind::Cast(ref expr, _) => allow_multi_line(expr),
@ -441,7 +440,6 @@ fn is_block_closure_forced_inner(expr: &ast::Expr, version: Version) -> bool {
ast::ExprKind::If(..) | ast::ExprKind::While(..) | ast::ExprKind::ForLoop(..) => true,
ast::ExprKind::Loop(..) if version == Version::Two => true,
ast::ExprKind::AddrOf(_, _, ref expr)
| ast::ExprKind::Box(ref expr)
| ast::ExprKind::Try(ref expr)
| ast::ExprKind::Unary(_, ref expr)
| ast::ExprKind::Cast(ref expr, _) => is_block_closure_forced_inner(expr, version),

5
src/tools/rustfmt/src/expr.rs
View file

@ -236,7 +236,6 @@ pub(crate) fn format_expr(
ast::ExprKind::Yeet(Some(ref expr)) => {
rewrite_unary_prefix(context, "do yeet ", &**expr, shape)
}
ast::ExprKind::Box(ref expr) => rewrite_unary_prefix(context, "box ", &**expr, shape),
ast::ExprKind::AddrOf(borrow_kind, mutability, ref expr) => {
rewrite_expr_addrof(context, borrow_kind, mutability, expr, shape)
}
@ -1299,7 +1298,6 @@ pub(crate) fn is_simple_expr(expr: &ast::Expr) -> bool {
ast::ExprKind::Lit(..) => true,
ast::ExprKind::Path(ref qself, ref path) => qself.is_none() && path.segments.len() <= 1,
ast::ExprKind::AddrOf(_, _, ref expr)
| ast::ExprKind::Box(ref expr)
| ast::ExprKind::Cast(ref expr, _)
| ast::ExprKind::Field(ref expr, _)
| ast::ExprKind::Try(ref expr)
@ -1361,7 +1359,6 @@ pub(crate) fn can_be_overflowed_expr(
// Handle unary-like expressions
ast::ExprKind::AddrOf(_, _, ref expr)
| ast::ExprKind::Box(ref expr)
| ast::ExprKind::Try(ref expr)
| ast::ExprKind::Unary(_, ref expr)
| ast::ExprKind::Cast(ref expr, _) => can_be_overflowed_expr(context, expr, args_len),
@ -1373,7 +1370,6 @@ pub(crate) fn is_nested_call(expr: &ast::Expr) -> bool {
match expr.kind {
ast::ExprKind::Call(..) | ast::ExprKind::MacCall(..) => true,
ast::ExprKind::AddrOf(_, _, ref expr)
| ast::ExprKind::Box(ref expr)
| ast::ExprKind::Try(ref expr)
| ast::ExprKind::Unary(_, ref expr)
| ast::ExprKind::Cast(ref expr, _) => is_nested_call(expr),
@ -2133,7 +2129,6 @@ pub(crate) fn is_method_call(expr: &ast::Expr) -> bool {
match expr.kind {
ast::ExprKind::MethodCall(..) => true,
ast::ExprKind::AddrOf(_, _, ref expr)
| ast::ExprKind::Box(ref expr)
| ast::ExprKind::Cast(ref expr, _)
| ast::ExprKind::Try(ref expr)
| ast::ExprKind::Unary(_, ref expr) => is_method_call(expr),

1
src/tools/rustfmt/src/matches.rs
View file

@ -592,7 +592,6 @@ fn can_flatten_block_around_this(body: &ast::Expr) -> bool {
| ast::ExprKind::Struct(..)
| ast::ExprKind::Tup(..) => true,
ast::ExprKind::AddrOf(_, _, ref expr)
| ast::ExprKind::Box(ref expr)
| ast::ExprKind::Try(ref expr)
| ast::ExprKind::Unary(_, ref expr)
| ast::ExprKind::Index(ref expr, _)

1
src/tools/rustfmt/src/utils.rs
View file

@ -492,7 +492,6 @@ pub(crate) fn is_block_expr(context: &RewriteContext<'_>, expr: &ast::Expr, repr
| ast::ExprKind::Assign(..)
| ast::ExprKind::AssignOp(..)
| ast::ExprKind::Await(..)
| ast::ExprKind::Box(..)
| ast::ExprKind::Break(..)
| ast::ExprKind::Cast(..)
| ast::ExprKind::Continue(..)

11
src/tools/rustfmt/tests/source/expr.rs
View file

@ -3,7 +3,6 @@
// Test expressions
fn foo() -> bool {
let boxed: Box<i32> = box 5;
let referenced = &5 ;
let very_long_variable_name = ( a + first + simple + test );
@ -132,12 +131,6 @@ fn qux() {
}
}
fn issue227() {
{
let handler = box DocumentProgressHandler::new(addr, DocumentProgressTask::DOMContentLoaded);
}
}
fn issue184(source: &str) {
for c in source.chars() {
if index < 'a' {
@ -413,10 +406,6 @@ fn issue2704() {
.concat(&requires1)
.concat(&requires2)
.distinct_total());
let requires = requires.set(box requires0
.concat(&requires1)
.concat(&requires2)
.distinct_total());
let requires = requires.set(requires0
.concat(&requires1)
.concat(&requires2)

6
src/tools/rustfmt/tests/target/configs/combine_control_expr/false.rs
View file

@ -108,12 +108,6 @@ fn main() {
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
));
// Box
foo(box Bar {
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
});
// Unary
foo(!bar(
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,

6
src/tools/rustfmt/tests/target/configs/combine_control_expr/true.rs
View file

@ -96,12 +96,6 @@ fn main() {
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
));
// Box
foo(box Bar {
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
});
// Unary
foo(!bar(
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,

14
src/tools/rustfmt/tests/target/expr.rs
View file

@ -3,7 +3,6 @@
// Test expressions
fn foo() -> bool {
let boxed: Box<i32> = box 5;
let referenced = &5;
let very_long_variable_name = (a + first + simple + test);
@ -179,13 +178,6 @@ fn qux() {
}
}
fn issue227() {
{
let handler =
box DocumentProgressHandler::new(addr, DocumentProgressTask::DOMContentLoaded);
}
}
fn issue184(source: &str) {
for c in source.chars() {
if index < 'a' {
@ -454,12 +446,6 @@ fn issue2704() {
.concat(&requires2)
.distinct_total(),
);
let requires = requires.set(
box requires0
.concat(&requires1)
.concat(&requires2)
.distinct_total(),
);
let requires = requires.set(
requires0
.concat(&requires1)

64
tests/mir-opt/box_expr.main.ElaborateDrops.before.mir
View file

@ -3,12 +3,12 @@
fn main() -> () {
let mut _0: (); // return place in scope 0 at $DIR/box_expr.rs:+0:11: +0:11
let _1: std::boxed::Box<S>; // in scope 0 at $DIR/box_expr.rs:+1:9: +1:10
let mut _2: usize; // in scope 0 at $DIR/box_expr.rs:+1:13: +1:25
let mut _3: usize; // in scope 0 at $DIR/box_expr.rs:+1:13: +1:25
let mut _4: *mut u8; // in scope 0 at $DIR/box_expr.rs:+1:13: +1:25
let mut _5: std::boxed::Box<S>; // in scope 0 at $DIR/box_expr.rs:+1:13: +1:25
let _6: (); // in scope 0 at $DIR/box_expr.rs:+2:5: +2:12
let mut _7: std::boxed::Box<S>; // in scope 0 at $DIR/box_expr.rs:+2:10: +2:11
let mut _2: usize; // in scope 0 at $DIR/box_expr.rs:+2:5: +2:23
let mut _3: usize; // in scope 0 at $DIR/box_expr.rs:+2:5: +2:23
let mut _4: *mut u8; // in scope 0 at $DIR/box_expr.rs:+2:5: +2:23
let mut _5: std::boxed::Box<S>; // in scope 0 at $DIR/box_expr.rs:+2:5: +2:23
let _6: (); // in scope 0 at $DIR/box_expr.rs:+3:5: +3:12
let mut _7: std::boxed::Box<S>; // in scope 0 at $DIR/box_expr.rs:+3:10: +3:11
scope 1 {
debug x => _1; // in scope 1 at $DIR/box_expr.rs:+1:9: +1:10
}
@ -17,64 +17,64 @@ fn main() -> () {
bb0: {
StorageLive(_1); // scope 0 at $DIR/box_expr.rs:+1:9: +1:10
_2 = SizeOf(S); // scope 2 at $DIR/box_expr.rs:+1:13: +1:25
_3 = AlignOf(S); // scope 2 at $DIR/box_expr.rs:+1:13: +1:25
_4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 2 at $DIR/box_expr.rs:+1:13: +1:25
_2 = SizeOf(S); // scope 2 at $DIR/box_expr.rs:+2:5: +2:23
_3 = AlignOf(S); // scope 2 at $DIR/box_expr.rs:+2:5: +2:23
_4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 2 at $DIR/box_expr.rs:+2:5: +2:23
// mir::Constant
// + span: $DIR/box_expr.rs:7:13: 7:25
// + span: $DIR/box_expr.rs:8:5: 8:23
// + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
}
bb1: {
StorageLive(_5); // scope 0 at $DIR/box_expr.rs:+1:13: +1:25
_5 = ShallowInitBox(move _4, S); // scope 0 at $DIR/box_expr.rs:+1:13: +1:25
(*_5) = S::new() -> [return: bb2, unwind: bb8]; // scope 0 at $DIR/box_expr.rs:+1:17: +1:25
StorageLive(_5); // scope 0 at $DIR/box_expr.rs:+2:5: +2:23
_5 = ShallowInitBox(move _4, S); // scope 0 at $DIR/box_expr.rs:+2:5: +2:23
(*_5) = S::new() -> [return: bb2, unwind: bb8]; // scope 0 at $DIR/box_expr.rs:+2:14: +2:22
// mir::Constant
// + span: $DIR/box_expr.rs:7:17: 7:23
// + span: $DIR/box_expr.rs:8:14: 8:20
// + literal: Const { ty: fn() -> S {S::new}, val: Value(<ZST>) }
}
bb2: {
_1 = move _5; // scope 0 at $DIR/box_expr.rs:+1:13: +1:25
drop(_5) -> bb3; // scope 0 at $DIR/box_expr.rs:+1:24: +1:25
_1 = move _5; // scope 0 at $DIR/box_expr.rs:+2:5: +2:23
drop(_5) -> bb3; // scope 0 at $DIR/box_expr.rs:+2:22: +2:23
}
bb3: {
StorageDead(_5); // scope 0 at $DIR/box_expr.rs:+1:24: +1:25
StorageLive(_6); // scope 1 at $DIR/box_expr.rs:+2:5: +2:12
StorageLive(_7); // scope 1 at $DIR/box_expr.rs:+2:10: +2:11
_7 = move _1; // scope 1 at $DIR/box_expr.rs:+2:10: +2:11
_6 = std::mem::drop::<Box<S>>(move _7) -> [return: bb4, unwind: bb6]; // scope 1 at $DIR/box_expr.rs:+2:5: +2:12
StorageDead(_5); // scope 0 at $DIR/box_expr.rs:+2:22: +2:23
StorageLive(_6); // scope 1 at $DIR/box_expr.rs:+3:5: +3:12
StorageLive(_7); // scope 1 at $DIR/box_expr.rs:+3:10: +3:11
_7 = move _1; // scope 1 at $DIR/box_expr.rs:+3:10: +3:11
_6 = std::mem::drop::<Box<S>>(move _7) -> [return: bb4, unwind: bb6]; // scope 1 at $DIR/box_expr.rs:+3:5: +3:12
// mir::Constant
// + span: $DIR/box_expr.rs:8:5: 8:9
// + span: $DIR/box_expr.rs:9:5: 9:9
// + literal: Const { ty: fn(Box<S>) {std::mem::drop::<Box<S>>}, val: Value(<ZST>) }
}
bb4: {
StorageDead(_7); // scope 1 at $DIR/box_expr.rs:+2:11: +2:12
StorageDead(_6); // scope 1 at $DIR/box_expr.rs:+2:12: +2:13
_0 = const (); // scope 0 at $DIR/box_expr.rs:+0:11: +3:2
drop(_1) -> bb5; // scope 0 at $DIR/box_expr.rs:+3:1: +3:2
StorageDead(_7); // scope 1 at $DIR/box_expr.rs:+3:11: +3:12
StorageDead(_6); // scope 1 at $DIR/box_expr.rs:+3:12: +3:13
_0 = const (); // scope 0 at $DIR/box_expr.rs:+0:11: +4:2
drop(_1) -> bb5; // scope 0 at $DIR/box_expr.rs:+4:1: +4:2
}
bb5: {
StorageDead(_1); // scope 0 at $DIR/box_expr.rs:+3:1: +3:2
return; // scope 0 at $DIR/box_expr.rs:+3:2: +3:2
StorageDead(_1); // scope 0 at $DIR/box_expr.rs:+4:1: +4:2
return; // scope 0 at $DIR/box_expr.rs:+4:2: +4:2
}
bb6 (cleanup): {
drop(_7) -> bb7; // scope 1 at $DIR/box_expr.rs:+2:11: +2:12
drop(_7) -> bb7; // scope 1 at $DIR/box_expr.rs:+3:11: +3:12
}
bb7 (cleanup): {
drop(_1) -> bb9; // scope 0 at $DIR/box_expr.rs:+3:1: +3:2
drop(_1) -> bb9; // scope 0 at $DIR/box_expr.rs:+4:1: +4:2
}
bb8 (cleanup): {
drop(_5) -> bb9; // scope 0 at $DIR/box_expr.rs:+1:24: +1:25
drop(_5) -> bb9; // scope 0 at $DIR/box_expr.rs:+2:22: +2:23
}
bb9 (cleanup): {
resume; // scope 0 at $DIR/box_expr.rs:+0:1: +3:2
resume; // scope 0 at $DIR/box_expr.rs:+0:1: +4:2
}
}

9
tests/mir-opt/box_expr.rs
View file

@ -1,17 +1,20 @@
// ignore-wasm32-bare compiled with panic=abort by default
#![feature(box_syntax)]
#![feature(rustc_attrs, stmt_expr_attributes)]
// EMIT_MIR box_expr.main.ElaborateDrops.before.mir
fn main() {
let x = box S::new();
let x = #[rustc_box]
Box::new(S::new());
drop(x);
}
struct S;
impl S {
fn new() -> Self { S }
fn new() -> Self {
S
}
}
impl Drop for S {

104
tests/mir-opt/building/uniform_array_move_out.move_out_by_subslice.built.after.mir
View file

@ -3,21 +3,21 @@
fn move_out_by_subslice() -> () {
let mut _0: (); // return place in scope 0 at $DIR/uniform_array_move_out.rs:+0:27: +0:27
let _1: [std::boxed::Box<i32>; 2]; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:9: +1:10
let mut _2: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
let mut _3: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
let mut _4: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
let mut _5: *mut u8; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
let mut _6: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
let mut _7: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
let mut _8: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
let mut _9: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
let mut _10: *mut u8; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
let mut _11: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
let mut _2: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
let mut _3: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
let mut _4: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
let mut _5: *mut u8; // in scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
let mut _6: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
let mut _7: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
let mut _8: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
let mut _9: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
let mut _10: *mut u8; // in scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
let mut _11: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
scope 1 {
debug a => _1; // in scope 1 at $DIR/uniform_array_move_out.rs:+1:9: +1:10
let _12: [std::boxed::Box<i32>; 2]; // in scope 1 at $DIR/uniform_array_move_out.rs:+2:10: +2:12
let _12: [std::boxed::Box<i32>; 2]; // in scope 1 at $DIR/uniform_array_move_out.rs:+7:10: +7:12
scope 4 {
debug _y => _12; // in scope 4 at $DIR/uniform_array_move_out.rs:+2:10: +2:12
debug _y => _12; // in scope 4 at $DIR/uniform_array_move_out.rs:+7:10: +7:12
}
}
scope 2 {
@ -27,86 +27,86 @@ fn move_out_by_subslice() -> () {
bb0: {
StorageLive(_1); // scope 0 at $DIR/uniform_array_move_out.rs:+1:9: +1:10
StorageLive(_2); // scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
_3 = SizeOf(i32); // scope 2 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
_4 = AlignOf(i32); // scope 2 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
_5 = alloc::alloc::exchange_malloc(move _3, move _4) -> [return: bb1, unwind: bb12]; // scope 2 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
StorageLive(_2); // scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
_3 = SizeOf(i32); // scope 2 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
_4 = AlignOf(i32); // scope 2 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
_5 = alloc::alloc::exchange_malloc(move _3, move _4) -> [return: bb1, unwind: bb12]; // scope 2 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
// mir::Constant
// + span: $DIR/uniform_array_move_out.rs:11:14: 11:19
// + span: $DIR/uniform_array_move_out.rs:18:9: 18:20
// + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
}
bb1: {
StorageLive(_6); // scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
_6 = ShallowInitBox(move _5, i32); // scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
(*_6) = const 1_i32; // scope 0 at $DIR/uniform_array_move_out.rs:+1:18: +1:19
_2 = move _6; // scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
drop(_6) -> [return: bb2, unwind: bb11]; // scope 0 at $DIR/uniform_array_move_out.rs:+1:18: +1:19
StorageLive(_6); // scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
_6 = ShallowInitBox(move _5, i32); // scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
(*_6) = const 1_i32; // scope 0 at $DIR/uniform_array_move_out.rs:+3:18: +3:19
_2 = move _6; // scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
drop(_6) -> [return: bb2, unwind: bb11]; // scope 0 at $DIR/uniform_array_move_out.rs:+3:19: +3:20
}
bb2: {
StorageDead(_6); // scope 0 at $DIR/uniform_array_move_out.rs:+1:18: +1:19
StorageLive(_7); // scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
_8 = SizeOf(i32); // scope 3 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
_9 = AlignOf(i32); // scope 3 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
_10 = alloc::alloc::exchange_malloc(move _8, move _9) -> [return: bb3, unwind: bb11]; // scope 3 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
StorageDead(_6); // scope 0 at $DIR/uniform_array_move_out.rs:+3:19: +3:20
StorageLive(_7); // scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
_8 = SizeOf(i32); // scope 3 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
_9 = AlignOf(i32); // scope 3 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
_10 = alloc::alloc::exchange_malloc(move _8, move _9) -> [return: bb3, unwind: bb11]; // scope 3 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
// mir::Constant
// + span: $DIR/uniform_array_move_out.rs:11:21: 11:26
// + span: $DIR/uniform_array_move_out.rs:20:9: 20:20
// + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
}
bb3: {
StorageLive(_11); // scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
_11 = ShallowInitBox(move _10, i32); // scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
(*_11) = const 2_i32; // scope 0 at $DIR/uniform_array_move_out.rs:+1:25: +1:26
_7 = move _11; // scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
drop(_11) -> [return: bb4, unwind: bb10]; // scope 0 at $DIR/uniform_array_move_out.rs:+1:25: +1:26
StorageLive(_11); // scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
_11 = ShallowInitBox(move _10, i32); // scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
(*_11) = const 2_i32; // scope 0 at $DIR/uniform_array_move_out.rs:+5:18: +5:19
_7 = move _11; // scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
drop(_11) -> [return: bb4, unwind: bb10]; // scope 0 at $DIR/uniform_array_move_out.rs:+5:19: +5:20
}
bb4: {
StorageDead(_11); // scope 0 at $DIR/uniform_array_move_out.rs:+1:25: +1:26
_1 = [move _2, move _7]; // scope 0 at $DIR/uniform_array_move_out.rs:+1:13: +1:27
drop(_7) -> [return: bb5, unwind: bb11]; // scope 0 at $DIR/uniform_array_move_out.rs:+1:26: +1:27
StorageDead(_11); // scope 0 at $DIR/uniform_array_move_out.rs:+5:19: +5:20
_1 = [move _2, move _7]; // scope 0 at $DIR/uniform_array_move_out.rs:+1:13: +6:6
drop(_7) -> [return: bb5, unwind: bb11]; // scope 0 at $DIR/uniform_array_move_out.rs:+6:5: +6:6
}
bb5: {
StorageDead(_7); // scope 0 at $DIR/uniform_array_move_out.rs:+1:26: +1:27
drop(_2) -> [return: bb6, unwind: bb12]; // scope 0 at $DIR/uniform_array_move_out.rs:+1:26: +1:27
StorageDead(_7); // scope 0 at $DIR/uniform_array_move_out.rs:+6:5: +6:6
drop(_2) -> [return: bb6, unwind: bb12]; // scope 0 at $DIR/uniform_array_move_out.rs:+6:5: +6:6
}
bb6: {
StorageDead(_2); // scope 0 at $DIR/uniform_array_move_out.rs:+1:26: +1:27
StorageDead(_2); // scope 0 at $DIR/uniform_array_move_out.rs:+6:5: +6:6
FakeRead(ForLet(None), _1); // scope 0 at $DIR/uniform_array_move_out.rs:+1:9: +1:10
PlaceMention(_1); // scope 1 at $DIR/uniform_array_move_out.rs:+2:21: +2:22
StorageLive(_12); // scope 1 at $DIR/uniform_array_move_out.rs:+2:10: +2:12
_12 = move _1[0..2]; // scope 1 at $DIR/uniform_array_move_out.rs:+2:10: +2:12
_0 = const (); // scope 0 at $DIR/uniform_array_move_out.rs:+0:27: +3:2
drop(_12) -> [return: bb7, unwind: bb9]; // scope 1 at $DIR/uniform_array_move_out.rs:+3:1: +3:2
PlaceMention(_1); // scope 1 at $DIR/uniform_array_move_out.rs:+7:21: +7:22
StorageLive(_12); // scope 1 at $DIR/uniform_array_move_out.rs:+7:10: +7:12
_12 = move _1[0..2]; // scope 1 at $DIR/uniform_array_move_out.rs:+7:10: +7:12
_0 = const (); // scope 0 at $DIR/uniform_array_move_out.rs:+0:27: +8:2
drop(_12) -> [return: bb7, unwind: bb9]; // scope 1 at $DIR/uniform_array_move_out.rs:+8:1: +8:2
}
bb7: {
StorageDead(_12); // scope 1 at $DIR/uniform_array_move_out.rs:+3:1: +3:2
drop(_1) -> [return: bb8, unwind: bb12]; // scope 0 at $DIR/uniform_array_move_out.rs:+3:1: +3:2
StorageDead(_12); // scope 1 at $DIR/uniform_array_move_out.rs:+8:1: +8:2
drop(_1) -> [return: bb8, unwind: bb12]; // scope 0 at $DIR/uniform_array_move_out.rs:+8:1: +8:2
}
bb8: {
StorageDead(_1); // scope 0 at $DIR/uniform_array_move_out.rs:+3:1: +3:2
return; // scope 0 at $DIR/uniform_array_move_out.rs:+3:2: +3:2
StorageDead(_1); // scope 0 at $DIR/uniform_array_move_out.rs:+8:1: +8:2
return; // scope 0 at $DIR/uniform_array_move_out.rs:+8:2: +8:2
}
bb9 (cleanup): {
drop(_1) -> bb12; // scope 0 at $DIR/uniform_array_move_out.rs:+3:1: +3:2
drop(_1) -> bb12; // scope 0 at $DIR/uniform_array_move_out.rs:+8:1: +8:2
}
bb10 (cleanup): {
drop(_7) -> bb11; // scope 0 at $DIR/uniform_array_move_out.rs:+1:26: +1:27
drop(_7) -> bb11; // scope 0 at $DIR/uniform_array_move_out.rs:+6:5: +6:6
}
bb11 (cleanup): {
drop(_2) -> bb12; // scope 0 at $DIR/uniform_array_move_out.rs:+1:26: +1:27
drop(_2) -> bb12; // scope 0 at $DIR/uniform_array_move_out.rs:+6:5: +6:6
}
bb12 (cleanup): {
resume; // scope 0 at $DIR/uniform_array_move_out.rs:+0:1: +3:2
resume; // scope 0 at $DIR/uniform_array_move_out.rs:+0:1: +8:2
}
}

104
tests/mir-opt/building/uniform_array_move_out.move_out_from_end.built.after.mir
View file

@ -3,21 +3,21 @@
fn move_out_from_end() -> () {
let mut _0: (); // return place in scope 0 at $DIR/uniform_array_move_out.rs:+0:24: +0:24
let _1: [std::boxed::Box<i32>; 2]; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:9: +1:10
let mut _2: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
let mut _3: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
let mut _4: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
let mut _5: *mut u8; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
let mut _6: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
let mut _7: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
let mut _8: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
let mut _9: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
let mut _10: *mut u8; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
let mut _11: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
let mut _2: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
let mut _3: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
let mut _4: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
let mut _5: *mut u8; // in scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
let mut _6: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
let mut _7: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
let mut _8: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
let mut _9: usize; // in scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
let mut _10: *mut u8; // in scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
let mut _11: std::boxed::Box<i32>; // in scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
scope 1 {
debug a => _1; // in scope 1 at $DIR/uniform_array_move_out.rs:+1:9: +1:10
let _12: std::boxed::Box<i32>; // in scope 1 at $DIR/uniform_array_move_out.rs:+2:14: +2:16
let _12: std::boxed::Box<i32>; // in scope 1 at $DIR/uniform_array_move_out.rs:+7:14: +7:16
scope 4 {
debug _y => _12; // in scope 4 at $DIR/uniform_array_move_out.rs:+2:14: +2:16
debug _y => _12; // in scope 4 at $DIR/uniform_array_move_out.rs:+7:14: +7:16
}
}
scope 2 {
@ -27,86 +27,86 @@ fn move_out_from_end() -> () {
bb0: {
StorageLive(_1); // scope 0 at $DIR/uniform_array_move_out.rs:+1:9: +1:10
StorageLive(_2); // scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
_3 = SizeOf(i32); // scope 2 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
_4 = AlignOf(i32); // scope 2 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
_5 = alloc::alloc::exchange_malloc(move _3, move _4) -> [return: bb1, unwind: bb12]; // scope 2 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
StorageLive(_2); // scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
_3 = SizeOf(i32); // scope 2 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
_4 = AlignOf(i32); // scope 2 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
_5 = alloc::alloc::exchange_malloc(move _3, move _4) -> [return: bb1, unwind: bb12]; // scope 2 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
// mir::Constant
// + span: $DIR/uniform_array_move_out.rs:5:14: 5:19
// + span: $DIR/uniform_array_move_out.rs:7:9: 7:20
// + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
}
bb1: {
StorageLive(_6); // scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
_6 = ShallowInitBox(move _5, i32); // scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
(*_6) = const 1_i32; // scope 0 at $DIR/uniform_array_move_out.rs:+1:18: +1:19
_2 = move _6; // scope 0 at $DIR/uniform_array_move_out.rs:+1:14: +1:19
drop(_6) -> [return: bb2, unwind: bb11]; // scope 0 at $DIR/uniform_array_move_out.rs:+1:18: +1:19
StorageLive(_6); // scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
_6 = ShallowInitBox(move _5, i32); // scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
(*_6) = const 1_i32; // scope 0 at $DIR/uniform_array_move_out.rs:+3:18: +3:19
_2 = move _6; // scope 0 at $DIR/uniform_array_move_out.rs:+3:9: +3:20
drop(_6) -> [return: bb2, unwind: bb11]; // scope 0 at $DIR/uniform_array_move_out.rs:+3:19: +3:20
}
bb2: {
StorageDead(_6); // scope 0 at $DIR/uniform_array_move_out.rs:+1:18: +1:19
StorageLive(_7); // scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
_8 = SizeOf(i32); // scope 3 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
_9 = AlignOf(i32); // scope 3 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
_10 = alloc::alloc::exchange_malloc(move _8, move _9) -> [return: bb3, unwind: bb11]; // scope 3 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
StorageDead(_6); // scope 0 at $DIR/uniform_array_move_out.rs:+3:19: +3:20
StorageLive(_7); // scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
_8 = SizeOf(i32); // scope 3 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
_9 = AlignOf(i32); // scope 3 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
_10 = alloc::alloc::exchange_malloc(move _8, move _9) -> [return: bb3, unwind: bb11]; // scope 3 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
// mir::Constant
// + span: $DIR/uniform_array_move_out.rs:5:21: 5:26
// + span: $DIR/uniform_array_move_out.rs:9:9: 9:20
// + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
}
bb3: {
StorageLive(_11); // scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
_11 = ShallowInitBox(move _10, i32); // scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
(*_11) = const 2_i32; // scope 0 at $DIR/uniform_array_move_out.rs:+1:25: +1:26
_7 = move _11; // scope 0 at $DIR/uniform_array_move_out.rs:+1:21: +1:26
drop(_11) -> [return: bb4, unwind: bb10]; // scope 0 at $DIR/uniform_array_move_out.rs:+1:25: +1:26
StorageLive(_11); // scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
_11 = ShallowInitBox(move _10, i32); // scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
(*_11) = const 2_i32; // scope 0 at $DIR/uniform_array_move_out.rs:+5:18: +5:19
_7 = move _11; // scope 0 at $DIR/uniform_array_move_out.rs:+5:9: +5:20
drop(_11) -> [return: bb4, unwind: bb10]; // scope 0 at $DIR/uniform_array_move_out.rs:+5:19: +5:20
}
bb4: {
StorageDead(_11); // scope 0 at $DIR/uniform_array_move_out.rs:+1:25: +1:26
_1 = [move _2, move _7]; // scope 0 at $DIR/uniform_array_move_out.rs:+1:13: +1:27
drop(_7) -> [return: bb5, unwind: bb11]; // scope 0 at $DIR/uniform_array_move_out.rs:+1:26: +1:27
StorageDead(_11); // scope 0 at $DIR/uniform_array_move_out.rs:+5:19: +5:20
_1 = [move _2, move _7]; // scope 0 at $DIR/uniform_array_move_out.rs:+1:13: +6:6
drop(_7) -> [return: bb5, unwind: bb11]; // scope 0 at $DIR/uniform_array_move_out.rs:+6:5: +6:6
}
bb5: {
StorageDead(_7); // scope 0 at $DIR/uniform_array_move_out.rs:+1:26: +1:27
drop(_2) -> [return: bb6, unwind: bb12]; // scope 0 at $DIR/uniform_array_move_out.rs:+1:26: +1:27
StorageDead(_7); // scope 0 at $DIR/uniform_array_move_out.rs:+6:5: +6:6
drop(_2) -> [return: bb6, unwind: bb12]; // scope 0 at $DIR/uniform_array_move_out.rs:+6:5: +6:6
}
bb6: {
StorageDead(_2); // scope 0 at $DIR/uniform_array_move_out.rs:+1:26: +1:27
StorageDead(_2); // scope 0 at $DIR/uniform_array_move_out.rs:+6:5: +6:6
FakeRead(ForLet(None), _1); // scope 0 at $DIR/uniform_array_move_out.rs:+1:9: +1:10
PlaceMention(_1); // scope 1 at $DIR/uniform_array_move_out.rs:+2:20: +2:21
StorageLive(_12); // scope 1 at $DIR/uniform_array_move_out.rs:+2:14: +2:16
_12 = move _1[1 of 2]; // scope 1 at $DIR/uniform_array_move_out.rs:+2:14: +2:16
_0 = const (); // scope 0 at $DIR/uniform_array_move_out.rs:+0:24: +3:2
drop(_12) -> [return: bb7, unwind: bb9]; // scope 1 at $DIR/uniform_array_move_out.rs:+3:1: +3:2
PlaceMention(_1); // scope 1 at $DIR/uniform_array_move_out.rs:+7:20: +7:21
StorageLive(_12); // scope 1 at $DIR/uniform_array_move_out.rs:+7:14: +7:16
_12 = move _1[1 of 2]; // scope 1 at $DIR/uniform_array_move_out.rs:+7:14: +7:16
_0 = const (); // scope 0 at $DIR/uniform_array_move_out.rs:+0:24: +8:2
drop(_12) -> [return: bb7, unwind: bb9]; // scope 1 at $DIR/uniform_array_move_out.rs:+8:1: +8:2
}
bb7: {
StorageDead(_12); // scope 1 at $DIR/uniform_array_move_out.rs:+3:1: +3:2
drop(_1) -> [return: bb8, unwind: bb12]; // scope 0 at $DIR/uniform_array_move_out.rs:+3:1: +3:2
StorageDead(_12); // scope 1 at $DIR/uniform_array_move_out.rs:+8:1: +8:2
drop(_1) -> [return: bb8, unwind: bb12]; // scope 0 at $DIR/uniform_array_move_out.rs:+8:1: +8:2
}
bb8: {
StorageDead(_1); // scope 0 at $DIR/uniform_array_move_out.rs:+3:1: +3:2
return; // scope 0 at $DIR/uniform_array_move_out.rs:+3:2: +3:2
StorageDead(_1); // scope 0 at $DIR/uniform_array_move_out.rs:+8:1: +8:2
return; // scope 0 at $DIR/uniform_array_move_out.rs:+8:2: +8:2
}
bb9 (cleanup): {
drop(_1) -> bb12; // scope 0 at $DIR/uniform_array_move_out.rs:+3:1: +3:2
drop(_1) -> bb12; // scope 0 at $DIR/uniform_array_move_out.rs:+8:1: +8:2
}
bb10 (cleanup): {
drop(_7) -> bb11; // scope 0 at $DIR/uniform_array_move_out.rs:+1:26: +1:27
drop(_7) -> bb11; // scope 0 at $DIR/uniform_array_move_out.rs:+6:5: +6:6
}
bb11 (cleanup): {
drop(_2) -> bb12; // scope 0 at $DIR/uniform_array_move_out.rs:+1:26: +1:27
drop(_2) -> bb12; // scope 0 at $DIR/uniform_array_move_out.rs:+6:5: +6:6
}
bb12 (cleanup): {
resume; // scope 0 at $DIR/uniform_array_move_out.rs:+0:1: +3:2
resume; // scope 0 at $DIR/uniform_array_move_out.rs:+0:1: +8:2
}
}

16
tests/mir-opt/building/uniform_array_move_out.rs
View file

@ -1,14 +1,24 @@
#![feature(box_syntax)]
#![feature(stmt_expr_attributes, rustc_attrs)]
// EMIT_MIR uniform_array_move_out.move_out_from_end.built.after.mir
fn move_out_from_end() {
let a = [box 1, box 2];
let a = [
#[rustc_box]
Box::new(1),
#[rustc_box]
Box::new(2),
];
let [.., _y] = a;
}
// EMIT_MIR uniform_array_move_out.move_out_by_subslice.built.after.mir
fn move_out_by_subslice() {
let a = [box 1, box 2];
let a = [
#[rustc_box]
Box::new(1),
#[rustc_box]
Box::new(2),
];
let [_y @ ..] = a;
}

64
tests/mir-opt/const_prop/boxes.main.ConstProp.diff
View file

@ -4,14 +4,14 @@
fn main() -> () {
let mut _0: (); // return place in scope 0 at $DIR/boxes.rs:+0:11: +0:11
let _1: i32; // in scope 0 at $DIR/boxes.rs:+1:9: +1:10
let mut _2: i32; // in scope 0 at $DIR/boxes.rs:+1:13: +1:22
let mut _3: std::boxed::Box<i32>; // in scope 0 at $DIR/boxes.rs:+1:14: +1:22
let mut _4: usize; // in scope 0 at $DIR/boxes.rs:+1:14: +1:22
let mut _5: usize; // in scope 0 at $DIR/boxes.rs:+1:14: +1:22
let mut _6: *mut u8; // in scope 0 at $DIR/boxes.rs:+1:14: +1:22
let mut _7: std::boxed::Box<i32>; // in scope 0 at $DIR/boxes.rs:+1:14: +1:22
let mut _8: *const i32; // in scope 0 at $DIR/boxes.rs:+1:14: +1:22
let mut _9: *const i32; // in scope 0 at $DIR/boxes.rs:+1:14: +1:22
let mut _2: i32; // in scope 0 at $DIR/boxes.rs:+1:13: +2:18
let mut _3: std::boxed::Box<i32>; // in scope 0 at $DIR/boxes.rs:+1:14: +2:18
let mut _4: usize; // in scope 0 at $DIR/boxes.rs:+1:14: +2:18
let mut _5: usize; // in scope 0 at $DIR/boxes.rs:+1:14: +2:18
let mut _6: *mut u8; // in scope 0 at $DIR/boxes.rs:+1:14: +2:18
let mut _7: std::boxed::Box<i32>; // in scope 0 at $DIR/boxes.rs:+1:14: +2:18
let mut _8: *const i32; // in scope 0 at $DIR/boxes.rs:+1:14: +2:18
let mut _9: *const i32; // in scope 0 at $DIR/boxes.rs:+1:14: +2:18
scope 1 {
debug x => _1; // in scope 1 at $DIR/boxes.rs:+1:9: +1:10
}
@ -20,41 +20,41 @@
bb0: {
StorageLive(_1); // scope 0 at $DIR/boxes.rs:+1:9: +1:10
StorageLive(_2); // scope 0 at $DIR/boxes.rs:+1:13: +1:22
StorageLive(_3); // scope 0 at $DIR/boxes.rs:+1:14: +1:22
- _4 = SizeOf(i32); // scope 2 at $DIR/boxes.rs:+1:14: +1:22
- _5 = AlignOf(i32); // scope 2 at $DIR/boxes.rs:+1:14: +1:22
+ _4 = const 4_usize; // scope 2 at $DIR/boxes.rs:+1:14: +1:22
+ _5 = const 4_usize; // scope 2 at $DIR/boxes.rs:+1:14: +1:22
_6 = alloc::alloc::exchange_malloc(move _4, move _5) -> bb1; // scope 2 at $DIR/boxes.rs:+1:14: +1:22
StorageLive(_2); // scope 0 at $DIR/boxes.rs:+1:13: +2:18
StorageLive(_3); // scope 0 at $DIR/boxes.rs:+1:14: +2:18
- _4 = SizeOf(i32); // scope 2 at $DIR/boxes.rs:+1:14: +2:18
- _5 = AlignOf(i32); // scope 2 at $DIR/boxes.rs:+1:14: +2:18
+ _4 = const 4_usize; // scope 2 at $DIR/boxes.rs:+1:14: +2:18
+ _5 = const 4_usize; // scope 2 at $DIR/boxes.rs:+1:14: +2:18
_6 = alloc::alloc::exchange_malloc(move _4, move _5) -> bb1; // scope 2 at $DIR/boxes.rs:+1:14: +2:18
// mir::Constant
// + span: $DIR/boxes.rs:13:14: 13:22
// + span: $DIR/boxes.rs:13:14: 14:18
// + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
}
bb1: {
StorageLive(_7); // scope 0 at $DIR/boxes.rs:+1:14: +1:22
_7 = ShallowInitBox(move _6, i32); // scope 0 at $DIR/boxes.rs:+1:14: +1:22
_8 = (((_7.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32); // scope 0 at $DIR/boxes.rs:+1:19: +1:21
(*_8) = const 42_i32; // scope 0 at $DIR/boxes.rs:+1:19: +1:21
_3 = move _7; // scope 0 at $DIR/boxes.rs:+1:14: +1:22
StorageDead(_7); // scope 0 at $DIR/boxes.rs:+1:21: +1:22
_9 = (((_3.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32); // scope 0 at $DIR/boxes.rs:+1:13: +1:22
_2 = (*_9); // scope 0 at $DIR/boxes.rs:+1:13: +1:22
_1 = Add(move _2, const 0_i32); // scope 0 at $DIR/boxes.rs:+1:13: +1:26
StorageDead(_2); // scope 0 at $DIR/boxes.rs:+1:25: +1:26
drop(_3) -> [return: bb2, unwind: bb3]; // scope 0 at $DIR/boxes.rs:+1:26: +1:27
StorageLive(_7); // scope 0 at $DIR/boxes.rs:+1:14: +2:18
_7 = ShallowInitBox(move _6, i32); // scope 0 at $DIR/boxes.rs:+1:14: +2:18
_8 = (((_7.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32); // scope 0 at $DIR/boxes.rs:+2:14: +2:16
(*_8) = const 42_i32; // scope 0 at $DIR/boxes.rs:+2:14: +2:16
_3 = move _7; // scope 0 at $DIR/boxes.rs:+1:14: +2:18
StorageDead(_7); // scope 0 at $DIR/boxes.rs:+2:17: +2:18
_9 = (((_3.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32); // scope 0 at $DIR/boxes.rs:+1:13: +2:18
_2 = (*_9); // scope 0 at $DIR/boxes.rs:+1:13: +2:18
_1 = Add(move _2, const 0_i32); // scope 0 at $DIR/boxes.rs:+1:13: +3:12
StorageDead(_2); // scope 0 at $DIR/boxes.rs:+3:11: +3:12
drop(_3) -> [return: bb2, unwind: bb3]; // scope 0 at $DIR/boxes.rs:+3:12: +3:13
}
bb2: {
StorageDead(_3); // scope 0 at $DIR/boxes.rs:+1:26: +1:27
_0 = const (); // scope 0 at $DIR/boxes.rs:+0:11: +2:2
StorageDead(_1); // scope 0 at $DIR/boxes.rs:+2:1: +2:2
return; // scope 0 at $DIR/boxes.rs:+2:2: +2:2
StorageDead(_3); // scope 0 at $DIR/boxes.rs:+3:12: +3:13
_0 = const (); // scope 0 at $DIR/boxes.rs:+0:11: +4:2
StorageDead(_1); // scope 0 at $DIR/boxes.rs:+4:1: +4:2
return; // scope 0 at $DIR/boxes.rs:+4:2: +4:2
}
bb3 (cleanup): {
resume; // scope 0 at $DIR/boxes.rs:+0:1: +2:2
resume; // scope 0 at $DIR/boxes.rs:+0:1: +4:2
}
}

8
tests/mir-opt/const_prop/boxes.rs
View file

@ -4,11 +4,13 @@
// ignore-wasm32
// ignore-wasm64
#![feature(box_syntax)]
#![feature(rustc_attrs, stmt_expr_attributes)]
// Note: this test verifies that we, in fact, do not const prop `box`
// Note: this test verifies that we, in fact, do not const prop `#[rustc_box]`
// EMIT_MIR boxes.main.ConstProp.diff
fn main() {
let x = *(box 42) + 0;
let x = *(#[rustc_box]
Box::new(42))
+ 0;
}

58
tests/mir-opt/derefer_inline_test.main.Derefer.diff
View file

@ -3,58 +3,42 @@
fn main() -> () {
let mut _0: (); // return place in scope 0 at $DIR/derefer_inline_test.rs:+0:11: +0:11
let _1: std::boxed::Box<std::boxed::Box<u32>>; // in scope 0 at $DIR/derefer_inline_test.rs:+1:5: +1:12
let mut _2: usize; // in scope 0 at $DIR/derefer_inline_test.rs:+1:5: +1:12
let mut _3: usize; // in scope 0 at $DIR/derefer_inline_test.rs:+1:5: +1:12
let mut _4: *mut u8; // in scope 0 at $DIR/derefer_inline_test.rs:+1:5: +1:12
let mut _5: std::boxed::Box<std::boxed::Box<u32>>; // in scope 0 at $DIR/derefer_inline_test.rs:+1:5: +1:12
scope 1 {
}
let _1: std::boxed::Box<std::boxed::Box<u32>>; // in scope 0 at $DIR/derefer_inline_test.rs:+1:5: +1:18
let mut _2: std::boxed::Box<u32>; // in scope 0 at $DIR/derefer_inline_test.rs:+1:14: +1:17
bb0: {
StorageLive(_1); // scope 0 at $DIR/derefer_inline_test.rs:+1:5: +1:12
_2 = SizeOf(std::boxed::Box<u32>); // scope 1 at $DIR/derefer_inline_test.rs:+1:5: +1:12
_3 = AlignOf(std::boxed::Box<u32>); // scope 1 at $DIR/derefer_inline_test.rs:+1:5: +1:12
_4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 1 at $DIR/derefer_inline_test.rs:+1:5: +1:12
StorageLive(_1); // scope 0 at $DIR/derefer_inline_test.rs:+1:5: +1:18
StorageLive(_2); // scope 0 at $DIR/derefer_inline_test.rs:+1:14: +1:17
_2 = f() -> bb1; // scope 0 at $DIR/derefer_inline_test.rs:+1:14: +1:17
// mir::Constant
// + span: $DIR/derefer_inline_test.rs:11:5: 11:12
// + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
}
bb1: {
StorageLive(_5); // scope 0 at $DIR/derefer_inline_test.rs:+1:5: +1:12
_5 = ShallowInitBox(move _4, std::boxed::Box<u32>); // scope 0 at $DIR/derefer_inline_test.rs:+1:5: +1:12
(*_5) = f() -> [return: bb2, unwind: bb6]; // scope 0 at $DIR/derefer_inline_test.rs:+1:9: +1:12
// mir::Constant
// + span: $DIR/derefer_inline_test.rs:11:9: 11:10
// + span: $DIR/derefer_inline_test.rs:10:14: 10:15
// + literal: Const { ty: fn() -> Box<u32> {f}, val: Value(<ZST>) }
}
bb1: {
_1 = Box::<Box<u32>>::new(move _2) -> [return: bb2, unwind: bb4]; // scope 0 at $DIR/derefer_inline_test.rs:+1:5: +1:18
// mir::Constant
// + span: $DIR/derefer_inline_test.rs:10:5: 10:13
// + user_ty: UserType(0)
// + literal: Const { ty: fn(Box<u32>) -> Box<Box<u32>> {Box::<Box<u32>>::new}, val: Value(<ZST>) }
}
bb2: {
_1 = move _5; // scope 0 at $DIR/derefer_inline_test.rs:+1:5: +1:12
drop(_5) -> [return: bb3, unwind: bb5]; // scope 0 at $DIR/derefer_inline_test.rs:+1:11: +1:12
StorageDead(_2); // scope 0 at $DIR/derefer_inline_test.rs:+1:17: +1:18
drop(_1) -> bb3; // scope 0 at $DIR/derefer_inline_test.rs:+1:18: +1:19
}
bb3: {
StorageDead(_5); // scope 0 at $DIR/derefer_inline_test.rs:+1:11: +1:12
drop(_1) -> bb4; // scope 0 at $DIR/derefer_inline_test.rs:+1:12: +1:13
}
bb4: {
StorageDead(_1); // scope 0 at $DIR/derefer_inline_test.rs:+1:12: +1:13
StorageDead(_1); // scope 0 at $DIR/derefer_inline_test.rs:+1:18: +1:19
_0 = const (); // scope 0 at $DIR/derefer_inline_test.rs:+0:11: +2:2
return; // scope 0 at $DIR/derefer_inline_test.rs:+2:2: +2:2
}
bb4 (cleanup): {
drop(_2) -> bb5; // scope 0 at $DIR/derefer_inline_test.rs:+1:17: +1:18
}
bb5 (cleanup): {
drop(_1) -> bb7; // scope 0 at $DIR/derefer_inline_test.rs:+1:12: +1:13
}
bb6 (cleanup): {
drop(_5) -> bb7; // scope 0 at $DIR/derefer_inline_test.rs:+1:11: +1:12
}
bb7 (cleanup): {
resume; // scope 0 at $DIR/derefer_inline_test.rs:+0:1: +2:2
}
}

5
tests/mir-opt/derefer_inline_test.rs
View file

@ -2,11 +2,10 @@
// EMIT_MIR derefer_inline_test.main.Derefer.diff
// ignore-wasm32 compiled with panic=abort by default
#![feature(box_syntax)]
#[inline]
fn f() -> Box<u32> {
box 0
Box::new(0)
}
fn main() {
box f();
Box::new(f());
}

117
tests/mir-opt/inline/inline_into_box_place.main.Inline.diff
View file

@ -4,81 +4,78 @@
fn main() -> () {
let mut _0: (); // return place in scope 0 at $DIR/inline_into_box_place.rs:+0:11: +0:11
let _1: std::boxed::Box<std::vec::Vec<u32>>; // in scope 0 at $DIR/inline_into_box_place.rs:+1:9: +1:11
let mut _2: usize; // in scope 0 at $DIR/inline_into_box_place.rs:+1:29: +1:43
let mut _3: usize; // in scope 0 at $DIR/inline_into_box_place.rs:+1:29: +1:43
let mut _4: *mut u8; // in scope 0 at $DIR/inline_into_box_place.rs:+1:29: +1:43
let mut _5: std::boxed::Box<std::vec::Vec<u32>>; // in scope 0 at $DIR/inline_into_box_place.rs:+1:29: +1:43
let mut _6: (); // in scope 0 at $DIR/inline_into_box_place.rs:+1:42: +1:43
let mut _7: *const std::vec::Vec<u32>; // in scope 0 at $DIR/inline_into_box_place.rs:+1:29: +1:43
+ let mut _8: &mut std::vec::Vec<u32>; // in scope 0 at $DIR/inline_into_box_place.rs:+1:33: +1:43
+ let mut _9: std::vec::Vec<u32>; // in scope 0 at $DIR/inline_into_box_place.rs:+1:33: +1:43
let mut _2: std::vec::Vec<u32>; // in scope 0 at $DIR/inline_into_box_place.rs:+1:38: +1:48
scope 1 {
debug _x => _1; // in scope 1 at $DIR/inline_into_box_place.rs:+1:9: +1:11
}
scope 2 {
}
+ scope 3 (inlined Vec::<u32>::new) { // at $DIR/inline_into_box_place.rs:8:33: 8:43
+ let mut _10: alloc::raw_vec::RawVec<u32>; // in scope 3 at $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
+ scope 2 (inlined Vec::<u32>::new) { // at $DIR/inline_into_box_place.rs:7:38: 7:48
+ let mut _3: alloc::raw_vec::RawVec<u32>; // in scope 2 at $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
+ }
+ scope 3 (inlined Box::<Vec<u32>>::new) { // at $DIR/inline_into_box_place.rs:7:29: 7:49
+ debug x => _2; // in scope 3 at $SRC_DIR/alloc/src/boxed.rs:LL:COL
+ let mut _4: usize; // in scope 3 at $SRC_DIR/alloc/src/boxed.rs:LL:COL
+ let mut _5: usize; // in scope 3 at $SRC_DIR/alloc/src/boxed.rs:LL:COL
+ let mut _6: *mut u8; // in scope 3 at $SRC_DIR/alloc/src/boxed.rs:LL:COL
+ let mut _7: *const std::vec::Vec<u32>; // in scope 3 at $SRC_DIR/alloc/src/boxed.rs:LL:COL
+ scope 4 {
+ }
+ }
bb0: {
StorageLive(_1); // scope 0 at $DIR/inline_into_box_place.rs:+1:9: +1:11
_2 = SizeOf(std::vec::Vec<u32>); // scope 2 at $DIR/inline_into_box_place.rs:+1:29: +1:43
_3 = AlignOf(std::vec::Vec<u32>); // scope 2 at $DIR/inline_into_box_place.rs:+1:29: +1:43
_4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 2 at $DIR/inline_into_box_place.rs:+1:29: +1:43
StorageLive(_2); // scope 0 at $DIR/inline_into_box_place.rs:+1:38: +1:48
- _2 = Vec::<u32>::new() -> bb1; // scope 0 at $DIR/inline_into_box_place.rs:+1:38: +1:48
+ StorageLive(_3); // scope 2 at $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
+ _3 = const _; // scope 2 at $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
// mir::Constant
// + span: $DIR/inline_into_box_place.rs:8:29: 8:43
// + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
}
bb1: {
StorageLive(_5); // scope 0 at $DIR/inline_into_box_place.rs:+1:29: +1:43
_5 = ShallowInitBox(move _4, std::vec::Vec<u32>); // scope 0 at $DIR/inline_into_box_place.rs:+1:29: +1:43
_7 = (((_5.0: std::ptr::Unique<std::vec::Vec<u32>>).0: std::ptr::NonNull<std::vec::Vec<u32>>).0: *const std::vec::Vec<u32>); // scope 0 at $DIR/inline_into_box_place.rs:+1:33: +1:43
- (*_7) = Vec::<u32>::new() -> [return: bb2, unwind: bb5]; // scope 0 at $DIR/inline_into_box_place.rs:+1:33: +1:43
+ StorageLive(_8); // scope 0 at $DIR/inline_into_box_place.rs:+1:33: +1:43
+ _8 = &mut (*_7); // scope 0 at $DIR/inline_into_box_place.rs:+1:33: +1:43
+ StorageLive(_9); // scope 0 at $DIR/inline_into_box_place.rs:+1:33: +1:43
+ StorageLive(_10); // scope 3 at $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
+ _10 = const _; // scope 3 at $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
// mir::Constant
- // + span: $DIR/inline_into_box_place.rs:8:33: 8:41
- // + user_ty: UserType(1)
- // + span: $DIR/inline_into_box_place.rs:7:38: 7:46
- // + user_ty: UserType(2)
- // + literal: Const { ty: fn() -> Vec<u32> {Vec::<u32>::new}, val: Value(<ZST>) }
- }
-
- bb2: {
+ // + span: $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
+ // + user_ty: UserType(0)
+ // + literal: Const { ty: alloc::raw_vec::RawVec<u32>, val: Unevaluated(alloc::raw_vec::RawVec::<T>::NEW, [u32], None) }
+ _9 = Vec::<u32> { buf: move _10, len: const 0_usize }; // scope 3 at $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
+ StorageDead(_10); // scope 3 at $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
+ (*_8) = move _9; // scope 0 at $DIR/inline_into_box_place.rs:+1:33: +1:43
+ StorageDead(_9); // scope 0 at $DIR/inline_into_box_place.rs:+1:33: +1:43
+ StorageDead(_8); // scope 0 at $DIR/inline_into_box_place.rs:+1:33: +1:43
_1 = move _5; // scope 0 at $DIR/inline_into_box_place.rs:+1:29: +1:43
StorageDead(_5); // scope 0 at $DIR/inline_into_box_place.rs:+1:42: +1:43
_0 = const (); // scope 0 at $DIR/inline_into_box_place.rs:+0:11: +2:2
- drop(_1) -> [return: bb3, unwind: bb4]; // scope 0 at $DIR/inline_into_box_place.rs:+2:1: +2:2
+ drop(_1) -> [return: bb2, unwind: bb3]; // scope 0 at $DIR/inline_into_box_place.rs:+2:1: +2:2
+ _2 = Vec::<u32> { buf: move _3, len: const 0_usize }; // scope 2 at $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
+ StorageDead(_3); // scope 2 at $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
+ _4 = SizeOf(std::vec::Vec<u32>); // scope 4 at $SRC_DIR/alloc/src/boxed.rs:LL:COL
+ _5 = AlignOf(std::vec::Vec<u32>); // scope 4 at $SRC_DIR/alloc/src/boxed.rs:LL:COL
+ _6 = alloc::alloc::exchange_malloc(move _4, move _5) -> [return: bb3, unwind: bb4]; // scope 4 at $SRC_DIR/alloc/src/boxed.rs:LL:COL
+ // mir::Constant
+ // + span: $SRC_DIR/alloc/src/boxed.rs:LL:COL
+ // + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
}
- bb3: {
+ bb2: {
StorageDead(_1); // scope 0 at $DIR/inline_into_box_place.rs:+2:1: +2:2
return; // scope 0 at $DIR/inline_into_box_place.rs:+2:2: +2:2
}
- bb4 (cleanup): {
+ bb3 (cleanup): {
resume; // scope 0 at $DIR/inline_into_box_place.rs:+0:1: +2:2
- }
-
- bb5 (cleanup): {
- _6 = alloc::alloc::box_free::<Vec<u32>, std::alloc::Global>(move (_5.0: std::ptr::Unique<std::vec::Vec<u32>>), move (_5.1: std::alloc::Global)) -> bb4; // scope 0 at $DIR/inline_into_box_place.rs:+1:42: +1:43
bb1: {
- _1 = Box::<Vec<u32>>::new(move _2) -> [return: bb2, unwind: bb4]; // scope 0 at $DIR/inline_into_box_place.rs:+1:29: +1:49
- // mir::Constant
- // + span: $DIR/inline_into_box_place.rs:8:42: 8:43
- // + literal: Const { ty: unsafe fn(Unique<Vec<u32>>, std::alloc::Global) {alloc::alloc::box_free::<Vec<u32>, std::alloc::Global>}, val: Value(<ZST>) }
- // + span: $DIR/inline_into_box_place.rs:7:29: 7:37
- // + user_ty: UserType(1)
- // + literal: Const { ty: fn(Vec<u32>) -> Box<Vec<u32>> {Box::<Vec<u32>>::new}, val: Value(<ZST>) }
+ StorageDead(_1); // scope 0 at $DIR/inline_into_box_place.rs:+2:1: +2:2
+ return; // scope 0 at $DIR/inline_into_box_place.rs:+2:2: +2:2
}
- bb2: {
- StorageDead(_2); // scope 0 at $DIR/inline_into_box_place.rs:+1:48: +1:49
- _0 = const (); // scope 0 at $DIR/inline_into_box_place.rs:+0:11: +2:2
- drop(_1) -> [return: bb3, unwind: bb4]; // scope 0 at $DIR/inline_into_box_place.rs:+2:1: +2:2
+ bb2 (cleanup): {
+ resume; // scope 0 at $DIR/inline_into_box_place.rs:+0:1: +2:2
}
bb3: {
- StorageDead(_1); // scope 0 at $DIR/inline_into_box_place.rs:+2:1: +2:2
- return; // scope 0 at $DIR/inline_into_box_place.rs:+2:2: +2:2
+ _1 = ShallowInitBox(move _6, std::vec::Vec<u32>); // scope 3 at $SRC_DIR/alloc/src/boxed.rs:LL:COL
+ _7 = (((_1.0: std::ptr::Unique<std::vec::Vec<u32>>).0: std::ptr::NonNull<std::vec::Vec<u32>>).0: *const std::vec::Vec<u32>); // scope 3 at $SRC_DIR/alloc/src/boxed.rs:LL:COL
+ (*_7) = move _2; // scope 3 at $SRC_DIR/alloc/src/boxed.rs:LL:COL
+ StorageDead(_2); // scope 0 at $DIR/inline_into_box_place.rs:+1:48: +1:49
+ _0 = const (); // scope 0 at $DIR/inline_into_box_place.rs:+0:11: +2:2
+ drop(_1) -> [return: bb1, unwind: bb2]; // scope 0 at $DIR/inline_into_box_place.rs:+2:1: +2:2
}
bb4 (cleanup): {
- resume; // scope 0 at $DIR/inline_into_box_place.rs:+0:1: +2:2
+ drop(_2) -> bb2; // scope 3 at $SRC_DIR/alloc/src/boxed.rs:LL:COL
}
}

3
tests/mir-opt/inline/inline_into_box_place.rs
View file

@ -2,8 +2,7 @@
// ignore-wasm32-bare compiled with panic=abort by default
// compile-flags: -Z mir-opt-level=4
#![feature(box_syntax)]
// EMIT_MIR inline_into_box_place.main.Inline.diff
fn main() {
let _x: Box<Vec<u32>> = box Vec::new();
let _x: Box<Vec<u32>> = Box::new(Vec::new());
}

7
tests/mir-opt/issue_62289.rs
View file

@ -2,11 +2,14 @@
// initializing it
// ignore-wasm32-bare compiled with panic=abort by default
#![feature(box_syntax)]
#![feature(rustc_attrs)]
// EMIT_MIR issue_62289.test.ElaborateDrops.before.mir
fn test() -> Option<Box<u32>> {
Some(box (None?))
Some(
#[rustc_box]
Box::new(None?),
)
}
fn main() {

118
tests/mir-opt/issue_62289.test.ElaborateDrops.before.mir
View file

@ -2,121 +2,121 @@
fn test() -> Option<Box<u32>> {
let mut _0: std::option::Option<std::boxed::Box<u32>>; // return place in scope 0 at $DIR/issue_62289.rs:+0:14: +0:30
let mut _1: std::boxed::Box<u32>; // in scope 0 at $DIR/issue_62289.rs:+1:10: +1:21
let mut _2: usize; // in scope 0 at $DIR/issue_62289.rs:+1:10: +1:21
let mut _3: usize; // in scope 0 at $DIR/issue_62289.rs:+1:10: +1:21
let mut _4: *mut u8; // in scope 0 at $DIR/issue_62289.rs:+1:10: +1:21
let mut _5: std::boxed::Box<u32>; // in scope 0 at $DIR/issue_62289.rs:+1:10: +1:21
let mut _6: std::ops::ControlFlow<std::option::Option<std::convert::Infallible>, u32>; // in scope 0 at $DIR/issue_62289.rs:+1:15: +1:20
let mut _7: std::option::Option<u32>; // in scope 0 at $DIR/issue_62289.rs:+1:15: +1:19
let mut _8: isize; // in scope 0 at $DIR/issue_62289.rs:+1:19: +1:20
let _9: std::option::Option<std::convert::Infallible>; // in scope 0 at $DIR/issue_62289.rs:+1:19: +1:20
let mut _10: !; // in scope 0 at $DIR/issue_62289.rs:+1:19: +1:20
let mut _11: std::option::Option<std::convert::Infallible>; // in scope 0 at $DIR/issue_62289.rs:+1:19: +1:20
let _12: u32; // in scope 0 at $DIR/issue_62289.rs:+1:15: +1:20
let mut _1: std::boxed::Box<u32>; // in scope 0 at $DIR/issue_62289.rs:+3:9: +3:24
let mut _2: usize; // in scope 0 at $DIR/issue_62289.rs:+3:9: +3:24
let mut _3: usize; // in scope 0 at $DIR/issue_62289.rs:+3:9: +3:24
let mut _4: *mut u8; // in scope 0 at $DIR/issue_62289.rs:+3:9: +3:24
let mut _5: std::boxed::Box<u32>; // in scope 0 at $DIR/issue_62289.rs:+3:9: +3:24
let mut _6: std::ops::ControlFlow<std::option::Option<std::convert::Infallible>, u32>; // in scope 0 at $DIR/issue_62289.rs:+3:18: +3:23
let mut _7: std::option::Option<u32>; // in scope 0 at $DIR/issue_62289.rs:+3:18: +3:22
let mut _8: isize; // in scope 0 at $DIR/issue_62289.rs:+3:22: +3:23
let _9: std::option::Option<std::convert::Infallible>; // in scope 0 at $DIR/issue_62289.rs:+3:22: +3:23
let mut _10: !; // in scope 0 at $DIR/issue_62289.rs:+3:22: +3:23
let mut _11: std::option::Option<std::convert::Infallible>; // in scope 0 at $DIR/issue_62289.rs:+3:22: +3:23
let _12: u32; // in scope 0 at $DIR/issue_62289.rs:+3:18: +3:23
scope 1 {
}
scope 2 {
debug residual => _9; // in scope 2 at $DIR/issue_62289.rs:+1:19: +1:20
debug residual => _9; // in scope 2 at $DIR/issue_62289.rs:+3:22: +3:23
scope 3 {
}
}
scope 4 {
debug val => _12; // in scope 4 at $DIR/issue_62289.rs:+1:15: +1:20
debug val => _12; // in scope 4 at $DIR/issue_62289.rs:+3:18: +3:23
scope 5 {
}
}
bb0: {
StorageLive(_1); // scope 0 at $DIR/issue_62289.rs:+1:10: +1:21
_2 = SizeOf(u32); // scope 1 at $DIR/issue_62289.rs:+1:10: +1:21
_3 = AlignOf(u32); // scope 1 at $DIR/issue_62289.rs:+1:10: +1:21
_4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 1 at $DIR/issue_62289.rs:+1:10: +1:21
StorageLive(_1); // scope 0 at $DIR/issue_62289.rs:+3:9: +3:24
_2 = SizeOf(u32); // scope 1 at $DIR/issue_62289.rs:+3:9: +3:24
_3 = AlignOf(u32); // scope 1 at $DIR/issue_62289.rs:+3:9: +3:24
_4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 1 at $DIR/issue_62289.rs:+3:9: +3:24
// mir::Constant
// + span: $DIR/issue_62289.rs:9:10: 9:21
// + span: $DIR/issue_62289.rs:11:9: 11:24
// + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
}
bb1: {
StorageLive(_5); // scope 0 at $DIR/issue_62289.rs:+1:10: +1:21
_5 = ShallowInitBox(move _4, u32); // scope 0 at $DIR/issue_62289.rs:+1:10: +1:21
StorageLive(_6); // scope 0 at $DIR/issue_62289.rs:+1:15: +1:20
StorageLive(_7); // scope 0 at $DIR/issue_62289.rs:+1:15: +1:19
_7 = Option::<u32>::None; // scope 0 at $DIR/issue_62289.rs:+1:15: +1:19
_6 = <Option<u32> as Try>::branch(move _7) -> [return: bb2, unwind: bb12]; // scope 0 at $DIR/issue_62289.rs:+1:15: +1:20
StorageLive(_5); // scope 0 at $DIR/issue_62289.rs:+3:9: +3:24
_5 = ShallowInitBox(move _4, u32); // scope 0 at $DIR/issue_62289.rs:+3:9: +3:24
StorageLive(_6); // scope 0 at $DIR/issue_62289.rs:+3:18: +3:23
StorageLive(_7); // scope 0 at $DIR/issue_62289.rs:+3:18: +3:22
_7 = Option::<u32>::None; // scope 0 at $DIR/issue_62289.rs:+3:18: +3:22
_6 = <Option<u32> as Try>::branch(move _7) -> [return: bb2, unwind: bb12]; // scope 0 at $DIR/issue_62289.rs:+3:18: +3:23
// mir::Constant
// + span: $DIR/issue_62289.rs:9:15: 9:20
// + span: $DIR/issue_62289.rs:11:18: 11:23
// + literal: Const { ty: fn(Option<u32>) -> ControlFlow<<Option<u32> as Try>::Residual, <Option<u32> as Try>::Output> {<Option<u32> as Try>::branch}, val: Value(<ZST>) }
}
bb2: {
StorageDead(_7); // scope 0 at $DIR/issue_62289.rs:+1:19: +1:20
_8 = discriminant(_6); // scope 0 at $DIR/issue_62289.rs:+1:15: +1:20
switchInt(move _8) -> [0: bb3, 1: bb5, otherwise: bb4]; // scope 0 at $DIR/issue_62289.rs:+1:15: +1:20
StorageDead(_7); // scope 0 at $DIR/issue_62289.rs:+3:22: +3:23
_8 = discriminant(_6); // scope 0 at $DIR/issue_62289.rs:+3:18: +3:23
switchInt(move _8) -> [0: bb3, 1: bb5, otherwise: bb4]; // scope 0 at $DIR/issue_62289.rs:+3:18: +3:23
}
bb3: {
StorageLive(_12); // scope 0 at $DIR/issue_62289.rs:+1:15: +1:20
_12 = ((_6 as Continue).0: u32); // scope 0 at $DIR/issue_62289.rs:+1:15: +1:20
(*_5) = _12; // scope 5 at $DIR/issue_62289.rs:+1:15: +1:20
StorageDead(_12); // scope 0 at $DIR/issue_62289.rs:+1:19: +1:20
_1 = move _5; // scope 0 at $DIR/issue_62289.rs:+1:10: +1:21
drop(_5) -> [return: bb7, unwind: bb11]; // scope 0 at $DIR/issue_62289.rs:+1:20: +1:21
StorageLive(_12); // scope 0 at $DIR/issue_62289.rs:+3:18: +3:23
_12 = ((_6 as Continue).0: u32); // scope 0 at $DIR/issue_62289.rs:+3:18: +3:23
(*_5) = _12; // scope 5 at $DIR/issue_62289.rs:+3:18: +3:23
StorageDead(_12); // scope 0 at $DIR/issue_62289.rs:+3:22: +3:23
_1 = move _5; // scope 0 at $DIR/issue_62289.rs:+3:9: +3:24
drop(_5) -> [return: bb7, unwind: bb11]; // scope 0 at $DIR/issue_62289.rs:+3:23: +3:24
}
bb4: {
unreachable; // scope 0 at $DIR/issue_62289.rs:+1:15: +1:20
unreachable; // scope 0 at $DIR/issue_62289.rs:+3:18: +3:23
}
bb5: {
StorageLive(_9); // scope 0 at $DIR/issue_62289.rs:+1:19: +1:20
_9 = ((_6 as Break).0: std::option::Option<std::convert::Infallible>); // scope 0 at $DIR/issue_62289.rs:+1:19: +1:20
StorageLive(_11); // scope 3 at $DIR/issue_62289.rs:+1:19: +1:20
_11 = _9; // scope 3 at $DIR/issue_62289.rs:+1:19: +1:20
_0 = <Option<Box<u32>> as FromResidual<Option<Infallible>>>::from_residual(move _11) -> [return: bb6, unwind: bb12]; // scope 3 at $DIR/issue_62289.rs:+1:15: +1:20
StorageLive(_9); // scope 0 at $DIR/issue_62289.rs:+3:22: +3:23
_9 = ((_6 as Break).0: std::option::Option<std::convert::Infallible>); // scope 0 at $DIR/issue_62289.rs:+3:22: +3:23
StorageLive(_11); // scope 3 at $DIR/issue_62289.rs:+3:22: +3:23
_11 = _9; // scope 3 at $DIR/issue_62289.rs:+3:22: +3:23
_0 = <Option<Box<u32>> as FromResidual<Option<Infallible>>>::from_residual(move _11) -> [return: bb6, unwind: bb12]; // scope 3 at $DIR/issue_62289.rs:+3:18: +3:23
// mir::Constant
// + span: $DIR/issue_62289.rs:9:19: 9:20
// + span: $DIR/issue_62289.rs:11:22: 11:23
// + literal: Const { ty: fn(Option<Infallible>) -> Option<Box<u32>> {<Option<Box<u32>> as FromResidual<Option<Infallible>>>::from_residual}, val: Value(<ZST>) }
}
bb6: {
StorageDead(_11); // scope 3 at $DIR/issue_62289.rs:+1:19: +1:20
StorageDead(_9); // scope 0 at $DIR/issue_62289.rs:+1:19: +1:20
drop(_5) -> bb9; // scope 0 at $DIR/issue_62289.rs:+1:20: +1:21
StorageDead(_11); // scope 3 at $DIR/issue_62289.rs:+3:22: +3:23
StorageDead(_9); // scope 0 at $DIR/issue_62289.rs:+3:22: +3:23
drop(_5) -> bb9; // scope 0 at $DIR/issue_62289.rs:+3:23: +3:24
}
bb7: {
StorageDead(_5); // scope 0 at $DIR/issue_62289.rs:+1:20: +1:21
_0 = Option::<Box<u32>>::Some(move _1); // scope 0 at $DIR/issue_62289.rs:+1:5: +1:22
drop(_1) -> bb8; // scope 0 at $DIR/issue_62289.rs:+1:21: +1:22
StorageDead(_5); // scope 0 at $DIR/issue_62289.rs:+3:23: +3:24
_0 = Option::<Box<u32>>::Some(move _1); // scope 0 at $DIR/issue_62289.rs:+1:5: +4:6
drop(_1) -> bb8; // scope 0 at $DIR/issue_62289.rs:+4:5: +4:6
}
bb8: {
StorageDead(_1); // scope 0 at $DIR/issue_62289.rs:+1:21: +1:22
StorageDead(_6); // scope 0 at $DIR/issue_62289.rs:+2:1: +2:2
goto -> bb10; // scope 0 at $DIR/issue_62289.rs:+2:2: +2:2
StorageDead(_1); // scope 0 at $DIR/issue_62289.rs:+4:5: +4:6
StorageDead(_6); // scope 0 at $DIR/issue_62289.rs:+5:1: +5:2
goto -> bb10; // scope 0 at $DIR/issue_62289.rs:+5:2: +5:2
}
bb9: {
StorageDead(_5); // scope 0 at $DIR/issue_62289.rs:+1:20: +1:21
StorageDead(_1); // scope 0 at $DIR/issue_62289.rs:+1:21: +1:22
StorageDead(_6); // scope 0 at $DIR/issue_62289.rs:+2:1: +2:2
goto -> bb10; // scope 0 at $DIR/issue_62289.rs:+2:2: +2:2
StorageDead(_5); // scope 0 at $DIR/issue_62289.rs:+3:23: +3:24
StorageDead(_1); // scope 0 at $DIR/issue_62289.rs:+4:5: +4:6
StorageDead(_6); // scope 0 at $DIR/issue_62289.rs:+5:1: +5:2
goto -> bb10; // scope 0 at $DIR/issue_62289.rs:+5:2: +5:2
}
bb10: {
return; // scope 0 at $DIR/issue_62289.rs:+2:2: +2:2
return; // scope 0 at $DIR/issue_62289.rs:+5:2: +5:2
}
bb11 (cleanup): {
drop(_1) -> bb13; // scope 0 at $DIR/issue_62289.rs:+1:21: +1:22
drop(_1) -> bb13; // scope 0 at $DIR/issue_62289.rs:+4:5: +4:6
}
bb12 (cleanup): {
drop(_5) -> bb13; // scope 0 at $DIR/issue_62289.rs:+1:20: +1:21
drop(_5) -> bb13; // scope 0 at $DIR/issue_62289.rs:+3:23: +3:24
}
bb13 (cleanup): {
resume; // scope 0 at $DIR/issue_62289.rs:+0:1: +2:2
resume; // scope 0 at $DIR/issue_62289.rs:+0:1: +5:2
}
}

1
tests/pretty/ast-stmt-expr-attr.rs
View file

@ -4,7 +4,6 @@ fn main() {}
#[cfg(FALSE)]
fn syntax() {
let _ = #[attr] box 0;
let _ = #[attr] [];
let _ = #[attr] [0];
let _ = #[attr] [0; 0];

2
tests/pretty/stmt_expr_attributes.rs
View file

@ -1,6 +1,5 @@
// pp-exact
#![feature(box_syntax)]
#![feature(inline_const)]
#![feature(inline_const_pat)]
#![feature(rustc_attrs)]
@ -140,7 +139,6 @@ fn _10() {
}
fn _11() {
let _ = #[rustc_dummy] box 0;
let _: [(); 0] = #[rustc_dummy] [];
let _ = #[rustc_dummy] [0, 0];
let _ = #[rustc_dummy] [0; 0];

43
tests/ui-fulldeps/pprust-expr-roundtrip.rs
View file

@ -73,11 +73,10 @@ fn iter_exprs(depth: usize, f: &mut dyn FnMut(P<Expr>)) {
let mut g = |e| f(expr(e));
for kind in 0..=19 {
for kind in 0..=18 {
match kind {
0 => iter_exprs(depth - 1, &mut |e| g(ExprKind::Box(e))),
1 => iter_exprs(depth - 1, &mut |e| g(ExprKind::Call(e, thin_vec![]))),
2 => {
0 => iter_exprs(depth - 1, &mut |e| g(ExprKind::Call(e, thin_vec![]))),
1 => {
let seg = PathSegment::from_ident(Ident::from_str("x"));
iter_exprs(depth - 1, &mut |e| {
g(ExprKind::MethodCall(Box::new(MethodCall {
@ -90,26 +89,26 @@ fn iter_exprs(depth: usize, f: &mut dyn FnMut(P<Expr>)) {
}))
)});
}
3..=8 => {
2..=7 => {
let op = Spanned {
span: DUMMY_SP,
node: match kind {
3 => BinOpKind::Add,
4 => BinOpKind::Mul,
5 => BinOpKind::Shl,
6 => BinOpKind::And,
7 => BinOpKind::Or,
8 => BinOpKind::Lt,
2 => BinOpKind::Add,
3 => BinOpKind::Mul,
4 => BinOpKind::Shl,
5 => BinOpKind::And,
6 => BinOpKind::Or,
7 => BinOpKind::Lt,
_ => unreachable!(),
},
};
iter_exprs(depth - 1, &mut |e| g(ExprKind::Binary(op, e, make_x())));
iter_exprs(depth - 1, &mut |e| g(ExprKind::Binary(op, make_x(), e)));
}
9 => {
8 => {
iter_exprs(depth - 1, &mut |e| g(ExprKind::Unary(UnOp::Deref, e)));
}
10 => {
9 => {
let block = P(Block {
stmts: ThinVec::new(),
id: DUMMY_NODE_ID,
@ -120,7 +119,7 @@ fn iter_exprs(depth: usize, f: &mut dyn FnMut(P<Expr>)) {
});
iter_exprs(depth - 1, &mut |e| g(ExprKind::If(e, block.clone(), None)));
}
11 => {
10 => {
let decl = P(FnDecl { inputs: thin_vec![], output: FnRetTy::Default(DUMMY_SP) });
iter_exprs(depth - 1, &mut |e| {
g(ExprKind::Closure(Box::new(Closure {
@ -136,14 +135,14 @@ fn iter_exprs(depth: usize, f: &mut dyn FnMut(P<Expr>)) {
})))
});
}
12 => {
11 => {
iter_exprs(depth - 1, &mut |e| g(ExprKind::Assign(e, make_x(), DUMMY_SP)));
iter_exprs(depth - 1, &mut |e| g(ExprKind::Assign(make_x(), e, DUMMY_SP)));
}
13 => {
12 => {
iter_exprs(depth - 1, &mut |e| g(ExprKind::Field(e, Ident::from_str("f"))));
}
14 => {
13 => {
iter_exprs(depth - 1, &mut |e| {
g(ExprKind::Range(Some(e), Some(make_x()), RangeLimits::HalfOpen))
});
@ -151,16 +150,16 @@ fn iter_exprs(depth: usize, f: &mut dyn FnMut(P<Expr>)) {
g(ExprKind::Range(Some(make_x()), Some(e), RangeLimits::HalfOpen))
});
}
15 => {
14 => {
iter_exprs(depth - 1, &mut |e| {
g(ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, e))
});
}
16 => {
15 => {
g(ExprKind::Ret(None));
iter_exprs(depth - 1, &mut |e| g(ExprKind::Ret(Some(e))));
}
17 => {
16 => {
let path = Path::from_ident(Ident::from_str("S"));
g(ExprKind::Struct(P(StructExpr {
qself: None,
@ -169,10 +168,10 @@ fn iter_exprs(depth: usize, f: &mut dyn FnMut(P<Expr>)) {
rest: StructRest::Base(make_x()),
})));
}
18 => {
17 => {
iter_exprs(depth - 1, &mut |e| g(ExprKind::Try(e)));
}
19 => {
18 => {
let pat =
P(Pat { id: DUMMY_NODE_ID, kind: PatKind::Wild, span: DUMMY_SP, tokens: None });
iter_exprs(depth - 1, &mut |e| g(ExprKind::Let(pat.clone(), e, DUMMY_SP)))

73
tests/ui/check-static-values-constraints.rs
View file

@ -1,7 +1,6 @@
// Verifies all possible restrictions for statics values.
#![allow(warnings)]
#![feature(box_syntax)]
use std::marker;
@ -19,7 +18,7 @@ enum SafeEnum {
Variant1,
Variant2(isize),
Variant3(WithDtor),
Variant4(String)
Variant4(String),
}
// These should be ok
@ -29,42 +28,45 @@ enum SafeEnum {
enum UnsafeEnum {
Variant5,
Variant6(isize)
Variant6(isize),
}
impl Drop for UnsafeEnum {
fn drop(&mut self) {}
}
static STATIC4: UnsafeEnum = UnsafeEnum::Variant5;
static STATIC5: UnsafeEnum = UnsafeEnum::Variant6(0);
struct SafeStruct {
field1: SafeEnum,
field2: SafeEnum,
}
// Struct fields are safe, hence this static should be safe
static STATIC6: SafeStruct = SafeStruct{field1: SafeEnum::Variant1, field2: SafeEnum::Variant2(0)};
static STATIC6: SafeStruct =
SafeStruct { field1: SafeEnum::Variant1, field2: SafeEnum::Variant2(0) };
static STATIC7: SafeStruct = SafeStruct{field1: SafeEnum::Variant1,
field2: SafeEnum::Variant3(WithDtor)};
static STATIC7: SafeStruct =
SafeStruct { field1: SafeEnum::Variant1, field2: SafeEnum::Variant3(WithDtor) };
// Test variadic constructor for structs. The base struct should be examined
// as well as every field present in the constructor.
// This example shouldn't fail because all the fields are safe.
static STATIC8: SafeStruct = SafeStruct{field1: SafeEnum::Variant1,
..SafeStruct{field1: SafeEnum::Variant1,
field2: SafeEnum::Variant1}};
static STATIC8: SafeStruct = SafeStruct {
field1: SafeEnum::Variant1,
..SafeStruct { field1: SafeEnum::Variant1, field2: SafeEnum::Variant1 }
};
// This example should fail because field1 in the base struct is not safe
static STATIC9: SafeStruct = SafeStruct{field1: SafeEnum::Variant1,
..SafeStruct{field1: SafeEnum::Variant3(WithDtor),
//~^ ERROR destructor of
field2: SafeEnum::Variant1}};
static STATIC9: SafeStruct = SafeStruct {
field1: SafeEnum::Variant1,
..SafeStruct {
//~^ ERROR destructor of
field1: SafeEnum::Variant3(WithDtor),
field2: SafeEnum::Variant1,
}
};
struct UnsafeStruct;
@ -76,38 +78,45 @@ fn drop(&mut self) {}
struct MyOwned;
static STATIC11: Box<MyOwned> = box MyOwned;
static STATIC11: Vec<MyOwned> = vec![MyOwned];
//~^ ERROR allocations are not allowed in statics
//~^^ ERROR cannot call non-const
static mut STATIC12: UnsafeStruct = UnsafeStruct;
static mut STATIC13: SafeStruct = SafeStruct{field1: SafeEnum::Variant1,
field2: SafeEnum::Variant3(WithDtor)};
static mut STATIC13: SafeStruct =
SafeStruct { field1: SafeEnum::Variant1, field2: SafeEnum::Variant3(WithDtor) };
static mut STATIC14: SafeStruct = SafeStruct {
field1: SafeEnum::Variant1,
field2: SafeEnum::Variant4("str".to_string())
//~^ ERROR cannot call non-const fn
field2: SafeEnum::Variant4("str".to_string()), //~ ERROR cannot call non-const fn
};
static STATIC15: &'static [Box<MyOwned>] = &[
box MyOwned, //~ ERROR allocations are not allowed in statics
box MyOwned, //~ ERROR allocations are not allowed in statics
static STATIC15: &'static [Vec<MyOwned>] = &[
vec![MyOwned], //~ ERROR allocations are not allowed in statics
//~^ ERROR cannot call non-const
vec![MyOwned], //~ ERROR allocations are not allowed in statics
//~^ ERROR cannot call non-const
];
static STATIC16: (&'static Box<MyOwned>, &'static Box<MyOwned>) = (
&box MyOwned, //~ ERROR allocations are not allowed in statics
&box MyOwned, //~ ERROR allocations are not allowed in statics
static STATIC16: (&'static Vec<MyOwned>, &'static Vec<MyOwned>) = (
&vec![MyOwned], //~ ERROR allocations are not allowed in statics
//~^ ERROR cannot call non-const
&vec![MyOwned], //~ ERROR allocations are not allowed in statics
//~^ ERROR cannot call non-const
);
static mut STATIC17: SafeEnum = SafeEnum::Variant1;
static STATIC19: Box<isize> =
box 3;
static STATIC19: Vec<isize> = vec![3];
//~^ ERROR allocations are not allowed in statics
//~^^ ERROR cannot call non-const
pub fn main() {
let y = { static x: Box<isize> = box 3; x };
//~^ ERROR allocations are not allowed in statics
//~| ERROR cannot move out of static item
let y = {
static x: Vec<isize> = vec![3]; //~ ERROR allocations are not allowed in statics
//~^ ERROR cannot call non-const
x
//~^ ERROR cannot move out of static
};
}

158
tests/ui/check-static-values-constraints.stderr
View file

@ -1,24 +1,38 @@
error[E0493]: destructor of `SafeStruct` cannot be evaluated at compile-time
--> $DIR/check-static-values-constraints.rs:65:43
--> $DIR/check-static-values-constraints.rs:64:7
|
LL | ..SafeStruct{field1: SafeEnum::Variant3(WithDtor),
| ___________________________________________^
LL | ..SafeStruct {
| _______^
LL | |
LL | | field2: SafeEnum::Variant1}};
| | ^- value is dropped here
| |________________________________________________________________________________|
| the destructor for this type cannot be evaluated in statics
LL | | field1: SafeEnum::Variant3(WithDtor),
LL | | field2: SafeEnum::Variant1,
LL | | }
| |_____^ the destructor for this type cannot be evaluated in statics
LL | };
| - value is dropped here
error[E0010]: allocations are not allowed in statics
--> $DIR/check-static-values-constraints.rs:79:33
--> $DIR/check-static-values-constraints.rs:81:33
|
LL | static STATIC11: Box<MyOwned> = box MyOwned;
| ^^^^^^^^^^^ allocation not allowed in statics
LL | static STATIC11: Vec<MyOwned> = vec![MyOwned];
| ^^^^^^^^^^^^^ allocation not allowed in statics
|
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0015]: cannot call non-const fn `slice::<impl [MyOwned]>::into_vec::<std::alloc::Global>` in statics
--> $DIR/check-static-values-constraints.rs:81:33
|
LL | static STATIC11: Vec<MyOwned> = vec![MyOwned];
| ^^^^^^^^^^^^^
|
= note: calls in statics are limited to constant functions, tuple structs and tuple variants
= note: consider wrapping this expression in `Lazy::new(|| ...)` from the `once_cell` crate: https://crates.io/crates/once_cell
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0015]: cannot call non-const fn `<str as ToString>::to_string` in statics
--> $DIR/check-static-values-constraints.rs:89:38
--> $DIR/check-static-values-constraints.rs:92:38
|
LL | field2: SafeEnum::Variant4("str".to_string())
LL | field2: SafeEnum::Variant4("str".to_string()),
| ^^^^^^^^^^^
|
= note: calls in statics are limited to constant functions, tuple structs and tuple variants
@ -26,53 +40,125 @@ LL | field2: SafeEnum::Variant4("str".to_string())
= note: consider wrapping this expression in `Lazy::new(|| ...)` from the `once_cell` crate: https://crates.io/crates/once_cell
error[E0010]: allocations are not allowed in statics
--> $DIR/check-static-values-constraints.rs:94:5
--> $DIR/check-static-values-constraints.rs:96:5
|
LL | box MyOwned,
| ^^^^^^^^^^^ allocation not allowed in statics
LL | vec![MyOwned],
| ^^^^^^^^^^^^^ allocation not allowed in statics
|
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0015]: cannot call non-const fn `slice::<impl [MyOwned]>::into_vec::<std::alloc::Global>` in statics
--> $DIR/check-static-values-constraints.rs:96:5
|
LL | vec![MyOwned],
| ^^^^^^^^^^^^^
|
= note: calls in statics are limited to constant functions, tuple structs and tuple variants
= note: consider wrapping this expression in `Lazy::new(|| ...)` from the `once_cell` crate: https://crates.io/crates/once_cell
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0010]: allocations are not allowed in statics
--> $DIR/check-static-values-constraints.rs:95:5
--> $DIR/check-static-values-constraints.rs:98:5
|
LL | box MyOwned,
| ^^^^^^^^^^^ allocation not allowed in statics
LL | vec![MyOwned],
| ^^^^^^^^^^^^^ allocation not allowed in statics
|
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0015]: cannot call non-const fn `slice::<impl [MyOwned]>::into_vec::<std::alloc::Global>` in statics
--> $DIR/check-static-values-constraints.rs:98:5
|
LL | vec![MyOwned],
| ^^^^^^^^^^^^^
|
= note: calls in statics are limited to constant functions, tuple structs and tuple variants
= note: consider wrapping this expression in `Lazy::new(|| ...)` from the `once_cell` crate: https://crates.io/crates/once_cell
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0010]: allocations are not allowed in statics
--> $DIR/check-static-values-constraints.rs:99:6
--> $DIR/check-static-values-constraints.rs:103:6
|
LL | &box MyOwned,
| ^^^^^^^^^^^ allocation not allowed in statics
LL | &vec![MyOwned],
| ^^^^^^^^^^^^^ allocation not allowed in statics
|
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0015]: cannot call non-const fn `slice::<impl [MyOwned]>::into_vec::<std::alloc::Global>` in statics
--> $DIR/check-static-values-constraints.rs:103:6
|
LL | &vec![MyOwned],
| ^^^^^^^^^^^^^
|
= note: calls in statics are limited to constant functions, tuple structs and tuple variants
= note: consider wrapping this expression in `Lazy::new(|| ...)` from the `once_cell` crate: https://crates.io/crates/once_cell
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0010]: allocations are not allowed in statics
--> $DIR/check-static-values-constraints.rs:100:6
--> $DIR/check-static-values-constraints.rs:105:6
|
LL | &box MyOwned,
| ^^^^^^^^^^^ allocation not allowed in statics
LL | &vec![MyOwned],
| ^^^^^^^^^^^^^ allocation not allowed in statics
|
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0015]: cannot call non-const fn `slice::<impl [MyOwned]>::into_vec::<std::alloc::Global>` in statics
--> $DIR/check-static-values-constraints.rs:105:6
|
LL | &vec![MyOwned],
| ^^^^^^^^^^^^^
|
= note: calls in statics are limited to constant functions, tuple structs and tuple variants
= note: consider wrapping this expression in `Lazy::new(|| ...)` from the `once_cell` crate: https://crates.io/crates/once_cell
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0010]: allocations are not allowed in statics
--> $DIR/check-static-values-constraints.rs:106:5
--> $DIR/check-static-values-constraints.rs:111:31
|
LL | box 3;
| ^^^^^ allocation not allowed in statics
LL | static STATIC19: Vec<isize> = vec![3];
| ^^^^^^^ allocation not allowed in statics
|
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0015]: cannot call non-const fn `slice::<impl [isize]>::into_vec::<std::alloc::Global>` in statics
--> $DIR/check-static-values-constraints.rs:111:31
|
LL | static STATIC19: Vec<isize> = vec![3];
| ^^^^^^^
|
= note: calls in statics are limited to constant functions, tuple structs and tuple variants
= note: consider wrapping this expression in `Lazy::new(|| ...)` from the `once_cell` crate: https://crates.io/crates/once_cell
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0507]: cannot move out of static item `x`
--> $DIR/check-static-values-constraints.rs:110:45
--> $DIR/check-static-values-constraints.rs:119:9
|
LL | let y = { static x: Box<isize> = box 3; x };
| ^ move occurs because `x` has type `Box<isize>`, which does not implement the `Copy` trait
LL | x
| ^ move occurs because `x` has type `Vec<isize>`, which does not implement the `Copy` trait
|
help: consider borrowing here
|
LL | let y = { static x: Box<isize> = box 3; &x };
| +
LL | &x
| +
error[E0010]: allocations are not allowed in statics
--> $DIR/check-static-values-constraints.rs:110:38
--> $DIR/check-static-values-constraints.rs:117:32
|
LL | let y = { static x: Box<isize> = box 3; x };
| ^^^^^ allocation not allowed in statics
LL | static x: Vec<isize> = vec![3];
| ^^^^^^^ allocation not allowed in statics
|
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 10 previous errors
error[E0015]: cannot call non-const fn `slice::<impl [isize]>::into_vec::<std::alloc::Global>` in statics
--> $DIR/check-static-values-constraints.rs:117:32
|
LL | static x: Vec<isize> = vec![3];
| ^^^^^^^
|
= note: calls in statics are limited to constant functions, tuple structs and tuple variants
= note: consider wrapping this expression in `Lazy::new(|| ...)` from the `once_cell` crate: https://crates.io/crates/once_cell
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 17 previous errors
Some errors have detailed explanations: E0010, E0015, E0493, E0507.
For more information about an error, try `rustc --explain E0010`.

17
tests/ui/coercion/coerce-expect-unsized-ascribed.rs
View file

@ -1,18 +1,19 @@
// A version of coerce-expect-unsized that uses type ascription.
// Doesn't work so far, but supposed to work eventually
#![feature(box_syntax, type_ascription)]
#![feature(type_ascription)]
use std::fmt::Debug;
pub fn main() {
let _ = type_ascribe!(box { [1, 2, 3] }, Box<[i32]>); //~ ERROR mismatched types
let _ = type_ascribe!(box if true { [1, 2, 3] } else { [1, 3, 4] }, Box<[i32]>); //~ ERROR mismatched types
let _ = type_ascribe!(box match true { true => [1, 2, 3], false => [1, 3, 4] }, Box<[i32]>);
let _ = type_ascribe!(Box::new({ [1, 2, 3] }), Box<[i32]>); //~ ERROR mismatched types
let _ = type_ascribe!(Box::new( if true { [1, 2, 3] } else { [1, 3, 4] }), Box<[i32]>); //~ ERROR mismatched types
let _ = type_ascribe!(
Box::new( match true { true => [1, 2, 3], false => [1, 3, 4] }), Box<[i32]>);
//~^ ERROR mismatched types
let _ = type_ascribe!(box { |x| (x as u8) }, Box<dyn Fn(i32) -> _>); //~ ERROR mismatched types
let _ = type_ascribe!(box if true { false } else { true }, Box<dyn Debug>); //~ ERROR mismatched types
let _ = type_ascribe!(box match true { true => 'a', false => 'b' }, Box<dyn Debug>); //~ ERROR mismatched types
let _ = type_ascribe!(Box::new( { |x| (x as u8) }), Box<dyn Fn(i32) -> _>); //~ ERROR mismatched types
let _ = type_ascribe!(Box::new( if true { false } else { true }), Box<dyn Debug>); //~ ERROR mismatched types
let _ = type_ascribe!(Box::new( match true { true => 'a', false => 'b' }), Box<dyn Debug>); //~ ERROR mismatched types
let _ = type_ascribe!(&{ [1, 2, 3] }, &[i32]); //~ ERROR mismatched types
let _ = type_ascribe!(&if true { [1, 2, 3] } else { [1, 3, 4] }, &[i32]); //~ ERROR mismatched types
@ -27,6 +28,6 @@ pub fn main() {
let _ = type_ascribe!(vec![
Box::new(|x| (x as u8)),
box |x| (x as i16 as u8),
Box::new(|x| (x as i16 as u8)),
], Vec<Box<dyn Fn(i32) -> _>>);
}

66
tests/ui/coercion/coerce-expect-unsized-ascribed.stderr
View file

@ -1,8 +1,8 @@
error[E0308]: mismatched types
--> $DIR/coerce-expect-unsized-ascribed.rs:9:27
|
LL | let _ = type_ascribe!(box { [1, 2, 3] }, Box<[i32]>);
| ^^^^^^^^^^^^^^^^^ expected `Box<[i32]>`, found `Box<[i32; 3]>`
LL | let _ = type_ascribe!(Box::new({ [1, 2, 3] }), Box<[i32]>);
| ^^^^^^^^^^^^^^^^^^^^^^^ expected `Box<[i32]>`, found `Box<[i32; 3]>`
|
= note: expected struct `Box<[i32]>`
found struct `Box<[i32; 3]>`
@ -10,50 +10,50 @@ LL | let _ = type_ascribe!(box { [1, 2, 3] }, Box<[i32]>);
error[E0308]: mismatched types
--> $DIR/coerce-expect-unsized-ascribed.rs:10:27
|
LL | let _ = type_ascribe!(box if true { [1, 2, 3] } else { [1, 3, 4] }, Box<[i32]>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Box<[i32]>`, found `Box<[i32; 3]>`
LL | let _ = type_ascribe!(Box::new( if true { [1, 2, 3] } else { [1, 3, 4] }), Box<[i32]>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Box<[i32]>`, found `Box<[i32; 3]>`
|
= note: expected struct `Box<[i32]>`
found struct `Box<[i32; 3]>`
error[E0308]: mismatched types
--> $DIR/coerce-expect-unsized-ascribed.rs:11:27
--> $DIR/coerce-expect-unsized-ascribed.rs:12:9
|
LL | let _ = type_ascribe!(box match true { true => [1, 2, 3], false => [1, 3, 4] }, Box<[i32]>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Box<[i32]>`, found `Box<[i32; 3]>`
LL | Box::new( match true { true => [1, 2, 3], false => [1, 3, 4] }), Box<[i32]>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Box<[i32]>`, found `Box<[i32; 3]>`
|
= note: expected struct `Box<[i32]>`
found struct `Box<[i32; 3]>`
error[E0308]: mismatched types
--> $DIR/coerce-expect-unsized-ascribed.rs:13:27
|
LL | let _ = type_ascribe!(box { |x| (x as u8) }, Box<dyn Fn(i32) -> _>);
| ^^^^^^^^^^^^^^^^^^^^^ expected `Box<dyn Fn(i32) -> u8>`, found `Box<[closure@coerce-expect-unsized-ascribed.rs:13:33]>`
|
= note: expected struct `Box<dyn Fn(i32) -> u8>`
found struct `Box<[closure@$DIR/coerce-expect-unsized-ascribed.rs:13:33: 13:36]>`
error[E0308]: mismatched types
--> $DIR/coerce-expect-unsized-ascribed.rs:14:27
|
LL | let _ = type_ascribe!(box if true { false } else { true }, Box<dyn Debug>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Box<dyn Debug>`, found `Box<bool>`
LL | let _ = type_ascribe!(Box::new( { |x| (x as u8) }), Box<dyn Fn(i32) -> _>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Box<dyn Fn(i32) -> u8>`, found `Box<[closure@coerce-expect-unsized-ascribed.rs:14:39]>`
|
= note: expected struct `Box<dyn Fn(i32) -> u8>`
found struct `Box<[closure@$DIR/coerce-expect-unsized-ascribed.rs:14:39: 14:42]>`
error[E0308]: mismatched types
--> $DIR/coerce-expect-unsized-ascribed.rs:15:27
|
LL | let _ = type_ascribe!(Box::new( if true { false } else { true }), Box<dyn Debug>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Box<dyn Debug>`, found `Box<bool>`
|
= note: expected struct `Box<dyn Debug>`
found struct `Box<bool>`
error[E0308]: mismatched types
--> $DIR/coerce-expect-unsized-ascribed.rs:15:27
--> $DIR/coerce-expect-unsized-ascribed.rs:16:27
|
LL | let _ = type_ascribe!(box match true { true => 'a', false => 'b' }, Box<dyn Debug>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Box<dyn Debug>`, found `Box<char>`
LL | let _ = type_ascribe!(Box::new( match true { true => 'a', false => 'b' }), Box<dyn Debug>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Box<dyn Debug>`, found `Box<char>`
|
= note: expected struct `Box<dyn Debug>`
found struct `Box<char>`
error[E0308]: mismatched types
--> $DIR/coerce-expect-unsized-ascribed.rs:17:27
--> $DIR/coerce-expect-unsized-ascribed.rs:18:27
|
LL | let _ = type_ascribe!(&{ [1, 2, 3] }, &[i32]);
| ^^^^^^^^^^^^^^ expected `&[i32]`, found `&[i32; 3]`
@ -62,7 +62,7 @@ LL | let _ = type_ascribe!(&{ [1, 2, 3] }, &[i32]);
found reference `&[i32; 3]`
error[E0308]: mismatched types
--> $DIR/coerce-expect-unsized-ascribed.rs:18:27
--> $DIR/coerce-expect-unsized-ascribed.rs:19:27
|
LL | let _ = type_ascribe!(&if true { [1, 2, 3] } else { [1, 3, 4] }, &[i32]);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&[i32]`, found `&[i32; 3]`
@ -71,7 +71,7 @@ LL | let _ = type_ascribe!(&if true { [1, 2, 3] } else { [1, 3, 4] }, &[i32]
found reference `&[i32; 3]`
error[E0308]: mismatched types
--> $DIR/coerce-expect-unsized-ascribed.rs:19:27
--> $DIR/coerce-expect-unsized-ascribed.rs:20:27
|
LL | let _ = type_ascribe!(&match true { true => [1, 2, 3], false => [1, 3, 4] }, &[i32]);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&[i32]`, found `&[i32; 3]`
@ -80,16 +80,16 @@ LL | let _ = type_ascribe!(&match true { true => [1, 2, 3], false => [1, 3,
found reference `&[i32; 3]`
error[E0308]: mismatched types
--> $DIR/coerce-expect-unsized-ascribed.rs:21:27
--> $DIR/coerce-expect-unsized-ascribed.rs:22:27
|
LL | let _ = type_ascribe!(&{ |x| (x as u8) }, &dyn Fn(i32) -> _);
| ^^^^^^^^^^^^^^^^^^ expected `&dyn Fn(i32) -> u8`, found `&[closure@coerce-expect-unsized-ascribed.rs:21:30]`
| ^^^^^^^^^^^^^^^^^^ expected `&dyn Fn(i32) -> u8`, found `&[closure@coerce-expect-unsized-ascribed.rs:22:30]`
|
= note: expected reference `&dyn Fn(i32) -> u8`
found reference `&[closure@$DIR/coerce-expect-unsized-ascribed.rs:21:30: 21:33]`
found reference `&[closure@$DIR/coerce-expect-unsized-ascribed.rs:22:30: 22:33]`
error[E0308]: mismatched types
--> $DIR/coerce-expect-unsized-ascribed.rs:22:27
--> $DIR/coerce-expect-unsized-ascribed.rs:23:27
|
LL | let _ = type_ascribe!(&if true { false } else { true }, &dyn Debug);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&dyn Debug`, found `&bool`
@ -98,7 +98,7 @@ LL | let _ = type_ascribe!(&if true { false } else { true }, &dyn Debug);
found reference `&bool`
error[E0308]: mismatched types
--> $DIR/coerce-expect-unsized-ascribed.rs:23:27
--> $DIR/coerce-expect-unsized-ascribed.rs:24:27
|
LL | let _ = type_ascribe!(&match true { true => 'a', false => 'b' }, &dyn Debug);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&dyn Debug`, found `&char`
@ -107,7 +107,7 @@ LL | let _ = type_ascribe!(&match true { true => 'a', false => 'b' }, &dyn D
found reference `&char`
error[E0308]: mismatched types
--> $DIR/coerce-expect-unsized-ascribed.rs:25:27
--> $DIR/coerce-expect-unsized-ascribed.rs:26:27
|
LL | let _ = type_ascribe!(Box::new([1, 2, 3]), Box<[i32]>);
| ^^^^^^^^^^^^^^^^^^^ expected `Box<[i32]>`, found `Box<[i32; 3]>`
@ -116,13 +116,13 @@ LL | let _ = type_ascribe!(Box::new([1, 2, 3]), Box<[i32]>);
found struct `Box<[i32; 3]>`
error[E0308]: mismatched types
--> $DIR/coerce-expect-unsized-ascribed.rs:26:27
--> $DIR/coerce-expect-unsized-ascribed.rs:27:27
|
LL | let _ = type_ascribe!(Box::new(|x| (x as u8)), Box<dyn Fn(i32) -> _>);
| ^^^^^^^^^^^^^^^^^^^^^^^ expected `Box<dyn Fn(i32) -> u8>`, found `Box<[closure@coerce-expect-unsized-ascribed.rs:26:36]>`
| ^^^^^^^^^^^^^^^^^^^^^^^ expected `Box<dyn Fn(i32) -> u8>`, found `Box<[closure@coerce-expect-unsized-ascribed.rs:27:36]>`
|
= note: expected struct `Box<dyn Fn(i32) -> u8>`
found struct `Box<[closure@$DIR/coerce-expect-unsized-ascribed.rs:26:36: 26:39]>`
found struct `Box<[closure@$DIR/coerce-expect-unsized-ascribed.rs:27:36: 27:39]>`
error: aborting due to 14 previous errors

5
tests/ui/consts/miri_unleashed/box.rs
View file

@ -1,12 +1,11 @@
// compile-flags: -Zunleash-the-miri-inside-of-you
#![feature(box_syntax)]
use std::mem::ManuallyDrop;
fn main() {}
static TEST_BAD: &mut i32 = {
&mut *(box 0)
&mut *(Box::new(0))
//~^ ERROR could not evaluate static initializer
//~| NOTE calling non-const function `alloc::alloc::exchange_malloc`
//~| NOTE calling non-const function `Box::<i32>::new`
};

29
tests/ui/consts/miri_unleashed/box.stderr
View file

@ -1,31 +1,26 @@
error[E0080]: could not evaluate static initializer
--> $DIR/box.rs:9:11
--> $DIR/box.rs:8:11
|
LL | &mut *(box 0)
| ^^^^^^^ calling non-const function `alloc::alloc::exchange_malloc`
LL | &mut *(Box::new(0))
| ^^^^^^^^^^^^^ calling non-const function `Box::<i32>::new`
warning: skipping const checks
|
help: skipping check that does not even have a feature gate
--> $DIR/box.rs:9:11
--> $DIR/box.rs:8:11
|
LL | &mut *(box 0)
| ^^^^^^^
LL | &mut *(Box::new(0))
| ^^^^^^^^^^^^^
help: skipping check for `const_mut_refs` feature
--> $DIR/box.rs:9:16
--> $DIR/box.rs:8:5
|
LL | &mut *(box 0)
| ^
help: skipping check for `const_mut_refs` feature
--> $DIR/box.rs:9:5
|
LL | &mut *(box 0)
| ^^^^^^^^^^^^^
LL | &mut *(Box::new(0))
| ^^^^^^^^^^^^^^^^^^^
help: skipping check that does not even have a feature gate
--> $DIR/box.rs:9:5
--> $DIR/box.rs:8:5
|
LL | &mut *(box 0)
| ^^^^^^^^^^^^^
LL | &mut *(Box::new(0))
| ^^^^^^^^^^^^^^^^^^^
error: aborting due to previous error; 1 warning emitted

5
tests/ui/error-codes/E0010-teach.rs
View file

@ -1,8 +1,7 @@
// compile-flags: -Z teach
#![feature(box_syntax)]
#![allow(warnings)]
const CON : Box<i32> = box 0; //~ ERROR E0010
const CON: Vec<i32> = vec![1, 2, 3]; //~ ERROR E0010
//~| ERROR cannot call non-const fn
fn main() {}

21
tests/ui/error-codes/E0010-teach.stderr
View file

@ -1,11 +1,22 @@
error[E0010]: allocations are not allowed in constants
--> $DIR/E0010-teach.rs:6:24
--> $DIR/E0010-teach.rs:5:23
|
LL | const CON : Box<i32> = box 0;
| ^^^^^ allocation not allowed in constants
LL | const CON: Vec<i32> = vec![1, 2, 3];
| ^^^^^^^^^^^^^ allocation not allowed in constants
|
= note: The value of statics and constants must be known at compile time, and they live for the entire lifetime of a program. Creating a boxed value allocates memory on the heap at runtime, and therefore cannot be done at compile time.
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to previous error
error[E0015]: cannot call non-const fn `slice::<impl [i32]>::into_vec::<std::alloc::Global>` in constants
--> $DIR/E0010-teach.rs:5:23
|
LL | const CON: Vec<i32> = vec![1, 2, 3];
| ^^^^^^^^^^^^^
|
= note: calls in constants are limited to constant functions, tuple structs and tuple variants
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
For more information about this error, try `rustc --explain E0010`.
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0010, E0015.
For more information about an error, try `rustc --explain E0010`.

5
tests/ui/error-codes/E0010.rs
View file

@ -1,6 +1,5 @@
#![feature(box_syntax)]
#![allow(warnings)]
const CON : Box<i32> = box 0; //~ ERROR E0010
const CON: Vec<i32> = vec![1, 2, 3]; //~ ERROR E0010
//~| ERROR cannot call non-const fn
fn main() {}

22
tests/ui/error-codes/E0010.stderr
View file

@ -1,9 +1,21 @@
error[E0010]: allocations are not allowed in constants
--> $DIR/E0010.rs:4:24
--> $DIR/E0010.rs:3:23
|
LL | const CON : Box<i32> = box 0;
| ^^^^^ allocation not allowed in constants
LL | const CON: Vec<i32> = vec![1, 2, 3];
| ^^^^^^^^^^^^^ allocation not allowed in constants
|
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to previous error
error[E0015]: cannot call non-const fn `slice::<impl [i32]>::into_vec::<std::alloc::Global>` in constants
--> $DIR/E0010.rs:3:23
|
LL | const CON: Vec<i32> = vec![1, 2, 3];
| ^^^^^^^^^^^^^
|
= note: calls in constants are limited to constant functions, tuple structs and tuple variants
= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
For more information about this error, try `rustc --explain E0010`.
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0010, E0015.
For more information about an error, try `rustc --explain E0010`.

14
tests/ui/feature-gates/feature-gate-box-expr.rs
View file

@ -1,14 +0,0 @@
// gate-test-box_syntax
// Check that `box EXPR` is feature-gated.
//
// See also feature-gate-placement-expr.rs
//
// (Note that the two tests are separated since the checks appear to
// be performed at distinct phases, with an abort_if_errors call
// separating them.)
fn main() {
let x = box 'c'; //~ ERROR box expression syntax is experimental
println!("x: {}", x);
}

12
tests/ui/feature-gates/feature-gate-box-expr.stderr
View file

@ -1,12 +0,0 @@
error[E0658]: box expression syntax is experimental; you can call `Box::new` instead
--> $DIR/feature-gate-box-expr.rs:12:13
|
LL | let x = box 'c';
| ^^^^^^^
|
= note: see issue #49733 <https://github.com/rust-lang/rust/issues/49733> for more information
= help: add `#![feature(box_syntax)]` to the crate attributes to enable
error: aborting due to previous error
For more information about this error, try `rustc --explain E0658`.

6
tests/ui/feature-gates/feature-gate-box_syntax.rs
View file

@ -1,6 +0,0 @@
// Test that the use of the box syntax is gated by `box_syntax` feature gate.
fn main() {
let x = box 3;
//~^ ERROR box expression syntax is experimental; you can call `Box::new` instead
}

12
tests/ui/feature-gates/feature-gate-box_syntax.stderr
View file

@ -1,12 +0,0 @@
error[E0658]: box expression syntax is experimental; you can call `Box::new` instead
--> $DIR/feature-gate-box_syntax.rs:4:13
|
LL | let x = box 3;
| ^^^^^
|
= note: see issue #49733 <https://github.com/rust-lang/rust/issues/49733> for more information
= help: add `#![feature(box_syntax)]` to the crate attributes to enable
error: aborting due to previous error
For more information about this error, try `rustc --explain E0658`.

16
tests/ui/generator/issue-105084.drop_tracking_mir.stderr
View file

@ -1,5 +1,5 @@
error[E0382]: borrow of moved value: `g`
--> $DIR/issue-105084.rs:44:14
--> $DIR/issue-105084.rs:45:14
|
LL | let mut g = || {
| ----- move occurs because `g` has type `[generator@$DIR/issue-105084.rs:22:17: 22:19]`, which does not implement the `Copy` trait
@ -23,7 +23,7 @@ LL | let mut h = copy(g.clone());
| ++++++++
error[E0277]: the trait bound `Box<(i32, ())>: Copy` is not satisfied in `[generator@$DIR/issue-105084.rs:22:17: 22:19]`
--> $DIR/issue-105084.rs:38:17
--> $DIR/issue-105084.rs:39:17
|
LL | let mut g = || {
| -- within this `[generator@$DIR/issue-105084.rs:22:17: 22:19]`
@ -32,13 +32,13 @@ LL | let mut h = copy(g);
| ^^^^ within `[generator@$DIR/issue-105084.rs:22:17: 22:19]`, the trait `Copy` is not implemented for `Box<(i32, ())>`
|
note: generator does not implement `Copy` as this value is used across a yield
--> $DIR/issue-105084.rs:28:25
--> $DIR/issue-105084.rs:29:22
|
LL | let t = box (5, yield);
| --------^^^^^-
| | |
| | yield occurs here, with `box (5, yield)` maybe used later
| has type `Box<(i32, ())>` which does not implement `Copy`
LL | Box::new((5, yield));
| -------------^^^^^--
| | |
| | yield occurs here, with `Box::new((5, yield))` maybe used later
| has type `Box<(i32, ())>` which does not implement `Copy`
note: required by a bound in `copy`
--> $DIR/issue-105084.rs:17:12
|

5
tests/ui/generator/issue-105084.rs
View file

@ -9,7 +9,7 @@
#![feature(generators)]
#![feature(generator_clone)]
#![feature(generator_trait)]
#![feature(box_syntax)]
#![feature(rustc_attrs, stmt_expr_attributes)]
use std::ops::Generator;
use std::pin::Pin;
@ -25,7 +25,8 @@ fn main() {
// - create a Box that is ignored for trait computations;
// - compute fields (and yields);
// - assign to `t`.
let t = box (5, yield);
let t = #[rustc_box]
Box::new((5, yield));
drop(t);
};

24
tests/ui/generator/yield-in-box.rs
View file

@ -1,24 +0,0 @@
// run-pass
// Test that box-statements with yields in them work.
#![feature(generators, box_syntax, generator_trait)]
use std::pin::Pin;
use std::ops::Generator;
use std::ops::GeneratorState;
fn main() {
let x = 0i32;
|| { //~ WARN unused generator that must be used
let y = 2u32;
{
let _t = box (&x, yield 0, &y);
}
match box (&x, yield 0, &y) {
_t => {}
}
};
let mut g = |_| box yield;
assert_eq!(Pin::new(&mut g).resume(1), GeneratorState::Yielded(()));
assert_eq!(Pin::new(&mut g).resume(2), GeneratorState::Complete(box 2));
}

17
tests/ui/generator/yield-in-box.stderr
View file

@ -1,17 +0,0 @@
warning: unused generator that must be used
--> $DIR/yield-in-box.rs:11:5
|
LL | / || {
LL | | let y = 2u32;
LL | | {
LL | | let _t = box (&x, yield 0, &y);
... |
LL | | }
LL | | };
| |_____^
|
= note: generators are lazy and do nothing unless resumed
= note: `#[warn(unused_must_use)]` on by default
warning: 1 warning emitted

16
tests/ui/lang-items/no_owned_box_lang_item.rs
View file

@ -1,16 +0,0 @@
// Test that we don't ICE when we are missing the owned_box lang item.
// error-pattern: requires `owned_box` lang_item
#![feature(lang_items, box_syntax)]
#![no_std]
use core::panic::PanicInfo;
fn main() {
let x = box 1i32;
}
#[lang = "eh_personality"] extern "C" fn eh_personality() {}
#[lang = "eh_catch_typeinfo"] static EH_CATCH_TYPEINFO: u8 = 0;
#[lang = "panic_impl"] fn panic_impl(panic: &PanicInfo) -> ! { loop {} }

4
tests/ui/lang-items/no_owned_box_lang_item.stderr
View file

@ -1,4 +0,0 @@
error: requires `owned_box` lang_item
error: aborting due to previous error

5
tests/ui/macros/rfc-2011-nicer-assert-messages/all-expr-kinds.rs
View file

@ -5,7 +5,7 @@
// needs-unwind Asserting on contents of error message
#![allow(path_statements, unused_allocation)]
#![feature(box_syntax, core_intrinsics, generic_assert, generic_assert_internals)]
#![feature(core_intrinsics, generic_assert, generic_assert_internals)]
macro_rules! test {
(
@ -127,9 +127,6 @@ fn main() {
// block
[ { elem } == 3 ] => "Assertion failed: { elem } == 3"
// box
[ box elem == box 3 ] => "Assertion failed: box elem == box 3"
// break
[ loop { break elem; } == 3 ] => "Assertion failed: loop { break elem; } == 3"

4
tests/ui/macros/stringify.rs
View file

@ -4,7 +4,6 @@
#![feature(async_closure)]
#![feature(box_patterns)]
#![feature(box_syntax)]
#![feature(const_trait_impl)]
#![feature(decl_macro)]
#![feature(generators)]
@ -91,9 +90,6 @@ fn test_block() {
#[test]
fn test_expr() {
// ExprKind::Box
assert_eq!(stringify_expr!(box expr), "box expr");
// ExprKind::Array
assert_eq!(stringify_expr!([]), "[]");
assert_eq!(stringify_expr!([true]), "[true]");

10
tests/ui/mir/mir_boxing.rs
View file

@ -1,10 +0,0 @@
// run-pass
#![feature(box_syntax)]
fn test() -> Box<i32> {
box 42
}
fn main() {
assert_eq!(*test(), 42);
}

2
tests/ui/parser/attr-stmt-expr-attr-bad.rs
View file

@ -1,7 +1,5 @@
fn main() {}
#[cfg(FALSE)] fn e() { let _ = box #![attr] 0; }
//~^ ERROR an inner attribute is not permitted in this context
#[cfg(FALSE)] fn e() { let _ = [#[attr]]; }
//~^ ERROR expected expression, found `]`
#[cfg(FALSE)] fn e() { let _ = foo#[attr](); }

115
tests/ui/parser/attr-stmt-expr-attr-bad.stderr
View file

@ -1,26 +1,17 @@
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:3:36
|
LL | #[cfg(FALSE)] fn e() { let _ = box #![attr] 0; }
| ^^^^^^^^
|
= note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
= note: outer attributes, like `#[test]`, annotate the item following them
error: expected expression, found `]`
--> $DIR/attr-stmt-expr-attr-bad.rs:5:40
--> $DIR/attr-stmt-expr-attr-bad.rs:3:40
|
LL | #[cfg(FALSE)] fn e() { let _ = [#[attr]]; }
| ^ expected expression
error: expected one of `!`, `.`, `::`, `;`, `?`, `else`, `{`, or an operator, found `#`
--> $DIR/attr-stmt-expr-attr-bad.rs:7:35
--> $DIR/attr-stmt-expr-attr-bad.rs:5:35
|
LL | #[cfg(FALSE)] fn e() { let _ = foo#[attr](); }
| ^ expected one of 8 possible tokens
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:9:36
--> $DIR/attr-stmt-expr-attr-bad.rs:7:36
|
LL | #[cfg(FALSE)] fn e() { let _ = foo(#![attr]); }
| ^^^^^^^^
@ -29,13 +20,13 @@ LL | #[cfg(FALSE)] fn e() { let _ = foo(#![attr]); }
= note: outer attributes, like `#[test]`, annotate the item following them
error: expected expression, found `)`
--> $DIR/attr-stmt-expr-attr-bad.rs:9:44
--> $DIR/attr-stmt-expr-attr-bad.rs:7:44
|
LL | #[cfg(FALSE)] fn e() { let _ = foo(#![attr]); }
| ^ expected expression
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:12:38
--> $DIR/attr-stmt-expr-attr-bad.rs:10:38
|
LL | #[cfg(FALSE)] fn e() { let _ = x.foo(#![attr]); }
| ^^^^^^^^
@ -44,13 +35,13 @@ LL | #[cfg(FALSE)] fn e() { let _ = x.foo(#![attr]); }
= note: outer attributes, like `#[test]`, annotate the item following them
error: expected expression, found `)`
--> $DIR/attr-stmt-expr-attr-bad.rs:12:46
--> $DIR/attr-stmt-expr-attr-bad.rs:10:46
|
LL | #[cfg(FALSE)] fn e() { let _ = x.foo(#![attr]); }
| ^ expected expression
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:15:36
--> $DIR/attr-stmt-expr-attr-bad.rs:13:36
|
LL | #[cfg(FALSE)] fn e() { let _ = 0 + #![attr] 0; }
| ^^^^^^^^
@ -59,7 +50,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = 0 + #![attr] 0; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:17:33
--> $DIR/attr-stmt-expr-attr-bad.rs:15:33
|
LL | #[cfg(FALSE)] fn e() { let _ = !#![attr] 0; }
| ^^^^^^^^
@ -68,7 +59,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = !#![attr] 0; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:19:33
--> $DIR/attr-stmt-expr-attr-bad.rs:17:33
|
LL | #[cfg(FALSE)] fn e() { let _ = -#![attr] 0; }
| ^^^^^^^^
@ -77,13 +68,13 @@ LL | #[cfg(FALSE)] fn e() { let _ = -#![attr] 0; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: expected one of `!`, `.`, `::`, `;`, `?`, `else`, `{`, or an operator, found `#`
--> $DIR/attr-stmt-expr-attr-bad.rs:21:34
--> $DIR/attr-stmt-expr-attr-bad.rs:19:34
|
LL | #[cfg(FALSE)] fn e() { let _ = x #![attr] as Y; }
| ^ expected one of 8 possible tokens
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:23:35
--> $DIR/attr-stmt-expr-attr-bad.rs:21:35
|
LL | #[cfg(FALSE)] fn e() { let _ = || #![attr] foo; }
| ^^^^^^^^
@ -92,7 +83,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = || #![attr] foo; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:25:40
--> $DIR/attr-stmt-expr-attr-bad.rs:23:40
|
LL | #[cfg(FALSE)] fn e() { let _ = move || #![attr] foo; }
| ^^^^^^^^
@ -101,7 +92,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = move || #![attr] foo; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:27:35
--> $DIR/attr-stmt-expr-attr-bad.rs:25:35
|
LL | #[cfg(FALSE)] fn e() { let _ = || #![attr] {foo}; }
| ^^^^^^^^
@ -110,7 +101,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = || #![attr] {foo}; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:29:40
--> $DIR/attr-stmt-expr-attr-bad.rs:27:40
|
LL | #[cfg(FALSE)] fn e() { let _ = move || #![attr] {foo}; }
| ^^^^^^^^
@ -119,19 +110,19 @@ LL | #[cfg(FALSE)] fn e() { let _ = move || #![attr] {foo}; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: expected expression, found `..`
--> $DIR/attr-stmt-expr-attr-bad.rs:31:40
--> $DIR/attr-stmt-expr-attr-bad.rs:29:40
|
LL | #[cfg(FALSE)] fn e() { let _ = #[attr] ..#[attr] 0; }
| ^^ expected expression
error: expected expression, found `..`
--> $DIR/attr-stmt-expr-attr-bad.rs:33:40
--> $DIR/attr-stmt-expr-attr-bad.rs:31:40
|
LL | #[cfg(FALSE)] fn e() { let _ = #[attr] ..; }
| ^^ expected expression
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:35:41
--> $DIR/attr-stmt-expr-attr-bad.rs:33:41
|
LL | #[cfg(FALSE)] fn e() { let _ = #[attr] &#![attr] 0; }
| ^^^^^^^^
@ -140,7 +131,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = #[attr] &#![attr] 0; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:37:45
--> $DIR/attr-stmt-expr-attr-bad.rs:35:45
|
LL | #[cfg(FALSE)] fn e() { let _ = #[attr] &mut #![attr] 0; }
| ^^^^^^^^
@ -149,7 +140,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = #[attr] &mut #![attr] 0; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: outer attributes are not allowed on `if` and `else` branches
--> $DIR/attr-stmt-expr-attr-bad.rs:39:37
--> $DIR/attr-stmt-expr-attr-bad.rs:37:37
|
LL | #[cfg(FALSE)] fn e() { let _ = if 0 #[attr] {}; }
| -- ^^^^^^^ -- the attributes are attached to this branch
@ -158,7 +149,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if 0 #[attr] {}; }
| the branch belongs to this `if`
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:41:38
--> $DIR/attr-stmt-expr-attr-bad.rs:39:38
|
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {#![attr]}; }
| ^^^^^^^^
@ -167,13 +158,13 @@ LL | #[cfg(FALSE)] fn e() { let _ = if 0 {#![attr]}; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `#`
--> $DIR/attr-stmt-expr-attr-bad.rs:43:40
--> $DIR/attr-stmt-expr-attr-bad.rs:41:40
|
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} #[attr] else {}; }
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
error: outer attributes are not allowed on `if` and `else` branches
--> $DIR/attr-stmt-expr-attr-bad.rs:45:45
--> $DIR/attr-stmt-expr-attr-bad.rs:43:45
|
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else #[attr] {}; }
| ---- ^^^^^^^ -- the attributes are attached to this branch
@ -182,7 +173,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else #[attr] {}; }
| the branch belongs to this `else`
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:47:46
--> $DIR/attr-stmt-expr-attr-bad.rs:45:46
|
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else {#![attr]}; }
| ^^^^^^^^
@ -191,7 +182,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else {#![attr]}; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: outer attributes are not allowed on `if` and `else` branches
--> $DIR/attr-stmt-expr-attr-bad.rs:49:45
--> $DIR/attr-stmt-expr-attr-bad.rs:47:45
|
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else #[attr] if 0 {}; }
| ---- ^^^^^^^ ------- the attributes are attached to this branch
@ -200,7 +191,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else #[attr] if 0 {}; }
| the branch belongs to this `else`
error: outer attributes are not allowed on `if` and `else` branches
--> $DIR/attr-stmt-expr-attr-bad.rs:51:50
--> $DIR/attr-stmt-expr-attr-bad.rs:49:50
|
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else if 0 #[attr] {}; }
| -- ^^^^^^^ -- the attributes are attached to this branch
@ -209,7 +200,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else if 0 #[attr] {}; }
| the branch belongs to this `if`
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:53:51
--> $DIR/attr-stmt-expr-attr-bad.rs:51:51
|
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else if 0 {#![attr]}; }
| ^^^^^^^^
@ -218,7 +209,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else if 0 {#![attr]}; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: outer attributes are not allowed on `if` and `else` branches
--> $DIR/attr-stmt-expr-attr-bad.rs:55:45
--> $DIR/attr-stmt-expr-attr-bad.rs:53:45
|
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 #[attr] {}; }
| -- ^^^^^^^ -- the attributes are attached to this branch
@ -227,7 +218,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 #[attr] {}; }
| the branch belongs to this `if`
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:57:46
--> $DIR/attr-stmt-expr-attr-bad.rs:55:46
|
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {#![attr]}; }
| ^^^^^^^^
@ -236,13 +227,13 @@ LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {#![attr]}; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `#`
--> $DIR/attr-stmt-expr-attr-bad.rs:59:48
--> $DIR/attr-stmt-expr-attr-bad.rs:57:48
|
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} #[attr] else {}; }
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
error: outer attributes are not allowed on `if` and `else` branches
--> $DIR/attr-stmt-expr-attr-bad.rs:61:53
--> $DIR/attr-stmt-expr-attr-bad.rs:59:53
|
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else #[attr] {}; }
| ---- ^^^^^^^ -- the attributes are attached to this branch
@ -251,7 +242,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else #[attr] {}; }
| the branch belongs to this `else`
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:63:54
--> $DIR/attr-stmt-expr-attr-bad.rs:61:54
|
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else {#![attr]}; }
| ^^^^^^^^
@ -260,7 +251,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else {#![attr]}; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: outer attributes are not allowed on `if` and `else` branches
--> $DIR/attr-stmt-expr-attr-bad.rs:65:53
--> $DIR/attr-stmt-expr-attr-bad.rs:63:53
|
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else #[attr] if let _ = 0 {}; }
| ---- ^^^^^^^ --------------- the attributes are attached to this branch
@ -269,7 +260,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else #[attr] if let _ = 0 {}
| the branch belongs to this `else`
error: outer attributes are not allowed on `if` and `else` branches
--> $DIR/attr-stmt-expr-attr-bad.rs:67:66
--> $DIR/attr-stmt-expr-attr-bad.rs:65:66
|
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else if let _ = 0 #[attr] {}; }
| -- ^^^^^^^ -- the attributes are attached to this branch
@ -278,7 +269,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else if let _ = 0 #[attr] {}
| the branch belongs to this `if`
error: an inner attribute is not permitted in this context
--> $DIR/attr-stmt-expr-attr-bad.rs:69:67
--> $DIR/attr-stmt-expr-attr-bad.rs:67:67
|
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else if let _ = 0 {#![attr]}; }
| ^^^^^^^^
@ -287,7 +278,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else if let _ = 0 {#![attr]}
= note: outer attributes, like `#[test]`, annotate the item following them
error: an inner attribute is not permitted following an outer attribute
--> $DIR/attr-stmt-expr-attr-bad.rs:72:32
--> $DIR/attr-stmt-expr-attr-bad.rs:70:32
|
LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] let _ = 0; }
| ------- ^^^^^^^^ not permitted following an outer attribute
@ -298,7 +289,7 @@ LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] let _ = 0; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: an inner attribute is not permitted following an outer attribute
--> $DIR/attr-stmt-expr-attr-bad.rs:74:32
--> $DIR/attr-stmt-expr-attr-bad.rs:72:32
|
LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] 0; }
| ------- ^^^^^^^^ not permitted following an outer attribute
@ -309,7 +300,7 @@ LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] 0; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: an inner attribute is not permitted following an outer attribute
--> $DIR/attr-stmt-expr-attr-bad.rs:76:32
--> $DIR/attr-stmt-expr-attr-bad.rs:74:32
|
LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!(); }
| ------- ^^^^^^^^ ------- the inner attribute doesn't annotate this item macro invocation
@ -325,7 +316,7 @@ LL + #[cfg(FALSE)] fn s() { #[attr] #[attr] foo!(); }
|
error: an inner attribute is not permitted following an outer attribute
--> $DIR/attr-stmt-expr-attr-bad.rs:78:32
--> $DIR/attr-stmt-expr-attr-bad.rs:76:32
|
LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo![]; }
| ------- ^^^^^^^^ ------- the inner attribute doesn't annotate this item macro invocation
@ -341,7 +332,7 @@ LL + #[cfg(FALSE)] fn s() { #[attr] #[attr] foo![]; }
|
error: an inner attribute is not permitted following an outer attribute
--> $DIR/attr-stmt-expr-attr-bad.rs:80:32
--> $DIR/attr-stmt-expr-attr-bad.rs:78:32
|
LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!{}; }
| ------- ^^^^^^^^ ------ the inner attribute doesn't annotate this item macro invocation
@ -357,7 +348,7 @@ LL + #[cfg(FALSE)] fn s() { #[attr] #[attr] foo!{}; }
|
error[E0586]: inclusive range with no end
--> $DIR/attr-stmt-expr-attr-bad.rs:86:35
--> $DIR/attr-stmt-expr-attr-bad.rs:84:35
|
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] 10 => () } }
| ^^^ help: use `..` instead
@ -365,13 +356,13 @@ LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] 10 => () } }
= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
error: expected one of `=>`, `if`, or `|`, found `#`
--> $DIR/attr-stmt-expr-attr-bad.rs:86:38
--> $DIR/attr-stmt-expr-attr-bad.rs:84:38
|
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] 10 => () } }
| ^ expected one of `=>`, `if`, or `|`
error[E0586]: inclusive range with no end
--> $DIR/attr-stmt-expr-attr-bad.rs:89:35
--> $DIR/attr-stmt-expr-attr-bad.rs:87:35
|
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] -10 => () } }
| ^^^ help: use `..` instead
@ -379,19 +370,19 @@ LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] -10 => () } }
= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
error: expected one of `=>`, `if`, or `|`, found `#`
--> $DIR/attr-stmt-expr-attr-bad.rs:89:38
--> $DIR/attr-stmt-expr-attr-bad.rs:87:38
|
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] -10 => () } }
| ^ expected one of `=>`, `if`, or `|`
error: unexpected token: `#`
--> $DIR/attr-stmt-expr-attr-bad.rs:92:39
--> $DIR/attr-stmt-expr-attr-bad.rs:90:39
|
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=-#[attr] 10 => () } }
| ^
error[E0586]: inclusive range with no end
--> $DIR/attr-stmt-expr-attr-bad.rs:94:35
--> $DIR/attr-stmt-expr-attr-bad.rs:92:35
|
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] FOO => () } }
| ^^^ help: use `..` instead
@ -399,47 +390,47 @@ LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] FOO => () } }
= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
error: expected one of `=>`, `if`, or `|`, found `#`
--> $DIR/attr-stmt-expr-attr-bad.rs:94:38
--> $DIR/attr-stmt-expr-attr-bad.rs:92:38
|
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] FOO => () } }
| ^ expected one of `=>`, `if`, or `|`
error: unexpected token: `#`
--> $DIR/attr-stmt-expr-attr-bad.rs:98:34
--> $DIR/attr-stmt-expr-attr-bad.rs:96:34
|
LL | #[cfg(FALSE)] fn e() { let _ = x.#![attr]foo(); }
| ^
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `#`
--> $DIR/attr-stmt-expr-attr-bad.rs:98:34
--> $DIR/attr-stmt-expr-attr-bad.rs:96:34
|
LL | #[cfg(FALSE)] fn e() { let _ = x.#![attr]foo(); }
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
error: unexpected token: `#`
--> $DIR/attr-stmt-expr-attr-bad.rs:101:34
--> $DIR/attr-stmt-expr-attr-bad.rs:99:34
|
LL | #[cfg(FALSE)] fn e() { let _ = x.#[attr]foo(); }
| ^
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `#`
--> $DIR/attr-stmt-expr-attr-bad.rs:101:34
--> $DIR/attr-stmt-expr-attr-bad.rs:99:34
|
LL | #[cfg(FALSE)] fn e() { let _ = x.#[attr]foo(); }
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
error: expected statement after outer attribute
--> $DIR/attr-stmt-expr-attr-bad.rs:106:37
--> $DIR/attr-stmt-expr-attr-bad.rs:104:37
|
LL | #[cfg(FALSE)] fn e() { { fn foo() { #[attr]; } } }
| ^^^^^^^
error: expected statement after outer attribute
--> $DIR/attr-stmt-expr-attr-bad.rs:108:37
--> $DIR/attr-stmt-expr-attr-bad.rs:106:37
|
LL | #[cfg(FALSE)] fn e() { { fn foo() { #[attr] } } }
| ^^^^^^^
error: aborting due to 53 previous errors
error: aborting due to 52 previous errors
For more information about this error, try `rustc --explain E0586`.

14
tests/ui/parser/issues/issue-65846-rollback-gating-failing-matcher.rs
View file

@ -5,11 +5,17 @@
#[allow(unused_macro_rules)]
macro_rules! m {
($e:expr) => { 0 }; // This fails on the input below due to `, foo`.
($e:expr,) => { 1 }; // This also fails to match due to `foo`.
(box $e:expr, foo) => { 2 }; // Successful matcher, we should get `2`.
($e:expr) => {
0
}; // This fails on the input below due to `, foo`.
($e:expr,) => {
1
}; // This also fails to match due to `foo`.
(do yeet $e:expr, foo) => {
2
}; // Successful matcher, we should get `2`.
}
fn main() {
assert_eq!(2, m!(box 42, foo));
assert_eq!(2, m!(do yeet 42, foo));
}

14
tests/ui/parser/removed-syntax-box.fixed Normal file
View file

@ -0,0 +1,14 @@
// run-rustfix
fn main() {
#[allow(dead_code)]
struct T {
a: u8,
b: u8,
}
let _ = Box::new(()); //~ ERROR `box_syntax` has been removed
let _ = Box::new(1); //~ ERROR `box_syntax` has been removed
let _ = Box::new(T { a: 12, b: 18 }); //~ ERROR `box_syntax` has been removed
let _ = Box::new([5; 30]); //~ ERROR `box_syntax` has been removed
let _: Box<()> = Box::new(()); //~ ERROR `box_syntax` has been removed
}

14
tests/ui/parser/removed-syntax-box.rs Normal file
View file

@ -0,0 +1,14 @@
// run-rustfix
fn main() {
#[allow(dead_code)]
struct T {
a: u8,
b: u8,
}
let _ = box (); //~ ERROR `box_syntax` has been removed
let _ = box 1; //~ ERROR `box_syntax` has been removed
let _ = box T { a: 12, b: 18 }; //~ ERROR `box_syntax` has been removed
let _ = box [5; 30]; //~ ERROR `box_syntax` has been removed
let _: Box<()> = box (); //~ ERROR `box_syntax` has been removed
}

57
tests/ui/parser/removed-syntax-box.stderr Normal file
View file

@ -0,0 +1,57 @@
error: `box_syntax` has been removed
--> $DIR/removed-syntax-box.rs:9:13
|
LL | let _ = box ();
| ^^^^^^
|
help: use `Box::new()` instead
|
LL | let _ = Box::new(());
| ~~~~~~~~~~~~
error: `box_syntax` has been removed
--> $DIR/removed-syntax-box.rs:10:13
|
LL | let _ = box 1;
| ^^^^^
|
help: use `Box::new()` instead
|
LL | let _ = Box::new(1);
| ~~~~~~~~~~~
error: `box_syntax` has been removed
--> $DIR/removed-syntax-box.rs:11:13
|
LL | let _ = box T { a: 12, b: 18 };
| ^^^^^^^^^^^^^^^^^^^^^^
|
help: use `Box::new()` instead
|
LL | let _ = Box::new(T { a: 12, b: 18 });
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: `box_syntax` has been removed
--> $DIR/removed-syntax-box.rs:12:13
|
LL | let _ = box [5; 30];
| ^^^^^^^^^^^
|
help: use `Box::new()` instead
|
LL | let _ = Box::new([5; 30]);
| ~~~~~~~~~~~~~~~~~
error: `box_syntax` has been removed
--> $DIR/removed-syntax-box.rs:13:22
|
LL | let _: Box<()> = box ();
| ^^^^^^
|
help: use `Box::new()` instead
|
LL | let _: Box<()> = Box::new(());
| ~~~~~~~~~~~~
error: aborting due to 5 previous errors

Some files were not shown because too many files have changed in this diff Show more