---

yaml
---
r: 273141
b: refs/heads/beta
c: 7e42a78
h: refs/heads/master
i:
  273139: c602c27

Author: aturon

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 957ee5ce347999ef2c1acfdb63a76643c61f6516
+refs/heads/beta: 7e42a780161e757ddd7d20925691a861f9d86725
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/src/librustc/middle/traits/coherence.rs

@@ -85,10 +85,7 @@ fn overlap<'cx, 'tcx>(selcx: &mut SelectionContext<'cx, 'tcx>,
         return None
     }
 
-    let substituted = selcx.infcx().resolve_type_vars_if_possible(&a_impl_header);
-    let freshened = selcx.infcx().freshen(substituted);
-
-    Some(freshened)
+    Some(selcx.infcx().resolve_type_vars_if_possible(&a_impl_header))
 }
 
 pub fn trait_ref_is_knowable<'tcx>(tcx: &TyCtxt<'tcx>, trait_ref: &ty::TraitRef<'tcx>) -> bool

branches/beta/src/librustc/middle/traits/mod.rs

@@ -50,7 +50,7 @@ pub use self::select::SelectionContext;
 pub use self::select::SelectionCache;
 pub use self::select::{MethodMatchResult, MethodMatched, MethodAmbiguous, MethodDidNotMatch};
 pub use self::select::{MethodMatchedData}; // intentionally don't export variants
-pub use self::specialize::{Overlap, SpecializationGraph, specializes};
+pub use self::specialize::{Overlap, SpecializationGraph, get_impl_item_or_default, ItemSource, specializes};
 pub use self::util::elaborate_predicates;
 pub use self::util::get_vtable_index_of_object_method;
 pub use self::util::trait_ref_for_builtin_bound;

branches/beta/src/librustc/middle/traits/select.rs

@@ -1629,7 +1629,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 // i.e. EvaluatedToOk:
                 if other.evaluation == EvaluatedToOk {
                     if let ImplCandidate(victim_def) = victim.candidate {
-                        return traits::specializes(self.infcx(), other_def, victim_def);
+                        return traits::specializes(self.tcx(), other_def, victim_def);
                     }
                 }
 

branches/beta/src/librustc/middle/traits/specialize.rs

@@ -23,7 +23,7 @@ use middle::infer::{self, InferCtxt, TypeOrigin};
 use middle::region;
 use middle::subst::{Subst, Substs};
 use middle::traits;
-use middle::ty;
+use middle::ty::{self, ImplOrTraitItem};
 use syntax::codemap::DUMMY_SP;
 use util::nodemap::DefIdMap;
 
@@ -51,6 +51,8 @@ pub struct SpecializationGraph {
 /// Information pertinent to an overlapping impl error.
 pub struct Overlap<'tcx> {
     pub with_impl: DefId,
+
+    /// NB: this TraitRef can contain inference variables!
     pub on_trait_ref: ty::TraitRef<'tcx>,
 }
 
@@ -72,9 +74,7 @@ impl SpecializationGraph {
                         -> Result<(), Overlap<'tcx>> {
         assert!(impl_def_id.is_local());
 
-        let infcx = infer::new_infer_ctxt(tcx, &tcx.tables, None, false);
         let mut parent = trait_ref.def_id;
-
         let mut my_children = vec![];
 
         // descend the existing tree, looking for the right location to add this impl
@@ -84,13 +84,12 @@ impl SpecializationGraph {
             for slot in possible_siblings.iter_mut() {
                 let possible_sibling = *slot;
 
-                let overlap = infcx.probe(|_| {
-                    traits::overlapping_impls(&infcx, possible_sibling, impl_def_id)
-                });
+                let infcx = infer::new_infer_ctxt(tcx, &tcx.tables, None, false);
+                let overlap = traits::overlapping_impls(&infcx, possible_sibling, impl_def_id);
 
                 if let Some(trait_ref) = overlap {
-                    let le = specializes(&infcx, impl_def_id, possible_sibling);
-                    let ge = specializes(&infcx, possible_sibling, impl_def_id);
+                    let le = specializes(tcx, impl_def_id, possible_sibling);
+                    let ge = specializes(tcx, possible_sibling, impl_def_id);
 
                     if le && !ge {
                         // the impl specializes possible_sibling
@@ -120,22 +119,184 @@ impl SpecializationGraph {
         }
 
         if self.children.insert(impl_def_id, my_children).is_some() {
-            panic!("When inserting an impl into the specialization graph, existing children for \
-                    the impl were already present.");
+            tcx.sess
+               .bug("When inserting an impl into the specialization graph, existing children for \
+                     the impl were already present.");
         }
 
         Ok(())
     }
 
-    /// Insert cached metadata mapping from a child impl back to its parent
+    /// Insert cached metadata mapping from a child impl back to its parent.
     pub fn record_impl_from_cstore(&mut self, parent: DefId, child: DefId) {
-        if self.parent.insert(child, Some(parent)).is_some() {
+        if self.parent.insert(child, parent).is_some() {
             panic!("When recording an impl from the crate store, information about its parent \
                     was already present.");
         }
 
         self.children.entry(parent).or_insert(vec![]).push(child);
     }
+
+    /// The parent of a given impl, which is the def id of the trait when the
+    /// impl is a "specialization root".
+    pub fn parent(&self, child: DefId) -> DefId {
+        *self.parent.get(&child).unwrap()
+    }
+}
+
+/// When we have selected one impl, but are actually using item definitions from
+/// a parent impl providing a default, we need a way to translate between the
+/// type parameters of the two impls. Here the `source_impl` is the one we've
+/// selected, and `source_substs` is a substitution of its generics (and possibly
+/// some relevant `FnSpace` variables as well). And `target_impl` is the impl
+/// we're actually going to get the definition from.
+fn translate_substs_between_impls<'tcx>(tcx: &ty::ctxt<'tcx>,
+                                        source_impl: DefId,
+                                        source_substs: Substs<'tcx>,
+                                        target_impl: DefId)
+                                        -> Substs<'tcx> {
+
+    // We need to build a subst that covers all the generics of
+    // `target_impl`. Start by introducing fresh infer variables:
+    let target_generics = tcx.lookup_item_type(target_impl).generics;
+    let mut infcx = infer::normalizing_infer_ctxt(tcx, &tcx.tables);
+    let mut target_substs = infcx.fresh_substs_for_generics(DUMMY_SP, &target_generics);
+    if source_substs.regions.is_erased() {
+        target_substs = target_substs.erase_regions()
+    }
+
+    if !fulfill_implication(&mut infcx,
+                            source_impl,
+                            source_substs.clone(),
+                            target_impl,
+                            target_substs.clone()) {
+        tcx.sess
+           .bug("When translating substitutions for specialization, the expected specializaiton \
+                 failed to hold")
+    }
+
+    // Now resolve the *substitution* we built for the target earlier, replacing
+    // the inference variables inside with whatever we got from fulfillment. We
+    // also carry along any FnSpace substitutions, which don't need to be
+    // adjusted when mapping from one impl to another.
+    infcx.resolve_type_vars_if_possible(&target_substs)
+         .with_method_from_subst(&source_substs)
+}
+
+/// When we've selected an impl but need to use an item definition provided by
+/// the trait itself, we need to translate the substitution applied to the impl
+/// to one that makes sense for the trait.
+fn translate_substs_from_impl_to_trait<'tcx>(tcx: &ty::ctxt<'tcx>,
+                                             source_impl: DefId,
+                                             source_substs: Substs<'tcx>)
+                                             -> Substs<'tcx> {
+
+    let source_trait_ref = tcx.impl_trait_ref(source_impl).unwrap().subst(tcx, &source_substs);
+
+    let mut new_substs = source_trait_ref.substs.clone();
+    if source_substs.regions.is_erased() {
+        new_substs = new_substs.erase_regions()
+    }
+
+    // Carry any FnSpace substitutions along; they don't need to be adjusted
+    new_substs.with_method_from_subst(&source_substs)
+}
+
+#[derive(Debug, Copy, Clone)]
+/// When looking up an item in an impl, it may turn out that the item
+/// is actually provided as a default by a more generic impl, or by
+/// the trait itself. This enum says where the item came from.
+pub enum ItemSource {
+    Impl {
+        requested_impl: DefId,
+        actual_impl: DefId,
+    },
+    Trait {
+        requested_impl: DefId,
+    },
+}
+
+impl ItemSource {
+    pub fn is_from_trait(&self) -> bool {
+        match *self {
+            ItemSource::Trait { .. } => true,
+            _ => false,
+        }
+    }
+
+    /// Given a subst for the requested impl, translate it to a subst
+    /// appropriate for the actual item definition (whether it be in that impl,
+    /// a parent impl, or the trait).
+    pub fn translate_substs<'tcx>(&self,
+                                  tcx: &ty::ctxt<'tcx>,
+                                  requested_impl_substs: Substs<'tcx>)
+                                  -> Substs<'tcx> {
+        match *self {
+            ItemSource::Impl { requested_impl, actual_impl } => {
+                // no need to translate if we're targetting the impl we started with
+                if requested_impl == actual_impl {
+                    return requested_impl_substs;
+                }
+
+                translate_substs_between_impls(tcx,
+                                               requested_impl,
+                                               requested_impl_substs,
+                                               actual_impl)
+
+            }
+            ItemSource::Trait { requested_impl } => {
+                translate_substs_from_impl_to_trait(tcx, requested_impl, requested_impl_substs)
+            }
+        }
+    }
+}
+
+/// Lookup the definition of an item within `requested_impl` or its specialization
+/// parents, including provided items from the trait itself.
+///
+/// The closure `f` works in the style of `filter_map`.
+pub fn get_impl_item_or_default<'tcx, I, F>(tcx: &ty::ctxt<'tcx>,
+                                            requested_impl: DefId,
+                                            mut f: F)
+                                            -> Option<(I, ItemSource)>
+    where F: for<'a> FnMut(&ImplOrTraitItem<'tcx>) -> Option<I>
+{
+    let impl_or_trait_items_map = tcx.impl_or_trait_items.borrow();
+    let trait_def_id = tcx.trait_id_of_impl(requested_impl).unwrap();
+    let trait_def = tcx.lookup_trait_def(trait_def_id);
+
+    // Walk up the specialization tree, looking for a matching item definition
+
+    let mut current_impl = requested_impl;
+    loop {
+        for impl_item_id in &tcx.impl_items.borrow()[&current_impl] {
+            let impl_item = &impl_or_trait_items_map[&impl_item_id.def_id()];
+            if let Some(t) = f(impl_item) {
+                let source = ItemSource::Impl {
+                    requested_impl: requested_impl,
+                    actual_impl: current_impl,
+                };
+                return Some((t, source));
+            }
+        }
+
+        if let Some(parent) = trait_def.parent_of_impl(current_impl) {
+            current_impl = parent;
+        } else {
+            break;
+        }
+    }
+
+    // The item isn't defined anywhere in the hierarchy. Get the
+    // default from the trait.
+
+    for trait_item in tcx.trait_items(trait_def_id).iter() {
+        if let Some(t) = f(trait_item) {
+            return Some((t, ItemSource::Trait { requested_impl: requested_impl }));
+        }
+    }
+
+    None
 }
 
 fn skolemizing_subst_for_impl<'a>(tcx: &ty::ctxt<'a>, impl_def_id: DefId) -> Substs<'a> {
@@ -155,30 +316,57 @@ fn skolemizing_subst_for_impl<'a>(tcx: &ty::ctxt<'a>, impl_def_id: DefId) -> Sub
 /// Specialization is determined by the sets of types to which the impls apply;
 /// impl1 specializes impl2 if it applies to a subset of the types impl2 applies
 /// to.
-pub fn specializes(infcx: &InferCtxt, impl1_def_id: DefId, impl2_def_id: DefId) -> bool {
-    let tcx = &infcx.tcx;
-
+pub fn specializes(tcx: &ty::ctxt, impl1_def_id: DefId, impl2_def_id: DefId) -> bool {
     // We determine whether there's a subset relationship by:
     //
     // - skolemizing impl1,
+    // - instantiating impl2 with fresh inference variables,
     // - assuming the where clauses for impl1,
     // - unifying,
     // - attempting to prove the where clauses for impl2
     //
+    // The last three steps are essentially checking for an implication between two impls
+    // after appropriate substitutions. This is what `fulfill_implication` checks for.
+    //
     // See RFC 1210 for more details and justification.
 
+    let mut infcx = infer::normalizing_infer_ctxt(tcx, &tcx.tables);
+
     let impl1_substs = skolemizing_subst_for_impl(tcx, impl1_def_id);
+    let impl2_substs = util::fresh_type_vars_for_impl(&infcx, DUMMY_SP, impl2_def_id);
+
+    fulfill_implication(&mut infcx,
+                        impl1_def_id,
+                        impl1_substs,
+                        impl2_def_id,
+                        impl2_substs)
+}
+
+/// Does impl1 (instantiated with the impl1_substs) imply impl2
+/// (instantiated with impl2_substs)?
+///
+/// Mutates the `infcx` in two ways:
+/// - by adding the obligations of impl1 to the parameter environment
+/// - via fulfillment, so that if the implication holds the various unifications
+fn fulfill_implication<'a, 'tcx>(infcx: &mut InferCtxt<'a, 'tcx>,
+                                 impl1_def_id: DefId,
+                                 impl1_substs: Substs<'tcx>,
+                                 impl2_def_id: DefId,
+                                 impl2_substs: Substs<'tcx>)
+                                 -> bool {
+    let tcx = &infcx.tcx;
+
     let (impl1_trait_ref, impl1_obligations) = {
         let selcx = &mut SelectionContext::new(&infcx);
         util::impl_trait_ref_and_oblig(selcx, impl1_def_id, &impl1_substs)
     };
 
     let impl1_predicates: Vec<_> = impl1_obligations.iter()
-        .cloned()
-        .map(|oblig| oblig.predicate)
-        .collect();
+                                                    .cloned()
+                                                    .map(|oblig| oblig.predicate)
+                                                    .collect();
 
-    let penv = ty::ParameterEnvironment {
+    infcx.parameter_environment = ty::ParameterEnvironment {
         tcx: tcx,
         free_substs: impl1_substs,
         implicit_region_bound: ty::ReEmpty, // FIXME: is this OK?
@@ -188,21 +376,18 @@ pub fn specializes(infcx: &InferCtxt, impl1_def_id: DefId, impl2_def_id: DefId)
         free_id_outlive: region::DUMMY_CODE_EXTENT, // FIXME: is this OK?
     };
 
-    // FIXME: unclear what `errors_will_be_reported` should be here...
-    let infcx = infer::new_infer_ctxt(tcx, infcx.tables, Some(penv), true);
     let selcx = &mut SelectionContext::new(&infcx);
-
-    let impl2_substs = util::fresh_type_vars_for_impl(&infcx, DUMMY_SP, impl2_def_id);
-    let (impl2_trait_ref, impl2_obligations) =
-        util::impl_trait_ref_and_oblig(selcx, impl2_def_id, &impl2_substs);
+    let (impl2_trait_ref, impl2_obligations) = util::impl_trait_ref_and_oblig(selcx,
+                                                                              impl2_def_id,
+                                                                              &impl2_substs);
 
     // do the impls unify? If not, no specialization.
     if let Err(_) = infer::mk_eq_trait_refs(&infcx,
                                             true,
                                             TypeOrigin::Misc(DUMMY_SP),
                                             impl1_trait_ref,
                                             impl2_trait_ref) {
-        debug!("specializes: {:?} does not unify with {:?}",
+        debug!("fulfill_implication: {:?} does not unify with {:?}",
                impl1_trait_ref,
                impl2_trait_ref);
         return false;
@@ -212,21 +397,24 @@ pub fn specializes(infcx: &InferCtxt, impl1_def_id: DefId, impl2_def_id: DefId)
 
     // attempt to prove all of the predicates for impl2 given those for impl1
     // (which are packed up in penv)
+
     for oblig in impl2_obligations.into_iter() {
         fulfill_cx.register_predicate_obligation(&infcx, oblig);
     }
 
     if let Err(errors) = infer::drain_fulfillment_cx(&infcx, &mut fulfill_cx, &()) {
-        debug!("specializes: for impls on {:?} and {:?}, could not fulfill: {:?} given {:?}",
+        // no dice!
+        debug!("fulfill_implication: for impls on {:?} and {:?}, could not fulfill: {:?} given \
+                {:?}",
                impl1_trait_ref,
                impl2_trait_ref,
                errors,
                infcx.parameter_environment.caller_bounds);
-        return false;
+        false
+    } else {
+        debug!("fulfill_implication: an impl for {:?} specializes {:?} (`where` clauses elided)",
+               impl1_trait_ref,
+               impl2_trait_ref);
+        true
     }
-
-    debug!("specializes: an impl for {:?} specializes {:?} (`where` clauses elided)",
-           impl1_trait_ref,
-           impl2_trait_ref);
-    true
 }