Run pass tests.

The happy kind of test.

Author: leoyvens

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

@@ -21,16 +21,16 @@ impl<A> Id for A {
     type This = A;
 }
 
-struct Foo<X: Default = usize, Y = <X as Id>::This> {
+struct Foo<X, Y> {
     data: PhantomData<(X, Y)>
 }
 
-impl<X: Default, Y> Foo<X, Y> {
+impl<X: Default = usize, Y = <X as Id>::This> Foo<X, Y> {
     fn new() -> Foo<X, Y> {
         Foo { data: PhantomData }
     }
 }
 
 fn main() {
-    let foo = Foo::new();
+    let _ = Foo::new();
 }

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

@@ -12,8 +12,15 @@
 #![feature(default_type_parameter_fallback)]
 use std::marker::PhantomData;
 
+#[allow(dead_code)]
 struct Foo<T,U=T> { t: T, data: PhantomData<U> }
 
+impl<T,U=T> Foo<T,U> {
+    fn new(t: T) -> Foo<T,U> {
+        Foo { t, data: PhantomData }
+    }
+}
+
 fn main() {
-    let foo = Foo { t: 'a', data: PhantomData };
+    let _ = Foo::new('a');
 }

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

@@ -10,17 +10,22 @@
 
 #![feature(default_type_parameter_fallback)]
 
-// An example from the RFC
-trait Foo { fn takes_foo(&self); }
-trait Bar { }
+use std::path::Path;
 
-impl<T:Bar=usize> Foo for Vec<T> {
-    fn takes_foo(&self) {}
+enum Opt<T=String> {
+    Som(T),
+    Non,
 }
 
-impl Bar for usize {}
-
 fn main() {
-    let x = Vec::new(); // x: Vec<$0>
-    x.takes_foo(); // adds oblig Vec<$0> : Foo
+    // 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/run-pass/default_ty_param_fallback_default_dependent_associated_type.rs renamed to src/test/run-pass/default-ty-param-fallback/dependent_associated_type.rs

@@ -19,6 +19,9 @@ impl Foo {
 }
 
 fn main() {
-    let f = Foo.method();
-    println!("{}", f);
+    // Bug: Replacing with Foo.method::<_>() fails.
+    // Suspicion: astconv and tycheck are considering this a "A provided type parameter.",
+    // resulting in type_var_for_def not being called and a TypeInference var being created
+    // rather than a TypeParameterDefinition var.
+    let _ = Foo.method();
 }

src/test/run-pass/default_ty_param_fallback_dependent_defaults.rs renamed to src/test/run-pass/default-ty-param-fallback/dependent_defaults.rs

@@ -19,5 +19,5 @@ impl<A:Default=i32> Foo<A> {
 }
 
 fn main() {
-    let foo = Foo::new();
+    let _ = Foo::new();
 }

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

@@ -10,16 +10,30 @@
 
 #![feature(default_type_parameter_fallback)]
 
-// Another example from the RFC
+struct Vac<T>(Vec<T>);
+
+impl<T=usize> Vac<T> {
+    fn new() -> Self {
+        Vac(Vec::new())
+    }
+}
+
 trait Foo { }
 trait Bar { }
 
-impl<T:Bar=usize> Foo for Vec<T> {}
+impl<T:Bar=usize> Foo for Vac<T> {}
 impl Bar for usize {}
 
-fn takes_foo<F:Foo>(f: F) {}
+fn takes_foo<F:Foo>(_: F) {}
 
 fn main() {
-    let x = Vec::new(); // x: Vec<$0>
-    takes_foo(x); // adds oblig Vec<$0> : Foo
+    let x = Vac::new(); // x: Vac<$0>
+    // adds oblig Vac<$0> : Foo,
+    // 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,
+    // because the corresponding inference var will be generalized
+    // to Vac<_>.
+    takes_foo(x);
 }

src/test/run-pass/default-ty-param-fallback/default_ty_param_fallback_struct.rs renamed to src/test/run-pass/default-ty-param-fallback/fallback_in_impls.rs

@@ -0,0 +1,45 @@
+// 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 A<T = Self> {
+    fn a(t: &T) -> Self;
+}
+
+trait B<T = Self> {
+    fn b(&self) -> T;
+}
+
+impl<T = X> B<T> for X
+    where T: A<X>
+{
+    fn b(&self) -> T {
+        T::a(self)
+    }
+}
+
+struct X(u8);
+
+impl A for X {
+    fn a(x: &X) -> X {
+        X(x.0)
+    }
+}
+
+fn g(x: &X) {
+    // Bug: replacing with `let x = X::b(x)` will cause `x` to be unknown in `x.0`.
+    let x = <X as B>::b(x);
+    x.0;
+}
+
+fn main() {
+    g(&X(0));
+}

src/test/run-pass/default_ty_param_fallback_method_call_test.rs renamed to src/test/run-pass/default-ty-param-fallback/method_call.rs

@@ -10,15 +10,16 @@
 
 #![feature(default_type_parameter_fallback)]
 
-struct Foo;
+struct HeshMep<K, V, S=String>(Vec<K>, Vec<V>, S);
 
-impl Foo {
-    fn method<A:Default=String>(&self) -> A {
-        A::default()
+impl<V, K=usize, S:Default=String> HeshMep<K, V, S> {
+    fn new() -> HeshMep<K, V, S> {
+        HeshMep(Vec::new(), Vec::new(), S::default())
     }
 }
 
+type IntMap<K> = HeshMep<K, usize>;
+
 fn main() {
-    let f = Foo.method();
-    println!("{}", f);
+    let _ = IntMap::new();
 }