Prevent default match bindings in destructuring assignment

varkor · fanzier · commit a0d4c5509ea6 · 2020-11-04T14:25:45.000Z
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
@@ -945,19 +945,23 @@ impl<'hir> LoweringContext<'_, 'hir> {
         match &lhs.kind {
             // Underscore pattern.
             ExprKind::Underscore => {
-                return self.pat(lhs.span, hir::PatKind::Wild);
+                return self.pat_without_dbm(lhs.span, hir::PatKind::Wild);
             }
             // Slice patterns.
             ExprKind::Array(elements) => {
                 let (pats, rest) =
                     self.destructure_sequence(elements, "slice", eq_sign_span, assignments);
                 let slice_pat = if let Some((i, span)) = rest {
                     let (before, after) = pats.split_at(i);
-                    hir::PatKind::Slice(before, Some(self.pat(span, hir::PatKind::Wild)), after)
+                    hir::PatKind::Slice(
+                        before,
+                        Some(self.pat_without_dbm(span, hir::PatKind::Wild)),
+                        after,
+                    )
                 } else {
                     hir::PatKind::Slice(pats, None, &[])
                 };
-                return self.pat(lhs.span, slice_pat);
+                return self.pat_without_dbm(lhs.span, slice_pat);
             }
             // Tuple structs.
             ExprKind::Call(callee, args) => {
@@ -979,7 +983,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             // Destructure like a tuple struct since the path is in fact a constructor.
                             let tuple_struct_pat =
                                 hir::PatKind::TupleStruct(qpath, pats, rest.map(|r| r.0));
-                            return self.pat(lhs.span, tuple_struct_pat);
+                            return self.pat_without_dbm(lhs.span, tuple_struct_pat);
                         }
                         _ => {
                             // If the path is not a constructor, lower as an ordinary LHS.
@@ -1028,20 +1032,20 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     StructRest::None => false,
                 };
                 let struct_pat = hir::PatKind::Struct(qpath, field_pats, fields_omitted);
-                return self.pat(lhs.span, struct_pat);
+                return self.pat_without_dbm(lhs.span, struct_pat);
             }
             // Tuples.
             ExprKind::Tup(elements) => {
                 let (pats, rest) =
                     self.destructure_sequence(elements, "tuple", eq_sign_span, assignments);
                 let tuple_pat = hir::PatKind::Tuple(pats, rest.map(|r| r.0));
-                return self.pat(lhs.span, tuple_pat);
+                return self.pat_without_dbm(lhs.span, tuple_pat);
             }
             // `(..)`. We special-case this for consistency with declarations.
             ExprKind::Paren(e) => {
                 if let ExprKind::Range(None, None, RangeLimits::HalfOpen) = e.kind {
                     let tuple_pat = hir::PatKind::Tuple(&[], Some(0));
-                    return self.pat(lhs.span, tuple_pat);
+                    return self.pat_without_dbm(lhs.span, tuple_pat);
                 }
             }
             _ => {}
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2531,6 +2531,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 hir_id,
                 kind: hir::PatKind::Binding(bm, hir_id, ident.with_span_pos(span), None),
                 span,
+                default_binding_modes: true,
             }),
             hir_id,
         )
@@ -2541,7 +2542,21 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     fn pat(&mut self, span: Span, kind: hir::PatKind<'hir>) -> &'hir hir::Pat<'hir> {
-        self.arena.alloc(hir::Pat { hir_id: self.next_id(), kind, span })
+        self.arena.alloc(hir::Pat {
+            hir_id: self.next_id(),
+            kind,
+            span,
+            default_binding_modes: true,
+        })
+    }
+
+    fn pat_without_dbm(&mut self, span: Span, kind: hir::PatKind<'hir>) -> &'hir hir::Pat<'hir> {
+        self.arena.alloc(hir::Pat {
+            hir_id: self.next_id(),
+            kind,
+            span,
+            default_binding_modes: false,
+        })
     }
 
     fn ty_path(
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
@@ -273,7 +273,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
     /// Construct a `Pat` with the `HirId` of `p.id` lowered.
     fn pat_with_node_id_of(&mut self, p: &Pat, kind: hir::PatKind<'hir>) -> &'hir hir::Pat<'hir> {
-        self.arena.alloc(hir::Pat { hir_id: self.lower_node_id(p.id), kind, span: p.span })
+        self.arena.alloc(hir::Pat {
+            hir_id: self.lower_node_id(p.id),
+            kind,
+            span: p.span,
+            default_binding_modes: true,
+        })
     }
 
     /// Emit a friendly error for extra `..` patterns in a tuple/tuple struct/slice pattern.
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -732,6 +732,9 @@ pub struct Pat<'hir> {
     pub hir_id: HirId,
     pub kind: PatKind<'hir>,
     pub span: Span,
+    // Whether to use default binding modes.
+    // At present, this is false only for destructuring assignment.
+    pub default_binding_modes: bool,
 }
 
 impl Pat<'_> {
diff --git a/compiler/rustc_typeck/src/check/pat.rs b/compiler/rustc_typeck/src/check/pat.rs
@@ -270,6 +270,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     ///
     /// When the pattern is a path pattern, `opt_path_res` must be `Some(res)`.
     fn calc_adjust_mode(&self, pat: &'tcx Pat<'tcx>, opt_path_res: Option<Res>) -> AdjustMode {
+        // When we perform destructuring assignment, we disable default match bindings, which are
+        // unintuitive in this context.
+        if !pat.default_binding_modes {
+            return AdjustMode::Reset;
+        }
         match &pat.kind {
             // Type checking these product-like types successfully always require
             // that the expected type be of those types and not reference types.
diff --git a/compiler/rustc_typeck/src/check/regionck.rs b/compiler/rustc_typeck/src/check/regionck.rs
@@ -577,7 +577,7 @@ impl<'a, 'tcx> RegionCtxt<'a, 'tcx> {
     fn link_pattern(&self, discr_cmt: PlaceWithHirId<'tcx>, root_pat: &hir::Pat<'_>) {
         debug!("link_pattern(discr_cmt={:?}, root_pat={:?})", discr_cmt, root_pat);
         ignore_err!(self.with_mc(|mc| {
-            mc.cat_pattern(discr_cmt, root_pat, |sub_cmt, hir::Pat { kind, span, hir_id }| {
+            mc.cat_pattern(discr_cmt, root_pat, |sub_cmt, hir::Pat { kind, span, hir_id, .. }| {
                 // `ref x` pattern
                 if let PatKind::Binding(..) = kind {
                     if let Some(ty::BindByReference(mutbl)) =
diff --git a/src/test/ui/destructuring-assignment/default-match-bindings-forbidden.rs b/src/test/ui/destructuring-assignment/default-match-bindings-forbidden.rs
@@ -0,0 +1,7 @@
+#![feature(destructuring_assignment)]
+
+fn main() {
+    let mut x = &0;
+    let mut y = &0;
+    (x, y) = &(1, 2); //~ ERROR mismatched types
+}
diff --git a/src/test/ui/destructuring-assignment/default-match-bindings-forbidden.stderr b/src/test/ui/destructuring-assignment/default-match-bindings-forbidden.stderr
@@ -0,0 +1,14 @@
+error[E0308]: mismatched types
+  --> $DIR/default-match-bindings-forbidden.rs:6:5
+   |
+LL |     (x, y) = &(1, 2);
+   |     ^^^^^^   ------- this expression has type `&({integer}, {integer})`
+   |     |
+   |     expected reference, found tuple
+   |
+   = note: expected type `&({integer}, {integer})`
+             found tuple `(_, _)`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/src/test/ui/destructuring-assignment/tuple_destructure_fail.stderr b/src/test/ui/destructuring-assignment/tuple_destructure_fail.stderr
@@ -14,8 +14,8 @@ LL |     (a, a, b) = (1, 2);
    |     |
    |     expected a tuple with 2 elements, found one with 3 elements
    |
-   = note: expected tuple `({integer}, {integer})`
-              found tuple `(_, _, _)`
+   = note: expected type `({integer}, {integer})`
+             found tuple `(_, _, _)`
 
 error[E0308]: mismatched types
   --> $DIR/tuple_destructure_fail.rs:7:5
@@ -25,8 +25,8 @@ LL |     (_,) = (1, 2);
    |     |
    |     expected a tuple with 2 elements, found one with 1 element
    |
-   = note: expected tuple `({integer}, {integer})`
-              found tuple `(_,)`
+   = note: expected type `({integer}, {integer})`
+             found tuple `(_,)`
 
 error: aborting due to 3 previous errors
 

Original file line number	Diff line number	Diff line change
`@@ -732,6 +732,9 @@ pub struct Pat<'hir> {`
`732`	`732`	`pub hir_id: HirId,`
`733`	`733`	`pub kind: PatKind<'hir>,`
`734`	`734`	`pub span: Span,`
	`735`	`+ // Whether to use default binding modes.`
	`736`	`+ // At present, this is false only for destructuring assignment.`
	`737`	`+ pub default_binding_modes: bool,`
`735`	`738`	`}`
`736`	`739`
`737`	`740`	`impl Pat<'_> {`