rustc_metadata: use 0 in index::Index to indicate missing entries.

Author: eddyb

src/librustc_metadata/index.rs

@@ -4,7 +4,6 @@ use rustc::hir::def_id::{DefId, DefIndex, DefIndexAddressSpace};
 use rustc_serialize::opaque::Encoder;
 use std::marker::PhantomData;
 use std::num::NonZeroUsize;
-use std::u32;
 use log::debug;
 
 /// Helper trait, for encoding to, and decoding from, a fixed number of bytes.
@@ -73,7 +72,7 @@ impl FixedSizeEncoding for u32 {
 /// of each DefIndex. It is not required that all definitions appear
 /// in the metadata, nor that they are serialized in order, and
 /// therefore we first allocate the vector here and fill it with
-/// `u32::MAX`. Whenever an index is visited, we fill in the
+/// `0`. Whenever an index is visited, we fill in the
 /// appropriate spot by calling `record_position`. We should never
 /// visit the same index twice.
 pub struct Index<'tcx> {
@@ -84,8 +83,8 @@ pub struct Index<'tcx> {
 impl Index<'tcx> {
     pub fn new((max_index_lo, max_index_hi): (usize, usize)) -> Self {
         Index {
-            positions: [vec![0xff; max_index_lo * 4],
-                        vec![0xff; max_index_hi * 4]],
+            positions: [vec![0; max_index_lo * 4],
+                        vec![0; max_index_hi * 4]],
             _marker: PhantomData,
         }
     }
@@ -96,13 +95,13 @@ impl Index<'tcx> {
     }
 
     pub fn record_index(&mut self, item: DefIndex, entry: Lazy<Entry<'tcx>>) {
-        assert!(entry.position.get() < (u32::MAX as usize));
         let position = entry.position.get() as u32;
+        assert_eq!(position as usize, entry.position.get());
         let space_index = item.address_space().index();
         let array_index = item.as_array_index();
 
         let positions = &mut self.positions[space_index];
-        assert!(u32::read_from_bytes_at(positions, array_index) == u32::MAX,
+        assert!(u32::read_from_bytes_at(positions, array_index) == 0,
                 "recorded position for item {:?} twice, first at {:?} and now at {:?}",
                 item,
                 u32::read_from_bytes_at(positions, array_index),
@@ -147,12 +146,7 @@ impl Lazy<[Index<'tcx>]> {
         };
 
         let position = u32::read_from_bytes_at(bytes, 1 + i);
-        if position == u32::MAX {
-            debug!("Index::lookup: position=u32::MAX");
-            None
-        } else {
-            debug!("Index::lookup: position={:?}", position);
-            Some(Lazy::from_position(NonZeroUsize::new(position as usize).unwrap()))
-        }
+        debug!("Index::lookup: position={:?}", position);
+        NonZeroUsize::new(position as usize).map(Lazy::from_position)
     }
 }