Tests for default fallback: ui tests, run fail test, more run pass tests.

The tests under bad_messages in ui are the ones that have bad messages
that need fixing.

Author: leoyvens

src/test/run-fail/default_over_literal.rs

@@ -0,0 +1,17 @@
+// 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.
+
+// error-pattern:assertion failed: `(left == right)`
+
+#![feature(default_type_parameter_fallback)]
+
+fn foo<T=u64>(t: T) -> usize { std::mem::size_of_val(&t) }
+
+fn main() { assert_eq!(foo(22), std::mem::size_of::<u64>()) }

src/test/run-pass/default-ty-param-fallback/enum.rs

@@ -11,6 +11,7 @@
 #![feature(default_type_parameter_fallback)]
 
 use std::path::Path;
+use std::mem::size_of;
 
 enum Opt<T=String> {
     Som(T),
@@ -27,5 +28,11 @@ fn main() {
 }
 
 // Defaults on fns take precedence.
-fn func1<P: AsRef<Path> = String>(p: Option<P>) { }
-fn func2<P: AsRef<Path> = String>(p: Opt<P>) { }
+fn func1<P: AsRef<Path> = &'static str>(p: Option<P>) {
+    // Testing that we got &str rather than String.
+    assert_eq!(size_of::<P>(), size_of::<&str>())
+}
+
+fn func2<P: AsRef<Path> = &'static str>(p: Opt<P>) {
+    assert_eq!(size_of::<P>(), size_of::<&str>())
+}

src/test/run-pass/default-ty-param-fallback/heterogeneous_partial_eq_for_option.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.
+
+#![feature(default_type_parameter_fallback)]
+
+trait PartialQe<Rhs = Self> {
+        fn qe(&self, _: &Rhs) {}
+}
+
+impl<A, B = A> PartialQe<Option<B>> for Option<A> {}
+
+fn main() {
+    PartialQe::qe(&Some("str"), &None);
+    Some('a').qe(&None);
+}

src/test/run-pass/default-ty-param-fallback/trait_impl.rs

@@ -29,7 +29,7 @@ fn takes_foo<F:Foo>(_: F) {}
 fn main() {
     let x = Vac::new(); // x: Vac<$0>
     // adds oblig Vac<$0> : Foo,
-    // and applies the default of `impl<T> Vac<T>` and 
+    // and applies the default of `impl<T> Vac<T>` and
     // `impl<T:Bar> Foo for Vac<T>`, which must agree.
     //
     // The default of F in takes_foo<F> makes no difference here,

src/test/compile-fail/auxiliary/default_ty_param_cross_crate_crate.rs renamed to src/test/ui/default-ty-param-fallback/bad_messages/auxiliary/default_ty_param_cross_crate_crate.rs

@@ -14,19 +14,13 @@ use std::fmt::Debug;
 
 // Example from the RFC
 fn foo<F:Default=usize>() -> F { F::default() }
-//~^ NOTE: a default was defined here...
 
 fn bar<B:Debug=isize>(b: B) { println!("{:?}", b); }
-//~^ NOTE: a second default was defined here...
 
 fn main() {
     // Here, F is instantiated with $0=uint
     let x = foo();
-    //~^ ERROR: mismatched types
-    //~| NOTE: conflicting type parameter defaults `usize` and `isize`
-    //~| NOTE: ...that was applied to an unconstrained type variable here
 
     // Here, B is instantiated with $1=uint, and constraint $0 <: $1 is added.
     bar(x);
-    //~^ NOTE: ...that also applies to the same type variable here
 }

src/test/compile-fail/default_ty_param_fallback_conflict.rs renamed to src/test/ui/default-ty-param-fallback/bad_messages/fallback_conflict.rs

@@ -0,0 +1,8 @@
+error[E0308]: mismatched types
+  --> $DIR/fallback_conflict.rs:25:9
+   |
+25 |     bar(x);
+   |         ^ expected isize, found usize
+
+error: aborting due to previous error
+

src/test/ui/default-ty-param-fallback/bad_messages/fallback_conflict.stderr

@@ -17,13 +17,9 @@ extern crate default_param_test;
 use default_param_test::{Foo, bleh};
 
 fn meh<X, B=bool>(x: Foo<X, B>) {}
-//~^ NOTE: a default was defined here...
 
 fn main() {
     let foo = bleh();
-    //~^ NOTE: ...that also applies to the same type variable here
 
     meh(foo);
-    //~^ ERROR: mismatched types:
-    //~| NOTE: conflicting type parameter defaults `bool` and `char`
 }

src/test/compile-fail/default_ty_param_fallback_conflict_cross_crate.rs renamed to src/test/ui/default-ty-param-fallback/bad_messages/fallback_conflict_cross_crate.rs

@@ -0,0 +1,8 @@
+error[E0308]: mismatched types
+  --> $DIR/fallback_conflict_cross_crate.rs:24:9
+   |
+24 |     meh(foo);
+   |         ^^^ expected bool, found char
+
+error: aborting due to previous error
+

src/test/ui/default-ty-param-fallback/bad_messages/fallback_conflict_cross_crate.stderr

@@ -0,0 +1,36 @@
+// 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.
+//
+
+#![feature(default_type_parameter_fallback)]
+
+use std::marker::PhantomData;
+
+trait Id {
+    type This;
+}
+
+impl<A> Id for A {
+    type This = A;
+}
+
+struct Foo<X: Default = usize, Y = <X as Id>::This> {
+    data: PhantomData<(X, Y)>
+}
+
+impl<X: Default, Y> Foo<X, Y> {
+    fn new() -> Foo<X, Y> {
+        Foo { data: PhantomData }
+    }
+}
+
+fn main() {
+    let foo = Foo::new();
+}

src/test/ui/default-ty-param-fallback/default_dependent_associated_type.rs

@@ -0,0 +1,10 @@
+error[E0283]: type annotations required: cannot resolve `_: std::default::Default`
+  --> $DIR/default_dependent_associated_type.rs:35:15
+   |
+35 |     let foo = Foo::new();
+   |               ^^^^^^^^
+   |
+   = note: required by `<Foo<X, Y>>::new`
+
+error: aborting due to previous error
+

src/test/ui/default-ty-param-fallback/default_dependent_associated_type.stderr

@@ -0,0 +1,19 @@
+// 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.
+//
+
+#![feature(default_type_parameter_fallback)]
+use std::marker::PhantomData;
+
+struct Foo<T,U=T> { t: T, data: PhantomData<U> }
+
+fn main() {
+    let foo = Foo { t: 'a', data: PhantomData };
+}

src/test/ui/default-ty-param-fallback/dependent_defaults.rs

@@ -0,0 +1,10 @@
+error[E0282]: type annotations needed
+  --> $DIR/dependent_defaults.rs:18:15
+   |
+18 |     let foo = Foo { t: 'a', data: PhantomData };
+   |         ---   ^^^ cannot infer type for `U`
+   |         |
+   |         consider giving `foo` a type
+
+error: aborting due to previous error
+

src/test/ui/default-ty-param-fallback/dependent_defaults.stderr

@@ -0,0 +1,18 @@
+// 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.
+
+enum Opt<T=String> {
+    Som(T),
+    Non,
+}
+
+fn main() {
+    Opt::Non;
+}

src/test/ui/default-ty-param-fallback/feature_gate.rs

@@ -0,0 +1,8 @@
+error[E0282]: type annotations needed
+  --> $DIR/feature_gate.rs:17:5
+   |
+17 |     Opt::Non;
+   |     ^^^^^^^^ cannot infer type for `T`
+
+error: aborting due to previous error
+

src/test/ui/default-ty-param-fallback/feature_gate.stderr

@@ -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.
+
+#![feature(default_type_parameter_fallback)]
+
+use std::path::Path;
+
+enum Opt<T=String> {
+    Som(T),
+    Non,
+}
+
+fn main() {
+    // Defaults on the type definiton work, as long no other params are interfering.
+    let _ = Opt::Non;
+    let _: Opt<_> = Opt::Non;
+
+    func1(None);
+    func2(Opt::Non);
+}
+
+// Defaults on fns take precedence.
+fn func1<P: AsRef<Path> = String>(p: Option<P>) { }
+fn func2<P: AsRef<Path> = String>(p: Opt<P>) { }

src/test/ui/default-ty-param-fallback/fn_priority_over_ty_def.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.
+
+#![feature(default_type_parameter_fallback)]
+
+use std::path::Path;
+
+fn func<P: AsRef<Path> = String>(p: Option<P>) {
+    match p {
+        None => { println!("None"); }
+        Some(path) => { println!("{:?}", path.as_ref()); }
+    }
+}
+
+fn main() {
+    // Dont fallback to future-proof against default on `noner`.
+    func(noner());
+}
+
+fn noner<T>() -> Option<T> { None }

src/test/ui/default-ty-param-fallback/future_proof.rs

@@ -0,0 +1,8 @@
+error[E0282]: type annotations needed
+  --> $DIR/future_proof.rs:24:5
+   |
+24 |     func(noner());
+   |     ^^^^ cannot infer type for `P`
+
+error: aborting due to previous error
+

src/test/ui/default-ty-param-fallback/future_proof.stderr

@@ -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.
+
+#![feature(default_type_parameter_fallback)]
+
+struct Foo;
+
+impl Foo {
+    fn method<A:Default=String>(&self) -> A {
+        A::default()
+    }
+}
+
+fn main() {
+    let f = Foo.method();
+    println!("{}", f);
+}

src/test/ui/default-ty-param-fallback/method_call_test.rs

@@ -0,0 +1,11 @@
+error[E0282]: type annotations needed
+  --> $DIR/method_call_test.rs:22:9
+   |
+22 |     let f = Foo.method();
+   |         ^
+   |         |
+   |         cannot infer type for `_`
+   |         consider giving `f` a type
+
+error: aborting due to previous error
+

src/test/ui/default-ty-param-fallback/method_call_test.stderr

@@ -0,0 +1,40 @@
+// 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.
+//
+
+#![feature(default_type_parameter_fallback)]
+
+use std::marker::PhantomData;
+
+struct DeterministicHasher;
+struct RandomHasher;
+
+
+struct MyHashMap<K, V, H=DeterministicHasher> {
+    data: PhantomData<(K, V, H)>
+}
+
+impl<K, V, H> MyHashMap<K, V, H> {
+    fn new() -> MyHashMap<K, V, H> {
+        MyHashMap { data: PhantomData }
+    }
+}
+
+mod mystd {
+    use super::{MyHashMap, RandomHasher};
+    pub type HashMap<K, V, H=RandomHasher> = MyHashMap<K, V, H>;
+}
+
+fn try_me<H>(hash_map: mystd::HashMap<i32, i32, H>) {}
+
+fn main() {
+    let hash_map = mystd::HashMap::new();
+    try_me(hash_map);
+}

src/test/ui/default-ty-param-fallback/struct_and_type_alias.rs

@@ -0,0 +1,10 @@
+error[E0282]: type annotations needed
+  --> $DIR/struct_and_type_alias.rs:38:20
+   |
+38 |     let hash_map = mystd::HashMap::new();
+   |         --------   ^^^^^^^^^^^^^^^^^^^ cannot infer type for `H`
+   |         |
+   |         consider giving `hash_map` a type
+
+error: aborting due to previous error
+