This works, except that coherence problems go in the wrong order

It compile-tests, and causes ICE when the "first" impl comes
from a local crate. Will give perf numbers tomorrow.

Author: arielb1

src/librustc/metadata/encoder.rs

@@ -977,7 +977,7 @@ fn encode_extension_implementations(ecx: &EncodeContext,
     // TODO: how do we ensure only locals?
     let def = ty::lookup_trait_def(ecx.tcx, trait_def_id);
 
-    def.for_each_impl(|impl_def_id| {
+    def.for_each_impl(ecx.tcx, |impl_def_id| {
         rbml_w.start_tag(tag_items_data_item_extension_impl);
         encode_def_id(rbml_w, impl_def_id);
         rbml_w.end_tag();

src/librustc/middle/ty.rs

@@ -761,6 +761,9 @@ pub struct ctxt<'tcx> {
     /// The set of external nominal types whose implementations have been read.
     /// This is used for lazy resolution of methods.
     pub populated_external_types: RefCell<DefIdSet>,
+    /// The set of external primitive types whose implementations have been read.
+    /// FIXME(arielb1): why is this separate from populated_external_types?
+    pub populated_external_primitive_impls: RefCell<DefIdSet>,
 
     /// Borrows
     pub upvar_capture_map: RefCell<UpvarCaptureMap>,
@@ -949,6 +952,7 @@ impl fmt::Debug for TypeFlags {
 }
 
 impl<'tcx> PartialEq for TyS<'tcx> {
+    #[inline]
     fn eq(&self, other: &TyS<'tcx>) -> bool {
         // (self as *const _) == (other as *const _)
         (self as *const TyS<'tcx>) == (other as *const TyS<'tcx>)
@@ -2490,7 +2494,6 @@ bitflags! {
         const IS_OBJECT_SAFE        = 0b10,
         const OBJECT_SAFETY_VALID   = 0b100,
         const IMPLS_VALID           = 0b1000,
-        const PRIMITIVE_IMPLS_VALID = 0b10000
     }
 }
 
@@ -2548,7 +2551,9 @@ impl<'tcx> TraitDef<'tcx> {
         );
     }
 
-    pub fn for_each_impl<F: FnMut(DefId)>(&self, mut f: F)  {
+    pub fn for_each_impl<F: FnMut(DefId)>(&self, tcx: &ctxt<'tcx>, mut f: F)  {
+        ty::populate_implementations_for_trait_if_necessary(tcx, self.trait_ref.def_id);
+
         for &impl_def_id in self.blanket_impls.borrow().iter() {
             f(impl_def_id);
         }
@@ -2565,6 +2570,8 @@ impl<'tcx> TraitDef<'tcx> {
                                                    trait_ref: TraitRef<'tcx>,
                                                    mut f: F)
     {
+        ty::populate_implementations_for_trait_if_necessary(tcx, self.trait_ref.def_id);
+
         for &impl_def_id in self.blanket_impls.borrow().iter() {
             f(impl_def_id);
         }
@@ -2751,6 +2758,7 @@ pub fn mk_ctxt<'tcx>(s: Session,
         used_unsafe: RefCell::new(NodeSet()),
         used_mut_nodes: RefCell::new(NodeSet()),
         populated_external_types: RefCell::new(DefIdSet()),
+        populated_external_primitive_impls: RefCell::new(DefIdSet()),
         upvar_capture_map: RefCell::new(FnvHashMap()),
         extern_const_statics: RefCell::new(DefIdMap()),
         extern_const_variants: RefCell::new(DefIdMap()),
@@ -6314,24 +6322,24 @@ pub fn record_trait_implementation<'tcx>(tcx: &ctxt<'tcx>,
 }
 
 /// Load primitive inherent implementations if necessary
-pub fn populate_implementations_for_primitive_if_necessary(tcx: &ctxt, lang_def_id: ast::DefId) {
-    if lang_def_id.krate == LOCAL_CRATE {
+pub fn populate_implementations_for_primitive_if_necessary(tcx: &ctxt,
+                                                           primitive_def_id: ast::DefId) {
+    if primitive_def_id.krate == LOCAL_CRATE {
         return
     }
 
-    let def = lookup_trait_def(tcx, lang_def_id);
-    if def.flags.get().intersects(PRIMITIVE_IMPLS_VALID) {
+    if tcx.populated_external_primitive_impls.borrow().contains(&primitive_def_id) {
         return
     }
 
-    debug!("populate_implementations_for_primitive_if_necessary: searching for {:?}", lang_def_id);
+    debug!("populate_implementations_for_primitive_if_necessary: searching for {:?}",
+           primitive_def_id);
 
-    let impl_items = csearch::get_impl_items(&tcx.sess.cstore, lang_def_id);
+    let impl_items = csearch::get_impl_items(&tcx.sess.cstore, primitive_def_id);
 
     // Store the implementation info.
-    tcx.impl_items.borrow_mut().insert(lang_def_id, impl_items);
-
-    def.flags.set(def.flags.get() | PRIMITIVE_IMPLS_VALID);
+    tcx.impl_items.borrow_mut().insert(primitive_def_id, impl_items);
+    tcx.populated_external_primitive_impls.borrow_mut().insert(primitive_def_id);
 }
 
 /// Populates the type context with all the implementations for the given type

src/librustc_lint/builtin.rs

@@ -1747,7 +1747,7 @@ impl LintPass for MissingDebugImplementations {
         if self.impling_types.is_none() {
             let debug_def = ty::lookup_trait_def(cx.tcx, debug);
             let mut impls = NodeSet();
-            debug_def.for_each_impl(|d| {
+            debug_def.for_each_impl(cx.tcx, |d| {
                 if d.krate == ast::LOCAL_CRATE {
                     if let Some(ty_def) = ty::ty_to_def_id(ty::node_id_to_type(cx.tcx, d.node)) {
                         impls.insert(ty_def.node);

src/librustc_typeck/check/method/probe.rs

@@ -624,13 +624,10 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
                                                      item: ty::ImplOrTraitItem<'tcx>,
                                                      item_index: usize)
     {
-        ty::populate_implementations_for_trait_if_necessary(self.tcx(),
-                                                            trait_def_id);
-
         let trait_def = ty::lookup_trait_def(self.tcx(), trait_def_id);
 
         // FIXME(arielb1): can we use for_each_relevant_impl here?
-        trait_def.for_each_impl(|impl_def_id| {
+        trait_def.for_each_impl(self.tcx(), |impl_def_id| {
             debug!("assemble_extension_candidates_for_trait_impl: trait_def_id={} impl_def_id={}",
                    trait_def_id.repr(self.tcx()),
                    impl_def_id.repr(self.tcx()));

src/librustc_typeck/coherence/mod.rs

@@ -385,11 +385,12 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
         let drop_trait = match tcx.lang_items.drop_trait() {
             Some(id) => id, None => { return }
         };
+        ty::populate_implementations_for_trait_if_necessary(tcx, drop_trait);
         let drop_trait = ty::lookup_trait_def(tcx, drop_trait);
 
         let impl_items = tcx.impl_items.borrow();
 
-        drop_trait.for_each_impl(|impl_did| {
+        drop_trait.for_each_impl(tcx, |impl_did| {
             let items = impl_items.get(&impl_did).unwrap();
             if items.is_empty() {
                 // We'll error out later. For now, just don't ICE.
@@ -443,7 +444,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
         ty::populate_implementations_for_trait_if_necessary(tcx, copy_trait);
         let copy_trait = ty::lookup_trait_def(tcx, copy_trait);
 
-        copy_trait.for_each_impl(|impl_did| {
+        copy_trait.for_each_impl(tcx, |impl_did| {
             debug!("check_implementations_of_copy: impl_did={}",
                    impl_did.repr(tcx));
 

src/test/compile-fail/associated-types-coherence-failure.rs

@@ -23,13 +23,13 @@ pub trait IntoCow<'a, B: ?Sized> {
 }
 
 impl<'a, B: ?Sized> IntoCow<'a, B> for Cow<'a, B> where B: ToOwned {
-//~^ ERROR E0119
     fn into_cow(self) -> Cow<'a, B> {
         self
     }
 }
 
 impl<'a, B: ?Sized> IntoCow<'a, B> for <B as ToOwned>::Owned where B: ToOwned {
+//~^ ERROR E0119
 //~^ ERROR E0119
     fn into_cow(self) -> Cow<'a, B> {
         Cow