---

yaml
---
r: 111387
b: refs/heads/master
c: 3b9ade0
h: refs/heads/master
i:
  111385: 280db65
  111383: 5a7e710
v: v3

Author: Ryman

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 3f8e68686f826ed333321a6650481162c95911f6
+refs/heads/master: 3b9ade0f81d519733940ec28b796c11fdb0fd17b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b5dd3f05fe95168b5569d0f519636149479eb6ac
 refs/heads/try: 38201d7c6bf0c32b0e5bdc8ecd63976ebc1b3a4c

trunk/src/libcollections/bitv.rs

@@ -97,12 +97,12 @@ impl SmallBitv {
     pub fn set_all(&mut self) { self.bits = !0; }
 
     #[inline]
-    pub fn all(&self, nbits: uint) -> bool {
+    pub fn is_true(&self, nbits: uint) -> bool {
         small_mask(nbits) & !self.bits == 0
     }
 
     #[inline]
-    pub fn none(&self, nbits: uint) -> bool {
+    pub fn is_false(&self, nbits: uint) -> bool {
         small_mask(nbits) & self.bits == 0
     }
 
@@ -412,10 +412,13 @@ impl Bitv {
 
     /// Returns `true` if all bits are 1
     #[inline]
-    pub fn all(&self) -> bool {
+    pub fn is_true(&self) -> bool {
       match self.rep {
-        Small(ref b) => b.all(self.nbits),
-        _ => self.iter().all(|x| x)
+        Small(ref b) => b.is_true(self.nbits),
+        _ => {
+          for i in self.iter() { if !i { return false; } }
+          true
+        }
       }
     }
 
@@ -430,19 +433,16 @@ impl Bitv {
     }
 
     /// Returns `true` if all bits are 0
-    pub fn none(&self) -> bool {
+    pub fn is_false(&self) -> bool {
       match self.rep {
-        Small(ref b) => b.none(self.nbits),
-        _ => self.iter().all(|x| !x)
+        Small(ref b) => b.is_false(self.nbits),
+        Big(_) => {
+          for i in self.iter() { if i { return false; } }
+          true
+        }
       }
     }
 
-    #[inline]
-    /// Returns `true` if any bit is 1
-    pub fn any(&self) -> bool {
-        !self.none()
-    }
-
     pub fn init_to_vec(&self, i: uint) -> uint {
       return if self.get(i) { 1 } else { 0 };
     }
@@ -1551,51 +1551,6 @@ mod tests {
         assert!(b.contains(&1000));
     }
 
-    #[test]
-    fn test_small_bitv_tests() {
-        let v = from_bytes([0]);
-        assert!(!v.all());
-        assert!(!v.any());
-        assert!(v.none());
-
-        let v = from_bytes([0b00010100]);
-        assert!(!v.all());
-        assert!(v.any());
-        assert!(!v.none());
-
-        let v = from_bytes([0xFF]);
-        assert!(v.all());
-        assert!(v.any());
-        assert!(!v.none());
-    }
-
-    #[test]
-    fn test_big_bitv_tests() {
-        let v = from_bytes([ // 88 bits
-            0, 0, 0, 0,
-            0, 0, 0, 0,
-            0, 0, 0]);
-        assert!(!v.all());
-        assert!(!v.any());
-        assert!(v.none());
-
-        let v = from_bytes([ // 88 bits
-            0, 0, 0b00010100, 0,
-            0, 0, 0, 0b00110100,
-            0, 0, 0]);
-        assert!(!v.all());
-        assert!(v.any());
-        assert!(!v.none());
-
-        let v = from_bytes([ // 88 bits
-            0xFF, 0xFF, 0xFF, 0xFF,
-            0xFF, 0xFF, 0xFF, 0xFF,
-            0xFF, 0xFF, 0xFF]);
-        assert!(v.all());
-        assert!(v.any());
-        assert!(!v.none());
-    }
-
     fn rng() -> rand::IsaacRng {
         let seed = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
         rand::SeedableRng::from_seed(seed)

trunk/src/librustc/metadata/creader.rs

@@ -300,6 +300,10 @@ fn resolve_crate<'a>(e: &mut Env,
                 dylib, rlib, metadata
             } = load_ctxt.load_library_crate(root);
 
+            // Claim this crate number and cache it
+            let cnum = e.next_crate_num;
+            e.next_crate_num += 1;
+
             // Stash paths for top-most crate locally if necessary.
             let crate_paths = if root.is_none() {
                 Some(CratePaths {
@@ -320,17 +324,6 @@ fn resolve_crate<'a>(e: &mut Env,
                 @RefCell::new(HashMap::new())
             };
 
-            // Claim this crate number and cache it if we're linking to the
-            // crate, otherwise it's a syntax-only crate and we don't need to
-            // reserve a number
-            let cnum = if should_link {
-                let n = e.next_crate_num;
-                e.next_crate_num += 1;
-                n
-            } else {
-                -1
-            };
-
             let cmeta = @cstore::crate_metadata {
                 name: load_ctxt.crate_id.name.to_owned(),
                 data: metadata,

trunk/src/librustc/middle/trans/monomorphize.rs

@@ -272,7 +272,6 @@ pub fn monomorphic_fn(ccx: &CrateContext,
         }
 
         // Ugh -- but this ensures any new variants won't be forgotten
-        ast_map::NodeLifetime(..) |
         ast_map::NodeExpr(..) |
         ast_map::NodeStmt(..) |
         ast_map::NodeArg(..) |

trunk/src/librustc/middle/typeck/variance.rs

@@ -198,7 +198,6 @@ use arena::Arena;
 use middle::ty;
 use std::fmt;
 use syntax::ast;
-use syntax::ast_map;
 use syntax::ast_util;
 use syntax::owned_slice::OwnedSlice;
 use syntax::visit;
@@ -518,13 +517,6 @@ impl<'a> Visitor<()> for ConstraintContext<'a> {
     }
 }
 
-/// Is `param_id` a lifetime according to `map`?
-fn is_lifetime(map: &ast_map::Map, param_id: ast::NodeId) -> bool {
-    match map.find(param_id) {
-        Some(ast_map::NodeLifetime(..)) => true, _ => false
-    }
-}
-
 impl<'a> ConstraintContext<'a> {
     fn tcx(&self) -> &'a ty::ctxt {
         self.terms_cx.tcx
@@ -541,70 +533,6 @@ impl<'a> ConstraintContext<'a> {
         }
     }
 
-    fn find_binding_for_lifetime(&self, param_id: ast::NodeId) -> ast::NodeId {
-        let tcx = self.terms_cx.tcx;
-        assert!(is_lifetime(&tcx.map, param_id));
-        match tcx.named_region_map.find(&param_id) {
-            Some(&ast::DefEarlyBoundRegion(_, lifetime_decl_id))
-                => lifetime_decl_id,
-            Some(_) => fail!("should not encounter non early-bound cases"),
-
-            // The lookup should only fail when `param_id` is
-            // itself a lifetime binding: use it as the decl_id.
-            None    => param_id,
-        }
-
-    }
-
-    /// Is `param_id` a type parameter for which we infer variance?
-    fn is_to_be_inferred(&self, param_id: ast::NodeId) -> bool {
-        let result = self.terms_cx.inferred_map.contains_key(&param_id);
-
-        // To safe-guard against invalid inferred_map constructions,
-        // double-check if variance is inferred at some use of a type
-        // parameter (by inspecting parent of its binding declaration
-        // to see if it is introduced by a type or by a fn/impl).
-
-        let check_result = |this:&ConstraintContext| -> bool {
-            let tcx = this.terms_cx.tcx;
-            let decl_id = this.find_binding_for_lifetime(param_id);
-            // Currently only called on lifetimes; double-checking that.
-            assert!(is_lifetime(&tcx.map, param_id));
-            let parent_id = tcx.map.get_parent(decl_id);
-            let parent = tcx.map.find(parent_id).unwrap_or_else(
-                || fail!("tcx.map missing entry for id: {}", parent_id));
-
-            let is_inferred;
-            macro_rules! cannot_happen { () => { {
-                fail!("invalid parent: {:s} for {:s}",
-                      tcx.map.node_to_str(parent_id),
-                      tcx.map.node_to_str(param_id));
-            } } }
-
-            match parent {
-                ast_map::NodeItem(p) => {
-                    match p.node {
-                        ast::ItemTy(..) |
-                        ast::ItemEnum(..) |
-                        ast::ItemStruct(..) |
-                        ast::ItemTrait(..)   => is_inferred = true,
-                        ast::ItemFn(..)      => is_inferred = false,
-                        _                    => cannot_happen!(),
-                    }
-                }
-                ast_map::NodeTraitMethod(..) => is_inferred = false,
-                ast_map::NodeMethod(_)       => is_inferred = false,
-                _                            => cannot_happen!(),
-            }
-
-            return is_inferred;
-        };
-
-        assert_eq!(result, check_result(self));
-
-        return result;
-    }
-
     fn declared_variance(&self,
                          param_def_id: ast::DefId,
                          item_def_id: ast::DefId,
@@ -860,10 +788,8 @@ impl<'a> ConstraintContext<'a> {
                                    variance: VarianceTermPtr<'a>) {
         match region {
             ty::ReEarlyBound(param_id, _, _) => {
-                if self.is_to_be_inferred(param_id) {
-                    let index = self.inferred_index(param_id);
-                    self.add_constraint(index, variance);
-                }
+                let index = self.inferred_index(param_id);
+                self.add_constraint(index, variance);
             }
 
             ty::ReStatic => { }

trunk/src/libstd/intrinsics.rs

@@ -394,7 +394,9 @@ extern "rust-intrinsic" {
 
     pub fn roundf32(x: f32) -> f32;
     pub fn roundf64(x: f64) -> f64;
-
+}
+#[cfg(not(stage0))]
+extern "rust-intrinsic" {
     pub fn ctpop8(x: u8) -> u8;
     pub fn ctpop16(x: u16) -> u16;
     pub fn ctpop32(x: u32) -> u32;
@@ -413,7 +415,29 @@ extern "rust-intrinsic" {
     pub fn bswap16(x: u16) -> u16;
     pub fn bswap32(x: u32) -> u32;
     pub fn bswap64(x: u64) -> u64;
+}
 
+// NOTE: remove this after a snap, and merge the extern block above
+macro_rules! stage0_hack {
+    ($( $u_ty:ty, $i_ty:ty => $($name:ident),*);*) => {
+        $(
+            $(
+                #[cfg(stage0)]
+                pub unsafe fn $name(x: $u_ty) -> $u_ty {
+                    extern "rust-intrinsic" { fn $name(x: $i_ty) -> $i_ty; }
+                    $name(x as $i_ty) as $u_ty
+                }
+            )*)*
+    }
+}
+stage0_hack! {
+    u8, i8 => ctpop8, ctlz8, cttz8;
+    u16, i16 => ctpop16, ctlz16, cttz16, bswap16;
+    u32, i32 => ctpop32, ctlz32, cttz32, bswap32;
+    u64, i64 => ctpop64, ctlz64, cttz64, bswap64
+}
+
+extern "rust-intrinsic" {
     pub fn i8_add_with_overflow(x: i8, y: i8) -> (i8, bool);
     pub fn i16_add_with_overflow(x: i16, y: i16) -> (i16, bool);
     pub fn i32_add_with_overflow(x: i32, y: i32) -> (i32, bool);

trunk/src/libsyntax/ast_map.rs

@@ -107,8 +107,6 @@ pub enum Node {
 
     /// NodeStructCtor represents a tuple struct.
     NodeStructCtor(@StructDef),
-
-    NodeLifetime(@Lifetime),
 }
 
 // The odd layout is to bring down the total size.
@@ -129,7 +127,6 @@ enum MapEntry {
     EntryLocal(NodeId, @Pat),
     EntryBlock(NodeId, P<Block>),
     EntryStructCtor(NodeId, @StructDef),
-    EntryLifetime(NodeId, @Lifetime),
 
     // Roots for node trees.
     RootCrate,
@@ -156,7 +153,6 @@ impl MapEntry {
             EntryLocal(id, _) => id,
             EntryBlock(id, _) => id,
             EntryStructCtor(id, _) => id,
-            EntryLifetime(id, _) => id,
             _ => return None
         })
     }
@@ -174,7 +170,6 @@ impl MapEntry {
             EntryLocal(_, p) => NodeLocal(p),
             EntryBlock(_, p) => NodeBlock(p),
             EntryStructCtor(_, p) => NodeStructCtor(p),
-            EntryLifetime(_, p) => NodeLifetime(p),
             _ => return None
         })
     }
@@ -218,8 +213,6 @@ impl Map {
         self.find_entry(id).and_then(|x| x.to_node())
     }
 
-    /// Retrieve the parent NodeId for `id`, or `id` itself if no
-    /// parent is registered in this map.
     pub fn get_parent(&self, id: NodeId) -> NodeId {
         self.find_entry(id).and_then(|x| x.parent()).unwrap_or(id)
     }
@@ -507,15 +500,6 @@ impl<'a, F: FoldOps> Folder for Ctx<'a, F> {
         SmallVector::one(stmt)
     }
 
-    fn fold_type_method(&mut self, m: &TypeMethod) -> TypeMethod {
-        let parent = self.parent;
-        self.parent = DUMMY_NODE_ID;
-        let m = fold::noop_fold_type_method(m, self);
-        assert_eq!(self.parent, m.id);
-        self.parent = parent;
-        m
-    }
-
     fn fold_method(&mut self, m: @Method) -> @Method {
         let parent = self.parent;
         self.parent = DUMMY_NODE_ID;
@@ -538,12 +522,6 @@ impl<'a, F: FoldOps> Folder for Ctx<'a, F> {
         self.insert(block.id, EntryBlock(self.parent, block));
         block
     }
-
-    fn fold_lifetime(&mut self, lifetime: &Lifetime) -> Lifetime {
-        let lifetime = fold::noop_fold_lifetime(lifetime, self);
-        self.insert(lifetime.id, EntryLifetime(self.parent, @lifetime));
-        lifetime
-    }
 }
 
 pub fn map_crate<F: FoldOps>(krate: Crate, fold_ops: F) -> (Crate, Map) {
@@ -680,9 +658,6 @@ fn node_id_to_str(map: &Map, id: NodeId) -> ~str {
         Some(NodeStructCtor(_)) => {
             format!("struct_ctor {} (id={})", map.path_to_str(id), id)
         }
-        Some(NodeLifetime(ref l)) => {
-            format!("lifetime {} (id={})", pprust::lifetime_to_str(*l), id)
-        }
         None => {
             format!("unknown node (id={})", id)
         }