10 files changed, 488 insertions, 150 deletions

diff --git a/crates/ra_hir/src/marks.rs b/crates/ra_hir/src/marks.rs
index bbf57004d..5b6400042 100644
--- a/crates/ra_hir/src/marks.rs
+++ b/crates/ra_hir/src/marks.rs
@@ -8,4 +8,5 @@ test_utils::marks!(
     glob_enum
     glob_across_crates
     std_prelude
+    match_ergonomics_ref
 );
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index c9a5bc7a1..735cdecb9 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -63,6 +63,30 @@ enum ExprOrPatId {
 
 impl_froms!(ExprOrPatId: ExprId, PatId);
 
+/// Binding modes inferred for patterns.
+/// https://doc.rust-lang.org/reference/patterns.html#binding-modes
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+enum BindingMode {
+    Move,
+    Ref(Mutability),
+}
+
+impl BindingMode {
+    pub fn convert(annotation: &BindingAnnotation) -> BindingMode {
+        match annotation {
+            BindingAnnotation::Unannotated | BindingAnnotation::Mutable => BindingMode::Move,
+            BindingAnnotation::Ref => BindingMode::Ref(Mutability::Shared),
+            BindingAnnotation::RefMut => BindingMode::Ref(Mutability::Mut),
+        }
+    }
+}
+
+impl Default for BindingMode {
+    fn default() -> Self {
+        BindingMode::Move
+    }
+}
+
 /// The result of type inference: A mapping from expressions and patterns to types.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct InferenceResult {
@@ -530,6 +554,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         path: Option<&Path>,
         subpats: &[PatId],
         expected: &Ty,
+        default_bm: BindingMode,
     ) -> Ty {
         let (ty, def) = self.resolve_variant(path);
 
@@ -542,13 +567,19 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 .and_then(|d| d.field(self.db, &Name::tuple_field_name(i)))
                 .map_or(Ty::Unknown, |field| field.ty(self.db))
                 .subst(&substs);
-            self.infer_pat(subpat, &expected_ty);
+            self.infer_pat(subpat, &expected_ty, default_bm);
         }
 
         ty
     }
 
-    fn infer_struct_pat(&mut self, path: Option<&Path>, subpats: &[FieldPat], expected: &Ty) -> Ty {
+    fn infer_struct_pat(
+        &mut self,
+        path: Option<&Path>,
+        subpats: &[FieldPat],
+        expected: &Ty,
+        default_bm: BindingMode,
+    ) -> Ty {
         let (ty, def) = self.resolve_variant(path);
 
         self.unify(&ty, expected);
@@ -559,15 +590,45 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             let matching_field = def.and_then(|it| it.field(self.db, &subpat.name));
             let expected_ty =
                 matching_field.map_or(Ty::Unknown, |field| field.ty(self.db)).subst(&substs);
-            self.infer_pat(subpat.pat, &expected_ty);
+            self.infer_pat(subpat.pat, &expected_ty, default_bm);
         }
 
         ty
     }
 
-    fn infer_pat(&mut self, pat: PatId, expected: &Ty) -> Ty {
+    fn infer_pat(&mut self, pat: PatId, mut expected: &Ty, mut default_bm: BindingMode) -> Ty {
         let body = Arc::clone(&self.body); // avoid borrow checker problem
 
+        let is_non_ref_pat = match &body[pat] {
+            Pat::Tuple(..)
+            | Pat::TupleStruct { .. }
+            | Pat::Struct { .. }
+            | Pat::Range { .. }
+            | Pat::Slice { .. } => true,
+            // TODO: Path/Lit might actually evaluate to ref, but inference is unimplemented.
+            Pat::Path(..) | Pat::Lit(..) => true,
+            Pat::Wild | Pat::Bind { .. } | Pat::Ref { .. } | Pat::Missing => false,
+        };
+        if is_non_ref_pat {
+            while let Ty::Ref(inner, mutability) = expected {
+                expected = inner;
+                default_bm = match default_bm {
+                    BindingMode::Move => BindingMode::Ref(*mutability),
+                    BindingMode::Ref(Mutability::Shared) => BindingMode::Ref(Mutability::Shared),
+                    BindingMode::Ref(Mutability::Mut) => BindingMode::Ref(*mutability),
+                }
+            }
+        } else if let Pat::Ref { .. } = &body[pat] {
+            tested_by!(match_ergonomics_ref);
+            // When you encounter a `&pat` pattern, reset to Move.
+            // This is so that `w` is by value: `let (_, &w) = &(1, &2);`
+            default_bm = BindingMode::Move;
+        }
+
+        // Lose mutability.
+        let default_bm = default_bm;
+        let expected = expected;
+
         let ty = match &body[pat] {
             Pat::Tuple(ref args) => {
                 let expectations = match *expected {
@@ -579,7 +640,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let inner_tys = args
                     .iter()
                     .zip(expectations_iter)
-                    .map(|(&pat, ty)| self.infer_pat(pat, ty))
+                    .map(|(&pat, ty)| self.infer_pat(pat, ty, default_bm))
                     .collect::<Vec<_>>()
                     .into();
 
@@ -595,14 +656,14 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     }
                     _ => &Ty::Unknown,
                 };
-                let subty = self.infer_pat(*pat, expectation);
+                let subty = self.infer_pat(*pat, expectation, default_bm);
                 Ty::Ref(subty.into(), *mutability)
             }
             Pat::TupleStruct { path: ref p, args: ref subpats } => {
-                self.infer_tuple_struct_pat(p.as_ref(), subpats, expected)
+                self.infer_tuple_struct_pat(p.as_ref(), subpats, expected, default_bm)
             }
             Pat::Struct { path: ref p, args: ref fields } => {
-                self.infer_struct_pat(p.as_ref(), fields, expected)
+                self.infer_struct_pat(p.as_ref(), fields, expected, default_bm)
             }
             Pat::Path(path) => {
                 // TODO use correct resolver for the surrounding expression
@@ -610,17 +671,21 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 self.infer_path_expr(&resolver, &path, pat.into()).unwrap_or(Ty::Unknown)
             }
             Pat::Bind { mode, name: _name, subpat } => {
+                let mode = if mode == &BindingAnnotation::Unannotated {
+                    default_bm
+                } else {
+                    BindingMode::convert(mode)
+                };
                 let inner_ty = if let Some(subpat) = subpat {
-                    self.infer_pat(*subpat, expected)
+                    self.infer_pat(*subpat, expected, default_bm)
                 } else {
                     expected.clone()
                 };
                 let inner_ty = self.insert_type_vars_shallow(inner_ty);
 
                 let bound_ty = match mode {
-                    BindingAnnotation::Ref => Ty::Ref(inner_ty.clone().into(), Mutability::Shared),
-                    BindingAnnotation::RefMut => Ty::Ref(inner_ty.clone().into(), Mutability::Mut),
-                    BindingAnnotation::Mutable | BindingAnnotation::Unannotated => inner_ty.clone(),
+                    BindingMode::Ref(mutability) => Ty::Ref(inner_ty.clone().into(), mutability),
+                    BindingMode::Move => inner_ty.clone(),
                 };
                 let bound_ty = self.resolve_ty_as_possible(&mut vec![], bound_ty);
                 self.write_pat_ty(pat, bound_ty);
@@ -700,7 +765,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             }
             Expr::For { iterable, body, pat } => {
                 let _iterable_ty = self.infer_expr(*iterable, &Expectation::none());
-                self.infer_pat(*pat, &Ty::Unknown);
+                self.infer_pat(*pat, &Ty::Unknown, BindingMode::default());
                 self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
                 Ty::unit()
             }
@@ -714,7 +779,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     } else {
                         Ty::Unknown
                     };
-                    self.infer_pat(*arg_pat, &expected);
+                    self.infer_pat(*arg_pat, &expected, BindingMode::default());
                 }
 
                 // TODO: infer lambda type etc.
@@ -807,7 +872,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 
                 for arm in arms {
                     for &pat in &arm.pats {
-                        let _pat_ty = self.infer_pat(pat, &input_ty);
+                        let _pat_ty = self.infer_pat(pat, &input_ty, BindingMode::default());
                     }
                     if let Some(guard_expr) = arm.guard {
                         self.infer_expr(guard_expr, &Expectation::has_type(Ty::Bool));
@@ -1007,7 +1072,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                         decl_ty
                     };
 
-                    self.infer_pat(*pat, &ty);
+                    self.infer_pat(*pat, &ty, BindingMode::default());
                 }
                 Statement::Expr(expr) => {
                     self.infer_expr(*expr, &Expectation::none());
@@ -1023,7 +1088,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         for (type_ref, pat) in signature.params().iter().zip(body.params()) {
             let ty = self.make_ty(type_ref);
 
-            self.infer_pat(*pat, &ty);
+            self.infer_pat(*pat, &ty, BindingMode::default());
         }
         self.return_ty = self.make_ty(signature.ret_type());
     }
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index acae71c26..0f2172ddf 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -831,6 +831,60 @@ fn test(x: &i32) {
 }
 
 #[test]
+fn infer_pattern_match_ergonomics() {
+    assert_snapshot_matches!(
+        infer(r#"
+struct A<T>(T);
+
+fn test() {
+    let A(n) = &A(1);
+    let A(n) = &mut A(1);
+}
+"#),
+    @r###"
+[28; 79) '{     ...(1); }': ()
+[38; 42) 'A(n)': A<i32>
+[40; 41) 'n': &i32
+[45; 50) '&A(1)': &A<i32>
+[46; 47) 'A': A<i32>(T) -> A<T>
+[46; 50) 'A(1)': A<i32>
+[48; 49) '1': i32
+[60; 64) 'A(n)': A<i32>
+[62; 63) 'n': &mut i32
+[67; 76) '&mut A(1)': &mut A<i32>
+[72; 73) 'A': A<i32>(T) -> A<T>
+[72; 76) 'A(1)': A<i32>
+[74; 75) '1': i32"###
+    );
+}
+
+#[test]
+fn infer_pattern_match_ergonomics_ref() {
+    covers!(match_ergonomics_ref);
+    assert_snapshot_matches!(
+        infer(r#"
+fn test() {
+    let v = &(1, &2);
+    let (_, &w) = v;
+}
+"#),
+    @r###"
+[11; 57) '{     ...= v; }': ()
+[21; 22) 'v': &(i32, &i32)
+[25; 33) '&(1, &2)': &(i32, &i32)
+[26; 33) '(1, &2)': (i32, &i32)
+[27; 28) '1': i32
+[30; 32) '&2': &i32
+[31; 32) '2': i32
+[43; 50) '(_, &w)': (i32, &i32)
+[44; 45) '_': i32
+[47; 49) '&w': &i32
+[48; 49) 'w': i32
+[53; 54) 'v': &(i32, &i32)"###
+    );
+}
+
+#[test]
 fn infer_adt_pattern() {
     assert_snapshot_matches!(
         infer(r#"
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index 6d3e379a3..ccbc905ab 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -148,6 +148,7 @@ fn current_op(p: &Parser) -> (u8, Op) {
             (PLUS, EQ) => return (1, Op::Composite(PLUSEQ, 2)),
             (MINUS, EQ) => return (1, Op::Composite(MINUSEQ, 2)),
             (STAR, EQ) => return (1, Op::Composite(STAREQ, 2)),
+            (PERCENT, EQ) => return (1, Op::Composite(PERCENTEQ, 2)),
             (SLASH, EQ) => return (1, Op::Composite(SLASHEQ, 2)),
             (PIPE, EQ) => return (1, Op::Composite(PIPEEQ, 2)),
             (AMP, EQ) => return (1, Op::Composite(AMPEQ, 2)),
diff --git a/crates/ra_parser/src/grammar/expressions/atom.rs b/crates/ra_parser/src/grammar/expressions/atom.rs
index 53bb26c5f..d933288cd 100644
--- a/crates/ra_parser/src/grammar/expressions/atom.rs
+++ b/crates/ra_parser/src/grammar/expressions/atom.rs
@@ -342,21 +342,6 @@ pub(crate) fn match_arm_list(p: &mut Parser) {
             continue;
         }
 
-        // test match_arms_outer_attributes
-        // fn foo() {
-        //     match () {
-        //         #[cfg(feature = "some")]
-        //         _ => (),
-        //         #[cfg(feature = "other")]
-        //         _ => (),
-        //         #[cfg(feature = "many")]
-        //         #[cfg(feature = "attributes")]
-        //         #[cfg(feature = "before")]
-        //         _ => (),
-        //     }
-        // }
-        attributes::outer_attributes(p);
-
         // test match_arms_commas
         // fn foo() {
         //     match () {
@@ -387,6 +372,21 @@ pub(crate) fn match_arm_list(p: &mut Parser) {
 // }
 fn match_arm(p: &mut Parser) -> BlockLike {
     let m = p.start();
+    // test match_arms_outer_attributes
+    // fn foo() {
+    //     match () {
+    //         #[cfg(feature = "some")]
+    //         _ => (),
+    //         #[cfg(feature = "other")]
+    //         _ => (),
+    //         #[cfg(feature = "many")]
+    //         #[cfg(feature = "attributes")]
+    //         #[cfg(feature = "before")]
+    //         _ => (),
+    //     }
+    // }
+    attributes::outer_attributes(p);
+
     patterns::pattern_list_r(p, TokenSet::empty());
     if p.at(IF_KW) {
         match_guard(p);
diff --git a/crates/ra_syntax/tests/data/parser/err/0032_match_arms_inner_attrs.txt b/crates/ra_syntax/tests/data/parser/err/0032_match_arms_inner_attrs.txt
index b7543abc9..ed5735a63 100644
--- a/crates/ra_syntax/tests/data/parser/err/0032_match_arms_inner_attrs.txt
+++ b/crates/ra_syntax/tests/data/parser/err/0032_match_arms_inner_attrs.txt
@@ -33,11 +33,11 @@ SOURCE_FILE@[0; 293)
                 R_PAREN@[40; 41)
             COMMA@[41; 42)
             WHITESPACE@[42; 51)
-            ATTR@[51; 52)
-              POUND@[51; 52)
-              err: `expected `[``
-              err: `expected pattern`
-            MATCH_ARM@[52; 78)
+            MATCH_ARM@[51; 78)
+              ATTR@[51; 52)
+                POUND@[51; 52)
+                err: `expected `[``
+                err: `expected pattern`
               ERROR@[52; 53)
                 EXCL@[52; 53)
                 err: `expected FAT_ARROW`
@@ -103,11 +103,11 @@ SOURCE_FILE@[0; 293)
                 R_PAREN@[149; 150)
             COMMA@[150; 151)
             WHITESPACE@[151; 160)
-            ATTR@[160; 161)
-              POUND@[160; 161)
-              err: `expected `[``
-              err: `expected pattern`
-            MATCH_ARM@[161; 179)
+            MATCH_ARM@[160; 179)
+              ATTR@[160; 161)
+                POUND@[160; 161)
+                err: `expected `[``
+                err: `expected pattern`
               ERROR@[161; 162)
                 EXCL@[161; 162)
                 err: `expected FAT_ARROW`
@@ -138,22 +138,22 @@ SOURCE_FILE@[0; 293)
         MATCH_ARM_LIST@[200; 290)
           L_CURLY@[200; 201)
           WHITESPACE@[201; 210)
-          ATTR@[210; 222)
-            POUND@[210; 211)
-            TOKEN_TREE@[211; 222)
-              L_BRACK@[211; 212)
-              IDENT@[212; 215) "cfg"
-              TOKEN_TREE@[215; 221)
-                L_PAREN@[215; 216)
-                IDENT@[216; 220) "test"
-                R_PAREN@[220; 221)
-              R_BRACK@[221; 222)
-          WHITESPACE@[222; 231)
-          ATTR@[231; 232)
-            POUND@[231; 232)
-            err: `expected `[``
-            err: `expected pattern`
-          MATCH_ARM@[232; 250)
+          MATCH_ARM@[210; 250)
+            ATTR@[210; 222)
+              POUND@[210; 211)
+              TOKEN_TREE@[211; 222)
+                L_BRACK@[211; 212)
+                IDENT@[212; 215) "cfg"
+                TOKEN_TREE@[215; 221)
+                  L_PAREN@[215; 216)
+                  IDENT@[216; 220) "test"
+                  R_PAREN@[220; 221)
+                R_BRACK@[221; 222)
+            WHITESPACE@[222; 231)
+            ATTR@[231; 232)
+              POUND@[231; 232)
+              err: `expected `[``
+              err: `expected pattern`
             ERROR@[232; 233)
               EXCL@[232; 233)
               err: `expected FAT_ARROW`
diff --git a/crates/ra_syntax/tests/data/parser/err/0033_match_arms_outer_attrs.txt b/crates/ra_syntax/tests/data/parser/err/0033_match_arms_outer_attrs.txt
index 7f8767001..f540409bc 100644
--- a/crates/ra_syntax/tests/data/parser/err/0033_match_arms_outer_attrs.txt
+++ b/crates/ra_syntax/tests/data/parser/err/0033_match_arms_outer_attrs.txt
@@ -43,21 +43,21 @@ SOURCE_FILE@[0; 89)
               R_PAREN@[57; 58)
           COMMA@[58; 59)
           WHITESPACE@[59; 68)
-          ATTR@[68; 80)
-            POUND@[68; 69)
-            TOKEN_TREE@[69; 80)
-              L_BRACK@[69; 70)
-              IDENT@[70; 73) "cfg"
-              TOKEN_TREE@[73; 79)
-                L_PAREN@[73; 74)
-                IDENT@[74; 78) "test"
-                R_PAREN@[78; 79)
-              R_BRACK@[79; 80)
+          MATCH_ARM@[68; 80)
+            ATTR@[68; 80)
+              POUND@[68; 69)
+              TOKEN_TREE@[69; 80)
+                L_BRACK@[69; 70)
+                IDENT@[70; 73) "cfg"
+                TOKEN_TREE@[73; 79)
+                  L_PAREN@[73; 74)
+                  IDENT@[74; 78) "test"
+                  R_PAREN@[78; 79)
+                R_BRACK@[79; 80)
+                err: `expected pattern`
+                err: `expected FAT_ARROW`
+                err: `expected expression`
           WHITESPACE@[80; 85)
-          err: `expected pattern`
-          err: `expected FAT_ARROW`
-          err: `expected expression`
-          MATCH_ARM@[85; 85)
           R_CURLY@[85; 86)
       WHITESPACE@[86; 87)
       R_CURLY@[87; 88)
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0121_match_arms_outer_attributes.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0121_match_arms_outer_attributes.txt
index c888fb8f0..e52a290bf 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0121_match_arms_outer_attributes.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0121_match_arms_outer_attributes.txt
@@ -21,22 +21,22 @@ SOURCE_FILE@[0; 259)
         MATCH_ARM_LIST@[24; 256)
           L_CURLY@[24; 25)
           WHITESPACE@[25; 34)
-          ATTR@[34; 58)
-            POUND@[34; 35)
-            TOKEN_TREE@[35; 58)
-              L_BRACK@[35; 36)
-              IDENT@[36; 39) "cfg"
-              TOKEN_TREE@[39; 57)
-                L_PAREN@[39; 40)
-                IDENT@[40; 47) "feature"
-                WHITESPACE@[47; 48)
-                EQ@[48; 49)
-                WHITESPACE@[49; 50)
-                STRING@[50; 56)
-                R_PAREN@[56; 57)
-              R_BRACK@[57; 58)
-          WHITESPACE@[58; 67)
-          MATCH_ARM@[67; 74)
+          MATCH_ARM@[34; 74)
+            ATTR@[34; 58)
+              POUND@[34; 35)
+              TOKEN_TREE@[35; 58)
+                L_BRACK@[35; 36)
+                IDENT@[36; 39) "cfg"
+                TOKEN_TREE@[39; 57)
+                  L_PAREN@[39; 40)
+                  IDENT@[40; 47) "feature"
+                  WHITESPACE@[47; 48)
+                  EQ@[48; 49)
+                  WHITESPACE@[49; 50)
+                  STRING@[50; 56)
+                  R_PAREN@[56; 57)
+                R_BRACK@[57; 58)
+            WHITESPACE@[58; 67)
             PLACEHOLDER_PAT@[67; 68)
               UNDERSCORE@[67; 68)
             WHITESPACE@[68; 69)
@@ -47,22 +47,22 @@ SOURCE_FILE@[0; 259)
               R_PAREN@[73; 74)
           COMMA@[74; 75)
           WHITESPACE@[75; 84)
-          ATTR@[84; 109)
-            POUND@[84; 85)
-            TOKEN_TREE@[85; 109)
-              L_BRACK@[85; 86)
-              IDENT@[86; 89) "cfg"
-              TOKEN_TREE@[89; 108)
-                L_PAREN@[89; 90)
-                IDENT@[90; 97) "feature"
-                WHITESPACE@[97; 98)
-                EQ@[98; 99)
-                WHITESPACE@[99; 100)
-                STRING@[100; 107)
-                R_PAREN@[107; 108)
-              R_BRACK@[108; 109)
-          WHITESPACE@[109; 118)
-          MATCH_ARM@[118; 125)
+          MATCH_ARM@[84; 125)
+            ATTR@[84; 109)
+              POUND@[84; 85)
+              TOKEN_TREE@[85; 109)
+                L_BRACK@[85; 86)
+                IDENT@[86; 89) "cfg"
+                TOKEN_TREE@[89; 108)
+                  L_PAREN@[89; 90)
+                  IDENT@[90; 97) "feature"
+                  WHITESPACE@[97; 98)
+                  EQ@[98; 99)
+                  WHITESPACE@[99; 100)
+                  STRING@[100; 107)
+                  R_PAREN@[107; 108)
+                R_BRACK@[108; 109)
+            WHITESPACE@[109; 118)
             PLACEHOLDER_PAT@[118; 119)
               UNDERSCORE@[118; 119)
             WHITESPACE@[119; 120)
@@ -73,52 +73,52 @@ SOURCE_FILE@[0; 259)
               R_PAREN@[124; 125)
           COMMA@[125; 126)
           WHITESPACE@[126; 135)
-          ATTR@[135; 159)
-            POUND@[135; 136)
-            TOKEN_TREE@[136; 159)
-              L_BRACK@[136; 137)
-              IDENT@[137; 140) "cfg"
-              TOKEN_TREE@[140; 158)
-                L_PAREN@[140; 141)
-                IDENT@[141; 148) "feature"
-                WHITESPACE@[148; 149)
-                EQ@[149; 150)
-                WHITESPACE@[150; 151)
-                STRING@[151; 157)
-                R_PAREN@[157; 158)
-              R_BRACK@[158; 159)
-          WHITESPACE@[159; 168)
-          ATTR@[168; 198)
-            POUND@[168; 169)
-            TOKEN_TREE@[169; 198)
-              L_BRACK@[169; 170)
-              IDENT@[170; 173) "cfg"
-              TOKEN_TREE@[173; 197)
-                L_PAREN@[173; 174)
-                IDENT@[174; 181) "feature"
-                WHITESPACE@[181; 182)
-                EQ@[182; 183)
-                WHITESPACE@[183; 184)
-                STRING@[184; 196)
-                R_PAREN@[196; 197)
-              R_BRACK@[197; 198)
-          WHITESPACE@[198; 207)
-          ATTR@[207; 233)
-            POUND@[207; 208)
-            TOKEN_TREE@[208; 233)
-              L_BRACK@[208; 209)
-              IDENT@[209; 212) "cfg"
-              TOKEN_TREE@[212; 232)
-                L_PAREN@[212; 213)
-                IDENT@[213; 220) "feature"
-                WHITESPACE@[220; 221)
-                EQ@[221; 222)
-                WHITESPACE@[222; 223)
-                STRING@[223; 231)
-                R_PAREN@[231; 232)
-              R_BRACK@[232; 233)
-          WHITESPACE@[233; 242)
-          MATCH_ARM@[242; 249)
+          MATCH_ARM@[135; 249)
+            ATTR@[135; 159)
+              POUND@[135; 136)
+              TOKEN_TREE@[136; 159)
+                L_BRACK@[136; 137)
+                IDENT@[137; 140) "cfg"
+                TOKEN_TREE@[140; 158)
+                  L_PAREN@[140; 141)
+                  IDENT@[141; 148) "feature"
+                  WHITESPACE@[148; 149)
+                  EQ@[149; 150)
+                  WHITESPACE@[150; 151)
+                  STRING@[151; 157)
+                  R_PAREN@[157; 158)
+                R_BRACK@[158; 159)
+            WHITESPACE@[159; 168)
+            ATTR@[168; 198)
+              POUND@[168; 169)
+              TOKEN_TREE@[169; 198)
+                L_BRACK@[169; 170)
+                IDENT@[170; 173) "cfg"
+                TOKEN_TREE@[173; 197)
+                  L_PAREN@[173; 174)
+                  IDENT@[174; 181) "feature"
+                  WHITESPACE@[181; 182)
+                  EQ@[182; 183)
+                  WHITESPACE@[183; 184)
+                  STRING@[184; 196)
+                  R_PAREN@[196; 197)
+                R_BRACK@[197; 198)
+            WHITESPACE@[198; 207)
+            ATTR@[207; 233)
+              POUND@[207; 208)
+              TOKEN_TREE@[208; 233)
+                L_BRACK@[208; 209)
+                IDENT@[209; 212) "cfg"
+                TOKEN_TREE@[212; 232)
+                  L_PAREN@[212; 213)
+                  IDENT@[213; 220) "feature"
+                  WHITESPACE@[220; 221)
+                  EQ@[221; 222)
+                  WHITESPACE@[222; 223)
+                  STRING@[223; 231)
+                  R_PAREN@[231; 232)
+                R_BRACK@[232; 233)
+            WHITESPACE@[233; 242)
             PLACEHOLDER_PAT@[242; 243)
               UNDERSCORE@[242; 243)
             WHITESPACE@[243; 244)
diff --git a/crates/ra_syntax/tests/data/parser/ok/0048_compound_assignment.rs b/crates/ra_syntax/tests/data/parser/ok/0048_compound_assignment.rs
new file mode 100644
index 000000000..871720a49
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0048_compound_assignment.rs
@@ -0,0 +1,17 @@
+// https://github.com/rust-analyzer/rust-analyzer/pull/983
+
+fn compound_assignment() {
+    let mut a = 0;
+    a += 1;
+    a -= 2;
+    a *= 3;
+    a %= 4;
+    a /= 5;
+    a |= 6;
+    a &= 7;
+    a ^= 8;
+    a <= 9;
+    a >= 10;
+    a >>= 11;
+    a <<= 12;
+}
diff --git a/crates/ra_syntax/tests/data/parser/ok/0048_compound_assignment.txt b/crates/ra_syntax/tests/data/parser/ok/0048_compound_assignment.txt
new file mode 100644
index 000000000..c5ff06823
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0048_compound_assignment.txt
@@ -0,0 +1,200 @@
+SOURCE_FILE@[0; 257)
+  COMMENT@[0; 58)
+  WHITESPACE@[58; 60)
+  FN_DEF@[60; 256)
+    FN_KW@[60; 62)
+    WHITESPACE@[62; 63)
+    NAME@[63; 82)
+      IDENT@[63; 82) "compound_assignment"
+    PARAM_LIST@[82; 84)
+      L_PAREN@[82; 83)
+      R_PAREN@[83; 84)
+    WHITESPACE@[84; 85)
+    BLOCK@[85; 256)
+      L_CURLY@[85; 86)
+      WHITESPACE@[86; 91)
+      LET_STMT@[91; 105)
+        LET_KW@[91; 94)
+        WHITESPACE@[94; 95)
+        BIND_PAT@[95; 100)
+          MUT_KW@[95; 98)
+          WHITESPACE@[98; 99)
+          NAME@[99; 100)
+            IDENT@[99; 100) "a"
+        WHITESPACE@[100; 101)
+        EQ@[101; 102)
+        WHITESPACE@[102; 103)
+        LITERAL@[103; 104)
+          INT_NUMBER@[103; 104) "0"
+        SEMI@[104; 105)
+      WHITESPACE@[105; 110)
+      EXPR_STMT@[110; 117)
+        BIN_EXPR@[110; 116)
+          PATH_EXPR@[110; 111)
+            PATH@[110; 111)
+              PATH_SEGMENT@[110; 111)
+                NAME_REF@[110; 111)
+                  IDENT@[110; 111) "a"
+          WHITESPACE@[111; 112)
+          PLUSEQ@[112; 114)
+          WHITESPACE@[114; 115)
+          LITERAL@[115; 116)
+            INT_NUMBER@[115; 116) "1"
+        SEMI@[116; 117)
+      WHITESPACE@[117; 122)
+      EXPR_STMT@[122; 129)
+        BIN_EXPR@[122; 128)
+          PATH_EXPR@[122; 123)
+            PATH@[122; 123)
+              PATH_SEGMENT@[122; 123)
+                NAME_REF@[122; 123)
+                  IDENT@[122; 123) "a"
+          WHITESPACE@[123; 124)
+          MINUSEQ@[124; 126)
+          WHITESPACE@[126; 127)
+          LITERAL@[127; 128)
+            INT_NUMBER@[127; 128) "2"
+        SEMI@[128; 129)
+      WHITESPACE@[129; 134)
+      EXPR_STMT@[134; 141)
+        BIN_EXPR@[134; 140)
+          PATH_EXPR@[134; 135)
+            PATH@[134; 135)
+              PATH_SEGMENT@[134; 135)
+                NAME_REF@[134; 135)
+                  IDENT@[134; 135) "a"
+          WHITESPACE@[135; 136)
+          STAREQ@[136; 138)
+          WHITESPACE@[138; 139)
+          LITERAL@[139; 140)
+            INT_NUMBER@[139; 140) "3"
+        SEMI@[140; 141)
+      WHITESPACE@[141; 146)
+      EXPR_STMT@[146; 153)
+        BIN_EXPR@[146; 152)
+          PATH_EXPR@[146; 147)
+            PATH@[146; 147)
+              PATH_SEGMENT@[146; 147)
+                NAME_REF@[146; 147)
+                  IDENT@[146; 147) "a"
+          WHITESPACE@[147; 148)
+          PERCENTEQ@[148; 150)
+          WHITESPACE@[150; 151)
+          LITERAL@[151; 152)
+            INT_NUMBER@[151; 152) "4"
+        SEMI@[152; 153)
+      WHITESPACE@[153; 158)
+      EXPR_STMT@[158; 165)
+        BIN_EXPR@[158; 164)
+          PATH_EXPR@[158; 159)
+            PATH@[158; 159)
+              PATH_SEGMENT@[158; 159)
+                NAME_REF@[158; 159)
+                  IDENT@[158; 159) "a"
+          WHITESPACE@[159; 160)
+          SLASHEQ@[160; 162)
+          WHITESPACE@[162; 163)
+          LITERAL@[163; 164)
+            INT_NUMBER@[163; 164) "5"
+        SEMI@[164; 165)
+      WHITESPACE@[165; 170)
+      EXPR_STMT@[170; 177)
+        BIN_EXPR@[170; 176)
+          PATH_EXPR@[170; 171)
+            PATH@[170; 171)
+              PATH_SEGMENT@[170; 171)
+                NAME_REF@[170; 171)
+                  IDENT@[170; 171) "a"
+          WHITESPACE@[171; 172)
+          PIPEEQ@[172; 174)
+          WHITESPACE@[174; 175)
+          LITERAL@[175; 176)
+            INT_NUMBER@[175; 176) "6"
+        SEMI@[176; 177)
+      WHITESPACE@[177; 182)
+      EXPR_STMT@[182; 189)
+        BIN_EXPR@[182; 188)
+          PATH_EXPR@[182; 183)
+            PATH@[182; 183)
+              PATH_SEGMENT@[182; 183)
+                NAME_REF@[182; 183)
+                  IDENT@[182; 183) "a"
+          WHITESPACE@[183; 184)
+          AMPEQ@[184; 186)
+          WHITESPACE@[186; 187)
+          LITERAL@[187; 188)
+            INT_NUMBER@[187; 188) "7"
+        SEMI@[188; 189)
+      WHITESPACE@[189; 194)
+      EXPR_STMT@[194; 201)
+        BIN_EXPR@[194; 200)
+          PATH_EXPR@[194; 195)
+            PATH@[194; 195)
+              PATH_SEGMENT@[194; 195)
+                NAME_REF@[194; 195)
+                  IDENT@[194; 195) "a"
+          WHITESPACE@[195; 196)
+          CARETEQ@[196; 198)
+          WHITESPACE@[198; 199)
+          LITERAL@[199; 200)
+            INT_NUMBER@[199; 200) "8"
+        SEMI@[200; 201)
+      WHITESPACE@[201; 206)
+      EXPR_STMT@[206; 213)
+        BIN_EXPR@[206; 212)
+          PATH_EXPR@[206; 207)
+            PATH@[206; 207)
+              PATH_SEGMENT@[206; 207)
+                NAME_REF@[206; 207)
+                  IDENT@[206; 207) "a"
+          WHITESPACE@[207; 208)
+          LTEQ@[208; 210)
+          WHITESPACE@[210; 211)
+          LITERAL@[211; 212)
+            INT_NUMBER@[211; 212) "9"
+        SEMI@[212; 213)
+      WHITESPACE@[213; 218)
+      EXPR_STMT@[218; 226)
+        BIN_EXPR@[218; 225)
+          PATH_EXPR@[218; 219)
+            PATH@[218; 219)
+              PATH_SEGMENT@[218; 219)
+                NAME_REF@[218; 219)
+                  IDENT@[218; 219) "a"
+          WHITESPACE@[219; 220)
+          GTEQ@[220; 222)
+          WHITESPACE@[222; 223)
+          LITERAL@[223; 225)
+            INT_NUMBER@[223; 225) "10"
+        SEMI@[225; 226)
+      WHITESPACE@[226; 231)
+      EXPR_STMT@[231; 240)
+        BIN_EXPR@[231; 239)
+          PATH_EXPR@[231; 232)
+            PATH@[231; 232)
+              PATH_SEGMENT@[231; 232)
+                NAME_REF@[231; 232)
+                  IDENT@[231; 232) "a"
+          WHITESPACE@[232; 233)
+          SHREQ@[233; 236)
+          WHITESPACE@[236; 237)
+          LITERAL@[237; 239)
+            INT_NUMBER@[237; 239) "11"
+        SEMI@[239; 240)
+      WHITESPACE@[240; 245)
+      EXPR_STMT@[245; 254)
+        BIN_EXPR@[245; 253)
+          PATH_EXPR@[245; 246)
+            PATH@[245; 246)
+              PATH_SEGMENT@[245; 246)
+                NAME_REF@[245; 246)
+                  IDENT@[245; 246) "a"
+          WHITESPACE@[246; 247)
+          SHLEQ@[247; 250)
+          WHITESPACE@[250; 251)
+          LITERAL@[251; 253)
+            INT_NUMBER@[251; 253) "12"
+        SEMI@[253; 254)
+      WHITESPACE@[254; 255)
+      R_CURLY@[255; 256)
+  WHITESPACE@[256; 257)