rustc_typeck: hook up collect and item/body check to on-demand.

Author: eddyb

src/librustc/middle/dead.rs

@@ -159,10 +159,9 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
             hir_map::NodeItem(item) => {
                 match item.node {
                     hir::ItemStruct(..) | hir::ItemUnion(..) => {
-                        self.struct_has_extern_repr = item.attrs.iter().any(|attr| {
-                            attr::find_repr_attrs(self.tcx.sess.diagnostic(), attr)
-                                .contains(&attr::ReprExtern)
-                        });
+                        let def_id = self.tcx.hir.local_def_id(item.id);
+                        let def = self.tcx.lookup_adt_def(def_id);
+                        self.struct_has_extern_repr = def.repr.c;
 
                         intravisit::walk_item(self, &item);
                     }

src/librustc/mir/tcx.rs

@@ -173,9 +173,7 @@ impl<'tcx> Rvalue<'tcx> {
             Rvalue::Discriminant(ref lval) => {
                 let ty = lval.ty(mir, tcx).to_ty(tcx);
                 if let ty::TyAdt(adt_def, _) = ty.sty {
-                    let repr_hints = tcx.lookup_repr_hints(adt_def.did);
-                    let repr_type = tcx.enum_repr_type(repr_hints.get(0));
-                    Some(repr_type.to_ty(tcx))
+                    Some(adt_def.repr.discr_type().to_ty(tcx))
                 } else {
                     // Undefined behaviour, bug for now; may want to return something for
                     // the `discriminant` intrinsic later.

src/librustc/traits/fulfill.rs

@@ -11,21 +11,18 @@
 use dep_graph::DepGraph;
 use infer::{InferCtxt, InferOk};
 use ty::{self, Ty, TypeFoldable, ToPolyTraitRef, TyCtxt, ToPredicate};
-use ty::subst::Subst;
 use rustc_data_structures::obligation_forest::{ObligationForest, Error};
 use rustc_data_structures::obligation_forest::{ForestObligation, ObligationProcessor};
 use std::marker::PhantomData;
-use std::mem;
 use syntax::ast;
 use util::nodemap::{FxHashSet, NodeMap};
 use hir::def_id::DefId;
 
 use super::CodeAmbiguity;
 use super::CodeProjectionError;
 use super::CodeSelectionError;
-use super::{FulfillmentError, FulfillmentErrorCode, SelectionError};
-use super::{ObligationCause, BuiltinDerivedObligation};
-use super::{PredicateObligation, TraitObligation, Obligation};
+use super::{FulfillmentError, FulfillmentErrorCode};
+use super::{ObligationCause, PredicateObligation, Obligation};
 use super::project;
 use super::select::SelectionContext;
 use super::Unimplemented;
@@ -82,10 +79,6 @@ pub struct FulfillmentContext<'tcx> {
     // obligations (otherwise, it's easy to fail to walk to a
     // particular node-id).
     region_obligations: NodeMap<Vec<RegionObligation<'tcx>>>,
-
-    // A list of obligations that need to be deferred to
-    // a later time for them to be properly fulfilled.
-    deferred_obligations: Vec<DeferredObligation<'tcx>>,
 }
 
 #[derive(Clone)]
@@ -101,100 +94,12 @@ pub struct PendingPredicateObligation<'tcx> {
     pub stalled_on: Vec<Ty<'tcx>>,
 }
 
-/// An obligation which cannot be fulfilled in the context
-/// it was registered in, such as auto trait obligations on
-/// `impl Trait`, which require the concrete type to be
-/// available, only guaranteed after finishing type-checking.
-#[derive(Clone, Debug)]
-pub struct DeferredObligation<'tcx> {
-    pub predicate: ty::PolyTraitPredicate<'tcx>,
-    pub cause: ObligationCause<'tcx>
-}
-
-impl<'a, 'gcx, 'tcx> DeferredObligation<'tcx> {
-    /// If possible, create a `DeferredObligation` from
-    /// a trait predicate which had failed selection,
-    /// but could succeed later.
-    pub fn from_select_error(tcx: TyCtxt<'a, 'gcx, 'tcx>,
-                             obligation: &TraitObligation<'tcx>,
-                             selection_err: &SelectionError<'tcx>)
-                             -> Option<DeferredObligation<'tcx>> {
-        if let Unimplemented = *selection_err {
-            if DeferredObligation::must_defer(tcx, &obligation.predicate) {
-                return Some(DeferredObligation {
-                    predicate: obligation.predicate.clone(),
-                    cause: obligation.cause.clone()
-                });
-            }
-        }
-
-        None
-    }
-
-    /// Returns true if the given trait predicate can be
-    /// fulfilled at a later time.
-    pub fn must_defer(tcx: TyCtxt<'a, 'gcx, 'tcx>,
-                      predicate: &ty::PolyTraitPredicate<'tcx>)
-                      -> bool {
-        // Auto trait obligations on `impl Trait`.
-        if tcx.trait_has_default_impl(predicate.def_id()) {
-            let substs = predicate.skip_binder().trait_ref.substs;
-            if substs.types().count() == 1 && substs.regions().next().is_none() {
-                if let ty::TyAnon(..) = predicate.skip_binder().self_ty().sty {
-                    return true;
-                }
-            }
-        }
-
-        false
-    }
-
-    /// If possible, return the nested obligations required
-    /// to fulfill this obligation.
-    pub fn try_select(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>)
-                      -> Option<Vec<PredicateObligation<'tcx>>> {
-        if let ty::TyAnon(def_id, substs) = self.predicate.skip_binder().self_ty().sty {
-            let ty = if def_id.is_local() {
-                tcx.maps.ty.borrow().get(&def_id).cloned()
-            } else {
-                Some(tcx.item_type(def_id))
-            };
-            // We can resolve the `impl Trait` to its concrete type.
-            if let Some(concrete_ty) = ty.subst(tcx, substs) {
-                let predicate = ty::TraitRef {
-                    def_id: self.predicate.def_id(),
-                    substs: tcx.mk_substs_trait(concrete_ty, &[])
-                }.to_predicate();
-
-                let original_obligation = Obligation::new(self.cause.clone(),
-                                                          self.predicate.clone());
-                let cause = original_obligation.derived_cause(BuiltinDerivedObligation);
-                return Some(vec![Obligation::new(cause, predicate)]);
-            }
-        }
-
-        None
-    }
-
-    /// Return the `PredicateObligation` this was created from.
-    pub fn to_obligation(&self) -> PredicateObligation<'tcx> {
-        let predicate = ty::Predicate::Trait(self.predicate.clone());
-        Obligation::new(self.cause.clone(), predicate)
-    }
-
-    /// Return an error as if this obligation had failed.
-    pub fn to_error(&self) -> FulfillmentError<'tcx> {
-        FulfillmentError::new(self.to_obligation(), CodeSelectionError(Unimplemented))
-    }
-}
-
 impl<'a, 'gcx, 'tcx> FulfillmentContext<'tcx> {
     /// Creates a new fulfillment context.
     pub fn new() -> FulfillmentContext<'tcx> {
         FulfillmentContext {
             predicates: ObligationForest::new(),
             region_obligations: NodeMap(),
-            deferred_obligations: vec![],
         }
     }
 
@@ -294,16 +199,10 @@ impl<'a, 'gcx, 'tcx> FulfillmentContext<'tcx> {
     {
         self.select_where_possible(infcx)?;
 
-        // Fail all of the deferred obligations that haven't
-        // been otherwise removed from the context.
-        let deferred_errors = self.deferred_obligations.iter()
-                                  .map(|d| d.to_error());
-
         let errors: Vec<_> =
             self.predicates.to_errors(CodeAmbiguity)
                            .into_iter()
                            .map(|e| to_fulfillment_error(e))
-                           .chain(deferred_errors)
                            .collect();
         if errors.is_empty() {
             Ok(())
@@ -324,10 +223,6 @@ impl<'a, 'gcx, 'tcx> FulfillmentContext<'tcx> {
         self.predicates.pending_obligations()
     }
 
-    pub fn take_deferred_obligations(&mut self) -> Vec<DeferredObligation<'tcx>> {
-        mem::replace(&mut self.deferred_obligations, vec![])
-    }
-
     /// Attempts to select obligations using `selcx`. If `only_new_obligations` is true, then it
     /// only attempts to select obligations that haven't been seen before.
     fn select(&mut self, selcx: &mut SelectionContext<'a, 'gcx, 'tcx>)
@@ -343,7 +238,6 @@ impl<'a, 'gcx, 'tcx> FulfillmentContext<'tcx> {
             let outcome = self.predicates.process_obligations(&mut FulfillProcessor {
                 selcx: selcx,
                 region_obligations: &mut self.region_obligations,
-                deferred_obligations: &mut self.deferred_obligations
             });
             debug!("select: outcome={:?}", outcome);
 
@@ -378,7 +272,6 @@ impl<'a, 'gcx, 'tcx> FulfillmentContext<'tcx> {
 struct FulfillProcessor<'a, 'b: 'a, 'gcx: 'tcx, 'tcx: 'b> {
     selcx: &'a mut SelectionContext<'b, 'gcx, 'tcx>,
     region_obligations: &'a mut NodeMap<Vec<RegionObligation<'tcx>>>,
-    deferred_obligations: &'a mut Vec<DeferredObligation<'tcx>>
 }
 
 impl<'a, 'b, 'gcx, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'gcx, 'tcx> {
@@ -391,8 +284,7 @@ impl<'a, 'b, 'gcx, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'gcx,
     {
         process_predicate(self.selcx,
                           obligation,
-                          self.region_obligations,
-                          self.deferred_obligations)
+                          self.region_obligations)
             .map(|os| os.map(|os| os.into_iter().map(|o| PendingPredicateObligation {
                 obligation: o,
                 stalled_on: vec![]
@@ -432,8 +324,7 @@ fn trait_ref_type_vars<'a, 'gcx, 'tcx>(selcx: &mut SelectionContext<'a, 'gcx, 't
 fn process_predicate<'a, 'gcx, 'tcx>(
     selcx: &mut SelectionContext<'a, 'gcx, 'tcx>,
     pending_obligation: &mut PendingPredicateObligation<'tcx>,
-    region_obligations: &mut NodeMap<Vec<RegionObligation<'tcx>>>,
-    deferred_obligations: &mut Vec<DeferredObligation<'tcx>>)
+    region_obligations: &mut NodeMap<Vec<RegionObligation<'tcx>>>)
     -> Result<Option<Vec<PredicateObligation<'tcx>>>,
               FulfillmentErrorCode<'tcx>>
 {
@@ -502,21 +393,7 @@ fn process_predicate<'a, 'gcx, 'tcx>(
                     info!("selecting trait `{:?}` at depth {} yielded Err",
                           data, obligation.recursion_depth);
 
-                    let defer = DeferredObligation::from_select_error(selcx.tcx(),
-                                                                      &trait_obligation,
-                                                                      &selection_err);
-                    if let Some(deferred_obligation) = defer {
-                        if let Some(nested) = deferred_obligation.try_select(selcx.tcx()) {
-                            Ok(Some(nested))
-                        } else {
-                            // Pretend that the obligation succeeded,
-                            // but record it for later.
-                            deferred_obligations.push(deferred_obligation);
-                            Ok(Some(vec![]))
-                        }
-                    } else {
-                        Err(CodeSelectionError(selection_err))
-                    }
+                    Err(CodeSelectionError(selection_err))
                 }
             }
         }
@@ -714,12 +591,6 @@ impl<'a, 'gcx, 'tcx> GlobalFulfilledPredicates<'gcx> {
             // already has the required read edges, so we don't need
             // to add any more edges here.
             if data.is_global() {
-                // Don't cache predicates which were fulfilled
-                // by deferring them for later fulfillment.
-                if DeferredObligation::must_defer(tcx, data) {
-                    return;
-                }
-
                 if let Some(data) = tcx.lift_to_global(data) {
                     if self.set.insert(data.clone()) {
                         debug!("add_if_global: global predicate `{:?}` added", data);

src/librustc/traits/mod.rs

@@ -31,7 +31,6 @@ pub use self::coherence::orphan_check;
 pub use self::coherence::overlapping_impls;
 pub use self::coherence::OrphanCheckErr;
 pub use self::fulfill::{FulfillmentContext, GlobalFulfilledPredicates, RegionObligation};
-pub use self::fulfill::DeferredObligation;
 pub use self::project::MismatchedProjectionTypes;
 pub use self::project::{normalize, normalize_projection_type, Normalized};
 pub use self::project::{ProjectionCache, ProjectionCacheSnapshot, Reveal};

src/librustc/traits/select.rs

@@ -1478,8 +1478,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
                     // `assemble_candidates_from_object_ty`.
                 }
                 ty::TyParam(..) |
-                ty::TyProjection(..) |
-                ty::TyAnon(..) => {
+                ty::TyProjection(..) => {
                     // In these cases, we don't know what the actual
                     // type is.  Therefore, we cannot break it down
                     // into its constituent types. So we don't
@@ -1902,7 +1901,6 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
             ty::TyDynamic(..) |
             ty::TyParam(..) |
             ty::TyProjection(..) |
-            ty::TyAnon(..) |
             ty::TyInfer(ty::TyVar(_)) |
             ty::TyInfer(ty::FreshTy(_)) |
             ty::TyInfer(ty::FreshIntTy(_)) |
@@ -1947,6 +1945,13 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
                     .map(|f| f.ty(self.tcx(), substs))
                     .collect()
             }
+
+            ty::TyAnon(def_id, substs) => {
+                // We can resolve the `impl Trait` to its concrete type,
+                // which enforces a DAG between the functions requiring
+                // the auto trait bounds in question.
+                vec![self.tcx().item_type(def_id).subst(self.tcx(), substs)]
+            }
         }
     }
 

src/librustc/traits/structural_impls.rs

@@ -269,20 +269,6 @@ impl<'a, 'tcx> Lift<'tcx> for traits::ObligationCause<'a> {
     }
 }
 
-impl<'a, 'tcx> Lift<'tcx> for traits::DeferredObligation<'a> {
-    type Lifted = traits::DeferredObligation<'tcx>;
-    fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> {
-        tcx.lift(&self.predicate).and_then(|predicate| {
-            tcx.lift(&self.cause).map(|cause| {
-                traits::DeferredObligation {
-                    predicate: predicate,
-                    cause: cause
-                }
-            })
-        })
-    }
-}
-
 // For trans only.
 impl<'a, 'tcx> Lift<'tcx> for traits::Vtable<'a, ()> {
     type Lifted = traits::Vtable<'tcx, ()>;
@@ -589,16 +575,3 @@ impl<'tcx> TypeFoldable<'tcx> for traits::ObligationCause<'tcx> {
         self.code.visit_with(visitor)
     }
 }
-
-impl<'tcx> TypeFoldable<'tcx> for traits::DeferredObligation<'tcx> {
-    fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self {
-        traits::DeferredObligation {
-            predicate: self.predicate.fold_with(folder),
-            cause: self.cause.fold_with(folder)
-        }
-    }
-
-    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
-        self.predicate.visit_with(visitor) || self.cause.visit_with(visitor)
-    }
-}