Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 755dd14

Browse files
m-ou-sem-ou-se
authoredNov 12, 2020
Rollup merge of #78836 - fanzier:struct-and-slice-destructuring, r=petrochenkov
Implement destructuring assignment for structs and slices This is the second step towards implementing destructuring assignment (RFC: rust-lang/rfcs#2909, tracking issue: #71126). This PR is the second part of #71156, which was split up to allow for easier review. Note that the first PR (#78748) is not merged yet, so it is included as the first commit in this one. I thought this would allow the review to start earlier because I have some time this weekend to respond to reviews. If ``@petrochenkov`` prefers to wait until the first PR is merged, I totally understand, of course. This PR implements destructuring assignment for (tuple) structs and slices. In order to do this, the following *parser change* was necessary: struct expressions are not required to have a base expression, i.e. `Struct { a: 1, .. }` becomes legal (in order to act like a struct pattern). Unfortunately, this PR slightly regresses the diagnostics implemented in #77283. However, it is only a missing help message in `src/test/ui/issues/issue-77218.rs`. Other instances of this diagnostic are not affected. Since I don't exactly understand how this help message works and how to fix it yet, I was hoping it's OK to regress this temporarily and fix it in a follow-up PR. Thanks to ``@varkor`` who helped with the implementation, particularly around the struct rest changes. r? ``@petrochenkov``
2 parents 4b0b42a + de84ad9 commit 755dd14

32 files changed

+618
-107
lines changed
 

‎compiler/rustc_ast/src/ast.rs

Lines changed: 14 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1061,7 +1061,7 @@ pub struct Expr {
10611061

10621062
// `Expr` is used a lot. Make sure it doesn't unintentionally get bigger.
10631063
#[cfg(target_arch = "x86_64")]
1064-
rustc_data_structures::static_assert_size!(Expr, 112);
1064+
rustc_data_structures::static_assert_size!(Expr, 120);
10651065

10661066
impl Expr {
10671067
/// Returns `true` if this expression would be valid somewhere that expects a value;
@@ -1218,6 +1218,16 @@ pub enum RangeLimits {
12181218
Closed,
12191219
}
12201220

1221+
#[derive(Clone, Encodable, Decodable, Debug)]
1222+
pub enum StructRest {
1223+
/// `..x`.
1224+
Base(P<Expr>),
1225+
/// `..`.
1226+
Rest(Span),
1227+
/// No trailing `..` or expression.
1228+
None,
1229+
}
1230+
12211231
#[derive(Clone, Encodable, Decodable, Debug)]
12221232
pub enum ExprKind {
12231233
/// A `box x` expression.
@@ -1312,7 +1322,7 @@ pub enum ExprKind {
13121322
Field(P<Expr>, Ident),
13131323
/// An indexing operation (e.g., `foo[2]`).
13141324
Index(P<Expr>, P<Expr>),
1315-
/// A range (e.g., `1..2`, `1..`, `..2`, `1..=2`, `..=2`).
1325+
/// A range (e.g., `1..2`, `1..`, `..2`, `1..=2`, `..=2`; and `..` in destructuring assingment).
13161326
Range(Option<P<Expr>>, Option<P<Expr>>, RangeLimits),
13171327

13181328
/// Variable reference, possibly containing `::` and/or type
@@ -1340,9 +1350,8 @@ pub enum ExprKind {
13401350

13411351
/// A struct literal expression.
13421352
///
1343-
/// E.g., `Foo {x: 1, y: 2}`, or `Foo {x: 1, .. base}`,
1344-
/// where `base` is the `Option<Expr>`.
1345-
Struct(Path, Vec<Field>, Option<P<Expr>>),
1353+
/// E.g., `Foo {x: 1, y: 2}`, or `Foo {x: 1, .. rest}`.
1354+
Struct(Path, Vec<Field>, StructRest),
13461355

13471356
/// An array literal constructed from one repeated element.
13481357
///

‎compiler/rustc_ast/src/mut_visit.rs

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1288,7 +1288,11 @@ pub fn noop_visit_expr<T: MutVisitor>(
12881288
ExprKind::Struct(path, fields, expr) => {
12891289
vis.visit_path(path);
12901290
fields.flat_map_in_place(|field| vis.flat_map_field(field));
1291-
visit_opt(expr, |expr| vis.visit_expr(expr));
1291+
match expr {
1292+
StructRest::Base(expr) => vis.visit_expr(expr),
1293+
StructRest::Rest(_span) => {}
1294+
StructRest::None => {}
1295+
}
12921296
}
12931297
ExprKind::Paren(expr) => {
12941298
vis.visit_expr(expr);

‎compiler/rustc_ast/src/visit.rs

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -719,7 +719,11 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) {
719719
ExprKind::Struct(ref path, ref fields, ref optional_base) => {
720720
visitor.visit_path(path, expression.id);
721721
walk_list!(visitor, visit_field, fields);
722-
walk_list!(visitor, visit_expr, optional_base);
722+
match optional_base {
723+
StructRest::Base(expr) => visitor.visit_expr(expr),
724+
StructRest::Rest(_span) => {}
725+
StructRest::None => {}
726+
}
723727
}
724728
ExprKind::Tup(ref subexpressions) => {
725729
walk_list!(visitor, visit_expr, subexpressions);

‎compiler/rustc_ast_lowering/src/expr.rs

Lines changed: 119 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -187,8 +187,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
187187
}
188188
ExprKind::InlineAsm(ref asm) => self.lower_expr_asm(e.span, asm),
189189
ExprKind::LlvmInlineAsm(ref asm) => self.lower_expr_llvm_asm(asm),
190-
ExprKind::Struct(ref path, ref fields, ref maybe_expr) => {
191-
let maybe_expr = maybe_expr.as_ref().map(|x| self.lower_expr(x));
190+
ExprKind::Struct(ref path, ref fields, ref rest) => {
191+
let rest = match rest {
192+
StructRest::Base(e) => Some(self.lower_expr(e)),
193+
StructRest::Rest(sp) => {
194+
self.sess
195+
.struct_span_err(*sp, "base expression required after `..`")
196+
.span_label(*sp, "add a base expression here")
197+
.emit();
198+
Some(&*self.arena.alloc(self.expr_err(*sp)))
199+
}
200+
StructRest::None => None,
201+
};
192202
hir::ExprKind::Struct(
193203
self.arena.alloc(self.lower_qpath(
194204
e.id,
@@ -198,7 +208,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
198208
ImplTraitContext::disallowed(),
199209
)),
200210
self.arena.alloc_from_iter(fields.iter().map(|x| self.lower_field(x))),
201-
maybe_expr,
211+
rest,
202212
)
203213
}
204214
ExprKind::Yield(ref opt_expr) => self.lower_expr_yield(e.span, opt_expr.as_deref()),
@@ -851,20 +861,22 @@ impl<'hir> LoweringContext<'_, 'hir> {
851861
whole_span: Span,
852862
) -> hir::ExprKind<'hir> {
853863
// Return early in case of an ordinary assignment.
854-
fn is_ordinary(lhs: &Expr) -> bool {
864+
fn is_ordinary(lower_ctx: &mut LoweringContext<'_, '_>, lhs: &Expr) -> bool {
855865
match &lhs.kind {
856-
ExprKind::Tup(..) => false,
866+
ExprKind::Array(..) | ExprKind::Struct(..) | ExprKind::Tup(..) => false,
867+
// Check for tuple struct constructor.
868+
ExprKind::Call(callee, ..) => lower_ctx.extract_tuple_struct_path(callee).is_none(),
857869
ExprKind::Paren(e) => {
858870
match e.kind {
859871
// We special-case `(..)` for consistency with patterns.
860872
ExprKind::Range(None, None, RangeLimits::HalfOpen) => false,
861-
_ => is_ordinary(e),
873+
_ => is_ordinary(lower_ctx, e),
862874
}
863875
}
864876
_ => true,
865877
}
866878
}
867-
if is_ordinary(lhs) {
879+
if is_ordinary(self, lhs) {
868880
return hir::ExprKind::Assign(self.lower_expr(lhs), self.lower_expr(rhs), eq_sign_span);
869881
}
870882
if !self.sess.features_untracked().destructuring_assignment {
@@ -902,6 +914,26 @@ impl<'hir> LoweringContext<'_, 'hir> {
902914
hir::ExprKind::Block(&self.block_all(whole_span, stmts, None), None)
903915
}
904916

917+
/// If the given expression is a path to a tuple struct, returns that path.
918+
/// It is not a complete check, but just tries to reject most paths early
919+
/// if they are not tuple structs.
920+
/// Type checking will take care of the full validation later.
921+
fn extract_tuple_struct_path<'a>(&mut self, expr: &'a Expr) -> Option<&'a Path> {
922+
// For tuple struct destructuring, it must be a non-qualified path (like in patterns).
923+
if let ExprKind::Path(None, path) = &expr.kind {
924+
// Does the path resolves to something disallowed in a tuple struct/variant pattern?
925+
if let Some(partial_res) = self.resolver.get_partial_res(expr.id) {
926+
if partial_res.unresolved_segments() == 0
927+
&& !partial_res.base_res().expected_in_tuple_struct_pat()
928+
{
929+
return None;
930+
}
931+
}
932+
return Some(path);
933+
}
934+
None
935+
}
936+
905937
/// Convert the LHS of a destructuring assignment to a pattern.
906938
/// Each sub-assignment is recorded in `assignments`.
907939
fn destructure_assign(
@@ -911,6 +943,86 @@ impl<'hir> LoweringContext<'_, 'hir> {
911943
assignments: &mut Vec<hir::Stmt<'hir>>,
912944
) -> &'hir hir::Pat<'hir> {
913945
match &lhs.kind {
946+
// Slice patterns.
947+
ExprKind::Array(elements) => {
948+
let (pats, rest) =
949+
self.destructure_sequence(elements, "slice", eq_sign_span, assignments);
950+
let slice_pat = if let Some((i, span)) = rest {
951+
let (before, after) = pats.split_at(i);
952+
hir::PatKind::Slice(
953+
before,
954+
Some(self.pat_without_dbm(span, hir::PatKind::Wild)),
955+
after,
956+
)
957+
} else {
958+
hir::PatKind::Slice(pats, None, &[])
959+
};
960+
return self.pat_without_dbm(lhs.span, slice_pat);
961+
}
962+
// Tuple structs.
963+
ExprKind::Call(callee, args) => {
964+
if let Some(path) = self.extract_tuple_struct_path(callee) {
965+
let (pats, rest) = self.destructure_sequence(
966+
args,
967+
"tuple struct or variant",
968+
eq_sign_span,
969+
assignments,
970+
);
971+
let qpath = self.lower_qpath(
972+
callee.id,
973+
&None,
974+
path,
975+
ParamMode::Optional,
976+
ImplTraitContext::disallowed(),
977+
);
978+
// Destructure like a tuple struct.
979+
let tuple_struct_pat =
980+
hir::PatKind::TupleStruct(qpath, pats, rest.map(|r| r.0));
981+
return self.pat_without_dbm(lhs.span, tuple_struct_pat);
982+
}
983+
}
984+
// Structs.
985+
ExprKind::Struct(path, fields, rest) => {
986+
let field_pats = self.arena.alloc_from_iter(fields.iter().map(|f| {
987+
let pat = self.destructure_assign(&f.expr, eq_sign_span, assignments);
988+
hir::FieldPat {
989+
hir_id: self.next_id(),
990+
ident: f.ident,
991+
pat,
992+
is_shorthand: f.is_shorthand,
993+
span: f.span,
994+
}
995+
}));
996+
let qpath = self.lower_qpath(
997+
lhs.id,
998+
&None,
999+
path,
1000+
ParamMode::Optional,
1001+
ImplTraitContext::disallowed(),
1002+
);
1003+
let fields_omitted = match rest {
1004+
StructRest::Base(e) => {
1005+
self.sess
1006+
.struct_span_err(
1007+
e.span,
1008+
"functional record updates are not allowed in destructuring \
1009+
assignments",
1010+
)
1011+
.span_suggestion(
1012+
e.span,
1013+
"consider removing the trailing pattern",
1014+
String::new(),
1015+
rustc_errors::Applicability::MachineApplicable,
1016+
)
1017+
.emit();
1018+
true
1019+
}
1020+
StructRest::Rest(_) => true,
1021+
StructRest::None => false,
1022+
};
1023+
let struct_pat = hir::PatKind::Struct(qpath, field_pats, fields_omitted);
1024+
return self.pat_without_dbm(lhs.span, struct_pat);
1025+
}
9141026
// Tuples.
9151027
ExprKind::Tup(elements) => {
9161028
let (pats, rest) =

‎compiler/rustc_ast_passes/src/feature_gate.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -630,6 +630,7 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session) {
630630
gate_all!(const_trait_impl, "const trait impls are experimental");
631631
gate_all!(half_open_range_patterns, "half-open range patterns are unstable");
632632
gate_all!(inline_const, "inline-const is experimental");
633+
gate_all!(destructuring_assignment, "destructuring assignments are unstable");
633634

634635
// All uses of `gate_all!` below this point were added in #65742,
635636
// and subsequently disabled (with the non-early gating readded).

‎compiler/rustc_ast_pretty/src/pprust/state.rs

Lines changed: 10 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1729,7 +1729,7 @@ impl<'a> State<'a> {
17291729
&mut self,
17301730
path: &ast::Path,
17311731
fields: &[ast::Field],
1732-
wth: &Option<P<ast::Expr>>,
1732+
rest: &ast::StructRest,
17331733
attrs: &[ast::Attribute],
17341734
) {
17351735
self.print_path(path, true, 0);
@@ -1750,22 +1750,21 @@ impl<'a> State<'a> {
17501750
},
17511751
|f| f.span,
17521752
);
1753-
match *wth {
1754-
Some(ref expr) => {
1753+
match rest {
1754+
ast::StructRest::Base(_) | ast::StructRest::Rest(_) => {
17551755
self.ibox(INDENT_UNIT);
17561756
if !fields.is_empty() {
17571757
self.s.word(",");
17581758
self.s.space();
17591759
}
17601760
self.s.word("..");
1761-
self.print_expr(expr);
1762-
self.end();
1763-
}
1764-
_ => {
1765-
if !fields.is_empty() {
1766-
self.s.word(",")
1761+
if let ast::StructRest::Base(ref expr) = *rest {
1762+
self.print_expr(expr);
17671763
}
1764+
self.end();
17681765
}
1766+
ast::StructRest::None if !fields.is_empty() => self.s.word(","),
1767+
_ => {}
17691768
}
17701769
self.s.word("}");
17711770
}
@@ -1891,8 +1890,8 @@ impl<'a> State<'a> {
18911890
ast::ExprKind::Repeat(ref element, ref count) => {
18921891
self.print_expr_repeat(element, count, attrs);
18931892
}
1894-
ast::ExprKind::Struct(ref path, ref fields, ref wth) => {
1895-
self.print_expr_struct(path, &fields[..], wth, attrs);
1893+
ast::ExprKind::Struct(ref path, ref fields, ref rest) => {
1894+
self.print_expr_struct(path, &fields[..], rest, attrs);
18961895
}
18971896
ast::ExprKind::Tup(ref exprs) => {
18981897
self.print_expr_tup(&exprs[..], attrs);

‎compiler/rustc_expand/src/build.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -298,7 +298,7 @@ impl<'a> ExtCtxt<'a> {
298298
path: ast::Path,
299299
fields: Vec<ast::Field>,
300300
) -> P<ast::Expr> {
301-
self.expr(span, ast::ExprKind::Struct(path, fields, None))
301+
self.expr(span, ast::ExprKind::Struct(path, fields, ast::StructRest::None))
302302
}
303303
pub fn expr_struct_ident(
304304
&self,

‎compiler/rustc_hir/src/def.rs

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -484,4 +484,9 @@ impl<Id> Res<Id> {
484484
pub fn matches_ns(&self, ns: Namespace) -> bool {
485485
self.ns().map_or(true, |actual_ns| actual_ns == ns)
486486
}
487+
488+
/// Returns whether such a resolved path can occur in a tuple struct/variant pattern
489+
pub fn expected_in_tuple_struct_pat(&self) -> bool {
490+
matches!(self, Res::Def(DefKind::Ctor(_, CtorKind::Fn), _) | Res::SelfCtor(..))
491+
}
487492
}

‎compiler/rustc_parse/src/parser/expr.rs

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2087,7 +2087,7 @@ impl<'a> Parser<'a> {
20872087
recover: bool,
20882088
) -> PResult<'a, P<Expr>> {
20892089
let mut fields = Vec::new();
2090-
let mut base = None;
2090+
let mut base = ast::StructRest::None;
20912091
let mut recover_async = false;
20922092

20932093
attrs.extend(self.parse_inner_attributes()?);
@@ -2102,8 +2102,14 @@ impl<'a> Parser<'a> {
21022102
while self.token != token::CloseDelim(token::Brace) {
21032103
if self.eat(&token::DotDot) {
21042104
let exp_span = self.prev_token.span;
2105+
// We permit `.. }` on the left-hand side of a destructuring assignment.
2106+
if self.check(&token::CloseDelim(token::Brace)) {
2107+
self.sess.gated_spans.gate(sym::destructuring_assignment, self.prev_token.span);
2108+
base = ast::StructRest::Rest(self.prev_token.span.shrink_to_hi());
2109+
break;
2110+
}
21052111
match self.parse_expr() {
2106-
Ok(e) => base = Some(e),
2112+
Ok(e) => base = ast::StructRest::Base(e),
21072113
Err(mut e) if recover => {
21082114
e.emit();
21092115
self.recover_stmt();

‎compiler/rustc_resolve/src/late.rs

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -298,9 +298,7 @@ impl<'a> PathSource<'a> {
298298
_,
299299
)
300300
| Res::SelfCtor(..)),
301-
PathSource::TupleStruct(..) => {
302-
matches!(res, Res::Def(DefKind::Ctor(_, CtorKind::Fn), _) | Res::SelfCtor(..))
303-
}
301+
PathSource::TupleStruct(..) => res.expected_in_tuple_struct_pat(),
304302
PathSource::Struct => matches!(res, Res::Def(
305303
DefKind::Struct
306304
| DefKind::Union

‎compiler/rustc_save_analysis/src/dump_visitor.rs

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -816,7 +816,7 @@ impl<'tcx> DumpVisitor<'tcx> {
816816
path: &'tcx hir::QPath<'tcx>,
817817
fields: &'tcx [hir::Field<'tcx>],
818818
variant: &'tcx ty::VariantDef,
819-
base: Option<&'tcx hir::Expr<'tcx>>,
819+
rest: Option<&'tcx hir::Expr<'tcx>>,
820820
) {
821821
if let Some(struct_lit_data) = self.save_ctxt.get_expr_data(ex) {
822822
if let hir::QPath::Resolved(_, path) = path {
@@ -836,7 +836,9 @@ impl<'tcx> DumpVisitor<'tcx> {
836836
}
837837
}
838838

839-
walk_list!(self, visit_expr, base);
839+
if let Some(base) = rest {
840+
self.visit_expr(&base);
841+
}
840842
}
841843

842844
fn process_method_call(
@@ -1399,7 +1401,7 @@ impl<'tcx> Visitor<'tcx> for DumpVisitor<'tcx> {
13991401
debug!("visit_expr {:?}", ex.kind);
14001402
self.process_macro_use(ex.span);
14011403
match ex.kind {
1402-
hir::ExprKind::Struct(ref path, ref fields, ref base) => {
1404+
hir::ExprKind::Struct(ref path, ref fields, ref rest) => {
14031405
let hir_expr = self.save_ctxt.tcx.hir().expect_expr(ex.hir_id);
14041406
let adt = match self.save_ctxt.typeck_results().expr_ty_opt(&hir_expr) {
14051407
Some(ty) if ty.ty_adt_def().is_some() => ty.ty_adt_def().unwrap(),
@@ -1409,7 +1411,7 @@ impl<'tcx> Visitor<'tcx> for DumpVisitor<'tcx> {
14091411
}
14101412
};
14111413
let res = self.save_ctxt.get_path_res(hir_expr.hir_id);
1412-
self.process_struct_lit(ex, path, fields, adt.variant_of_res(res), *base)
1414+
self.process_struct_lit(ex, path, fields, adt.variant_of_res(res), *rest)
14131415
}
14141416
hir::ExprKind::MethodCall(ref seg, _, args, _) => {
14151417
self.process_method_call(ex, seg, args)

‎src/test/ui-fulldeps/pprust-expr-roundtrip.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -155,7 +155,7 @@ fn iter_exprs(depth: usize, f: &mut dyn FnMut(P<Expr>)) {
155155
},
156156
17 => {
157157
let path = Path::from_ident(Ident::from_str("S"));
158-
g(ExprKind::Struct(path, vec![], Some(make_x())));
158+
g(ExprKind::Struct(path, vec![], StructRest::Base(make_x())));
159159
},
160160
18 => {
161161
iter_exprs(depth - 1, &mut |e| g(ExprKind::Try(e)));

‎src/test/ui/destructuring-assignment/nested_destructure.rs

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
// run-pass
2+
3+
#![feature(destructuring_assignment)]
4+
5+
struct Struct<S, T> {
6+
a: S,
7+
b: T,
8+
}
9+
10+
struct TupleStruct<S, T>(S, T);
11+
12+
fn main() {
13+
let (a, b, c, d);
14+
Struct { a: TupleStruct((a, b), c), b: [d] } =
15+
Struct { a: TupleStruct((0, 1), 2), b: [3] };
16+
assert_eq!((a, b, c, d), (0, 1, 2, 3));
17+
}

‎src/test/ui/destructuring-assignment/note-unsupported.rs

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -7,18 +7,19 @@ fn main() {
77
(a, b) += (3, 4); //~ ERROR invalid left-hand side of assignment
88
//~| ERROR binary assignment operation `+=` cannot be applied
99

10-
[a, b] = [3, 4]; //~ ERROR invalid left-hand side of assignment
10+
[a, b] = [3, 4]; //~ ERROR destructuring assignments are unstable
1111
[a, b] += [3, 4]; //~ ERROR invalid left-hand side of assignment
1212
//~| ERROR binary assignment operation `+=` cannot be applied
1313

1414
let s = S { x: 3, y: 4 };
1515

16-
S { x: a, y: b } = s; //~ ERROR invalid left-hand side of assignment
16+
S { x: a, y: b } = s; //~ ERROR destructuring assignments are unstable
1717
S { x: a, y: b } += s; //~ ERROR invalid left-hand side of assignment
1818
//~| ERROR binary assignment operation `+=` cannot be applied
1919

2020
S { x: a, ..s } = S { x: 3, y: 4 };
21-
//~^ ERROR invalid left-hand side of assignment
21+
//~^ ERROR functional record updates are not allowed in destructuring assignments
22+
//~| ERROR destructuring assignments are unstable
2223

2324
let c = 3;
2425

‎src/test/ui/destructuring-assignment/note-unsupported.stderr

Lines changed: 42 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,46 @@ LL | (a, b) = (3, 4);
1010
= help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
1111

1212
error[E0658]: destructuring assignments are unstable
13-
--> $DIR/note-unsupported.rs:25:17
13+
--> $DIR/note-unsupported.rs:10:12
14+
|
15+
LL | [a, b] = [3, 4];
16+
| ------ ^
17+
| |
18+
| cannot assign to this expression
19+
|
20+
= note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
21+
= help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
22+
23+
error[E0658]: destructuring assignments are unstable
24+
--> $DIR/note-unsupported.rs:16:22
25+
|
26+
LL | S { x: a, y: b } = s;
27+
| ---------------- ^
28+
| |
29+
| cannot assign to this expression
30+
|
31+
= note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
32+
= help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
33+
34+
error[E0658]: destructuring assignments are unstable
35+
--> $DIR/note-unsupported.rs:20:21
36+
|
37+
LL | S { x: a, ..s } = S { x: 3, y: 4 };
38+
| --------------- ^
39+
| |
40+
| cannot assign to this expression
41+
|
42+
= note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
43+
= help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
44+
45+
error: functional record updates are not allowed in destructuring assignments
46+
--> $DIR/note-unsupported.rs:20:17
47+
|
48+
LL | S { x: a, ..s } = S { x: 3, y: 4 };
49+
| ^ help: consider removing the trailing pattern
50+
51+
error[E0658]: destructuring assignments are unstable
52+
--> $DIR/note-unsupported.rs:26:17
1453
|
1554
LL | ((a, b), c) = ((3, 4), 5);
1655
| ----------- ^
@@ -36,14 +75,6 @@ LL | (a, b) += (3, 4);
3675
| |
3776
| cannot assign to this expression
3877

39-
error[E0070]: invalid left-hand side of assignment
40-
--> $DIR/note-unsupported.rs:10:12
41-
|
42-
LL | [a, b] = [3, 4];
43-
| ------ ^
44-
| |
45-
| cannot assign to this expression
46-
4778
error[E0368]: binary assignment operation `+=` cannot be applied to type `[{integer}; 2]`
4879
--> $DIR/note-unsupported.rs:11:5
4980
|
@@ -60,14 +91,6 @@ LL | [a, b] += [3, 4];
6091
| |
6192
| cannot assign to this expression
6293

63-
error[E0070]: invalid left-hand side of assignment
64-
--> $DIR/note-unsupported.rs:16:22
65-
|
66-
LL | S { x: a, y: b } = s;
67-
| ---------------- ^
68-
| |
69-
| cannot assign to this expression
70-
7194
error[E0368]: binary assignment operation `+=` cannot be applied to type `S`
7295
--> $DIR/note-unsupported.rs:17:5
7396
|
@@ -86,15 +109,7 @@ LL | S { x: a, y: b } += s;
86109
| |
87110
| cannot assign to this expression
88111

89-
error[E0070]: invalid left-hand side of assignment
90-
--> $DIR/note-unsupported.rs:20:21
91-
|
92-
LL | S { x: a, ..s } = S { x: 3, y: 4 };
93-
| --------------- ^
94-
| |
95-
| cannot assign to this expression
96-
97-
error: aborting due to 11 previous errors
112+
error: aborting due to 12 previous errors
98113

99-
Some errors have detailed explanations: E0067, E0070, E0368, E0658.
114+
Some errors have detailed explanations: E0067, E0368, E0658.
100115
For more information about an error, try `rustc --explain E0067`.

‎src/test/ui/destructuring-assignment/slice_destructure.rs

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
// run-pass
2+
3+
#![feature(destructuring_assignment)]
4+
5+
fn main() {
6+
let (mut a, mut b);
7+
[a, b] = [0, 1];
8+
assert_eq!((a, b), (0, 1));
9+
let mut c;
10+
[a, .., b, c] = [1, 2, 3, 4, 5];
11+
assert_eq!((a, b, c), (1, 4, 5));
12+
[..] = [1, 2, 3];
13+
[c, ..] = [5, 6, 6];
14+
assert_eq!(c, 5);
15+
}

‎src/test/ui/destructuring-assignment/slice_destructure_fail.rs

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,7 @@
1+
#![feature(destructuring_assignment)]
2+
3+
fn main() {
4+
let (mut a, mut b);
5+
[a, .., b, ..] = [0, 1]; //~ ERROR `..` can only be used once per slice pattern
6+
[a, a, b] = [1, 2]; //~ ERROR pattern requires 3 elements but array has 2
7+
}

‎src/test/ui/destructuring-assignment/slice_destructure_fail.stderr

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
error: `..` can only be used once per slice pattern
2+
--> $DIR/slice_destructure_fail.rs:5:14
3+
|
4+
LL | [a, .., b, ..] = [0, 1];
5+
| -- ^^ can only be used once per slice pattern
6+
| |
7+
| previously used here
8+
9+
error[E0527]: pattern requires 3 elements but array has 2
10+
--> $DIR/slice_destructure_fail.rs:6:3
11+
|
12+
LL | [a, a, b] = [1, 2];
13+
| ^^^^^^^^^ expected 2 elements
14+
15+
error: aborting due to 2 previous errors
16+
17+
For more information about this error, try `rustc --explain E0527`.

‎src/test/ui/destructuring-assignment/struct_destructure.rs

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
// run-pass
2+
3+
#![feature(destructuring_assignment)]
4+
struct Struct<S, T> {
5+
a: S,
6+
b: T,
7+
}
8+
9+
fn main() {
10+
let (mut a, mut b);
11+
Struct { a, b } = Struct { a: 0, b: 1 };
12+
assert_eq!((a, b), (0, 1));
13+
Struct { a: b, b: a } = Struct { a: 1, b: 2 };
14+
assert_eq!((a,b), (2, 1));
15+
Struct { a, .. } = Struct { a: 1, b: 3 };
16+
assert_eq!((a, b), (1, 1));
17+
Struct { .. } = Struct { a: 1, b: 4 };
18+
assert_eq!((a, b), (1, 1));
19+
}

‎src/test/ui/destructuring-assignment/struct_destructure_fail.rs

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
#![feature(destructuring_assignment)]
2+
struct Struct<S, T> {
3+
a: S,
4+
b: T,
5+
}
6+
7+
fn main() {
8+
let (mut a, b);
9+
let mut c;
10+
let d = Struct { a: 0, b: 1 };
11+
Struct { a, b, c } = Struct { a: 0, b: 1 }; //~ ERROR does not have a field named `c`
12+
Struct { a, ..d } = Struct { a: 1, b: 2 };
13+
//~^ ERROR functional record updates are not allowed in destructuring assignments
14+
Struct { a, .. }; //~ ERROR base expression required after `..`
15+
}

‎src/test/ui/destructuring-assignment/struct_destructure_fail.stderr

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
error: functional record updates are not allowed in destructuring assignments
2+
--> $DIR/struct_destructure_fail.rs:12:19
3+
|
4+
LL | Struct { a, ..d } = Struct { a: 1, b: 2 };
5+
| ^ help: consider removing the trailing pattern
6+
7+
error: base expression required after `..`
8+
--> $DIR/struct_destructure_fail.rs:14:19
9+
|
10+
LL | Struct { a, .. };
11+
| ^ add a base expression here
12+
13+
error[E0026]: struct `Struct` does not have a field named `c`
14+
--> $DIR/struct_destructure_fail.rs:11:20
15+
|
16+
LL | Struct { a, b, c } = Struct { a: 0, b: 1 };
17+
| ^ struct `Struct` does not have this field
18+
19+
error: aborting due to 3 previous errors
20+
21+
For more information about this error, try `rustc --explain E0026`.

‎src/test/ui/destructuring-assignment/tuple_struct_destructure.rs

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
// run-pass
2+
3+
#![feature(destructuring_assignment)]
4+
5+
struct TupleStruct<S, T>(S, T);
6+
7+
impl<S, T> TupleStruct<S, T> {
8+
fn assign(self, first: &mut S, second: &mut T) {
9+
// Test usage of `Self` instead of the struct name:
10+
Self(*first, *second) = self
11+
}
12+
}
13+
14+
enum Enum<S, T> {
15+
SingleVariant(S, T)
16+
}
17+
18+
type Alias<S> = Enum<S, isize>;
19+
20+
fn main() {
21+
let (mut a, mut b);
22+
TupleStruct(a, b) = TupleStruct(0, 1);
23+
assert_eq!((a, b), (0, 1));
24+
TupleStruct(a, .., b) = TupleStruct(1, 2);
25+
assert_eq!((a, b), (1, 2));
26+
TupleStruct(..) = TupleStruct(3, 4);
27+
assert_eq!((a, b), (1, 2));
28+
TupleStruct(5,6).assign(&mut a, &mut b);
29+
assert_eq!((a, b), (5, 6));
30+
Enum::SingleVariant(a, b) = Enum::SingleVariant(7, 8);
31+
assert_eq!((a, b), (7, 8));
32+
Alias::SingleVariant(a, b) = Alias::SingleVariant(9, 10);
33+
assert_eq!((a, b), (9, 10));
34+
}

‎src/test/ui/destructuring-assignment/tuple_struct_destructure_fail.rs

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
1+
#![feature(destructuring_assignment)]
2+
3+
struct TupleStruct<S, T>(S, T);
4+
5+
enum Enum<S, T> {
6+
SingleVariant(S, T)
7+
}
8+
9+
type Alias<S> = Enum<S, isize>;
10+
11+
trait Test {
12+
fn test() -> TupleStruct<isize, isize> {
13+
TupleStruct(0, 0)
14+
}
15+
}
16+
17+
impl Test for Alias<isize> {}
18+
19+
fn test() -> TupleStruct<isize, isize> {
20+
TupleStruct(0, 0)
21+
}
22+
23+
fn main() {
24+
let (mut a, mut b);
25+
TupleStruct(a, .., b, ..) = TupleStruct(0, 1);
26+
//~^ ERROR `..` can only be used once per tuple struct or variant pattern
27+
Enum::SingleVariant(a, .., b, ..) = Enum::SingleVariant(0, 1);
28+
//~^ ERROR `..` can only be used once per tuple struct or variant pattern
29+
30+
TupleStruct(a, a, b) = TupleStruct(1, 2);
31+
//~^ ERROR this pattern has 3 fields, but the corresponding tuple struct has 2 fields
32+
Enum::SingleVariant(a, a, b) = Enum::SingleVariant(1, 2);
33+
//~^ ERROR this pattern has 3 fields, but the corresponding tuple variant has 2 fields
34+
35+
// Check if `test` is recognized as not a tuple struct but a function call:
36+
test() = TupleStruct(0, 0);
37+
//~^ ERROR invalid left-hand side of assignment
38+
(test)() = TupleStruct(0, 0);
39+
//~^ ERROR invalid left-hand side of assignment
40+
<Alias::<isize> as Test>::test() = TupleStruct(0, 0);
41+
//~^ ERROR invalid left-hand side of assignment
42+
}

‎src/test/ui/destructuring-assignment/tuple_struct_destructure_fail.stderr

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
error: `..` can only be used once per tuple struct or variant pattern
2+
--> $DIR/tuple_struct_destructure_fail.rs:25:27
3+
|
4+
LL | TupleStruct(a, .., b, ..) = TupleStruct(0, 1);
5+
| -- ^^ can only be used once per tuple struct or variant pattern
6+
| |
7+
| previously used here
8+
9+
error: `..` can only be used once per tuple struct or variant pattern
10+
--> $DIR/tuple_struct_destructure_fail.rs:27:35
11+
|
12+
LL | Enum::SingleVariant(a, .., b, ..) = Enum::SingleVariant(0, 1);
13+
| -- ^^ can only be used once per tuple struct or variant pattern
14+
| |
15+
| previously used here
16+
17+
error[E0023]: this pattern has 3 fields, but the corresponding tuple struct has 2 fields
18+
--> $DIR/tuple_struct_destructure_fail.rs:30:5
19+
|
20+
LL | struct TupleStruct<S, T>(S, T);
21+
| ------------------------------- tuple struct defined here
22+
...
23+
LL | TupleStruct(a, a, b) = TupleStruct(1, 2);
24+
| ^^^^^^^^^^^^^^^^^^^^ expected 2 fields, found 3
25+
26+
error[E0023]: this pattern has 3 fields, but the corresponding tuple variant has 2 fields
27+
--> $DIR/tuple_struct_destructure_fail.rs:32:5
28+
|
29+
LL | SingleVariant(S, T)
30+
| ------------------- tuple variant defined here
31+
...
32+
LL | Enum::SingleVariant(a, a, b) = Enum::SingleVariant(1, 2);
33+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected 2 fields, found 3
34+
35+
error[E0070]: invalid left-hand side of assignment
36+
--> $DIR/tuple_struct_destructure_fail.rs:36:12
37+
|
38+
LL | test() = TupleStruct(0, 0);
39+
| ------ ^
40+
| |
41+
| cannot assign to this expression
42+
43+
error[E0070]: invalid left-hand side of assignment
44+
--> $DIR/tuple_struct_destructure_fail.rs:38:14
45+
|
46+
LL | (test)() = TupleStruct(0, 0);
47+
| -------- ^
48+
| |
49+
| cannot assign to this expression
50+
51+
error[E0070]: invalid left-hand side of assignment
52+
--> $DIR/tuple_struct_destructure_fail.rs:40:38
53+
|
54+
LL | <Alias::<isize> as Test>::test() = TupleStruct(0, 0);
55+
| -------------------------------- ^
56+
| |
57+
| cannot assign to this expression
58+
59+
error: aborting due to 7 previous errors
60+
61+
Some errors have detailed explanations: E0023, E0070.
62+
For more information about an error, try `rustc --explain E0023`.

‎src/test/ui/destructuring-assignment/underscore-range-expr-gating.rs

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
fn main() {}
2+
3+
struct S { x : u32 }
4+
5+
#[cfg(FALSE)]
6+
fn foo() {
7+
S { x: 5, .. }; //~ ERROR destructuring assignments are unstable
8+
}

‎src/test/ui/destructuring-assignment/underscore-range-expr-gating.stderr

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
error[E0658]: destructuring assignments are unstable
2+
--> $DIR/underscore-range-expr-gating.rs:7:15
3+
|
4+
LL | S { x: 5, .. };
5+
| ^^
6+
|
7+
= note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
8+
= help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
9+
10+
error: aborting due to previous error
11+
12+
For more information about this error, try `rustc --explain E0658`.

‎src/test/ui/issues/issue-77218.rs

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,11 @@
11
fn main() {
22
let value = [7u8];
3-
while Some(0) = value.get(0) { //~ ERROR mismatched types
4-
//~^ NOTE expected `bool`, found `()`
5-
//~| HELP you might have meant to use pattern matching
3+
while Some(0) = value.get(0) { //~ ERROR destructuring assignments are unstable
4+
//~| ERROR invalid left-hand side of assignment
5+
//~| ERROR mismatched types
6+
//~| ERROR mismatched types
7+
8+
// FIXME The following diagnostic should also be emitted
9+
// HELP you might have meant to use pattern matching
610
}
711
}

‎src/test/ui/issues/issue-77218.stderr

Lines changed: 31 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,38 @@
1+
error[E0658]: destructuring assignments are unstable
2+
--> $DIR/issue-77218.rs:3:19
3+
|
4+
LL | while Some(0) = value.get(0) {
5+
| ------- ^
6+
| |
7+
| cannot assign to this expression
8+
|
9+
= note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
10+
= help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
11+
12+
error[E0070]: invalid left-hand side of assignment
13+
--> $DIR/issue-77218.rs:3:19
14+
|
15+
LL | while Some(0) = value.get(0) {
16+
| - ^
17+
| |
18+
| cannot assign to this expression
19+
20+
error[E0308]: mismatched types
21+
--> $DIR/issue-77218.rs:3:16
22+
|
23+
LL | while Some(0) = value.get(0) {
24+
| ^
25+
| |
26+
| expected integer, found `&u8`
27+
| help: consider dereferencing the borrow: `*0`
28+
129
error[E0308]: mismatched types
230
--> $DIR/issue-77218.rs:3:11
331
|
432
LL | while Some(0) = value.get(0) {
533
| ^^^^^^^^^^^^^^^^^^^^^^ expected `bool`, found `()`
6-
|
7-
help: you might have meant to use pattern matching
8-
|
9-
LL | while let Some(0) = value.get(0) {
10-
| ^^^
1134

12-
error: aborting due to previous error
35+
error: aborting due to 4 previous errors
1336

14-
For more information about this error, try `rustc --explain E0308`.
37+
Some errors have detailed explanations: E0070, E0308, E0658.
38+
For more information about an error, try `rustc --explain E0070`.

‎src/test/ui/suggestions/if-let-typo.rs

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,12 @@ fn main() {
22
let foo = Some(0);
33
let bar = None;
44
if Some(x) = foo {} //~ ERROR cannot find value `x` in this scope
5+
//~^ ERROR mismatched types
6+
//~^^ ERROR destructuring assignments are unstable
57
if Some(foo) = bar {} //~ ERROR mismatched types
8+
//~^ ERROR destructuring assignments are unstable
69
if 3 = foo {} //~ ERROR mismatched types
710
if Some(3) = foo {} //~ ERROR mismatched types
11+
//~^ ERROR destructuring assignments are unstable
12+
//~^^ ERROR invalid left-hand side of assignment
813
}

‎src/test/ui/suggestions/if-let-typo.stderr

Lines changed: 52 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -9,23 +9,53 @@ help: you might have meant to use pattern matching
99
LL | if let Some(x) = foo {}
1010
| ^^^
1111

12-
error[E0308]: mismatched types
13-
--> $DIR/if-let-typo.rs:5:8
12+
error[E0658]: destructuring assignments are unstable
13+
--> $DIR/if-let-typo.rs:4:16
14+
|
15+
LL | if Some(x) = foo {}
16+
| ------- ^
17+
| |
18+
| cannot assign to this expression
19+
|
20+
= note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
21+
= help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
22+
23+
error[E0658]: destructuring assignments are unstable
24+
--> $DIR/if-let-typo.rs:7:18
1425
|
1526
LL | if Some(foo) = bar {}
16-
| ^^^^^^^^^^^^^^^ expected `bool`, found `()`
27+
| --------- ^
28+
| |
29+
| cannot assign to this expression
1730
|
18-
help: you might have meant to use pattern matching
31+
= note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
32+
= help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
33+
34+
error[E0658]: destructuring assignments are unstable
35+
--> $DIR/if-let-typo.rs:10:16
1936
|
20-
LL | if let Some(foo) = bar {}
21-
| ^^^
22-
help: you might have meant to compare for equality
37+
LL | if Some(3) = foo {}
38+
| ------- ^
39+
| |
40+
| cannot assign to this expression
41+
|
42+
= note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
43+
= help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
44+
45+
error[E0308]: mismatched types
46+
--> $DIR/if-let-typo.rs:4:8
47+
|
48+
LL | if Some(x) = foo {}
49+
| ^^^^^^^^^^^^^ expected `bool`, found `()`
50+
51+
error[E0308]: mismatched types
52+
--> $DIR/if-let-typo.rs:7:8
2353
|
24-
LL | if Some(foo) == bar {}
25-
| ^^
54+
LL | if Some(foo) = bar {}
55+
| ^^^^^^^^^^^^^^^ expected `bool`, found `()`
2656

2757
error[E0308]: mismatched types
28-
--> $DIR/if-let-typo.rs:6:8
58+
--> $DIR/if-let-typo.rs:9:8
2959
|
3060
LL | if 3 = foo {}
3161
| ^^^^^^^ expected `bool`, found `()`
@@ -35,22 +65,21 @@ help: you might have meant to use pattern matching
3565
LL | if let 3 = foo {}
3666
| ^^^
3767

68+
error[E0070]: invalid left-hand side of assignment
69+
--> $DIR/if-let-typo.rs:10:16
70+
|
71+
LL | if Some(3) = foo {}
72+
| - ^
73+
| |
74+
| cannot assign to this expression
75+
3876
error[E0308]: mismatched types
39-
--> $DIR/if-let-typo.rs:7:8
77+
--> $DIR/if-let-typo.rs:10:8
4078
|
4179
LL | if Some(3) = foo {}
4280
| ^^^^^^^^^^^^^ expected `bool`, found `()`
43-
|
44-
help: you might have meant to use pattern matching
45-
|
46-
LL | if let Some(3) = foo {}
47-
| ^^^
48-
help: you might have meant to compare for equality
49-
|
50-
LL | if Some(3) == foo {}
51-
| ^^
5281

53-
error: aborting due to 4 previous errors
82+
error: aborting due to 9 previous errors
5483

55-
Some errors have detailed explanations: E0308, E0425.
56-
For more information about an error, try `rustc --explain E0308`.
84+
Some errors have detailed explanations: E0070, E0308, E0425, E0658.
85+
For more information about an error, try `rustc --explain E0070`.

‎src/tools/clippy/clippy_lints/src/utils/ast_utils.rs

Lines changed: 10 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -107,6 +107,15 @@ pub fn eq_expr_opt(l: &Option<P<Expr>>, r: &Option<P<Expr>>) -> bool {
107107
both(l, r, |l, r| eq_expr(l, r))
108108
}
109109

110+
pub fn eq_struct_rest(l: &StructRest, r: &StructRest) -> bool {
111+
match (l, r) {
112+
(StructRest::Base(lb), StructRest::Base(rb)) => eq_expr(lb, rb),
113+
(StructRest::Rest(_), StructRest::Rest(_)) => true,
114+
(StructRest::None, StructRest::None) => true,
115+
_ => false,
116+
}
117+
}
118+
110119
pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
111120
use ExprKind::*;
112121
if !over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r)) {
@@ -150,7 +159,7 @@ pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
150159
(Path(lq, lp), Path(rq, rp)) => both(lq, rq, |l, r| eq_qself(l, r)) && eq_path(lp, rp),
151160
(MacCall(l), MacCall(r)) => eq_mac_call(l, r),
152161
(Struct(lp, lfs, lb), Struct(rp, rfs, rb)) => {
153-
eq_path(lp, rp) && eq_expr_opt(lb, rb) && unordered_over(lfs, rfs, |l, r| eq_field(l, r))
162+
eq_path(lp, rp) && eq_struct_rest(lb, rb) && unordered_over(lfs, rfs, |l, r| eq_field(l, r))
154163
},
155164
_ => false,
156165
}

‎src/tools/clippy/tests/ui/crashes/ice-6250.stderr

Lines changed: 22 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,14 @@
1+
error[E0658]: destructuring assignments are unstable
2+
--> $DIR/ice-6250.rs:12:25
3+
|
4+
LL | Some(reference) = cache.data.get(key) {
5+
| --------------- ^
6+
| |
7+
| cannot assign to this expression
8+
|
9+
= note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
10+
= help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
11+
112
error[E0601]: `main` function not found in crate `ice_6250`
213
--> $DIR/ice-6250.rs:4:1
314
|
@@ -10,18 +21,22 @@ LL | | }
1021
LL | | }
1122
| |_^ consider adding a `main` function to `$DIR/ice-6250.rs`
1223

24+
error[E0308]: mismatched types
25+
--> $DIR/ice-6250.rs:12:14
26+
|
27+
LL | Some(reference) = cache.data.get(key) {
28+
| ^^^^^^^^^
29+
| |
30+
| expected integer, found `&i32`
31+
| help: consider dereferencing the borrow: `*reference`
32+
1333
error[E0308]: mismatched types
1434
--> $DIR/ice-6250.rs:12:9
1535
|
1636
LL | Some(reference) = cache.data.get(key) {
1737
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `bool`, found `()`
18-
|
19-
help: you might have meant to use pattern matching
20-
|
21-
LL | let Some(reference) = cache.data.get(key) {
22-
| ^^^
2338

24-
error: aborting due to 2 previous errors
39+
error: aborting due to 4 previous errors
2540

26-
Some errors have detailed explanations: E0308, E0601.
41+
Some errors have detailed explanations: E0308, E0601, E0658.
2742
For more information about an error, try `rustc --explain E0308`.

0 commit comments

Comments
 (0)
Please sign in to comment.