Auto merge of #54530 - pnkfelix:issue-54047-migrate-ui-run-pass-back-to-run-pass, r=alexcrichton

Migrate `src/test/ui/run-pass/*` back to `src/test/run-pass/`.

Moves all the tests from `src/test/ui/run-pass/**` back to `src/test/run-pass/`.

This should have no impact on our overall testing completeness due to PR #54223

Fix #54047

95 files changed, 3220 insertions, 0 deletions

diff --git a/src/test/run-pass/binding/allow_irrefutable_let_patterns.rs b/src/test/run-pass/binding/allow_irrefutable_let_patterns.rs
new file mode 100644
index 00000000000..866784e517c
--- /dev/null
+++ b/src/test/run-pass/binding/allow_irrefutable_let_patterns.rs
@@ -0,0 +1,22 @@
+// Copyright 2015 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.
+
+// run-pass
+#![feature(irrefutable_let_patterns)]
+
+// must-compile-successfully-irrefutable_let_patterns_with_gate
+#[allow(irrefutable_let_patterns)]
+fn main() {
+    if let _ = 5 {}
+
+    while let _ = 5 {
+        break;
+    }
+}
diff --git a/src/test/run-pass/binding/bind-field-short-with-modifiers.rs b/src/test/run-pass/binding/bind-field-short-with-modifiers.rs
new file mode 100644
index 00000000000..59fe52f7b59
--- /dev/null
+++ b/src/test/run-pass/binding/bind-field-short-with-modifiers.rs
@@ -0,0 +1,36 @@
+// Copyright 2013 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.
+
+// run-pass
+#![allow(unused_assignments)]
+#![allow(unused_variables)]
+#![allow(non_shorthand_field_patterns)]
+
+pub fn main() {
+    struct Foo { x: isize, y: isize }
+    let mut f = Foo { x: 10, y: 0 };
+    match f {
+        Foo { ref mut x, .. } => *x = 11,
+    }
+    match f {
+        Foo { ref x, ref y } => {
+            assert_eq!(f.x, 11);
+            assert_eq!(f.y, 0);
+        }
+    }
+    match f {
+        Foo { mut x, y: ref mut y } => {
+            x = 12;
+            *y = 1;
+        }
+    }
+    assert_eq!(f.x, 11);
+    assert_eq!(f.y, 1);
+}
diff --git a/src/test/run-pass/binding/borrowed-ptr-pattern-2.rs b/src/test/run-pass/binding/borrowed-ptr-pattern-2.rs
new file mode 100644
index 00000000000..6a23d159047
--- /dev/null
+++ b/src/test/run-pass/binding/borrowed-ptr-pattern-2.rs
@@ -0,0 +1,23 @@
+// Copyright 2012 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.
+
+// run-pass
+
+fn foo(s: &String) -> bool {
+    match &**s {
+        "kitty" => true,
+        _ => false
+    }
+}
+
+pub fn main() {
+    assert!(foo(&"kitty".to_string()));
+    assert!(!foo(&"gata".to_string()));
+}
diff --git a/src/test/run-pass/binding/borrowed-ptr-pattern-3.rs b/src/test/run-pass/binding/borrowed-ptr-pattern-3.rs
new file mode 100644
index 00000000000..cb40b3a0099
--- /dev/null
+++ b/src/test/run-pass/binding/borrowed-ptr-pattern-3.rs
@@ -0,0 +1,23 @@
+// Copyright 2012 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.
+
+// run-pass
+
+fn foo<'r>(s: &'r usize) -> bool {
+    match s {
+        &3 => true,
+        _ => false
+    }
+}
+
+pub fn main() {
+    assert!(foo(&3));
+    assert!(!foo(&4));
+}
diff --git a/src/test/run-pass/binding/borrowed-ptr-pattern-infallible.rs b/src/test/run-pass/binding/borrowed-ptr-pattern-infallible.rs
new file mode 100644
index 00000000000..5f906903ed2
--- /dev/null
+++ b/src/test/run-pass/binding/borrowed-ptr-pattern-infallible.rs
@@ -0,0 +1,18 @@
+// Copyright 2012 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.
+
+// run-pass
+
+
+pub fn main() {
+    let (&x, &y) = (&3, &'a');
+    assert_eq!(x, 3);
+    assert_eq!(y, 'a');
+}
diff --git a/src/test/run-pass/binding/borrowed-ptr-pattern-option.rs b/src/test/run-pass/binding/borrowed-ptr-pattern-option.rs
new file mode 100644
index 00000000000..1372a7a0789
--- /dev/null
+++ b/src/test/run-pass/binding/borrowed-ptr-pattern-option.rs
@@ -0,0 +1,25 @@
+// Copyright 2012 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.
+
+// run-pass
+
+fn select<'r>(x: &'r Option<isize>, y: &'r Option<isize>) -> &'r Option<isize> {
+    match (x, y) {
+        (&None, &None) => x,
+        (&Some(_), _) => x,
+        (&None, &Some(_)) => y
+    }
+}
+
+pub fn main() {
+    let x = None;
+    let y = Some(3);
+    assert_eq!(select(&x, &y).unwrap(), 3);
+}
diff --git a/src/test/run-pass/binding/borrowed-ptr-pattern.rs b/src/test/run-pass/binding/borrowed-ptr-pattern.rs
new file mode 100644
index 00000000000..f363bef36d6
--- /dev/null
+++ b/src/test/run-pass/binding/borrowed-ptr-pattern.rs
@@ -0,0 +1,22 @@
+// Copyright 2012 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.
+
+// run-pass
+
+fn foo<T:Clone>(x: &T) -> T{
+    match x {
+        &ref a => (*a).clone()
+    }
+}
+
+pub fn main() {
+    assert_eq!(foo(&3), 3);
+    assert_eq!(foo(&'a'), 'a');
+}
diff --git a/src/test/run-pass/binding/empty-types-in-patterns.rs b/src/test/run-pass/binding/empty-types-in-patterns.rs
new file mode 100644
index 00000000000..c230442eecc
--- /dev/null
+++ b/src/test/run-pass/binding/empty-types-in-patterns.rs
@@ -0,0 +1,67 @@
+// Copyright 2012 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.
+
+// run-pass
+#![feature(never_type)]
+#![feature(exhaustive_patterns)]
+#![feature(slice_patterns)]
+#![allow(unreachable_patterns)]
+#![allow(unreachable_code)]
+
+#[allow(dead_code)]
+fn foo(z: !) {
+    let x: Result<!, !> = Ok(z);
+
+    let Ok(_y) = x;
+    let Err(_y) = x;
+
+    let x = [z; 1];
+
+    match x {};
+    match x {
+        [q] => q,
+    };
+}
+
+fn bar(nevers: &[!]) {
+    match nevers {
+        &[]  => (),
+    };
+
+    match nevers {
+        &[]  => (),
+        &[_]  => (),
+        &[_, _, _, ..]  => (),
+    };
+}
+
+fn main() {
+    let x: Result<u32, !> = Ok(123);
+    let Ok(y) = x;
+
+    assert_eq!(123, y);
+
+    match x {
+        Ok(y) => y,
+    };
+
+    match x {
+        Ok(y) => y,
+        Err(e) => match e {},
+    };
+
+    let x: Result<u32, &!> = Ok(123);
+    match x {
+        Ok(y) => y,
+    };
+
+    bar(&[]);
+}
+
diff --git a/src/test/run-pass/binding/exhaustive-bool-match-sanity.rs b/src/test/run-pass/binding/exhaustive-bool-match-sanity.rs
new file mode 100644
index 00000000000..26e852eff23
--- /dev/null
+++ b/src/test/run-pass/binding/exhaustive-bool-match-sanity.rs
@@ -0,0 +1,32 @@
+// Copyright 2016 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.
+
+// run-pass
+// Issue #33540
+// We previously used to generate a 3-armed boolean `SwitchInt` in the
+// MIR of the function `foo` below. #33583 changed rustc to
+// generate an `If` terminator instead. This test is to just ensure
+// sanity in that we generate an if-else chain giving the correct
+// results.
+
+fn foo(x: bool, y: bool) -> u32 {
+    match (x, y) {
+        (false, _) => 0,
+        (_, false) => 1,
+        (true, true) => 2
+    }
+}
+
+fn main() {
+    assert_eq!(foo(false, true), 0);
+    assert_eq!(foo(false, false), 0);
+    assert_eq!(foo(true, false), 1);
+    assert_eq!(foo(true, true), 2);
+}
diff --git a/src/test/run-pass/binding/expr-match-generic-unique1.rs b/src/test/run-pass/binding/expr-match-generic-unique1.rs
new file mode 100644
index 00000000000..3325aa7b3df
--- /dev/null
+++ b/src/test/run-pass/binding/expr-match-generic-unique1.rs
@@ -0,0 +1,29 @@
+// Copyright 2012 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.
+
+// run-pass
+#![feature(box_syntax)]
+
+fn test_generic<T: Clone, F>(expected: Box<T>, eq: F) where F: FnOnce(Box<T>, Box<T>) -> bool {
+    let actual: Box<T> = match true {
+        true => { expected.clone() },
+        _ => panic!("wat")
+    };
+    assert!(eq(expected, actual));
+}
+
+fn test_box() {
+    fn compare_box(b1: Box<bool>, b2: Box<bool>) -> bool {
+        return *b1 == *b2;
+    }
+    test_generic::<bool, _>(box true, compare_box);
+}
+
+pub fn main() { test_box(); }
diff --git a/src/test/run-pass/binding/expr-match-generic-unique2.rs b/src/test/run-pass/binding/expr-match-generic-unique2.rs
new file mode 100644
index 00000000000..8daa33e6227
--- /dev/null
+++ b/src/test/run-pass/binding/expr-match-generic-unique2.rs
@@ -0,0 +1,27 @@
+// Copyright 2012-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.
+
+// run-pass
+#![feature(box_syntax)]
+
+fn test_generic<T: Clone, F>(expected: T, eq: F) where F: FnOnce(T, T) -> bool {
+    let actual: T = match true {
+        true => expected.clone(),
+        _ => panic!("wat")
+    };
+    assert!(eq(expected, actual));
+}
+
+fn test_vec() {
+    fn compare_box(v1: Box<isize>, v2: Box<isize>) -> bool { return v1 == v2; }
+    test_generic::<Box<isize>, _>(box 1, compare_box);
+}
+
+pub fn main() { test_vec(); }
diff --git a/src/test/run-pass/binding/expr-match-generic.rs b/src/test/run-pass/binding/expr-match-generic.rs
new file mode 100644
index 00000000000..11c907b9b2d
--- /dev/null
+++ b/src/test/run-pass/binding/expr-match-generic.rs
@@ -0,0 +1,39 @@
+// Copyright 2012-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.
+
+// run-pass
+#![allow(non_camel_case_types)]
+
+type compare<T> = extern "Rust" fn(T, T) -> bool;
+
+fn test_generic<T:Clone>(expected: T, eq: compare<T>) {
+  let actual: T = match true { true => { expected.clone() }, _ => panic!("wat") };
+    assert!((eq(expected, actual)));
+}
+
+fn test_bool() {
+    fn compare_bool(b1: bool, b2: bool) -> bool { return b1 == b2; }
+    test_generic::<bool>(true, compare_bool);
+}
+
+#[derive(Clone)]
+struct Pair {
+    a: isize,
+    b: isize,
+}
+
+fn test_rec() {
+    fn compare_rec(t1: Pair, t2: Pair) -> bool {
+        t1.a == t2.a && t1.b == t2.b
+    }
+    test_generic::<Pair>(Pair {a: 1, b: 2}, compare_rec);
+}
+
+pub fn main() { test_bool(); test_rec(); }
diff --git a/src/test/run-pass/binding/expr-match-panic-all.rs b/src/test/run-pass/binding/expr-match-panic-all.rs
new file mode 100644
index 00000000000..f283fdddb6a
--- /dev/null
+++ b/src/test/run-pass/binding/expr-match-panic-all.rs
@@ -0,0 +1,24 @@
+// Copyright 2012-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.
+
+// run-pass
+
+
+
+// When all branches of a match expression result in panic, the entire
+// match expression results in panic.
+
+pub fn main() {
+    let _x =
+        match true {
+          true => { 10 }
+          false => { match true { true => { panic!() } false => { panic!() } } }
+        };
+}
diff --git a/src/test/run-pass/binding/expr-match-panic.rs b/src/test/run-pass/binding/expr-match-panic.rs
new file mode 100644
index 00000000000..c6f8ae7bca6
--- /dev/null
+++ b/src/test/run-pass/binding/expr-match-panic.rs
@@ -0,0 +1,24 @@
+// Copyright 2012 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.
+
+// run-pass
+
+
+fn test_simple() {
+    let r = match true { true => { true } false => { panic!() } };
+    assert_eq!(r, true);
+}
+
+fn test_box() {
+    let r = match true { true => { vec![10] } false => { panic!() } };
+    assert_eq!(r[0], 10);
+}
+
+pub fn main() { test_simple(); test_box(); }
diff --git a/src/test/run-pass/binding/expr-match-unique.rs b/src/test/run-pass/binding/expr-match-unique.rs
new file mode 100644
index 00000000000..b67b9fa3dda
--- /dev/null
+++ b/src/test/run-pass/binding/expr-match-unique.rs
@@ -0,0 +1,20 @@
+// Copyright 2012 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.
+
+// run-pass
+#![feature(box_syntax)]
+
+// Tests for match as expressions resulting in boxed types
+fn test_box() {
+    let res: Box<_> = match true { true => { box 100 }, _ => panic!() };
+    assert_eq!(*res, 100);
+}
+
+pub fn main() { test_box(); }
diff --git a/src/test/run-pass/binding/expr-match.rs b/src/test/run-pass/binding/expr-match.rs
new file mode 100644
index 00000000000..83d44e42b32
--- /dev/null
+++ b/src/test/run-pass/binding/expr-match.rs
@@ -0,0 +1,55 @@
+// Copyright 2012 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.
+
+// run-pass
+
+
+
+
+// Tests for using match as an expression
+
+fn test_basic() {
+    let mut rs: bool = match true { true => { true } false => { false } };
+    assert!((rs));
+    rs = match false { true => { false } false => { true } };
+    assert!((rs));
+}
+
+fn test_inferrence() {
+    let rs = match true { true => { true } false => { false } };
+    assert!((rs));
+}
+
+fn test_alt_as_alt_head() {
+    // Yeah, this is kind of confusing ...
+
+    let rs =
+        match match false { true => { true } false => { false } } {
+          true => { false }
+          false => { true }
+        };
+    assert!((rs));
+}
+
+fn test_alt_as_block_result() {
+    let rs =
+        match false {
+          true => { false }
+          false => { match true { true => { true } false => { false } } }
+        };
+    assert!((rs));
+}
+
+pub fn main() {
+    test_basic();
+    test_inferrence();
+    test_alt_as_alt_head();
+    test_alt_as_block_result();
+}
diff --git a/src/test/run-pass/binding/fat-arrow-match.rs b/src/test/run-pass/binding/fat-arrow-match.rs
new file mode 100644
index 00000000000..678485b324d
--- /dev/null
+++ b/src/test/run-pass/binding/fat-arrow-match.rs
@@ -0,0 +1,27 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(dead_code)]
+#![allow(non_camel_case_types)]
+
+enum color {
+    red,
+    green,
+    blue
+}
+
+pub fn main() {
+    println!("{}", match color::red {
+        color::red => { 1 }
+        color::green => { 2 }
+        color::blue => { 3 }
+    });
+}
diff --git a/src/test/run-pass/binding/fn-pattern-expected-type-2.rs b/src/test/run-pass/binding/fn-pattern-expected-type-2.rs
new file mode 100644
index 00000000000..7926234161f
--- /dev/null
+++ b/src/test/run-pass/binding/fn-pattern-expected-type-2.rs
@@ -0,0 +1,18 @@
+// Copyright 2012 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.
+
+// run-pass
+pub fn main() {
+    let v : &[(isize,isize)] = &[ (1, 2), (3, 4), (5, 6) ];
+    for &(x, y) in v {
+        println!("{}", y);
+        println!("{}", x);
+    }
+}
diff --git a/src/test/run-pass/binding/fn-pattern-expected-type.rs b/src/test/run-pass/binding/fn-pattern-expected-type.rs
new file mode 100644
index 00000000000..a868267f371
--- /dev/null
+++ b/src/test/run-pass/binding/fn-pattern-expected-type.rs
@@ -0,0 +1,19 @@
+// Copyright 2012 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.
+
+// run-pass
+
+pub fn main() {
+    let f = |(x, y): (isize, isize)| {
+        assert_eq!(x, 1);
+        assert_eq!(y, 2);
+    };
+    f((1, 2));
+}
diff --git a/src/test/run-pass/binding/func-arg-incomplete-pattern.rs b/src/test/run-pass/binding/func-arg-incomplete-pattern.rs
new file mode 100644
index 00000000000..bc994f0f7fa
--- /dev/null
+++ b/src/test/run-pass/binding/func-arg-incomplete-pattern.rs
@@ -0,0 +1,34 @@
+// 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.
+
+// run-pass
+#![allow(dead_code)]
+// Test that we do not leak when the arg pattern must drop part of the
+// argument (in this case, the `y` field).
+
+#![feature(box_syntax)]
+
+struct Foo {
+    x: Box<usize>,
+    y: Box<usize>,
+}
+
+fn foo(Foo {x, ..}: Foo) -> *const usize {
+    let addr: *const usize = &*x;
+    addr
+}
+
+pub fn main() {
+    let obj: Box<_> = box 1;
+    let objptr: *const usize = &*obj;
+    let f = Foo {x: obj, y: box 2};
+    let xptr = foo(f);
+    assert_eq!(objptr, xptr);
+}
diff --git a/src/test/run-pass/binding/func-arg-ref-pattern.rs b/src/test/run-pass/binding/func-arg-ref-pattern.rs
new file mode 100644
index 00000000000..7e87f14e2c5
--- /dev/null
+++ b/src/test/run-pass/binding/func-arg-ref-pattern.rs
@@ -0,0 +1,38 @@
+// 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.
+
+// run-pass
+// exec-env:RUST_POISON_ON_FREE=1
+
+// Test argument patterns where we create refs to the inside of
+// boxes. Make sure that we don't free the box as we match the
+// pattern.
+
+#![feature(box_patterns)]
+#![feature(box_syntax)]
+
+fn getaddr(box ref x: Box<usize>) -> *const usize {
+    let addr: *const usize = &*x;
+    addr
+}
+
+fn checkval(box ref x: Box<usize>) -> usize {
+    *x
+}
+
+pub fn main() {
+    let obj: Box<_> = box 1;
+    let objptr: *const usize = &*obj;
+    let xptr = getaddr(obj);
+    assert_eq!(objptr, xptr);
+
+    let obj = box 22;
+    assert_eq!(checkval(obj), 22);
+}
diff --git a/src/test/run-pass/binding/func-arg-wild-pattern.rs b/src/test/run-pass/binding/func-arg-wild-pattern.rs
new file mode 100644
index 00000000000..18a1909b51e
--- /dev/null
+++ b/src/test/run-pass/binding/func-arg-wild-pattern.rs
@@ -0,0 +1,22 @@
+// 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.
+
+// run-pass
+// Test that we can compile code that uses a `_` in function argument
+// patterns.
+
+
+fn foo((x, _): (isize, isize)) -> isize {
+    x
+}
+
+pub fn main() {
+    assert_eq!(foo((22, 23)), 22);
+}
diff --git a/src/test/run-pass/binding/if-let.rs b/src/test/run-pass/binding/if-let.rs
new file mode 100644
index 00000000000..933865342c4
--- /dev/null
+++ b/src/test/run-pass/binding/if-let.rs
@@ -0,0 +1,70 @@
+// 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.
+
+// run-pass
+#![allow(dead_code)]
+
+pub fn main() {
+    let x = Some(3);
+    if let Some(y) = x {
+        assert_eq!(y, 3);
+    } else {
+        panic!("if-let panicked");
+    }
+    let mut worked = false;
+    if let Some(_) = x {
+        worked = true;
+    }
+    assert!(worked);
+    let clause: usize;
+    if let None = Some("test") {
+        clause = 1;
+    } else if 4_usize > 5 {
+        clause = 2;
+    } else if let Ok(()) = Err::<(),&'static str>("test") {
+        clause = 3;
+    } else {
+        clause = 4;
+    }
+    assert_eq!(clause, 4_usize);
+
+    if 3 > 4 {
+        panic!("bad math");
+    } else if let 1 = 2 {
+        panic!("bad pattern match");
+    }
+
+    enum Foo {
+        One,
+        Two(usize),
+        Three(String, isize)
+    }
+
+    let foo = Foo::Three("three".to_string(), 42);
+    if let Foo::One = foo {
+        panic!("bad pattern match");
+    } else if let Foo::Two(_x) = foo {
+        panic!("bad pattern match");
+    } else if let Foo::Three(s, _) = foo {
+        assert_eq!(s, "three");
+    } else {
+        panic!("bad else");
+    }
+
+    if false {
+        panic!("wat");
+    } else if let a@Foo::Two(_) = Foo::Two(42_usize) {
+        if let Foo::Two(b) = a {
+            assert_eq!(b, 42_usize);
+        } else {
+            panic!("panic in nested if-let");
+        }
+    }
+}
diff --git a/src/test/run-pass/binding/inconsistent-lifetime-mismatch.rs b/src/test/run-pass/binding/inconsistent-lifetime-mismatch.rs
new file mode 100644
index 00000000000..fd2764f84d7
--- /dev/null
+++ b/src/test/run-pass/binding/inconsistent-lifetime-mismatch.rs
@@ -0,0 +1,25 @@
+// 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.
+
+// run-pass
+#![allow(dead_code)]
+// pretty-expanded FIXME #23616
+
+fn foo(_: &[&str]) {}
+
+fn bad(a: &str, b: &str) {
+    foo(&[a, b]);
+}
+
+fn good(a: &str, b: &str) {
+    foo(&[a, b]);
+}
+
+fn main() {}
diff --git a/src/test/run-pass/binding/inferred-suffix-in-pattern-range.rs b/src/test/run-pass/binding/inferred-suffix-in-pattern-range.rs
new file mode 100644
index 00000000000..3be0991aea6
--- /dev/null
+++ b/src/test/run-pass/binding/inferred-suffix-in-pattern-range.rs
@@ -0,0 +1,34 @@
+// Copyright 2012 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.
+
+// run-pass
+
+pub fn main() {
+    let x = 2;
+    let x_message = match x {
+      0 ..= 1    => { "not many".to_string() }
+      _          => { "lots".to_string() }
+    };
+    assert_eq!(x_message, "lots".to_string());
+
+    let y = 2;
+    let y_message = match y {
+      0 ..= 1    => { "not many".to_string() }
+      _          => { "lots".to_string() }
+    };
+    assert_eq!(y_message, "lots".to_string());
+
+    let z = 1u64;
+    let z_message = match z {
+      0 ..= 1    => { "not many".to_string() }
+      _          => { "lots".to_string() }
+    };
+    assert_eq!(z_message, "not many".to_string());
+}
diff --git a/src/test/run-pass/binding/irrefutable-slice-patterns.rs b/src/test/run-pass/binding/irrefutable-slice-patterns.rs
new file mode 100644
index 00000000000..9cd62f9a901
--- /dev/null
+++ b/src/test/run-pass/binding/irrefutable-slice-patterns.rs
@@ -0,0 +1,25 @@
+// Copyright 2018 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.
+
+// run-pass
+// #47096
+
+#![feature(slice_patterns)]
+
+fn foo(s: &[i32]) -> &[i32] {
+    let &[ref xs..] = s;
+    xs
+}
+
+fn main() {
+    let x = [1, 2, 3];
+    let y = foo(&x);
+    assert_eq!(x, y);
+}
diff --git a/src/test/run-pass/binding/let-assignability.rs b/src/test/run-pass/binding/let-assignability.rs
new file mode 100644
index 00000000000..99fc172892c
--- /dev/null
+++ b/src/test/run-pass/binding/let-assignability.rs
@@ -0,0 +1,22 @@
+// Copyright 2012 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.
+
+// run-pass
+#![feature(box_syntax)]
+
+fn f() {
+    let a: Box<_> = box 1;
+    let b: &isize = &*a;
+    println!("{}", b);
+}
+
+pub fn main() {
+    f();
+}
diff --git a/src/test/run-pass/binding/let-destruct-ref.rs b/src/test/run-pass/binding/let-destruct-ref.rs
new file mode 100644
index 00000000000..1c1b1a39769
--- /dev/null
+++ b/src/test/run-pass/binding/let-destruct-ref.rs
@@ -0,0 +1,17 @@
+// 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.
+
+// run-pass
+
+pub fn main() {
+    let x = 3_usize;
+    let ref y = x;
+    assert_eq!(x, *y);
+}
diff --git a/src/test/run-pass/binding/let-var-hygiene.rs b/src/test/run-pass/binding/let-var-hygiene.rs
new file mode 100644
index 00000000000..d432dbe86b9
--- /dev/null
+++ b/src/test/run-pass/binding/let-var-hygiene.rs
@@ -0,0 +1,21 @@
+// Copyright 2012 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.
+
+// run-pass
+// shouldn't affect evaluation of $ex:
+
+macro_rules! bad_macro {
+    ($ex:expr) => ({let _x = 9; $ex})
+}
+
+pub fn main() {
+    let _x = 8;
+    assert_eq!(bad_macro!(_x),8)
+}
diff --git a/src/test/run-pass/binding/match-arm-statics.rs b/src/test/run-pass/binding/match-arm-statics.rs
new file mode 100644
index 00000000000..b6f4cb18d9a
--- /dev/null
+++ b/src/test/run-pass/binding/match-arm-statics.rs
@@ -0,0 +1,176 @@
+// 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.
+
+// run-pass
+#![allow(dead_code)]
+// compile-flags: -g
+
+#[derive(PartialEq, Eq)]
+struct NewBool(bool);
+
+#[derive(PartialEq, Eq)]
+enum Direction {
+    North,
+    East,
+    South,
+    West
+}
+
+#[derive(PartialEq, Eq)]
+struct Foo {
+    bar: Option<Direction>,
+    baz: NewBool
+}
+
+#[derive(PartialEq, Eq)]
+enum EnumWithStructVariants {
+    Variant1(bool),
+    Variant2 {
+        dir: Direction
+    }
+}
+
+const TRUE_TRUE: (bool, bool) = (true, true);
+const NONE: Option<Direction> = None;
+const EAST: Direction = Direction::East;
+const NEW_FALSE: NewBool = NewBool(false);
+const STATIC_FOO: Foo = Foo { bar: Some(Direction::South), baz: NEW_FALSE };
+const VARIANT2_NORTH: EnumWithStructVariants = EnumWithStructVariants::Variant2 {
+    dir: Direction::North };
+
+pub mod glfw {
+    #[derive(Copy, Clone, PartialEq, Eq)]
+    pub struct InputState(usize);
+
+    pub const RELEASE  : InputState = InputState(0);
+    pub const PRESS    : InputState = InputState(1);
+    pub const REPEAT   : InputState = InputState(2);
+}
+
+fn issue_6533() {
+    use glfw;
+
+    fn action_to_str(state: glfw::InputState) -> &'static str {
+        use glfw::{RELEASE, PRESS, REPEAT};
+        match state {
+            RELEASE => { "Released" }
+            PRESS   => { "Pressed"  }
+            REPEAT  => { "Repeated" }
+            _       => { "Unknown"  }
+        }
+    }
+
+    assert_eq!(action_to_str(glfw::RELEASE), "Released");
+    assert_eq!(action_to_str(glfw::PRESS), "Pressed");
+    assert_eq!(action_to_str(glfw::REPEAT), "Repeated");
+}
+
+fn issue_13626() {
+    const VAL: [u8; 1] = [0];
+    match [1] {
+        VAL => unreachable!(),
+        _ => ()
+    }
+}
+
+fn issue_14576() {
+    type Foo = (i32, i32);
+    const ON: Foo = (1, 1);
+    const OFF: Foo = (0, 0);
+
+    match (1, 1) {
+        OFF => unreachable!(),
+        ON => (),
+        _ => unreachable!()
+    }
+
+    #[derive(PartialEq, Eq)]
+    enum C { D = 3, E = 4 }
+    const F : C = C::D;
+
+    assert_eq!(match C::D { F => 1, _ => 2, }, 1);
+
+    // test gaps
+    #[derive(PartialEq, Eq)]
+    enum G { H = 3, I = 5 }
+    const K : G = G::I;
+
+    assert_eq!(match G::I { K => 1, _ => 2, }, 1);
+}
+
+fn issue_13731() {
+    #[derive(PartialEq, Eq)]
+    enum A { AA(()) }
+    const B: A = A::AA(());
+
+    match A::AA(()) {
+        B => ()
+    }
+}
+
+fn issue_15393() {
+    #![allow(dead_code)]
+    #[derive(PartialEq, Eq)]
+    struct Flags {
+        bits: usize
+    }
+
+    const FOO: Flags = Flags { bits: 0x01 };
+    const BAR: Flags = Flags { bits: 0x02 };
+    match (Flags { bits: 0x02 }) {
+        FOO => unreachable!(),
+        BAR => (),
+        _ => unreachable!()
+    }
+}
+
+fn main() {
+    assert_eq!(match (true, false) {
+        TRUE_TRUE => 1,
+        (false, false) => 2,
+        (false, true) => 3,
+        (true, false) => 4
+    }, 4);
+
+    assert_eq!(match Some(Some(Direction::North)) {
+        Some(NONE) => 1,
+        Some(Some(Direction::North)) => 2,
+        Some(Some(EAST)) => 3,
+        Some(Some(Direction::South)) => 4,
+        Some(Some(Direction::West)) => 5,
+        None => 6
+    }, 2);
+
+    assert_eq!(match (Foo { bar: Some(Direction::West), baz: NewBool(true) }) {
+        Foo { bar: None, baz: NewBool(true) } => 1,
+        Foo { bar: NONE, baz: NEW_FALSE } => 2,
+        STATIC_FOO => 3,
+        Foo { bar: _, baz: NEW_FALSE } => 4,
+        Foo { bar: Some(Direction::West), baz: NewBool(true) } => 5,
+        Foo { bar: Some(Direction::South), baz: NewBool(true) } => 6,
+        Foo { bar: Some(EAST), .. } => 7,
+        Foo { bar: Some(Direction::North), baz: NewBool(true) } => 8
+    }, 5);
+
+    assert_eq!(match (EnumWithStructVariants::Variant2 { dir: Direction::North }) {
+        EnumWithStructVariants::Variant1(true) => 1,
+        EnumWithStructVariants::Variant1(false) => 2,
+        EnumWithStructVariants::Variant2 { dir: Direction::West } => 3,
+        VARIANT2_NORTH => 4,
+        EnumWithStructVariants::Variant2 { dir: Direction::South } => 5,
+        EnumWithStructVariants::Variant2 { dir: Direction::East } => 6
+    }, 4);
+
+    issue_6533();
+    issue_13626();
+    issue_13731();
+    issue_14576();
+    issue_15393();
+}
diff --git a/src/test/run-pass/binding/match-beginning-vert.rs b/src/test/run-pass/binding/match-beginning-vert.rs
new file mode 100644
index 00000000000..16954f85752
--- /dev/null
+++ b/src/test/run-pass/binding/match-beginning-vert.rs
@@ -0,0 +1,29 @@
+// Copyright 2018 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.
+
+// run-pass
+enum Foo {
+    A,
+    B,
+    C,
+    D,
+    E,
+}
+use Foo::*;
+
+fn main() {
+    for foo in &[A, B, C, D, E] {
+        match *foo {
+            | A => println!("A"),
+            | B | C if 1 < 2 => println!("BC!"),
+            | _ => {},
+        }
+    }
+}
diff --git a/src/test/run-pass/binding/match-borrowed_str.rs b/src/test/run-pass/binding/match-borrowed_str.rs
new file mode 100644
index 00000000000..0871ff836cc
--- /dev/null
+++ b/src/test/run-pass/binding/match-borrowed_str.rs
@@ -0,0 +1,58 @@
+// Copyright 2013 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.
+
+// run-pass
+
+fn f1(ref_string: &str) -> String {
+    match ref_string {
+        "a" => "found a".to_string(),
+        "b" => "found b".to_string(),
+        _ => "not found".to_string()
+    }
+}
+
+fn f2(ref_string: &str) -> String {
+    match ref_string {
+        "a" => "found a".to_string(),
+        "b" => "found b".to_string(),
+        s => format!("not found ({})", s)
+    }
+}
+
+fn g1(ref_1: &str, ref_2: &str) -> String {
+    match (ref_1, ref_2) {
+        ("a", "b") => "found a,b".to_string(),
+        ("b", "c") => "found b,c".to_string(),
+        _ => "not found".to_string()
+    }
+}
+
+fn g2(ref_1: &str, ref_2: &str) -> String {
+    match (ref_1, ref_2) {
+        ("a", "b") => "found a,b".to_string(),
+        ("b", "c") => "found b,c".to_string(),
+        (s1, s2) => format!("not found ({}, {})", s1, s2)
+    }
+}
+
+pub fn main() {
+    assert_eq!(f1("b"), "found b".to_string());
+    assert_eq!(f1("c"), "not found".to_string());
+    assert_eq!(f1("d"), "not found".to_string());
+    assert_eq!(f2("b"), "found b".to_string());
+    assert_eq!(f2("c"), "not found (c)".to_string());
+    assert_eq!(f2("d"), "not found (d)".to_string());
+    assert_eq!(g1("b", "c"), "found b,c".to_string());
+    assert_eq!(g1("c", "d"), "not found".to_string());
+    assert_eq!(g1("d", "e"), "not found".to_string());
+    assert_eq!(g2("b", "c"), "found b,c".to_string());
+    assert_eq!(g2("c", "d"), "not found (c, d)".to_string());
+    assert_eq!(g2("d", "e"), "not found (d, e)".to_string());
+}
diff --git a/src/test/run-pass/binding/match-bot-2.rs b/src/test/run-pass/binding/match-bot-2.rs
new file mode 100644
index 00000000000..f25b423607b
--- /dev/null
+++ b/src/test/run-pass/binding/match-bot-2.rs
@@ -0,0 +1,16 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(unreachable_code)]
+// n.b. This was only ever failing with optimization disabled.
+
+fn a() -> isize { match return 1 { 2 => 3, _ => panic!() } }
+pub fn main() { a(); }
diff --git a/src/test/run-pass/binding/match-bot.rs b/src/test/run-pass/binding/match-bot.rs
new file mode 100644
index 00000000000..d91d95b826a
--- /dev/null
+++ b/src/test/run-pass/binding/match-bot.rs
@@ -0,0 +1,17 @@
+// Copyright 2012 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.
+
+// run-pass
+
+pub fn main() {
+    let i: isize =
+        match Some::<isize>(3) { None::<isize> => { panic!() } Some::<isize>(_) => { 5 } };
+    println!("{}", i);
+}
diff --git a/src/test/run-pass/binding/match-byte-array-patterns.rs b/src/test/run-pass/binding/match-byte-array-patterns.rs
new file mode 100644
index 00000000000..728d4a241fe
--- /dev/null
+++ b/src/test/run-pass/binding/match-byte-array-patterns.rs
@@ -0,0 +1,55 @@
+// Copyright 2016 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.
+
+// run-pass
+#![feature(slice_patterns)]
+
+fn main() {
+    let buf = &[0u8; 4];
+    match buf {
+        &[0, 1, 0, 0] => unimplemented!(),
+        b"true" => unimplemented!(),
+        _ => {}
+    }
+
+    match buf {
+        b"true" => unimplemented!(),
+        &[0, 1, 0, 0] => unimplemented!(),
+        _ => {}
+    }
+
+    match buf {
+        b"true" => unimplemented!(),
+        &[0, x, 0, 0] => assert_eq!(x, 0),
+        _ => unimplemented!(),
+    }
+
+    let buf: &[u8] = buf;
+
+    match buf {
+        &[0, 1, 0, 0] => unimplemented!(),
+        &[_] => unimplemented!(),
+        &[_, _, _, _, _, ..] => unimplemented!(),
+        b"true" => unimplemented!(),
+        _ => {}
+    }
+
+    match buf {
+        b"true" => unimplemented!(),
+        &[0, 1, 0, 0] => unimplemented!(),
+        _ => {}
+    }
+
+    match buf {
+        b"true" => unimplemented!(),
+        &[0, x, 0, 0] => assert_eq!(x, 0),
+        _ => unimplemented!(),
+    }
+}
diff --git a/src/test/run-pass/binding/match-enum-struct-0.rs b/src/test/run-pass/binding/match-enum-struct-0.rs
new file mode 100644
index 00000000000..bc364b04aec
--- /dev/null
+++ b/src/test/run-pass/binding/match-enum-struct-0.rs
@@ -0,0 +1,27 @@
+// Copyright 2013 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.
+
+// run-pass
+#![allow(dead_code)]
+// regression test for issue #5625
+
+
+enum E {
+    Foo{f : isize},
+    Bar
+}
+
+pub fn main() {
+    let e = E::Bar;
+    match e {
+        E::Foo{f: _f} => panic!(),
+        _ => (),
+    }
+}
diff --git a/src/test/run-pass/binding/match-enum-struct-1.rs b/src/test/run-pass/binding/match-enum-struct-1.rs
new file mode 100644
index 00000000000..71cacc2f6bf
--- /dev/null
+++ b/src/test/run-pass/binding/match-enum-struct-1.rs
@@ -0,0 +1,29 @@
+// Copyright 2013 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.
+
+// run-pass
+#![allow(dead_code)]
+
+enum E {
+    Foo{f : isize},
+    Bar
+}
+
+pub fn main() {
+    let e = E::Foo{f: 1};
+    match e {
+        E::Foo{..} => (),
+        _ => panic!(),
+    }
+    match e {
+        E::Foo{f: _f} => (),
+        _ => panic!(),
+    }
+}
diff --git a/src/test/run-pass/binding/match-implicit-copy-unique.rs b/src/test/run-pass/binding/match-implicit-copy-unique.rs
new file mode 100644
index 00000000000..68edbea3471
--- /dev/null
+++ b/src/test/run-pass/binding/match-implicit-copy-unique.rs
@@ -0,0 +1,27 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(non_shorthand_field_patterns)]
+#![feature(box_syntax)]
+
+struct Pair { a: Box<isize>, b: Box<isize> }
+
+pub fn main() {
+    let mut x: Box<_> = box Pair {a: box 10, b: box 20};
+    let x_internal = &mut *x;
+    match *x_internal {
+      Pair {a: ref mut a, b: ref mut _b} => {
+        assert_eq!(**a, 10);
+        *a = box 30;
+        assert_eq!(**a, 30);
+      }
+    }
+}
diff --git a/src/test/run-pass/binding/match-in-macro.rs b/src/test/run-pass/binding/match-in-macro.rs
new file mode 100644
index 00000000000..5c4c7c048ef
--- /dev/null
+++ b/src/test/run-pass/binding/match-in-macro.rs
@@ -0,0 +1,27 @@
+// Copyright 2012 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.
+
+// run-pass
+
+enum Foo {
+    B { b1: isize, bb1: isize},
+}
+
+macro_rules! match_inside_expansion {
+    () => (
+        match (Foo::B { b1:29 , bb1: 100}) {
+            Foo::B { b1:b2 , bb1:bb2 } => b2+bb2
+        }
+    )
+}
+
+pub fn main() {
+    assert_eq!(match_inside_expansion!(),129);
+}
diff --git a/src/test/run-pass/binding/match-join.rs b/src/test/run-pass/binding/match-join.rs
new file mode 100644
index 00000000000..cd7cc87a40b
--- /dev/null
+++ b/src/test/run-pass/binding/match-join.rs
@@ -0,0 +1,30 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(unused_mut)]
+fn foo<T>(y: Option<T>) {
+    let mut x: isize;
+    let mut rs: Vec<isize> = Vec::new();
+    /* tests that x doesn't get put in the precondition for the
+       entire if expression */
+
+    if true {
+    } else {
+        match y {
+          None::<T> => x = 17,
+          _ => x = 42
+        }
+        rs.push(x);
+    }
+    return;
+}
+
+pub fn main() { println!("hello"); foo::<isize>(Some::<isize>(5)); }
diff --git a/src/test/run-pass/binding/match-larger-const.rs b/src/test/run-pass/binding/match-larger-const.rs
new file mode 100644
index 00000000000..f649ce0ee0e
--- /dev/null
+++ b/src/test/run-pass/binding/match-larger-const.rs
@@ -0,0 +1,22 @@
+// Copyright 2018 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.
+
+// run-pass
+#[derive(Eq, PartialEq)]
+pub struct Data([u8; 4]);
+
+const DATA: Data = Data([1, 2, 3, 4]);
+
+fn main() {
+    match DATA {
+        DATA => (),
+        _ => (),
+    }
+}
diff --git a/src/test/run-pass/binding/match-naked-record-expr.rs b/src/test/run-pass/binding/match-naked-record-expr.rs
new file mode 100644
index 00000000000..f016ca8e43c
--- /dev/null
+++ b/src/test/run-pass/binding/match-naked-record-expr.rs
@@ -0,0 +1,22 @@
+// Copyright 2012 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.
+
+// run-pass
+// pretty-expanded FIXME #23616
+
+struct X { x: isize }
+
+pub fn main() {
+    let _x = match 0 {
+      _ => X {
+        x: 0
+      }.x
+    };
+}
diff --git a/src/test/run-pass/binding/match-naked-record.rs b/src/test/run-pass/binding/match-naked-record.rs
new file mode 100644
index 00000000000..9c4c36693b9
--- /dev/null
+++ b/src/test/run-pass/binding/match-naked-record.rs
@@ -0,0 +1,23 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(dead_code)]
+// pretty-expanded FIXME #23616
+
+struct X { x: isize }
+
+pub fn main() {
+    let _x = match 0 {
+      _ => X {
+        x: 0
+      }
+    };
+}
diff --git a/src/test/run-pass/binding/match-path.rs b/src/test/run-pass/binding/match-path.rs
new file mode 100644
index 00000000000..385713001a3
--- /dev/null
+++ b/src/test/run-pass/binding/match-path.rs
@@ -0,0 +1,24 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(dead_code)]
+#![allow(non_camel_case_types)]
+
+
+// pretty-expanded FIXME #23616
+
+mod m1 {
+    pub enum foo { foo1, foo2, }
+}
+
+fn bar(x: m1::foo) { match x { m1::foo::foo1 => { } m1::foo::foo2 => { } } }
+
+pub fn main() { }
diff --git a/src/test/run-pass/binding/match-pattern-bindings.rs b/src/test/run-pass/binding/match-pattern-bindings.rs
new file mode 100644
index 00000000000..e6242a0ee58
--- /dev/null
+++ b/src/test/run-pass/binding/match-pattern-bindings.rs
@@ -0,0 +1,31 @@
+// 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.
+
+// run-pass
+
+fn main() {
+    let value = Some(1);
+    assert_eq!(match value {
+        ref a @ Some(_) => a,
+        ref b @ None => b
+    }, &Some(1));
+    assert_eq!(match value {
+        ref c @ Some(_) => c,
+        ref b @ None => b
+    }, &Some(1));
+    assert_eq!(match "foobarbaz" {
+        b @ _ => b
+    }, "foobarbaz");
+    let a @ _ = "foobarbaz";
+    assert_eq!(a, "foobarbaz");
+    let value = Some(true);
+    let ref a @ _ = value;
+    assert_eq!(a, &Some(true));
+}
diff --git a/src/test/run-pass/binding/match-pattern-lit.rs b/src/test/run-pass/binding/match-pattern-lit.rs
new file mode 100644
index 00000000000..8e6129d60b5
--- /dev/null
+++ b/src/test/run-pass/binding/match-pattern-lit.rs
@@ -0,0 +1,25 @@
+// Copyright 2012 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.
+
+// run-pass
+
+
+fn altlit(f: isize) -> isize {
+    match f {
+      10 => { println!("case 10"); return 20; }
+      11 => { println!("case 11"); return 22; }
+      _  => panic!("the impossible happened")
+    }
+}
+
+pub fn main() {
+    assert_eq!(altlit(10), 20);
+    assert_eq!(altlit(11), 22);
+}
diff --git a/src/test/run-pass/binding/match-pattern-no-type-params.rs b/src/test/run-pass/binding/match-pattern-no-type-params.rs
new file mode 100644
index 00000000000..e42a24f20b9
--- /dev/null
+++ b/src/test/run-pass/binding/match-pattern-no-type-params.rs
@@ -0,0 +1,24 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(dead_code)]
+#![allow(non_camel_case_types)]
+
+enum maybe<T> { nothing, just(T), }
+
+fn foo(x: maybe<isize>) {
+    match x {
+        maybe::nothing => { println!("A"); }
+        maybe::just(_a) => { println!("B"); }
+    }
+}
+
+pub fn main() { }
diff --git a/src/test/run-pass/binding/match-pattern-simple.rs b/src/test/run-pass/binding/match-pattern-simple.rs
new file mode 100644
index 00000000000..3522ba71b6a
--- /dev/null
+++ b/src/test/run-pass/binding/match-pattern-simple.rs
@@ -0,0 +1,19 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(dead_code)]
+
+
+// pretty-expanded FIXME #23616
+
+fn altsimple(f: isize) { match f { _x => () } }
+
+pub fn main() { }
diff --git a/src/test/run-pass/binding/match-phi.rs b/src/test/run-pass/binding/match-phi.rs
new file mode 100644
index 00000000000..43a55da573b
--- /dev/null
+++ b/src/test/run-pass/binding/match-phi.rs
@@ -0,0 +1,29 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(dead_code)]
+#![allow(unused_assignments)]
+// pretty-expanded FIXME #23616
+#![allow(non_camel_case_types)]
+#![allow(unused_variables)]
+
+enum thing { a, b, c, }
+
+fn foo<F>(it: F) where F: FnOnce(isize) { it(10); }
+
+pub fn main() {
+    let mut x = true;
+    match thing::a {
+      thing::a => { x = true; foo(|_i| { } ) }
+      thing::b => { x = false; }
+      thing::c => { x = false; }
+    }
+}
diff --git a/src/test/run-pass/binding/match-pipe-binding.rs b/src/test/run-pass/binding/match-pipe-binding.rs
new file mode 100644
index 00000000000..577e5c97e42
--- /dev/null
+++ b/src/test/run-pass/binding/match-pipe-binding.rs
@@ -0,0 +1,71 @@
+// Copyright 2013 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.
+
+// run-pass
+// compile-flags: -Z borrowck=compare
+
+fn test1() {
+    // from issue 6338
+    match ((1, "a".to_string()), (2, "b".to_string())) {
+        ((1, a), (2, b)) | ((2, b), (1, a)) => {
+                assert_eq!(a, "a".to_string());
+                assert_eq!(b, "b".to_string());
+            },
+            _ => panic!(),
+    }
+}
+
+fn test2() {
+    match (1, 2, 3) {
+        (1, a, b) | (2, b, a) => {
+            assert_eq!(a, 2);
+            assert_eq!(b, 3);
+        },
+        _ => panic!(),
+    }
+}
+
+fn test3() {
+    match (1, 2, 3) {
+        (1, ref a, ref b) | (2, ref b, ref a) => {
+            assert_eq!(*a, 2);
+            assert_eq!(*b, 3);
+        },
+        _ => panic!(),
+    }
+}
+
+fn test4() {
+    match (1, 2, 3) {
+        (1, a, b) | (2, b, a) if a == 2 => {
+            assert_eq!(a, 2);
+            assert_eq!(b, 3);
+        },
+        _ => panic!(),
+    }
+}
+
+fn test5() {
+    match (1, 2, 3) {
+        (1, ref a, ref b) | (2, ref b, ref a) if *a == 2 => {
+            assert_eq!(*a, 2);
+            assert_eq!(*b, 3);
+        },
+        _ => panic!(),
+    }
+}
+
+pub fn main() {
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
+}
diff --git a/src/test/run-pass/binding/match-range-infer.rs b/src/test/run-pass/binding/match-range-infer.rs
new file mode 100644
index 00000000000..7178d1837c7
--- /dev/null
+++ b/src/test/run-pass/binding/match-range-infer.rs
@@ -0,0 +1,27 @@
+// Copyright 2015 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.
+
+// run-pass
+// Test that type inference for range patterns works correctly (is bi-directional).
+
+pub fn main() {
+    match 1 {
+        1 ..= 3 => {}
+        _ => panic!("should match range")
+    }
+    match 1 {
+        1 ..= 3u16 => {}
+        _ => panic!("should match range with inferred start type")
+    }
+    match 1 {
+        1u16 ..= 3 => {}
+        _ => panic!("should match range with inferred end type")
+    }
+}
diff --git a/src/test/run-pass/binding/match-range-static.rs b/src/test/run-pass/binding/match-range-static.rs
new file mode 100644
index 00000000000..5be8db5fc86
--- /dev/null
+++ b/src/test/run-pass/binding/match-range-static.rs
@@ -0,0 +1,23 @@
+// 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.
+
+// run-pass
+// pretty-expanded FIXME #23616
+#![allow(non_upper_case_globals)]
+
+const s: isize = 1;
+const e: isize = 42;
+
+pub fn main() {
+    match 7 {
+        s..=e => (),
+        _ => (),
+    }
+}
diff --git a/src/test/run-pass/binding/match-range.rs b/src/test/run-pass/binding/match-range.rs
new file mode 100644
index 00000000000..a9687943e99
--- /dev/null
+++ b/src/test/run-pass/binding/match-range.rs
@@ -0,0 +1,61 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(illegal_floating_point_literal_pattern)] // FIXME #41620
+#![feature(exclusive_range_pattern)]
+
+pub fn main() {
+    match 5_usize {
+      1_usize..=5_usize => {}
+      _ => panic!("should match range"),
+    }
+    match 1_usize {
+        1_usize..5_usize => {}
+        _ => panic!("should match range start"),
+    }
+    match 5_usize {
+      6_usize..=7_usize => panic!("shouldn't match range"),
+      _ => {}
+    }
+    match 7_usize {
+        6_usize..7_usize => panic!("shouldn't match range end"),
+        _ => {},
+    }
+    match 5_usize {
+      1_usize => panic!("should match non-first range"),
+      2_usize..=6_usize => {}
+      _ => panic!("math is broken")
+    }
+    match 'c' {
+      'a'..='z' => {}
+      _ => panic!("should support char ranges")
+    }
+    match -3 {
+      -7..=5 => {}
+      _ => panic!("should match signed range")
+    }
+    match 3.0f64 {
+      1.0..=5.0 => {}
+      _ => panic!("should match float range")
+    }
+    match -1.5f64 {
+      -3.6..=3.6 => {}
+      _ => panic!("should match negative float range")
+    }
+    match 3.5 {
+        0.0..3.5 => panic!("should not match the range end"),
+        _ => {},
+    }
+    match 0.0 {
+        0.0..3.5 => {},
+        _ => panic!("should match the range start"),
+    }
+}
diff --git a/src/test/run-pass/binding/match-reassign.rs b/src/test/run-pass/binding/match-reassign.rs
new file mode 100644
index 00000000000..89b12976355
--- /dev/null
+++ b/src/test/run-pass/binding/match-reassign.rs
@@ -0,0 +1,31 @@
+// Copyright 2015 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.
+
+// run-pass
+// Regression test for #23698: The reassignment checker only cared
+// about the last assignment in a match arm body
+
+// Use an extra function to make sure no extra assignments
+// are introduced by macros in the match statement
+fn check_eq(x: i32, y: i32) {
+    assert_eq!(x, y);
+}
+
+#[allow(unused_assignments)]
+fn main() {
+    let mut x = Box::new(1);
+    match x {
+        y => {
+            x = Box::new(2);
+            let _tmp = 1; // This assignment used to throw off the reassignment checker
+            check_eq(*y, 1);
+        }
+    }
+}
diff --git a/src/test/run-pass/binding/match-ref-binding-in-guard-3256.rs b/src/test/run-pass/binding/match-ref-binding-in-guard-3256.rs
new file mode 100644
index 00000000000..2da75d941b4
--- /dev/null
+++ b/src/test/run-pass/binding/match-ref-binding-in-guard-3256.rs
@@ -0,0 +1,23 @@
+// Copyright 2012 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.
+
+// run-pass
+
+use std::sync::Mutex;
+
+pub fn main() {
+    let x = Some(Mutex::new(true));
+    match x {
+        Some(ref z) if *z.lock().unwrap() => {
+            assert!(*z.lock().unwrap());
+        },
+        _ => panic!()
+    }
+}
diff --git a/src/test/run-pass/binding/match-ref-binding-mut-option.rs b/src/test/run-pass/binding/match-ref-binding-mut-option.rs
new file mode 100644
index 00000000000..a3d26024732
--- /dev/null
+++ b/src/test/run-pass/binding/match-ref-binding-mut-option.rs
@@ -0,0 +1,20 @@
+// Copyright 2012 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.
+
+// run-pass
+
+pub fn main() {
+    let mut v = Some(22);
+    match v {
+      None => {}
+      Some(ref mut p) => { *p += 1; }
+    }
+    assert_eq!(v, Some(23));
+}
diff --git a/src/test/run-pass/binding/match-ref-binding-mut.rs b/src/test/run-pass/binding/match-ref-binding-mut.rs
new file mode 100644
index 00000000000..c1f09502542
--- /dev/null
+++ b/src/test/run-pass/binding/match-ref-binding-mut.rs
@@ -0,0 +1,28 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(non_shorthand_field_patterns)]
+
+struct Rec {
+    f: isize
+}
+
+fn destructure(x: &mut Rec) {
+    match *x {
+      Rec {f: ref mut f} => *f += 1
+    }
+}
+
+pub fn main() {
+    let mut v = Rec {f: 22};
+    destructure(&mut v);
+    assert_eq!(v.f, 23);
+}
diff --git a/src/test/run-pass/binding/match-ref-binding.rs b/src/test/run-pass/binding/match-ref-binding.rs
new file mode 100644
index 00000000000..bc36b8102ce
--- /dev/null
+++ b/src/test/run-pass/binding/match-ref-binding.rs
@@ -0,0 +1,22 @@
+// Copyright 2012 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.
+
+// run-pass
+
+fn destructure(x: Option<isize>) -> isize {
+    match x {
+      None => 0,
+      Some(ref v) => *v
+    }
+}
+
+pub fn main() {
+    assert_eq!(destructure(Some(22)), 22);
+}
diff --git a/src/test/run-pass/binding/match-ref-unsized.rs b/src/test/run-pass/binding/match-ref-unsized.rs
new file mode 100644
index 00000000000..7ef19330015
--- /dev/null
+++ b/src/test/run-pass/binding/match-ref-unsized.rs
@@ -0,0 +1,21 @@
+// Copyright 2015 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.
+
+// run-pass
+// Binding unsized expressions to ref patterns
+
+pub fn main() {
+    let ref a = *"abcdef";
+    assert_eq!(a, "abcdef");
+
+    match *"12345" {
+        ref b => { assert_eq!(b, "12345") }
+    }
+}
diff --git a/src/test/run-pass/binding/match-static-const-rename.rs b/src/test/run-pass/binding/match-static-const-rename.rs
new file mode 100644
index 00000000000..0d75c81b1e6
--- /dev/null
+++ b/src/test/run-pass/binding/match-static-const-rename.rs
@@ -0,0 +1,74 @@
+// Copyright 2012-2013 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.
+
+// run-pass
+// Issue #7526: lowercase static constants in patterns look like bindings
+
+// This is similar to compile-fail/match-static-const-lc, except it
+// shows the expected usual workaround (choosing a different name for
+// the static definition) and also demonstrates that one can work
+// around this problem locally by renaming the constant in the `use`
+// form to an uppercase identifier that placates the lint.
+
+
+#![deny(non_upper_case_globals)]
+
+pub const A : isize = 97;
+
+fn f() {
+    let r = match (0,0) {
+        (0, A) => 0,
+        (x, y) => 1 + x + y,
+    };
+    assert_eq!(r, 1);
+    let r = match (0,97) {
+        (0, A) => 0,
+        (x, y) => 1 + x + y,
+    };
+    assert_eq!(r, 0);
+}
+
+mod m {
+    #[allow(non_upper_case_globals)]
+    pub const aha : isize = 7;
+}
+
+fn g() {
+    use self::m::aha as AHA;
+    let r = match (0,0) {
+        (0, AHA) => 0,
+        (x, y)   => 1 + x + y,
+    };
+    assert_eq!(r, 1);
+    let r = match (0,7) {
+        (0, AHA) => 0,
+        (x, y)   => 1 + x + y,
+    };
+    assert_eq!(r, 0);
+}
+
+fn h() {
+    let r = match (0,0) {
+        (0, self::m::aha) => 0,
+        (x, y)      => 1 + x + y,
+    };
+    assert_eq!(r, 1);
+    let r = match (0,7) {
+        (0, self::m::aha) => 0,
+        (x, y)      => 1 + x + y,
+    };
+    assert_eq!(r, 0);
+}
+
+pub fn main () {
+    f();
+    g();
+    h();
+}
diff --git a/src/test/run-pass/binding/match-str.rs b/src/test/run-pass/binding/match-str.rs
new file mode 100644
index 00000000000..7b051cfa435
--- /dev/null
+++ b/src/test/run-pass/binding/match-str.rs
@@ -0,0 +1,35 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(dead_code)]
+// Issue #53
+#![allow(non_camel_case_types)]
+
+
+pub fn main() {
+    match "test" { "not-test" => panic!(), "test" => (), _ => panic!() }
+
+    enum t { tag1(String), tag2, }
+
+
+    match t::tag1("test".to_string()) {
+      t::tag2 => panic!(),
+      t::tag1(ref s) if "test" != &**s => panic!(),
+      t::tag1(ref s) if "test" == &**s => (),
+      _ => panic!()
+    }
+
+    let x = match "a" { "a" => 1, "b" => 2, _ => panic!() };
+    assert_eq!(x, 1);
+
+    match "a" { "a" => { } "b" => { }, _ => panic!() }
+
+}
diff --git a/src/test/run-pass/binding/match-struct-0.rs b/src/test/run-pass/binding/match-struct-0.rs
new file mode 100644
index 00000000000..facfaae5405
--- /dev/null
+++ b/src/test/run-pass/binding/match-struct-0.rs
@@ -0,0 +1,31 @@
+// Copyright 2013 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.
+
+// run-pass
+
+struct Foo{
+    f : isize,
+}
+
+pub fn main() {
+    let f = Foo{f: 1};
+    match f {
+        Foo{f: 0} => panic!(),
+        Foo{..} => (),
+    }
+    match f {
+        Foo{f: 0} => panic!(),
+        Foo{f: _f} => (),
+    }
+    match f {
+        Foo{f: 0} => panic!(),
+        _ => (),
+    }
+}
diff --git a/src/test/run-pass/binding/match-tag.rs b/src/test/run-pass/binding/match-tag.rs
new file mode 100644
index 00000000000..ca7b7c70afb
--- /dev/null
+++ b/src/test/run-pass/binding/match-tag.rs
@@ -0,0 +1,40 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(unused_mut)]
+#![allow(non_camel_case_types)]
+
+
+
+enum color {
+    rgb(isize, isize, isize),
+    rgba(isize, isize, isize, isize),
+    hsl(isize, isize, isize),
+}
+
+fn process(c: color) -> isize {
+    let mut x: isize;
+    match c {
+      color::rgb(r, _, _) => { x = r; }
+      color::rgba(_, _, _, a) => { x = a; }
+      color::hsl(_, s, _) => { x = s; }
+    }
+    return x;
+}
+
+pub fn main() {
+    let gray: color = color::rgb(127, 127, 127);
+    let clear: color = color::rgba(50, 150, 250, 0);
+    let red: color = color::hsl(0, 255, 255);
+    assert_eq!(process(gray), 127);
+    assert_eq!(process(clear), 0);
+    assert_eq!(process(red), 255);
+}
diff --git a/src/test/run-pass/binding/match-unique-bind.rs b/src/test/run-pass/binding/match-unique-bind.rs
new file mode 100644
index 00000000000..a543527586f
--- /dev/null
+++ b/src/test/run-pass/binding/match-unique-bind.rs
@@ -0,0 +1,22 @@
+// Copyright 2012 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.
+
+// run-pass
+#![feature(box_patterns)]
+#![feature(box_syntax)]
+
+pub fn main() {
+    match box 100 {
+      box x => {
+        println!("{}", x);
+        assert_eq!(x, 100);
+      }
+    }
+}
diff --git a/src/test/run-pass/binding/match-unsized.rs b/src/test/run-pass/binding/match-unsized.rs
new file mode 100644
index 00000000000..2e2f0f0b7ea
--- /dev/null
+++ b/src/test/run-pass/binding/match-unsized.rs
@@ -0,0 +1,19 @@
+// Copyright 2016 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.
+
+// run-pass
+fn main() {
+    let data: &'static str = "Hello, World!";
+    match data {
+        &ref xs => {
+            assert_eq!(data, xs);
+        }
+    }
+}
diff --git a/src/test/run-pass/binding/match-value-binding-in-guard-3291.rs b/src/test/run-pass/binding/match-value-binding-in-guard-3291.rs
new file mode 100644
index 00000000000..a24a38af22f
--- /dev/null
+++ b/src/test/run-pass/binding/match-value-binding-in-guard-3291.rs
@@ -0,0 +1,29 @@
+// Copyright 2012 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.
+
+// run-pass
+// pretty-expanded FIXME #23616
+
+#![feature(box_syntax)]
+
+fn foo(x: Option<Box<isize>>, b: bool) -> isize {
+    match x {
+      None => { 1 }
+      Some(ref x) if b => { *x.clone() }
+      Some(_) => { 0 }
+    }
+}
+
+pub fn main() {
+    foo(Some(box 22), true);
+    foo(Some(box 22), false);
+    foo(None, true);
+    foo(None, false);
+}
diff --git a/src/test/run-pass/binding/match-var-hygiene.rs b/src/test/run-pass/binding/match-var-hygiene.rs
new file mode 100644
index 00000000000..5d4347559f7
--- /dev/null
+++ b/src/test/run-pass/binding/match-var-hygiene.rs
@@ -0,0 +1,21 @@
+// Copyright 2012 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.
+
+// run-pass
+// shouldn't affect evaluation of $ex.
+macro_rules! bad_macro { ($ex:expr) => (
+    {match 9 {_x => $ex}}
+)}
+
+fn main() {
+    match 8 {
+        _x => assert_eq!(bad_macro!(_x),8)
+    }
+}
diff --git a/src/test/run-pass/binding/match-vec-alternatives.rs b/src/test/run-pass/binding/match-vec-alternatives.rs
new file mode 100644
index 00000000000..4c728924556
--- /dev/null
+++ b/src/test/run-pass/binding/match-vec-alternatives.rs
@@ -0,0 +1,91 @@
+// 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.
+
+// run-pass
+#![feature(slice_patterns)]
+
+fn match_vecs<'a, T>(l1: &'a [T], l2: &'a [T]) -> &'static str {
+    match (l1, l2) {
+        (&[], &[]) => "both empty",
+        (&[], &[..]) | (&[..], &[]) => "one empty",
+        (&[..], &[..]) => "both non-empty"
+    }
+}
+
+fn match_vecs_cons<'a, T>(l1: &'a [T], l2: &'a [T]) -> &'static str {
+    match (l1, l2) {
+        (&[], &[]) => "both empty",
+        (&[], &[_, ..]) | (&[_, ..], &[]) => "one empty",
+        (&[_, ..], &[_, ..]) => "both non-empty"
+    }
+}
+
+fn match_vecs_snoc<'a, T>(l1: &'a [T], l2: &'a [T]) -> &'static str {
+    match (l1, l2) {
+        (&[], &[]) => "both empty",
+        (&[], &[.., _]) | (&[.., _], &[]) => "one empty",
+        (&[.., _], &[.., _]) => "both non-empty"
+    }
+}
+
+fn match_nested_vecs_cons<'a, T>(l1: Option<&'a [T]>, l2: Result<&'a [T], ()>) -> &'static str {
+    match (l1, l2) {
+        (Some(&[]), Ok(&[])) => "Some(empty), Ok(empty)",
+        (Some(&[_, ..]), Ok(_)) | (Some(&[_, ..]), Err(())) => "Some(non-empty), any",
+        (None, Ok(&[])) | (None, Err(())) | (None, Ok(&[_])) => "None, Ok(less than one element)",
+        (None, Ok(&[_, _, ..])) => "None, Ok(at least two elements)",
+        _ => "other"
+    }
+}
+
+fn match_nested_vecs_snoc<'a, T>(l1: Option<&'a [T]>, l2: Result<&'a [T], ()>) -> &'static str {
+    match (l1, l2) {
+        (Some(&[]), Ok(&[])) => "Some(empty), Ok(empty)",
+        (Some(&[.., _]), Ok(_)) | (Some(&[.., _]), Err(())) => "Some(non-empty), any",
+        (None, Ok(&[])) | (None, Err(())) | (None, Ok(&[_])) => "None, Ok(less than one element)",
+        (None, Ok(&[.., _, _])) => "None, Ok(at least two elements)",
+        _ => "other"
+    }
+}
+
+fn main() {
+    assert_eq!(match_vecs(&[1, 2], &[2, 3]), "both non-empty");
+    assert_eq!(match_vecs(&[], &[1, 2, 3, 4]), "one empty");
+    assert_eq!(match_vecs::<usize>(&[], &[]), "both empty");
+    assert_eq!(match_vecs(&[1, 2, 3], &[]), "one empty");
+
+    assert_eq!(match_vecs_cons(&[1, 2], &[2, 3]), "both non-empty");
+    assert_eq!(match_vecs_cons(&[], &[1, 2, 3, 4]), "one empty");
+    assert_eq!(match_vecs_cons::<usize>(&[], &[]), "both empty");
+    assert_eq!(match_vecs_cons(&[1, 2, 3], &[]), "one empty");
+
+    assert_eq!(match_vecs_snoc(&[1, 2], &[2, 3]), "both non-empty");
+    assert_eq!(match_vecs_snoc(&[], &[1, 2, 3, 4]), "one empty");
+    assert_eq!(match_vecs_snoc::<usize>(&[], &[]), "both empty");
+    assert_eq!(match_vecs_snoc(&[1, 2, 3], &[]), "one empty");
+
+    assert_eq!(match_nested_vecs_cons(None, Ok::<&[_], ()>(&[4_usize, 2_usize])),
+               "None, Ok(at least two elements)");
+    assert_eq!(match_nested_vecs_cons::<usize>(None, Err(())), "None, Ok(less than one element)");
+    assert_eq!(match_nested_vecs_cons::<bool>(Some::<&[_]>(&[]), Ok::<&[_], ()>(&[])),
+               "Some(empty), Ok(empty)");
+    assert_eq!(match_nested_vecs_cons(Some::<&[_]>(&[1]), Err(())), "Some(non-empty), any");
+    assert_eq!(match_nested_vecs_cons(Some::<&[_]>(&[(42, ())]), Ok::<&[_], ()>(&[(1, ())])),
+               "Some(non-empty), any");
+
+    assert_eq!(match_nested_vecs_snoc(None, Ok::<&[_], ()>(&[4_usize, 2_usize])),
+               "None, Ok(at least two elements)");
+    assert_eq!(match_nested_vecs_snoc::<usize>(None, Err(())), "None, Ok(less than one element)");
+    assert_eq!(match_nested_vecs_snoc::<bool>(Some::<&[_]>(&[]), Ok::<&[_], ()>(&[])),
+               "Some(empty), Ok(empty)");
+    assert_eq!(match_nested_vecs_snoc(Some::<&[_]>(&[1]), Err(())), "Some(non-empty), any");
+    assert_eq!(match_nested_vecs_snoc(Some::<&[_]>(&[(42, ())]), Ok::<&[_], ()>(&[(1, ())])),
+               "Some(non-empty), any");
+}
diff --git a/src/test/run-pass/binding/match-vec-rvalue.rs b/src/test/run-pass/binding/match-vec-rvalue.rs
new file mode 100644
index 00000000000..308a4938b3a
--- /dev/null
+++ b/src/test/run-pass/binding/match-vec-rvalue.rs
@@ -0,0 +1,25 @@
+// 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.
+
+// run-pass
+// Tests that matching rvalues with drops does not crash.
+
+
+
+pub fn main() {
+    match vec![1, 2, 3] {
+        x => {
+            assert_eq!(x.len(), 3);
+            assert_eq!(x[0], 1);
+            assert_eq!(x[1], 2);
+            assert_eq!(x[2], 3);
+        }
+    }
+}
diff --git a/src/test/run-pass/binding/match-with-ret-arm.rs b/src/test/run-pass/binding/match-with-ret-arm.rs
new file mode 100644
index 00000000000..fe7aa288d52
--- /dev/null
+++ b/src/test/run-pass/binding/match-with-ret-arm.rs
@@ -0,0 +1,22 @@
+// Copyright 2012 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.
+
+// run-pass
+pub fn main() {
+    // sometimes we have had trouble finding
+    // the right type for f, as we unified
+    // bot and u32 here
+    let f = match "1234".parse::<usize>().ok() {
+        None => return (),
+        Some(num) => num as u32
+    };
+    assert_eq!(f, 1234);
+    println!("{}", f)
+}
diff --git a/src/test/run-pass/binding/multi-let.rs b/src/test/run-pass/binding/multi-let.rs
new file mode 100644
index 00000000000..6ecd84d8c58
--- /dev/null
+++ b/src/test/run-pass/binding/multi-let.rs
@@ -0,0 +1,17 @@
+// Copyright 2012 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.
+
+// run-pass
+
+pub fn main() {
+    let x = 10;
+    let y = x;
+    assert_eq!(y, 10);
+}
diff --git a/src/test/run-pass/binding/mut-in-ident-patterns.rs b/src/test/run-pass/binding/mut-in-ident-patterns.rs
new file mode 100644
index 00000000000..e9f143cfbc9
--- /dev/null
+++ b/src/test/run-pass/binding/mut-in-ident-patterns.rs
@@ -0,0 +1,86 @@
+// Copyright 2013 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.
+
+// run-pass
+#![allow(dead_code)]
+#![allow(unused_assignments)]
+#![allow(non_camel_case_types)]
+#![allow(non_shorthand_field_patterns)]
+
+trait Foo {
+    fn foo(&self, mut x: isize) -> isize {
+        let val = x;
+        x = 37 * x;
+        val + x
+    }
+}
+
+struct X;
+impl Foo for X {}
+
+pub fn main() {
+    let (a, mut b) = (23, 4);
+    assert_eq!(a, 23);
+    assert_eq!(b, 4);
+    b = a + b;
+    assert_eq!(b, 27);
+
+
+    assert_eq!(X.foo(2), 76);
+
+    enum Bar {
+       Foo(isize),
+       Baz(f32, u8)
+    }
+
+    let (x, mut y) = (32, Bar::Foo(21));
+
+    match x {
+        mut z @ 32 => {
+            assert_eq!(z, 32);
+            z = 34;
+            assert_eq!(z, 34);
+        }
+        _ => {}
+    }
+
+    check_bar(&y);
+    y = Bar::Baz(10.0, 3);
+    check_bar(&y);
+
+    fn check_bar(y: &Bar) {
+        match y {
+            &Bar::Foo(a) => {
+                assert_eq!(a, 21);
+            }
+            &Bar::Baz(a, b) => {
+                assert_eq!(a, 10.0);
+                assert_eq!(b, 3);
+            }
+        }
+    }
+
+    fn foo1((x, mut y): (f64, isize), mut z: isize) -> isize {
+        y = 2 * 6;
+        z = y + (x as isize);
+        y - z
+    }
+
+    struct A {
+        x: isize
+    }
+    let A { x: mut x } = A { x: 10 };
+    assert_eq!(x, 10);
+    x = 30;
+    assert_eq!(x, 30);
+
+    (|A { x: mut t }: A| { t = t+1; t })(A { x: 34 });
+
+}
diff --git a/src/test/run-pass/binding/nested-exhaustive-match.rs b/src/test/run-pass/binding/nested-exhaustive-match.rs
new file mode 100644
index 00000000000..61bb0e8a468
--- /dev/null
+++ b/src/test/run-pass/binding/nested-exhaustive-match.rs
@@ -0,0 +1,24 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(dead_code)]
+// pretty-expanded FIXME #23616
+
+struct Foo { foo: bool, bar: Option<isize>, baz: isize }
+
+pub fn main() {
+    match (Foo{foo: true, bar: Some(10), baz: 20}) {
+      Foo{foo: true, bar: Some(_), ..} => {}
+      Foo{foo: false, bar: None, ..} => {}
+      Foo{foo: true, bar: None, ..} => {}
+      Foo{foo: false, bar: Some(_), ..} => {}
+    }
+}
diff --git a/src/test/run-pass/binding/nested-matchs.rs b/src/test/run-pass/binding/nested-matchs.rs
new file mode 100644
index 00000000000..0b37c495074
--- /dev/null
+++ b/src/test/run-pass/binding/nested-matchs.rs
@@ -0,0 +1,26 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(unused_mut)] // under NLL we get warning about `bar` below
+fn baz() -> ! { panic!(); }
+
+fn foo() {
+    match Some::<isize>(5) {
+      Some::<isize>(_x) => {
+        let mut bar;
+        match None::<isize> { None::<isize> => { bar = 5; } _ => { baz(); } }
+        println!("{}", bar);
+      }
+      None::<isize> => { println!("hello"); }
+    }
+}
+
+pub fn main() { foo(); }
diff --git a/src/test/run-pass/binding/nested-pattern.rs b/src/test/run-pass/binding/nested-pattern.rs
new file mode 100644
index 00000000000..96bdadc0624
--- /dev/null
+++ b/src/test/run-pass/binding/nested-pattern.rs
@@ -0,0 +1,26 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(dead_code)]
+#![allow(non_camel_case_types)]
+
+// a bug was causing this to complain about leaked memory on exit
+
+enum t { foo(isize, usize), bar(isize, Option<isize>), }
+
+fn nested(o: t) {
+    match o {
+        t::bar(_i, Some::<isize>(_)) => { println!("wrong pattern matched"); panic!(); }
+        _ => { println!("succeeded"); }
+    }
+}
+
+pub fn main() { nested(t::bar(1, None::<isize>)); }
diff --git a/src/test/run-pass/binding/nil-pattern.rs b/src/test/run-pass/binding/nil-pattern.rs
new file mode 100644
index 00000000000..39b2f2da624
--- /dev/null
+++ b/src/test/run-pass/binding/nil-pattern.rs
@@ -0,0 +1,14 @@
+// Copyright 2012 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.
+
+// run-pass
+// pretty-expanded FIXME #23616
+
+pub fn main() { let x = (); match x { () => { } } }
diff --git a/src/test/run-pass/binding/nullary-or-pattern.rs b/src/test/run-pass/binding/nullary-or-pattern.rs
new file mode 100644
index 00000000000..892464dd1db
--- /dev/null
+++ b/src/test/run-pass/binding/nullary-or-pattern.rs
@@ -0,0 +1,23 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(non_camel_case_types)]
+
+enum blah { a, b, }
+
+fn or_alt(q: blah) -> isize {
+  match q { blah::a | blah::b => { 42 } }
+}
+
+pub fn main() {
+    assert_eq!(or_alt(blah::a), 42);
+    assert_eq!(or_alt(blah::b), 42);
+}
diff --git a/src/test/run-pass/binding/optional_comma_in_match_arm.rs b/src/test/run-pass/binding/optional_comma_in_match_arm.rs
new file mode 100644
index 00000000000..304a0323297
--- /dev/null
+++ b/src/test/run-pass/binding/optional_comma_in_match_arm.rs
@@ -0,0 +1,50 @@
+// Copyright 2017 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.
+
+// run-pass
+#![allow(unused_unsafe)]
+// ignore-pretty issue #37199
+#![allow(while_true)]
+
+fn main() {
+    let x = 1;
+
+    match x {
+        1 => loop { break; },
+        2 => while true { break; },
+        3 => if true { () },
+        4 => if true { () } else { () },
+        5 => match () { () => () },
+        6 => { () },
+        7 => unsafe { () },
+        _ => (),
+    }
+
+    match x {
+        1 => loop { break; }
+        2 => while true { break; }
+        3 => if true { () }
+        4 => if true { () } else { () }
+        5 => match () { () => () }
+        6 => { () }
+        7 => unsafe { () }
+        _ => ()
+    }
+
+    let r: &i32 = &x;
+
+    match r {
+        // Absence of comma should not cause confusion between a pattern
+        // and a bitwise and.
+        &1 => if true { () } else { () }
+        &2 => (),
+        _ =>()
+    }
+}
diff --git a/src/test/run-pass/binding/or-pattern.rs b/src/test/run-pass/binding/or-pattern.rs
new file mode 100644
index 00000000000..a9b3e278652
--- /dev/null
+++ b/src/test/run-pass/binding/or-pattern.rs
@@ -0,0 +1,24 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(non_camel_case_types)]
+
+enum blah { a(isize, isize, usize), b(isize, isize), c, }
+
+fn or_alt(q: blah) -> isize {
+    match q { blah::a(x, y, _) | blah::b(x, y) => { return x + y; } blah::c => { return 0; } }
+}
+
+pub fn main() {
+    assert_eq!(or_alt(blah::c), 0);
+    assert_eq!(or_alt(blah::a(10, 100, 0)), 110);
+    assert_eq!(or_alt(blah::b(20, 200)), 220);
+}
diff --git a/src/test/run-pass/binding/order-drop-with-match.rs b/src/test/run-pass/binding/order-drop-with-match.rs
new file mode 100644
index 00000000000..7bb929325ad
--- /dev/null
+++ b/src/test/run-pass/binding/order-drop-with-match.rs
@@ -0,0 +1,67 @@
+// 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.
+
+// run-pass
+
+// Test to make sure the destructors run in the right order.
+// Each destructor sets it's tag in the corresponding entry
+// in ORDER matching up to when it ran.
+// Correct order is: matched, inner, outer
+
+
+static mut ORDER: [usize; 3] = [0, 0, 0];
+static mut INDEX: usize = 0;
+
+struct A;
+impl Drop for A {
+    fn drop(&mut self) {
+        unsafe {
+            ORDER[INDEX] = 1;
+            INDEX = INDEX + 1;
+        }
+    }
+}
+
+struct B;
+impl Drop for B {
+    fn drop(&mut self) {
+        unsafe {
+            ORDER[INDEX] = 2;
+            INDEX = INDEX + 1;
+        }
+    }
+}
+
+struct C;
+impl Drop for C {
+    fn drop(&mut self) {
+        unsafe {
+            ORDER[INDEX] = 3;
+            INDEX = INDEX + 1;
+        }
+    }
+}
+
+fn main() {
+    {
+        let matched = A;
+        let _outer = C;
+        {
+            match matched {
+                _s => {}
+            }
+            let _inner = B;
+        }
+    }
+    unsafe {
+        let expected: &[_] = &[1, 2, 3];
+        assert_eq!(expected, ORDER);
+    }
+}
diff --git a/src/test/run-pass/binding/pat-ranges.rs b/src/test/run-pass/binding/pat-ranges.rs
new file mode 100644
index 00000000000..44666eda3ca
--- /dev/null
+++ b/src/test/run-pass/binding/pat-ranges.rs
@@ -0,0 +1,24 @@
+// Copyright 2015 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.
+
+// run-pass
+// Parsing of range patterns
+
+const NUM1: i32 = 10;
+
+mod m {
+    pub const NUM2: i32 = 16;
+}
+
+fn main() {
+    if let NUM1 ... m::NUM2 = 10 {} else { panic!() }
+    if let ::NUM1 ... ::m::NUM2 = 11 {} else { panic!() }
+    if let -13 ... -10 = 12 { panic!() } else {}
+}
diff --git a/src/test/run-pass/binding/pat-tuple-1.rs b/src/test/run-pass/binding/pat-tuple-1.rs
new file mode 100644
index 00000000000..dc8a7ff7a07
--- /dev/null
+++ b/src/test/run-pass/binding/pat-tuple-1.rs
@@ -0,0 +1,103 @@
+// Copyright 2016 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.
+
+// run-pass
+fn tuple() {
+    let x = (1, 2, 3);
+    match x {
+        (a, b, ..) => {
+            assert_eq!(a, 1);
+            assert_eq!(b, 2);
+        }
+    }
+    match x {
+        (.., b, c) => {
+            assert_eq!(b, 2);
+            assert_eq!(c, 3);
+        }
+    }
+    match x {
+        (a, .., c) => {
+            assert_eq!(a, 1);
+            assert_eq!(c, 3);
+        }
+    }
+    match x {
+        (a, b, c) => {
+            assert_eq!(a, 1);
+            assert_eq!(b, 2);
+            assert_eq!(c, 3);
+        }
+    }
+    match x {
+        (a, b, c, ..) => {
+            assert_eq!(a, 1);
+            assert_eq!(b, 2);
+            assert_eq!(c, 3);
+        }
+    }
+    match x {
+        (.., a, b, c) => {
+            assert_eq!(a, 1);
+            assert_eq!(b, 2);
+            assert_eq!(c, 3);
+        }
+    }
+}
+
+fn tuple_struct() {
+    struct S(u8, u8, u8);
+
+    let x = S(1, 2, 3);
+    match x {
+        S(a, b, ..) => {
+            assert_eq!(a, 1);
+            assert_eq!(b, 2);
+        }
+    }
+    match x {
+        S(.., b, c) => {
+            assert_eq!(b, 2);
+            assert_eq!(c, 3);
+        }
+    }
+    match x {
+        S(a, .., c) => {
+            assert_eq!(a, 1);
+            assert_eq!(c, 3);
+        }
+    }
+    match x {
+        S(a, b, c) => {
+            assert_eq!(a, 1);
+            assert_eq!(b, 2);
+            assert_eq!(c, 3);
+        }
+    }
+    match x {
+        S(a, b, c, ..) => {
+            assert_eq!(a, 1);
+            assert_eq!(b, 2);
+            assert_eq!(c, 3);
+        }
+    }
+    match x {
+        S(.., a, b, c) => {
+            assert_eq!(a, 1);
+            assert_eq!(b, 2);
+            assert_eq!(c, 3);
+        }
+    }
+}
+
+fn main() {
+    tuple();
+    tuple_struct();
+}
diff --git a/src/test/run-pass/binding/pat-tuple-2.rs b/src/test/run-pass/binding/pat-tuple-2.rs
new file mode 100644
index 00000000000..0428e32c43b
--- /dev/null
+++ b/src/test/run-pass/binding/pat-tuple-2.rs
@@ -0,0 +1,33 @@
+// Copyright 2016 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.
+
+// run-pass
+fn tuple() {
+    let x = (1,);
+    match x {
+        (2, ..) => panic!(),
+        (..) => ()
+    }
+}
+
+fn tuple_struct() {
+    struct S(u8);
+
+    let x = S(1);
+    match x {
+        S(2, ..) => panic!(),
+        S(..) => ()
+    }
+}
+
+fn main() {
+    tuple();
+    tuple_struct();
+}
diff --git a/src/test/run-pass/binding/pat-tuple-3.rs b/src/test/run-pass/binding/pat-tuple-3.rs
new file mode 100644
index 00000000000..60b933e4ce4
--- /dev/null
+++ b/src/test/run-pass/binding/pat-tuple-3.rs
@@ -0,0 +1,39 @@
+// Copyright 2016 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.
+
+// run-pass
+fn tuple() {
+    let x = (1, 2, 3);
+    let branch = match x {
+        (1, 1, ..) => 0,
+        (1, 2, 3, ..) => 1,
+        (1, 2, ..) => 2,
+        _ => 3
+    };
+    assert_eq!(branch, 1);
+}
+
+fn tuple_struct() {
+    struct S(u8, u8, u8);
+
+    let x = S(1, 2, 3);
+    let branch = match x {
+        S(1, 1, ..) => 0,
+        S(1, 2, 3, ..) => 1,
+        S(1, 2, ..) => 2,
+        _ => 3
+    };
+    assert_eq!(branch, 1);
+}
+
+fn main() {
+    tuple();
+    tuple_struct();
+}
diff --git a/src/test/run-pass/binding/pat-tuple-4.rs b/src/test/run-pass/binding/pat-tuple-4.rs
new file mode 100644
index 00000000000..cd19f2c67a1
--- /dev/null
+++ b/src/test/run-pass/binding/pat-tuple-4.rs
@@ -0,0 +1,67 @@
+// Copyright 2016 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.
+
+// run-pass
+fn tuple() {
+    let x = (1, 2, 3);
+    match x {
+        (1, 2, 4) => unreachable!(),
+        (0, 2, 3, ..) => unreachable!(),
+        (0, .., 3) => unreachable!(),
+        (0, ..) => unreachable!(),
+        (1, 2, 3) => (),
+        (_, _, _) => unreachable!(),
+    }
+    match x {
+        (..) => (),
+    }
+    match x {
+        (_, _, _, ..) => (),
+    }
+    match x {
+        (a, b, c) => {
+            assert_eq!(1, a);
+            assert_eq!(2, b);
+            assert_eq!(3, c);
+        }
+    }
+}
+
+fn tuple_struct() {
+    struct S(u8, u8, u8);
+
+    let x = S(1, 2, 3);
+    match x {
+        S(1, 2, 4) => unreachable!(),
+        S(0, 2, 3, ..) => unreachable!(),
+        S(0, .., 3) => unreachable!(),
+        S(0, ..) => unreachable!(),
+        S(1, 2, 3) => (),
+        S(_, _, _) => unreachable!(),
+    }
+    match x {
+        S(..) => (),
+    }
+    match x {
+        S(_, _, _, ..) => (),
+    }
+    match x {
+        S(a, b, c) => {
+            assert_eq!(1, a);
+            assert_eq!(2, b);
+            assert_eq!(3, c);
+        }
+    }
+}
+
+fn main() {
+    tuple();
+    tuple_struct();
+}
diff --git a/src/test/run-pass/binding/pat-tuple-5.rs b/src/test/run-pass/binding/pat-tuple-5.rs
new file mode 100644
index 00000000000..0ac4c24c4ee
--- /dev/null
+++ b/src/test/run-pass/binding/pat-tuple-5.rs
@@ -0,0 +1,39 @@
+// Copyright 2016 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.
+
+// run-pass
+fn tuple() {
+    struct S;
+    struct Z;
+    struct W;
+    let x = (S, Z, W);
+    match x { (S, ..) => {} }
+    match x { (.., W) => {} }
+    match x { (S, .., W) => {} }
+    match x { (.., Z, _) => {} }
+}
+
+fn tuple_struct() {
+    struct SS(S, Z, W);
+
+    struct S;
+    struct Z;
+    struct W;
+    let x = SS(S, Z, W);
+    match x { SS(S, ..) => {} }
+    match x { SS(.., W) => {} }
+    match x { SS(S, .., W) => {} }
+    match x { SS(.., Z, _) => {} }
+}
+
+fn main() {
+    tuple();
+    tuple_struct();
+}
diff --git a/src/test/run-pass/binding/pat-tuple-6.rs b/src/test/run-pass/binding/pat-tuple-6.rs
new file mode 100644
index 00000000000..b3cd0e1b543
--- /dev/null
+++ b/src/test/run-pass/binding/pat-tuple-6.rs
@@ -0,0 +1,55 @@
+// Copyright 2016 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.
+
+// run-pass
+fn tuple() {
+    let x = (1, 2, 3, 4, 5);
+    match x {
+        (a, .., b, c) => {
+            assert_eq!(a, 1);
+            assert_eq!(b, 4);
+            assert_eq!(c, 5);
+        }
+    }
+    match x {
+        (a, b, c, .., d) => {
+            assert_eq!(a, 1);
+            assert_eq!(b, 2);
+            assert_eq!(c, 3);
+            assert_eq!(d, 5);
+        }
+    }
+}
+
+fn tuple_struct() {
+    struct S(u8, u8, u8, u8, u8);
+
+    let x = S(1, 2, 3, 4, 5);
+    match x {
+        S(a, .., b, c) => {
+            assert_eq!(a, 1);
+            assert_eq!(b, 4);
+            assert_eq!(c, 5);
+        }
+    }
+    match x {
+        S(a, b, c, .., d) => {
+            assert_eq!(a, 1);
+            assert_eq!(b, 2);
+            assert_eq!(c, 3);
+            assert_eq!(d, 5);
+        }
+    }
+}
+
+fn main() {
+    tuple();
+    tuple_struct();
+}
diff --git a/src/test/run-pass/binding/pat-tuple-7.rs b/src/test/run-pass/binding/pat-tuple-7.rs
new file mode 100644
index 00000000000..c32b52eac33
--- /dev/null
+++ b/src/test/run-pass/binding/pat-tuple-7.rs
@@ -0,0 +1,17 @@
+// Copyright 2016 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.
+
+// run-pass
+
+fn main() {
+    match 0 {
+        (pat) => assert_eq!(pat, 0)
+    }
+}
diff --git a/src/test/run-pass/binding/pattern-bound-var-in-for-each.rs b/src/test/run-pass/binding/pattern-bound-var-in-for-each.rs
new file mode 100644
index 00000000000..2ee697fe2ff
--- /dev/null
+++ b/src/test/run-pass/binding/pattern-bound-var-in-for-each.rs
@@ -0,0 +1,30 @@
+// Copyright 2012 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.
+
+// run-pass
+// Tests that codegen_path checks whether a
+// pattern-bound var is an upvar (when codegenning
+// the for-each body)
+
+
+fn foo(src: usize) {
+
+    match Some(src) {
+      Some(src_id) => {
+        for _i in 0_usize..10_usize {
+            let yyy = src_id;
+            assert_eq!(yyy, 0_usize);
+        }
+      }
+      _ => { }
+    }
+}
+
+pub fn main() { foo(0_usize); }
diff --git a/src/test/run-pass/binding/pattern-in-closure.rs b/src/test/run-pass/binding/pattern-in-closure.rs
new file mode 100644
index 00000000000..9a5a420a80b
--- /dev/null
+++ b/src/test/run-pass/binding/pattern-in-closure.rs
@@ -0,0 +1,24 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(non_shorthand_field_patterns)]
+
+struct Foo {
+    x: isize,
+    y: isize
+}
+
+pub fn main() {
+    let f = |(x, _): (isize, isize)| println!("{}", x + 1);
+    let g = |Foo { x: x, y: _y }: Foo| println!("{}", x + 1);
+    f((2, 3));
+    g(Foo { x: 1, y: 2 });
+}
diff --git a/src/test/run-pass/binding/range-inclusive-pattern-precedence.rs b/src/test/run-pass/binding/range-inclusive-pattern-precedence.rs
new file mode 100644
index 00000000000..d492edb1617
--- /dev/null
+++ b/src/test/run-pass/binding/range-inclusive-pattern-precedence.rs
@@ -0,0 +1,33 @@
+// Copyright 2018 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.
+
+// run-pass
+#![feature(box_patterns)]
+
+const VALUE: usize = 21;
+
+pub fn main() {
+    match &18 {
+        &(18..=18) => {}
+        _ => { unreachable!(); }
+    }
+    match &21 {
+        &(VALUE..=VALUE) => {}
+        _ => { unreachable!(); }
+    }
+    match Box::new(18) {
+        box (18..=18) => {}
+        _ => { unreachable!(); }
+    }
+    match Box::new(21) {
+        box (VALUE..=VALUE) => {}
+        _ => { unreachable!(); }
+    }
+}
diff --git a/src/test/run-pass/binding/simple-generic-match.rs b/src/test/run-pass/binding/simple-generic-match.rs
new file mode 100644
index 00000000000..13c16790e09
--- /dev/null
+++ b/src/test/run-pass/binding/simple-generic-match.rs
@@ -0,0 +1,18 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(non_camel_case_types)]
+
+// pretty-expanded FIXME #23616
+
+enum clam<T> { a(T), }
+
+pub fn main() { let c = clam::a(2); match c { clam::a::<isize>(_) => { } } }
diff --git a/src/test/run-pass/binding/use-uninit-match.rs b/src/test/run-pass/binding/use-uninit-match.rs
new file mode 100644
index 00000000000..472045fcdb3
--- /dev/null
+++ b/src/test/run-pass/binding/use-uninit-match.rs
@@ -0,0 +1,27 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(dead_code)]
+#![allow(non_camel_case_types)]
+
+
+fn foo<T>(o: myoption<T>) -> isize {
+    let mut x: isize = 5;
+    match o {
+        myoption::none::<T> => { }
+        myoption::some::<T>(_t) => { x += 1; }
+    }
+    return x;
+}
+
+enum myoption<T> { none, some(T), }
+
+pub fn main() { println!("{}", 5); }
diff --git a/src/test/run-pass/binding/use-uninit-match2.rs b/src/test/run-pass/binding/use-uninit-match2.rs
new file mode 100644
index 00000000000..2f8384f9e84
--- /dev/null
+++ b/src/test/run-pass/binding/use-uninit-match2.rs
@@ -0,0 +1,28 @@
+// Copyright 2012 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.
+
+// run-pass
+#![allow(dead_code)]
+#![allow(unused_mut)]
+#![allow(non_camel_case_types)]
+
+
+fn foo<T>(o: myoption<T>) -> isize {
+    let mut x: isize;
+    match o {
+        myoption::none::<T> => { panic!(); }
+        myoption::some::<T>(_t) => { x = 5; }
+    }
+    return x;
+}
+
+enum myoption<T> { none, some(T), }
+
+pub fn main() { println!("{}", 5); }
diff --git a/src/test/run-pass/binding/zero_sized_subslice_match.rs b/src/test/run-pass/binding/zero_sized_subslice_match.rs
new file mode 100644
index 00000000000..db71d97a19d
--- /dev/null
+++ b/src/test/run-pass/binding/zero_sized_subslice_match.rs
@@ -0,0 +1,22 @@
+// Copyright 2015 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.
+
+// run-pass
+#![feature(slice_patterns)]
+
+fn main() {
+    let x = [(), ()];
+
+    // The subslice used to go out of bounds for zero-sized array items, check that this doesn't
+    // happen anymore
+    match x {
+        [_, ref y..] => assert_eq!(&x[1] as *const (), &y[0] as *const ())
+    }
+}