tests: Move run-pass tests without naming conflicts to ui

26 files changed, 380 insertions, 0 deletions

diff --git a/src/test/ui/generics/auxiliary/default_type_params_xc.rs b/src/test/ui/generics/auxiliary/default_type_params_xc.rs
new file mode 100644
index 00000000000..aacbd672ade
--- /dev/null
+++ b/src/test/ui/generics/auxiliary/default_type_params_xc.rs
@@ -0,0 +1,5 @@
+pub struct Heap;
+
+pub struct FakeHeap;
+
+pub struct FakeVec<T, A = FakeHeap> { pub f: Option<(T,A)> }
diff --git a/src/test/ui/generics/generic-alias-unique.rs b/src/test/ui/generics/generic-alias-unique.rs
new file mode 100644
index 00000000000..76a184d8d25
--- /dev/null
+++ b/src/test/ui/generics/generic-alias-unique.rs
@@ -0,0 +1,11 @@
+// run-pass
+#![feature(box_syntax)]
+
+fn id<T:Send>(t: T) -> T { return t; }
+
+pub fn main() {
+    let expected: Box<_> = box 100;
+    let actual = id::<Box<isize>>(expected.clone());
+    println!("{}", *actual);
+    assert_eq!(*expected, *actual);
+}
diff --git a/src/test/ui/generics/generic-default-type-params-cross-crate.rs b/src/test/ui/generics/generic-default-type-params-cross-crate.rs
new file mode 100644
index 00000000000..9e5eaa72c15
--- /dev/null
+++ b/src/test/ui/generics/generic-default-type-params-cross-crate.rs
@@ -0,0 +1,17 @@
+// run-pass
+// aux-build:default_type_params_xc.rs
+
+// pretty-expanded FIXME #23616
+
+extern crate default_type_params_xc;
+
+struct Vec<T, A = default_type_params_xc::Heap>(Option<(T,A)>);
+
+struct Foo;
+
+fn main() {
+    let _a = Vec::<isize>(None);
+    let _b = Vec::<isize, default_type_params_xc::FakeHeap>(None);
+    let _c = default_type_params_xc::FakeVec::<isize> { f: None };
+    let _d = default_type_params_xc::FakeVec::<isize, Foo> { f: None };
+}
diff --git a/src/test/ui/generics/generic-default-type-params.rs b/src/test/ui/generics/generic-default-type-params.rs
new file mode 100644
index 00000000000..afdd301fde9
--- /dev/null
+++ b/src/test/ui/generics/generic-default-type-params.rs
@@ -0,0 +1,53 @@
+// run-pass
+struct Foo<A = (isize, char)> {
+    a: A
+}
+
+impl Foo<isize> {
+    fn bar_int(&self) -> isize {
+        self.a
+    }
+}
+
+impl Foo<char> {
+    fn bar_char(&self) -> char {
+        self.a
+    }
+}
+
+impl Foo {
+    fn bar(&self) {
+        let (i, c): (isize, char) = self.a;
+        assert_eq!(Foo { a: i }.bar_int(), i);
+        assert_eq!(Foo { a: c }.bar_char(), c);
+    }
+}
+
+impl<A: Clone> Foo<A> {
+    fn baz(&self) -> A {
+        self.a.clone()
+    }
+}
+
+fn default_foo(x: Foo) {
+    let (i, c): (isize, char) = x.a;
+    assert_eq!(i, 1);
+    assert_eq!(c, 'a');
+
+    x.bar();
+    assert_eq!(x.baz(), (1, 'a'));
+}
+
+#[derive(PartialEq, Debug)]
+struct BazHelper<T>(T);
+
+#[derive(PartialEq, Debug)]
+// Ensure that we can use previous type parameters in defaults.
+struct Baz<T, U = BazHelper<T>, V = Option<U>>(T, U, V);
+
+fn main() {
+    default_foo(Foo { a: (1, 'a') });
+
+    let x: Baz<bool> = Baz(true, BazHelper(false), Some(BazHelper(true)));
+    assert_eq!(x, Baz(true, BazHelper(false), Some(BazHelper(true))));
+}
diff --git a/src/test/ui/generics/generic-derived-type.rs b/src/test/ui/generics/generic-derived-type.rs
new file mode 100644
index 00000000000..c643496fa7f
--- /dev/null
+++ b/src/test/ui/generics/generic-derived-type.rs
@@ -0,0 +1,21 @@
+// run-pass
+fn g<X>(x: X) -> X { return x; }
+
+#[derive(Clone)]
+struct Pair<T> {
+    a: T,
+    b: T
+}
+
+fn f<T:Clone>(t: T) -> Pair<T> {
+    let x: Pair<T> = Pair {a: t.clone(), b: t};
+    return g::<Pair<T>>(x);
+}
+
+pub fn main() {
+    let b = f::<isize>(10);
+    println!("{}" ,b.a);
+    println!("{}", b.b);
+    assert_eq!(b.a, 10);
+    assert_eq!(b.b, 10);
+}
diff --git a/src/test/ui/generics/generic-exterior-unique.rs b/src/test/ui/generics/generic-exterior-unique.rs
new file mode 100644
index 00000000000..9b3e1ee02a2
--- /dev/null
+++ b/src/test/ui/generics/generic-exterior-unique.rs
@@ -0,0 +1,12 @@
+// run-pass
+#![feature(box_syntax)]
+
+struct Recbox<T> {x: Box<T>}
+
+fn reclift<T>(t: T) -> Recbox<T> { return Recbox {x: box t}; }
+
+pub fn main() {
+    let foo: isize = 17;
+    let rbfoo: Recbox<isize> = reclift::<isize>(foo);
+    assert_eq!(*rbfoo.x, foo);
+}
diff --git a/src/test/ui/generics/generic-extern-mangle.rs b/src/test/ui/generics/generic-extern-mangle.rs
new file mode 100644
index 00000000000..985a6f39cd7
--- /dev/null
+++ b/src/test/ui/generics/generic-extern-mangle.rs
@@ -0,0 +1,9 @@
+// run-pass
+use std::ops::Add;
+
+extern "C" fn foo<T: Add>(a: T, b: T) -> T::Output { a + b }
+
+fn main() {
+    assert_eq!(100u8, foo(0u8, 100u8));
+    assert_eq!(100u16, foo(0u16, 100u16));
+}
diff --git a/src/test/ui/generics/generic-fn-infer.rs b/src/test/ui/generics/generic-fn-infer.rs
new file mode 100644
index 00000000000..9ba4224732b
--- /dev/null
+++ b/src/test/ui/generics/generic-fn-infer.rs
@@ -0,0 +1,10 @@
+// run-pass
+
+
+
+
+// Issue #45: infer type parameters in function applications
+
+fn id<T>(x: T) -> T { return x; }
+
+pub fn main() { let x: isize = 42; let y: isize = id(x); assert_eq!(x, y); }
diff --git a/src/test/ui/generics/generic-fn-twice.rs b/src/test/ui/generics/generic-fn-twice.rs
new file mode 100644
index 00000000000..2f25fc24ced
--- /dev/null
+++ b/src/test/ui/generics/generic-fn-twice.rs
@@ -0,0 +1,11 @@
+// run-pass
+
+
+
+// pretty-expanded FIXME #23616
+
+mod foomod {
+    pub fn foo<T>() { }
+}
+
+pub fn main() { foomod::foo::<isize>(); foomod::foo::<isize>(); }
diff --git a/src/test/ui/generics/generic-fn-unique.rs b/src/test/ui/generics/generic-fn-unique.rs
new file mode 100644
index 00000000000..6cda1c3dc15
--- /dev/null
+++ b/src/test/ui/generics/generic-fn-unique.rs
@@ -0,0 +1,6 @@
+// run-pass
+#![feature(box_syntax)]
+
+fn f<T>(x: Box<T>) -> Box<T> { return x; }
+
+pub fn main() { let x = f(box 3); println!("{}", *x); }
diff --git a/src/test/ui/generics/generic-fn.rs b/src/test/ui/generics/generic-fn.rs
new file mode 100644
index 00000000000..8038fabc1ce
--- /dev/null
+++ b/src/test/ui/generics/generic-fn.rs
@@ -0,0 +1,28 @@
+// run-pass
+#![allow(dead_code)]
+#![allow(unused_assignments)]
+
+fn id<T>(x: T) -> T { return x; }
+
+#[derive(Copy, Clone)]
+struct Triple {x: isize, y: isize, z: isize}
+
+pub fn main() {
+    let mut x = 62;
+    let mut y = 63;
+    let a = 'a';
+    let mut b = 'b';
+    let p: Triple = Triple {x: 65, y: 66, z: 67};
+    let mut q: Triple = Triple {x: 68, y: 69, z: 70};
+    y = id::<isize>(x);
+    println!("{}", y);
+    assert_eq!(x, y);
+    b = id::<char>(a);
+    println!("{}", b);
+    assert_eq!(a, b);
+    q = id::<Triple>(p);
+    x = p.z;
+    y = q.z;
+    println!("{}", y);
+    assert_eq!(x, y);
+}
diff --git a/src/test/ui/generics/generic-ivec-leak.rs b/src/test/ui/generics/generic-ivec-leak.rs
new file mode 100644
index 00000000000..a8ea1d5069b
--- /dev/null
+++ b/src/test/ui/generics/generic-ivec-leak.rs
@@ -0,0 +1,5 @@
+// run-pass
+#![allow(non_camel_case_types)]
+enum wrapper<T> { wrapped(T), }
+
+pub fn main() { let _w = wrapper::wrapped(vec![1, 2, 3, 4, 5]); }
diff --git a/src/test/ui/generics/generic-newtype-struct.rs b/src/test/ui/generics/generic-newtype-struct.rs
new file mode 100644
index 00000000000..570c982cc87
--- /dev/null
+++ b/src/test/ui/generics/generic-newtype-struct.rs
@@ -0,0 +1,8 @@
+// run-pass
+// pretty-expanded FIXME #23616
+
+struct S<T>(T);
+
+pub fn main() {
+    let _s = S(2);
+}
diff --git a/src/test/ui/generics/generic-object.rs b/src/test/ui/generics/generic-object.rs
new file mode 100644
index 00000000000..870ff980ec6
--- /dev/null
+++ b/src/test/ui/generics/generic-object.rs
@@ -0,0 +1,22 @@
+// run-pass
+#![feature(box_syntax)]
+
+trait Foo<T> {
+    fn get(&self) -> T;
+}
+
+struct S {
+    x: isize
+}
+
+impl Foo<isize> for S {
+    fn get(&self) -> isize {
+        self.x
+    }
+}
+
+pub fn main() {
+    let x = box S { x: 1 };
+    let y = x as Box<dyn Foo<isize>>;
+    assert_eq!(y.get(), 1);
+}
diff --git a/src/test/ui/generics/generic-recursive-tag.rs b/src/test/ui/generics/generic-recursive-tag.rs
new file mode 100644
index 00000000000..e1875f0abbe
--- /dev/null
+++ b/src/test/ui/generics/generic-recursive-tag.rs
@@ -0,0 +1,13 @@
+// run-pass
+#![allow(non_camel_case_types)]
+#![feature(box_syntax)]
+
+enum list<T> { cons(Box<T>, Box<list<T>>), nil, }
+
+pub fn main() {
+    let _a: list<isize> =
+        list::cons::<isize>(box 10,
+        box list::cons::<isize>(box 12,
+        box list::cons::<isize>(box 13,
+        box list::nil::<isize>)));
+}
diff --git a/src/test/ui/generics/generic-static-methods.rs b/src/test/ui/generics/generic-static-methods.rs
new file mode 100644
index 00000000000..b39fa081a65
--- /dev/null
+++ b/src/test/ui/generics/generic-static-methods.rs
@@ -0,0 +1,21 @@
+// run-pass
+#![allow(non_camel_case_types)]
+
+
+trait vec_utils<T> {
+    fn map_<U, F>(x: &Self, f: F) -> Vec<U> where F: FnMut(&T) -> U;
+}
+
+impl<T> vec_utils<T> for Vec<T> {
+    fn map_<U, F>(x: &Vec<T> , mut f: F) -> Vec<U> where F: FnMut(&T) -> U {
+        let mut r = Vec::new();
+        for elt in x {
+            r.push(f(elt));
+        }
+        r
+    }
+}
+
+pub fn main() {
+    assert_eq!(vec_utils::map_(&vec![1,2,3], |&x| x+1), [2,3,4]);
+}
diff --git a/src/test/ui/generics/generic-tag-corruption.rs b/src/test/ui/generics/generic-tag-corruption.rs
new file mode 100644
index 00000000000..aa26183a0d4
--- /dev/null
+++ b/src/test/ui/generics/generic-tag-corruption.rs
@@ -0,0 +1,10 @@
+// run-pass
+#![allow(non_camel_case_types)]
+
+
+// This used to cause memory corruption in stage 0.
+// pretty-expanded FIXME #23616
+
+enum thing<K> { some(K), }
+
+pub fn main() { let _x = thing::some("hi".to_string()); }
diff --git a/src/test/ui/generics/generic-tag-local.rs b/src/test/ui/generics/generic-tag-local.rs
new file mode 100644
index 00000000000..cc85e6e0f0a
--- /dev/null
+++ b/src/test/ui/generics/generic-tag-local.rs
@@ -0,0 +1,8 @@
+// run-pass
+#![allow(non_camel_case_types)]
+
+// pretty-expanded FIXME #23616
+
+enum clam<T> { a(T), }
+
+pub fn main() { let _c = clam::a(3); }
diff --git a/src/test/ui/generics/generic-tag-match.rs b/src/test/ui/generics/generic-tag-match.rs
new file mode 100644
index 00000000000..09ed6a808e6
--- /dev/null
+++ b/src/test/ui/generics/generic-tag-match.rs
@@ -0,0 +1,13 @@
+// run-pass
+#![allow(unused_assignments)]
+#![allow(non_camel_case_types)]
+
+enum foo<T> { arm(T), }
+
+fn altfoo<T>(f: foo<T>) {
+    let mut hit = false;
+    match f { foo::arm::<T>(_x) => { println!("in arm"); hit = true; } }
+    assert!((hit));
+}
+
+pub fn main() { altfoo::<isize>(foo::arm::<isize>(10)); }
diff --git a/src/test/ui/generics/generic-tag-values.rs b/src/test/ui/generics/generic-tag-values.rs
new file mode 100644
index 00000000000..230f477b6e9
--- /dev/null
+++ b/src/test/ui/generics/generic-tag-values.rs
@@ -0,0 +1,20 @@
+// run-pass
+#![allow(non_camel_case_types)]
+
+enum noption<T> { some(T), }
+
+struct Pair { x: isize, y: isize }
+
+pub fn main() {
+    let nop: noption<isize> = noption::some::<isize>(5);
+    match nop { noption::some::<isize>(n) => { println!("{}", n); assert_eq!(n, 5); } }
+    let nop2: noption<Pair> = noption::some(Pair{x: 17, y: 42});
+    match nop2 {
+      noption::some(t) => {
+        println!("{}", t.x);
+        println!("{}", t.y);
+        assert_eq!(t.x, 17);
+        assert_eq!(t.y, 42);
+      }
+    }
+}
diff --git a/src/test/ui/generics/generic-tag.rs b/src/test/ui/generics/generic-tag.rs
new file mode 100644
index 00000000000..74ef4eeba8a
--- /dev/null
+++ b/src/test/ui/generics/generic-tag.rs
@@ -0,0 +1,15 @@
+// run-pass
+#![allow(unused_assignments)]
+#![allow(non_camel_case_types)]
+
+// pretty-expanded FIXME #23616
+
+#![allow(unused_variables)]
+#![feature(box_syntax)]
+
+enum option<T> { some(Box<T>), none, }
+
+pub fn main() {
+    let mut a: option<isize> = option::some::<isize>(box 10);
+    a = option::none::<isize>;
+}
diff --git a/src/test/ui/generics/generic-temporary.rs b/src/test/ui/generics/generic-temporary.rs
new file mode 100644
index 00000000000..b63b534d03f
--- /dev/null
+++ b/src/test/ui/generics/generic-temporary.rs
@@ -0,0 +1,16 @@
+// run-pass
+
+fn mk() -> isize { return 1; }
+
+fn chk(a: isize) { println!("{}", a); assert_eq!(a, 1); }
+
+fn apply<T>(produce: fn() -> T,
+            consume: fn(T)) {
+    consume(produce());
+}
+
+pub fn main() {
+    let produce: fn() -> isize = mk;
+    let consume: fn(v: isize) = chk;
+    apply::<isize>(produce, consume);
+}
diff --git a/src/test/ui/generics/generic-tup.rs b/src/test/ui/generics/generic-tup.rs
new file mode 100644
index 00000000000..79ebd648cd4
--- /dev/null
+++ b/src/test/ui/generics/generic-tup.rs
@@ -0,0 +1,8 @@
+// run-pass
+fn get_third<T>(t: (T, T, T)) -> T { let (_, _, x) = t; return x; }
+
+pub fn main() {
+    println!("{}", get_third((1, 2, 3)));
+    assert_eq!(get_third((1, 2, 3)), 3);
+    assert_eq!(get_third((5u8, 6u8, 7u8)), 7u8);
+}
diff --git a/src/test/ui/generics/generic-type-synonym.rs b/src/test/ui/generics/generic-type-synonym.rs
new file mode 100644
index 00000000000..4f181fbcc7e
--- /dev/null
+++ b/src/test/ui/generics/generic-type-synonym.rs
@@ -0,0 +1,15 @@
+// run-pass
+#![allow(dead_code)]
+
+
+// pretty-expanded FIXME #23616
+
+struct Foo<T> {
+    a: T
+}
+
+type Bar<T> = Foo<T>;
+
+fn takebar<T>(_b: Bar<T>) { }
+
+pub fn main() { }
diff --git a/src/test/ui/generics/generic-type.rs b/src/test/ui/generics/generic-type.rs
new file mode 100644
index 00000000000..aa46db07eee
--- /dev/null
+++ b/src/test/ui/generics/generic-type.rs
@@ -0,0 +1,11 @@
+// run-pass
+
+
+
+struct Pair<T> {x: T, y: T}
+
+pub fn main() {
+    let x: Pair<isize> = Pair {x: 10, y: 12};
+    assert_eq!(x.x, 10);
+    assert_eq!(x.y, 12);
+}
diff --git a/src/test/ui/generics/generic-unique.rs b/src/test/ui/generics/generic-unique.rs
new file mode 100644
index 00000000000..d36504c75dd
--- /dev/null
+++ b/src/test/ui/generics/generic-unique.rs
@@ -0,0 +1,12 @@
+// run-pass
+#![allow(dead_code)]
+#![feature(box_syntax)]
+
+struct Triple<T> { x: T, y: T, z: T }
+
+fn box_it<T>(x: Triple<T>) -> Box<Triple<T>> { return box x; }
+
+pub fn main() {
+    let x: Box<Triple<isize>> = box_it::<isize>(Triple{x: 1, y: 2, z: 3});
+    assert_eq!(x.y, 2);
+}