Add a lint for not using field pattern shorthands

Closes #17792.

2 files changed, 65 insertions, 1 deletions

diff --git a/src/test/compile-fail/lint-dead-code-4.rs b/src/test/compile-fail/lint-dead-code-4.rs
index ba02faf11c3..ac8b9c3821e 100644
--- a/src/test/compile-fail/lint-dead-code-4.rs
+++ b/src/test/compile-fail/lint-dead-code-4.rs
@@ -38,7 +38,7 @@ enum XYZ {
 
 fn field_match_in_patterns(b: XYZ) -> String {
     match b {
-        Y { a: a, .. } => a,
+        Y { a, .. } => a,
         _ => "".to_string()
     }
 }
diff --git a/src/test/compile-fail/lint-shorthand-field.rs b/src/test/compile-fail/lint-shorthand-field.rs
new file mode 100644
index 00000000000..ff9347b9fc5
--- /dev/null
+++ b/src/test/compile-fail/lint-shorthand-field.rs
@@ -0,0 +1,64 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(bad_style, unused_variables)]
+#![deny(non_shorthand_field_patterns)]
+
+struct Foo {
+    x: int,
+    y: int,
+}
+
+fn main() {
+    {
+        let Foo {
+            x: x, //~ ERROR the `x:` in this pattern is redundant
+            y: ref y, //~ ERROR the `y:` in this pattern is redundant
+        } = Foo { x: 0, y: 0 };
+
+        let Foo {
+            x,
+            ref y,
+        } = Foo { x: 0, y: 0 };
+    }
+
+    {
+        const x: int = 1;
+
+        match (Foo { x: 1, y: 1 }) {
+            Foo { x: x, ..} => {},
+            _ => {},
+        }
+    }
+
+    {
+        struct Bar {
+            x: x,
+        }
+
+        struct x;
+
+        match (Bar { x: x }) {
+            Bar { x: x } => {},
+        }
+    }
+
+    {
+        struct Bar {
+            x: Foo,
+        }
+
+        enum Foo { x }
+
+        match (Bar { x: x }) {
+            Bar { x: x } => {},
+        }
+    }
+}