Set OriginOfTyParam for methods.

Fixes bug with default fallback, and small refactorings to default
fallback.

Author: leoyvens

src/librustc/traits/fulfill.rs

@@ -180,9 +180,9 @@ impl<'a, 'gcx, 'tcx> FulfillmentContext<'tcx> {
         self.predicates.pending_obligations()
     }
 
-    pub fn vars_in_unsolved_obligations(&self) -> FxHashSet<ty::TyVid> {
+    pub fn vars_in_obligations(&self) -> FxHashSet<ty::TyVid> {
         let mut vars = FxHashSet();
-        for p in self.predicates.unsolved_obligations() {
+        for p in self.predicates.obligations() {
             for ty in p.obligation.predicate.walk_tys() {
                 if let TypeVariants::TyInfer(InferTy::TyVar(vid)) = ty.sty {
                     vars.insert(vid);

src/librustc_data_structures/obligation_forest/mod.rs

@@ -244,16 +244,11 @@ impl<O: ForestObligation> ObligationForest<O> {
             .collect()
     }
 
-    /// Returns the set of obligations that are in a pending or waiting state.
-    pub fn unsolved_obligations(&self) -> Vec<O>
+    /// Returns all obligations.
+    pub fn obligations(&self) -> Vec<O>
         where O: Clone
     {
-        self.nodes
-            .iter()
-            .filter(|n| n.state.get() == NodeState::Pending ||
-                        n.state.get() == NodeState::Waiting)
-            .map(|n| n.obligation.clone())
-            .collect()
+        self.nodes.iter().map(|n| n.obligation.clone()).collect()
     }
 
     /// Perform a pass through the obligation list. This must

src/librustc_typeck/check/mod.rs

@@ -2201,7 +2201,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
         // Collect variables that are unsolved and support fallback,
         // grouped in bags by subtyping equivalence.
         let mut bags = FxHashMap();
-        for vid in self.fulfillment_cx.borrow().vars_in_unsolved_obligations() {
+        for vid in self.fulfillment_cx.borrow().vars_in_obligations() {
             let mut type_variables = self.infcx.type_variables.borrow_mut();
             let not_known = type_variables.probe(vid).is_none();
             let supports_fallback = match type_variables.var_origin(vid) {
@@ -2236,17 +2236,20 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
             // For future-proofing against conflicting defaults,
             // if one of the variables has no default, nothing is unified.
             for &vid in &bag {
-                match self.infcx.type_variables.borrow().default(vid) {
-                    &Default::User(_) => {},
+                let default = self.infcx.type_variables.borrow().default(vid).clone();
+                debug!("apply_user_type_parameter_fallback: \
+                        checking var: {:?} with default: {:?}", vid, default);
+                match default {
+                    Default::User(_) => {},
                     _ => continue 'bags,
                 }
             }
             for &vid in &bag {
                 // If future-proof, then all vars have defaults.
                 let default = self.infcx.type_variables.borrow().default(vid).clone();
                 let ty = self.tcx.mk_var(vid);
-                debug!("apply_user_type_parameter_fallback: \
-                        ty: {:?} with default: {:?}", ty, default);
+                debug!("apply_user_type_parameter_fallback: applying fallback to var: {:?} \
+                        with ty: {:?} with default: {:?}", vid, ty, default);
                 if let Default::User(user_default) = default {
                     let normalized_default = self.normalize_associated_types_in(
                                         user_default.origin_span,

src/librustc_typeck/collect.rs

@@ -878,14 +878,20 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     let (ast_generics, opt_inputs) = match node {
         NodeTraitItem(item) => {
             match item.node {
-                TraitItemKind::Method(ref sig, _) => (&item.generics, Some(&sig.decl.inputs)),
+                TraitItemKind::Method(ref sig, _) => {
+                    origin = ty::OriginOfTyParam::Fn;
+                    (&item.generics, Some(&sig.decl.inputs))
+                }
                 _ => (&item.generics, None)
             }
         }
 
         NodeImplItem(item) => {
             match item.node {
-                ImplItemKind::Method(ref sig, _) => (&item.generics, Some(&sig.decl.inputs)),
+                ImplItemKind::Method(ref sig, _) => {
+                    origin = ty::OriginOfTyParam::Fn;
+                    (&item.generics, Some(&sig.decl.inputs))
+                }
                 _ => (&item.generics, None)
             }
         }

src/test/run-pass/default-ty-param-fallback/default_ty_param_fallback_method_call_test.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.
+
+#![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/run-pass/default-ty-param-fallback/default_ty_param_fallback_struct.rs

@@ -0,0 +1,23 @@
+// 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<A>(A);
+
+impl<A:Default=i32> Foo<A> {
+    fn new() -> Foo<A> {
+        Foo(A::default())
+    }
+}
+
+fn main() {
+    let foo = Foo::new();
+}

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

@@ -0,0 +1,25 @@
+// 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)]
+
+// Another example from the RFC
+trait Foo { }
+trait Bar { }
+
+impl<T:Bar=usize> Foo for Vec<T> {}
+impl Bar for usize {}
+
+fn takes_foo<F:Foo>(f: F) {}
+
+fn main() {
+    let x = Vec::new(); // x: Vec<$0>
+    takes_foo(x); // adds oblig Vec<$0> : Foo
+}

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

@@ -0,0 +1,26 @@
+// 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)]
+
+// An example from the RFC
+trait Foo { fn takes_foo(&self); }
+trait Bar { }
+
+impl<T:Bar=usize> Foo for Vec<T> {
+    fn takes_foo(&self) {}
+}
+
+impl Bar for usize {}
+
+fn main() {
+    let x = Vec::new(); // x: Vec<$0>
+    x.takes_foo(); // adds oblig Vec<$0> : Foo
+}

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

@@ -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::collections::HashMap;
+
+type IntMap<K=usize> = HashMap<K, usize>;
+
+fn main() {
+    let x = IntMap::new();
+}