WIP: Remove Self:Trait from predicates_of

Author: tmandry

src/librustc/infer/mod.rs

@@ -750,13 +750,16 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                       -> UnitResult<'tcx>
         where T: at::ToTrace<'tcx>
     {
+        debug!("can_sub({:?}, {:?})", a, b);
         let origin = &ObligationCause::dummy();
-        self.probe(|_| {
+        let result = self.probe(|_| {
             self.at(origin, param_env).sub(a, b).map(|InferOk { obligations: _, .. }| {
                 // Ignore obligations, since we are unrolling
                 // everything anyway.
             })
-        })
+        });
+        debug!("can_sub({:?}, {:?}) returning {:?}", a, b, result);
+        result
     }
 
     pub fn can_eq<T>(&self,
@@ -766,13 +769,16 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                       -> UnitResult<'tcx>
         where T: at::ToTrace<'tcx>
     {
+        debug!("can_eq({:?}, {:?})", a, b);
         let origin = &ObligationCause::dummy();
-        self.probe(|_| {
+        let result = self.probe(|_| {
             self.at(origin, param_env).eq(a, b).map(|InferOk { obligations: _, .. }| {
                 // Ignore obligations, since we are unrolling
                 // everything anyway.
             })
-        })
+        });
+        debug!("can_eq({:?}, {:?}) returning {:?}", a, b, result);
+        result
     }
 
     pub fn sub_regions(&self,

src/librustc/traits/select.rs

@@ -1934,9 +1934,6 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
     // attempt to evaluate recursive bounds to see if they are
     // satisfied.
 
-    /// Returns true if `candidate_i` should be dropped in favor of
-    /// `candidate_j`.  Generally speaking we will drop duplicate
-    /// candidates and prefer where-clause candidates.
     /// Returns true if `victim` should be dropped in favor of
     /// `other`.  Generally speaking we will drop duplicate
     /// candidates and prefer where-clause candidates.

src/librustc/ty/mod.rs

@@ -2718,7 +2718,7 @@ fn param_env<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     // Compute the bounds on Self and the type parameters.
 
     let bounds = tcx.predicates_of(def_id).instantiate_identity(tcx);
-    let predicates = bounds.predicates;
+    let mut predicates = bounds.predicates;
 
     // Finally, we have to normalize the bounds in the environment, in
     // case they contain any associated type projections. This process
@@ -2732,6 +2732,22 @@ fn param_env<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     // are any errors at that point, so after type checking you can be
     // sure that this will succeed without errors anyway.
 
+    let id = tcx.hir.as_local_node_id(def_id).unwrap();
+    debug!("param_env: handling def_id={:?}, id={:?}", def_id, id);
+
+    if let Some(hir::map::NodeItem(item)) = tcx.hir.find(id) {
+        debug!("  param_env: self node: {:?}", item.node);
+        if let hir::ItemTrait(..) = item.node {
+            debug!("    param_env: self is trait!");
+            let trait_ref = ty::TraitRef {
+                def_id: def_id,
+                substs: Substs::identity_for_item(tcx, def_id)
+            };
+            predicates.push(trait_ref.to_poly_trait_ref().to_predicate());
+        }
+    }
+    debug!("  param_env predicates: {:?}", predicates);
+
     let unnormalized_env = ty::ParamEnv::new(tcx.intern_predicates(&predicates),
                                              traits::Reveal::UserFacing);
 

src/librustc_typeck/check/compare_method.rs

@@ -30,7 +30,6 @@ use super::{Inherited, FnCtxt};
 /// - impl_m_span: span to use for reporting errors
 /// - trait_m: the method in the trait
 /// - impl_trait_ref: the TraitRef corresponding to the trait implementation
-
 pub fn compare_impl_method<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                      impl_m: &ty::AssociatedItem,
                                      impl_m_span: Span,

src/librustc_typeck/collect.rs

@@ -1321,12 +1321,17 @@ pub fn explicit_predicates_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     let node = tcx.hir.get(node_id);
 
     let mut is_trait = None;
+    let mut is_trait_item = None;
     let mut is_default_impl_trait = None;
 
     let icx = ItemCtxt::new(tcx, def_id);
     let no_generics = hir::Generics::empty();
     let ast_generics = match node {
-        NodeTraitItem(item) => &item.generics,
+        NodeTraitItem(item) => {
+            is_trait_item = Some(());
+            &item.generics
+        }
+
         NodeImplItem(item) => &item.generics,
 
         NodeItem(item) => {
@@ -1401,13 +1406,37 @@ pub fn explicit_predicates_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     // and the explicit where-clauses, but to get the full set of predicates
     // on a trait we need to add in the supertrait bounds and bounds found on
     // associated types.
-    if let Some((trait_ref, _)) = is_trait {
+    if let Some((_trait_ref, _)) = is_trait {
         predicates = tcx.super_predicates_of(def_id).predicates;
 
         // Add in a predicate that `Self:Trait` (where `Trait` is the
         // current trait).  This is needed for builtin bounds.
-        predicates.push(trait_ref.to_poly_trait_ref().to_predicate());
+        //predicates.push(trait_ref.to_poly_trait_ref().to_predicate());
+    }
+
+    if let Some(()) = is_trait_item {
+        let id = tcx.hir.as_local_node_id(def_id).unwrap();
+        debug!("explicit_predicates_of: handling def_id={:?}, id={:?}", def_id, id);
+
+        let parent_id = tcx.hir.get_parent(id);
+        let parent_def_id = tcx.hir.local_def_id(parent_id);
+        if let Some(hir::map::NodeItem(parent_item)) = tcx.hir.find(parent_id) {
+            debug!("  explicit_predicates_of: has parent, node: {:?}", parent_item.node);
+            if let hir::ItemTrait(..) = parent_item.node {
+                debug!("    explicit_predicates_of: parent is trait!");
+                let trait_ref = ty::TraitRef {
+                    def_id: parent_def_id,
+                    substs: Substs::identity_for_item(tcx, parent_def_id)
+                };
+                predicates.push(trait_ref.to_poly_trait_ref().to_predicate());
+            } else {
+                debug!("    explicit_predicates_of: parent is not trait :((");
+            }
+        } else {
+            debug!("  explicit_predicates_of: no parent :(");
+        }
     }
+    debug!("explicit_predicates_of: predicates={:?}", predicates);
 
     // In default impls, we can assume that the self type implements
     // the trait. So in: