Fallback: Stop relying on sty equality, use rollbacks.

I tried preventing having to rollback inference and being clever with
sty equality, but dependent defaults means we need full inference here.

All application of defaults goes in the same transaction, again because
of dependent defaults. We can't mess with the fulfillment context in a
snapshot, so we clone our own fulfillment context.

The downside is that if we fail one bag we fail all, which can be very
confusing as the user may be presented with several errors when only
one of them is the "real one".

This is not so bad because we may easily have a heuristic that solves
the bags that can be solved in isolation and then puts the complicated
cases in a single transaction, making the pathological situation quite
rare.

Author: leoyvens

src/librustc/traits/fulfill.rs

@@ -42,7 +42,7 @@ impl<'tcx> ForestObligation for PendingPredicateObligation<'tcx> {
 /// along. Once all type inference constraints have been generated, the
 /// method `select_all_or_error` can be used to report any remaining
 /// ambiguous cases as errors.
-
+#[derive(Clone)]
 pub struct FulfillmentContext<'tcx> {
     // A list of all obligations that have been registered with this
     // fulfillment context.

src/librustc_data_structures/obligation_forest/mod.rs

@@ -57,6 +57,7 @@ pub trait ObligationProcessor {
         where I: Clone + Iterator<Item=&'c Self::Obligation>;
 }
 
+#[derive(Clone)]
 pub struct ObligationForest<O: ForestObligation> {
     /// The list of obligations. In between calls to
     /// `process_obligations`, this list only contains nodes in the
@@ -81,7 +82,7 @@ pub struct ObligationForest<O: ForestObligation> {
     scratch: Option<Vec<usize>>,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 struct Node<O> {
     obligation: O,
     state: Cell<NodeState>,

src/librustc_typeck/check/mod.rs

@@ -113,7 +113,6 @@ use std::rc::Rc;
 use std::collections::hash_map::Entry;
 use std::cmp;
 use std::fmt::Display;
-use std::iter::FromIterator;
 use std::mem::replace;
 use std::ops::{self, Deref};
 use syntax::abi::Abi;
@@ -2002,27 +2001,6 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                                                          value)
     }
 
-    fn eager_normalize_in<T>(&self, span: Span, value: &T) -> Option<T>
-        where T : TypeFoldable<'tcx>
-    {
-        let infer_ok = self.inh.partially_normalize_associated_types_in(span,
-                                                                        self.body_id,
-                                                                        self.param_env,
-                                                                        value);
-        if infer_ok.obligations.is_empty() {
-            Some(infer_ok.value)
-        } else {
-            self.inh.register_predicates(infer_ok.obligations);
-            self.select_obligations_where_possible();
-            let resolved = self.resolve_type_vars_if_possible(&infer_ok.value);
-            if !resolved.needs_infer() {
-                Some(resolved)
-            } else {
-                None
-            }
-        }
-    }
-
     pub fn require_type_meets(&self,
                               ty: Ty<'tcx>,
                               span: Span,
@@ -2233,20 +2211,20 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                 bags.entry(root).or_insert(Vec::new()).push(vid);
             }
         }
-        // Discard key, bags is a sequence of pairs (bag, done).
-        let mut bags = Vec::from_iter(bags.into_iter().map(|b| b.1).map(|b| (b, false)));
-        // Attempt to find a fallback for each bag.
-        loop {
-            // For dependent defaults, solving a bag
-            // might allow us to normalize an associated type in another bag.
-            // For example in `impl<X = u32, Y = <X as Trait>::Type>`.
-            // Therefore we loop over the bags until we are at a fixed point.
-            let mut fixed_point = true;
-            // Loop over bags that are not done.
-            'bags: for &mut(ref bag, ref mut done) in bags.iter_mut().filter(|bag| !bag.1) {
+        // We put everything in a single transaction
+        // because dependent defaults create cross-bag dependencies.
+        // This is bad in that we may report errors
+        // for things that actually were successfully inferred.
+        let _ = self.commit_if_ok(|_| { self.save_and_restore_in_snapshot_flag(|infcx| {
+            // Clone the whole thing so we can use it for this snapshot.
+            let mut local_fullfilment = self.fulfillment_cx.borrow().clone();
+            // Attempt to find a fallback for each bag.
+            // - Fail if there are missing defaults.
+            // - Apply default if all default exist.
+            'bags: for bag in bags.into_iter().map(|b| b.1) {
                 // Partition the bag by the origin of the type param.
                 let (fn_or_impl, ty_def) = bag.iter().partition(|&&v| {
-                    match self.infcx.type_variables.borrow().var_origin(v) {
+                    match infcx.type_variables.borrow().var_origin(v) {
                         TypeParameterDefinition(_, _, OriginOfTyParam::Fn) |
                         TypeParameterDefinition(_, _, OriginOfTyParam::Impl) => true,
                         TypeParameterDefinition(_, _, OriginOfTyParam::TyDef) => false,
@@ -2259,42 +2237,40 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                 if bag.is_empty() {
                     bag = ty_def;
                 }
-                // - Try again later if a default can't be normalized.
-                // - Fail if there are conflicting or missing defaults.
-                // - Succeess if all defaults exist and agree.
-                let get_default = |&v| self.infcx.type_variables.borrow().default(v).as_user();
+                let get_default = |&v| infcx.type_variables.borrow().default(v).as_user();
                 let mut normalized_defaults = Vec::new();
-                for default in bag.iter().map(&get_default) {
-                    if let Some(default) = default {
-                        match self.eager_normalize_in(default.origin_span, &default.ty) {
-                            Some(default) => normalized_defaults.push(default),
-                            None => continue 'bags, // Try again later.
+                for (&vid, default) in bag.iter().zip(bag.iter().map(&get_default)) {
+                    if let Some(d) = default {
+                        let infr_ok = self.normalize_associated_types_in_as_infer_ok(d.origin_span,
+                                                                                    &d.ty);
+                        normalized_defaults.push((vid, infr_ok.value));
+                        for obligation in infr_ok.obligations {
+                            local_fullfilment.register_predicate_obligation(infcx, obligation);
                         }
                     } else {
-                        // Fail, missing default.
-                        *done = true;
-                        continue 'bags;
+                        continue 'bags; // Fail, missing default.
                     }
                 }
-                let equivalent_default = normalized_defaults[0];
-                // Fail on conflicting defaults.
-                if normalized_defaults.iter().any(|&d| d.sty != equivalent_default.sty) {
-                    break;
-                }
-                // All defaults exist and agree, success, apply the default.
-                fixed_point = false;
-                *done = true;
-                for &vid in &bag {
+                // All defaults exist, apply them.
+                for (vid, default) in normalized_defaults {
                     let ty = self.tcx.mk_var(vid);
-                    self.demand_eqtype(syntax_pos::DUMMY_SP, &ty, equivalent_default);
+                    let cause = self.misc(syntax_pos::DUMMY_SP);
+                    if let Ok(infer_ok) = self.at(&cause, self.param_env).sub(default, ty) {
+                        for obligation in infer_ok.obligations {
+                            local_fullfilment.register_predicate_obligation(infcx, obligation);
+                        }
+                    }
                     debug!("apply_user_type_parameter_fallback: applied fallback to var: {:?} \
-                        with ty: {:?} with default: {:?}", vid, ty, equivalent_default);
+                        with ty: {:?} with default: {:?}", vid, ty, default);
                 }
             }
-            if fixed_point {
-                break;
+            // Rollback on any conflict.
+            if local_fullfilment.select_where_possible(self).is_err() {
+                Err(())
+            } else {
+                Ok(())
             }
-        }
+        })});
     }
 
     // Implements type inference fallback algorithm

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

@@ -0,0 +1,44 @@
+// 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;
+
+#[derive(Copy, Clone)]
+enum Opt<T> {
+    Som(T),
+    Non,
+}
+
+trait Id {
+    type Me;
+}
+
+impl<A> Id for A {
+    type Me = A;
+}
+
+struct Foo<X, Y, Z> {
+    data: PhantomData<(X, Y, Z)>,
+}
+
+impl<X: Default = u32, Y = <X as Id>::Me, Z = <Y as Id>::Me>
+    Foo<X, Y, Z> {
+    fn new(_: Opt<X>, _: Opt<Y>, _: Opt<Z>) -> Foo<X, Y, Z> {
+        Foo { data: PhantomData }
+    }
+}
+
+fn main() {
+    let a = Opt::Non;
+    let _ = Foo::new(a, a, a);
+}

src/test/ui/default-ty-param-fallback/fn_priority_over_ty_def.rs renamed to src/test/run-pass/default-ty-param-fallback/fn_priority_over_ty_def.rs

@@ -7,6 +7,7 @@
 // <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.
+// compile-flags: --error-format=human
 
 #![feature(default_type_parameter_fallback)]
 

src/test/run-pass/default-ty-param-fallback/related_dependent_defaults.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.
+
+// 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)]
+
+#[derive(Copy, Clone)]
+enum Opt<T=String> {
+    Som(T),
+    Non,
+}
+
+fn main() {
+    let a = Opt::Non;
+    let b = Opt::Non;
+    func1(a, b);
+    func2(b, a);
+
+    let c = Opt::Non;
+    let d = Opt::Non;
+    func1(c, d);
+    func2(c, d);
+}
+
+fn func1<X = u32, Y = X>(_: Opt<X>, _: Opt<Y>) {
+}
+
+fn func2<X = u32, Y = X>(_: Opt<X>, _: Opt<Y>) {
+}

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

@@ -7,7 +7,7 @@
 // <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.
-//
+// compile-flags: --error-format=human
 
 #![feature(default_type_parameter_fallback)]
 

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

@@ -7,7 +7,7 @@
 // <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.
-//
+// compile-flags: --error-format=human
 
 #![feature(default_type_parameter_fallback)]
 use std::marker::PhantomData;

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

@@ -7,6 +7,7 @@
 // <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.
+// compile-flags: --error-format=human
 
 #![feature(default_type_parameter_fallback)]
 

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

@@ -1,7 +1,7 @@
 error[E0282]: type annotations needed
-  --> $DIR/dont_skip_conflict.rs:26:13
+  --> $DIR/dont_skip_conflict.rs:27:13
    |
-26 |     let x = Opt::Non;
+27 |     let x = Opt::Non;
    |         -   ^^^^^^^^ cannot infer type for `T`
    |         |
    |         consider giving `x` a type

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

@@ -7,6 +7,7 @@
 // <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.
+// compile-flags: --error-format=human
 
 #![feature(default_type_parameter_fallback)]
 
@@ -18,9 +19,6 @@ fn foo<F:Default=usize>() -> F { F::default() }
 fn bar<B:Debug=isize>(b: B) { println!("{:?}", b); }
 
 fn main() {
-    // Here, F is instantiated with $0=uint
     let x = foo();
-
-    // Here, B is instantiated with $1=uint, and constraint $0 <: $1 is added.
     bar(x);
 }

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

@@ -8,7 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 //
-//aux-build:default_ty_param_cross_crate_crate.rs
+// aux-build:default_ty_param_cross_crate_crate.rs
+// compile-flags: --error-format=human
 
 #![feature(default_type_parameter_fallback)]
 

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

@@ -1,7 +1,7 @@
 error[E0282]: type annotations needed
-  --> $DIR/fallback_conflict_cross_crate.rs:22:15
+  --> $DIR/fallback_conflict_cross_crate.rs:23:15
    |
-22 |     let foo = bleh();
+23 |     let foo = bleh();
    |         ---   ^^^^ cannot infer type for `A`
    |         |
    |         consider giving `foo` a type

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

@@ -7,6 +7,7 @@
 // <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.
+// compile-flags: --error-format=human
 
 enum Opt<T=String> {
     Som(T),

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

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

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

@@ -7,6 +7,7 @@
 // <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.
+// compile-flags: --error-format=human
 
 #![feature(default_type_parameter_fallback)]
 

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

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

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

@@ -7,6 +7,7 @@
 // <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.
+// compile-flags: --error-format=human
 
 #![feature(default_type_parameter_fallback)]
 

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

@@ -1,7 +1,7 @@
 error[E0282]: type annotations needed
-  --> $DIR/method_call_test.rs:22:9
+  --> $DIR/method_call_test.rs:23:9
    |
-22 |     let f = Foo.method();
+23 |     let f = Foo.method();
    |         ^
    |         |
    |         cannot infer type for `_`