Improved the mapping handling. Closes rust-lang#17.

This uses the newly added crate tracking to make errors more
discoverable and code more obvious in it's current behaviour.

Author: ibabushkin

src/semcheck/mapping.rs

@@ -7,7 +7,7 @@ use rustc::hir::def::{Def, Export};
 use rustc::hir::def_id::{CrateNum, DefId};
 use rustc::ty::TypeParameterDef;
 
-use std::collections::{BTreeSet, HashMap, VecDeque};
+use std::collections::{BTreeSet, HashMap, HashSet, VecDeque};
 
 use syntax::ast::Name;
 
@@ -23,6 +23,8 @@ pub struct IdMapping {
     new_crate: CrateNum,
     /// Toplevel items' old `DefId` mapped to old and new `Def`.
     toplevel_mapping: HashMap<DefId, (Def, Def)>,
+    /// The set of toplevel items that have been removed.
+    removed_items: HashSet<DefId>,
     /// Trait items' old `DefId` mapped to old and new `Def`.
     trait_item_mapping: HashMap<DefId, (Def, Def, DefId)>,
     /// Other items' old `DefId` mapped to new `DefId`.
@@ -39,6 +41,7 @@ impl IdMapping {
             old_crate: old_crate,
             new_crate: new_crate,
             toplevel_mapping: HashMap::new(),
+            removed_items: HashSet::new(),
             trait_item_mapping: HashMap::new(),
             internal_mapping: HashMap::new(),
             child_mapping: HashMap::new(),
@@ -48,19 +51,30 @@ impl IdMapping {
 
     /// Register two exports representing the same item across versions.
     pub fn add_export(&mut self, old: Def, new: Def) -> bool {
-        if self.toplevel_mapping.contains_key(&old.def_id()) {
+        let old_def_id = old.def_id();
+
+        if !self.in_old_crate(old_def_id) || self.toplevel_mapping.contains_key(&old_def_id) {
             return false;
         }
 
         self.toplevel_mapping
-            .insert(old.def_id(), (old, new));
+            .insert(old_def_id, (old, new));
 
         true
     }
 
+    /// Register that an old item has no corresponding new item.
+    pub fn add_removal(&mut self, old: DefId) {
+        self.removed_items.insert(old);
+    }
+
     /// Add any trait item's old and new `DefId`s.
     pub fn add_trait_item(&mut self, old: Def, new: Def, trait_def_id: DefId) {
-        self.trait_item_mapping.insert(old.def_id(), (old, new, trait_def_id));
+        let old_def_id = old.def_id();
+
+        assert!(self.in_old_crate(old_def_id));
+
+        self.trait_item_mapping.insert(old_def_id, (old, new, trait_def_id));
     }
 
     /// Add any other item's old and new `DefId`s.
@@ -70,12 +84,14 @@ impl IdMapping {
                 old,
                 self.internal_mapping[&old],
                 new);
+        assert!(self.in_old_crate(old));
 
         self.internal_mapping.insert(old, new);
     }
 
     /// Add any other item's old and new `DefId`s, together with a parent entry.
     pub fn add_subitem(&mut self, parent: DefId, old: DefId, new: DefId) {
+        // NB: we rely on the assers in `add_internal_item` here.
         self.add_internal_item(old, new);
         self.child_mapping
             .entry(parent)
@@ -85,29 +101,49 @@ impl IdMapping {
 
     /// Record that a `DefId` represents a new type parameter.
     pub fn add_type_param(&mut self, new: TypeParameterDef) {
+        assert!(self.in_new_crate(new.def_id));
         self.type_params.insert(new.def_id, new);
     }
 
     /// Get the type parameter represented by a given `DefId`.
-    pub fn get_type_param(&self, def_id: &DefId) -> TypeParameterDef {
-        self.type_params[def_id]
+    pub fn get_type_param(&self, did: &DefId) -> TypeParameterDef {
+        self.type_params[did]
     }
 
     /// Check whether a `DefId` represents a newly added defaulted type parameter.
     pub fn is_defaulted_type_param(&self, new: &DefId) -> bool {
+        // TODO?
         self.type_params
             .get(new)
             .map_or(false, |def| def.has_default)
     }
 
     /// Get the new `DefId` associated with the given old one.
     pub fn get_new_id(&self, old: DefId) -> DefId {
-        if let Some(new) = self.toplevel_mapping.get(&old) {
-            new.1.def_id()
-        } else if let Some(new) = self.trait_item_mapping.get(&old) {
-            new.1.def_id()
+        assert!(!self.in_new_crate(old));
+
+        if self.in_old_crate(old) && !self.removed_items.contains(&old) {
+            if let Some(new) = self.toplevel_mapping.get(&old) {
+                new.1.def_id()
+            } else if let Some(new) = self.trait_item_mapping.get(&old) {
+                new.1.def_id()
+            } else {
+                self.internal_mapping[&old]
+            }
+        } else {
+            old
+        }
+    }
+
+    /// Get the new `DefId` associated with the given old one, respecting possibly removed
+    /// traits that are a parent of the given `DefId`.
+    pub fn get_new_trait_item_id(&self, old: DefId, trait_id: DefId) -> DefId {
+        assert!(!self.in_new_crate(trait_id));
+
+        if !self.removed_items.contains(&trait_id) {
+            self.get_new_id(old)
         } else {
-            self.internal_mapping[&old]
+            old
         }
     }
 
@@ -148,10 +184,12 @@ impl IdMapping {
             .map(|m| m.iter().map(move |old| (*old, self.internal_mapping[old])))
     }
 
+    /// Check whether a `DefId` belongs to an item in the old crate.
     pub fn in_old_crate(&self, did: DefId) -> bool {
         self.old_crate == did.krate
     }
 
+    /// Check whether a `DefId` belongs to an item in the new crate.
     pub fn in_new_crate(&self, did: DefId) -> bool {
         self.new_crate == did.krate
     }

src/semcheck/mismatch.rs

@@ -111,14 +111,12 @@ impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for Mismatch<'a, 'gcx, 'tcx> {
                             .collect();
 
                     for field in a_adt.all_fields().filter(|f| f.vis == Public) {
-                        if self.id_mapping.contains_id(field.did) {
-                            let a_field_ty = field.ty(self.tcx, a_substs);
-                            let b_field_ty =
-                                b_fields[&self.id_mapping.get_new_id(field.did)]
-                                    .ty(self.tcx, b_substs);
-
-                            let _ = self.relate(&a_field_ty, &b_field_ty)?;
-                        }
+                        let a_field_ty = field.ty(self.tcx, a_substs);
+                        let b_field_ty =
+                            b_fields[&self.id_mapping.get_new_id(field.did)]
+                                .ty(self.tcx, b_substs);
+
+                        let _ = self.relate(&a_field_ty, &b_field_ty)?;
                     }
 
                     Some((a_def.did, b_def.did))
@@ -188,7 +186,8 @@ impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for Mismatch<'a, 'gcx, 'tcx> {
         };
 
         if let Some((old_def_id, new_def_id)) = matching {
-            if !self.id_mapping.contains_id(old_def_id) && self.id_mapping.in_old_crate(old_def_id) {
+            if !self.id_mapping.contains_id(old_def_id) &&
+                    self.id_mapping.in_old_crate(old_def_id) {
                 self.id_mapping.add_internal_item(old_def_id, new_def_id);
                 self.item_queue.push_back((old_def_id, new_def_id));
             }

src/semcheck/traverse.rs

@@ -261,6 +261,7 @@ fn diff_structure<'a, 'tcx>(changes: &mut ChangeSet,
             changes.new_path_change(n_def_id, o.ident.name, tcx.def_span(n_def_id));
             changes.add_path_removal(n_def_id, o.span);
         } else {
+            id_mapping.add_removal(o_def_id);
             changes.new_path_change(o_def_id, o.ident.name, tcx.def_span(o_def_id));
             changes.add_path_removal(o_def_id, o.span);
         }
@@ -732,7 +733,7 @@ fn fold_to_new<'a, 'tcx, T>(id_mapping: &IdMapping,
 
     old.fold_with(&mut BottomUpFolder { tcx: tcx, fldop: |ty| {
         match ty.sty {
-            TyAdt(&AdtDef { ref did, .. }, substs) if id_mapping.contains_id(*did) => {
+            TyAdt(&AdtDef { ref did, .. }, substs) if id_mapping.in_old_crate(*did) => {
                 let new_def_id = id_mapping.get_new_id(*did);
                 let new_adt = tcx.adt_def(new_def_id);
                 tcx.mk_adt(new_adt, substs)
@@ -747,23 +748,15 @@ fn fold_to_new<'a, 'tcx, T>(id_mapping: &IdMapping,
                 let new_preds = tcx.mk_existential_predicates(preds.iter().map(|p| {
                     match *p.skip_binder() {
                         Trait(ExistentialTraitRef { def_id: did, substs }) => {
-                            let new_def_id = if id_mapping.contains_id(did) {
-                                id_mapping.get_new_id(did)
-                            } else {
-                                did
-                            };
+                            let new_def_id = id_mapping.get_new_id(did);
 
                             Trait(ExistentialTraitRef {
                                 def_id: new_def_id,
                                 substs: substs
                             })
                         },
                         Projection(ExistentialProjection { item_def_id, substs, ty }) => {
-                            let new_def_id = if id_mapping.contains_id(item_def_id) {
-                                id_mapping.get_new_id(item_def_id)
-                            } else {
-                                item_def_id
-                            };
+                            let new_def_id = id_mapping.get_new_id(item_def_id);
 
                             Projection(ExistentialProjection {
                                 item_def_id: new_def_id,
@@ -772,23 +765,17 @@ fn fold_to_new<'a, 'tcx, T>(id_mapping: &IdMapping,
                             })
                         },
                         AutoTrait(did) => {
-                            if id_mapping.contains_id(did) {
-                                AutoTrait(id_mapping.get_new_id(did))
-                            } else {
-                                AutoTrait(did)
-                            }
+                            AutoTrait(id_mapping.get_new_id(did))
                         },
                     }
                 }));
 
                 tcx.mk_dynamic(Binder(new_preds), region)
             },
             TyProjection(proj) => {
-                let new_def_id = if id_mapping.contains_id(proj.item_def_id) {
-                    id_mapping.get_new_id(proj.item_def_id)
-                } else {
-                    proj.item_def_id
-                };
+                let trait_def_id = tcx.associated_item(proj.item_def_id).container.id();
+                let new_def_id =
+                    id_mapping.get_new_trait_item_id(proj.item_def_id, trait_def_id);
 
                 tcx.mk_projection(new_def_id, proj.substs)
             },
@@ -798,7 +785,7 @@ fn fold_to_new<'a, 'tcx, T>(id_mapping: &IdMapping,
             TyParam(param) => {
                 if param.idx != 0 { // `Self` is special
                     let old_did = index_map[&param.idx];
-                    if id_mapping.contains_id(old_did) {
+                    if id_mapping.in_old_crate(old_did) {
                         let new_def_id = id_mapping.get_new_id(old_did);
                         tcx.mk_param_from_def(&id_mapping.get_type_param(&new_def_id))
                     } else {