---

yaml
---
r: 97824
b: refs/heads/snap-stage3
c: 68517a2
h: refs/heads/master
v: v3

Author: huonw

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 6d55211700545d253dec4ebbe386832e00d2a247
+refs/heads/snap-stage3: 68517a2cca613d2018819d0eb38f6c0a864d1836
 refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/tutorial.md

@@ -1020,15 +1020,10 @@ being destroyed along with the owner. Since the `list` variable above is
 immutable, the whole list is immutable. The memory allocation itself is the
 box, while the owner holds onto a pointer to it:
 
-              List box             List box           List box            List box
-            +--------------+    +--------------+    +--------------+    +--------------+
-    list -> | Cons | 1 | ~ | -> | Cons | 2 | ~ | -> | Cons | 3 | ~ | -> | Nil          |
-            +--------------+    +--------------+    +--------------+    +--------------+
-
-> Note: the above diagram shows the logical contents of the enum. The actual
-> memory layout of the enum may vary. For example, for the `List` enum shown
-> above, Rust guarantees that there will be no enum tag field in the actual
-> structure. See the language reference for more details.
+      Cons cell        Cons cell        Cons cell
+    +-----------+    +-----+-----+    +-----+-----+
+    |  1  |  ~  | -> |  2  |  ~  | -> |  3  |  ~  | -> Nil
+    +-----------+    +-----+-----+    +-----+-----+
 
 An owned box is a common example of a type with a destructor. The allocated
 memory is cleaned up when the box is destroyed.

branches/snap-stage3/src/etc/vim/syntax/rust.vim

@@ -3,7 +3,7 @@
 " Maintainer:   Patrick Walton <[email protected]>
 " Maintainer:   Ben Blum <[email protected]>
 " Maintainer:   Chris Morgan <[email protected]>
-" Last Change:  2014 Jan 4
+" Last Change:  2013 Dec 10
 
 if version < 600
   syntax clear
@@ -147,8 +147,8 @@ syn match     rustMacro       '#\w\(\w\)*' contains=rustAssert,rustFail
 syn match     rustSpecialError display contained /\\./
 syn match     rustSpecial     display contained /\\\([nrt0\\'"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)/
 syn match     rustStringContinuation display contained /\\\n\s*/
-syn region    rustString      start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=rustSpecial,rustSpecialError,rustStringContinuation,@Spell
-syn region    rustString      start='r\z(#*\)"' end='"\z1' contains=@Spell
+syn region    rustString      start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=rustSpecial,rustSpecialError,rustStringContinuation
+syn region    rustString      start='r\z(#*\)"' end='"\z1'
 
 syn region    rustAttribute   start="#\[" end="\]" contains=rustString,rustDeriving
 syn region    rustDeriving    start="deriving(" end=")" contained contains=rustTrait
@@ -179,10 +179,10 @@ syn match     rustLifetime    display "\'\%([^[:cntrl:][:space:][:punct:][:digit
 syn match   rustCharacter   /'\([^'\\]\|\\\(.\|x\x\{2}\|u\x\{4}\|U\x\{8}\)\)'/ contains=rustSpecial,rustSpecialError
 
 syn cluster rustComment contains=rustCommentLine,rustCommentLineDoc,rustCommentBlock,rustCommentBlockDoc
-syn region rustCommentLine                                    start="//"                      end="$"   contains=rustTodo,@Spell
-syn region rustCommentLineDoc                                 start="//\%(//\@!\|!\)"         end="$"   contains=rustTodo,@Spell
-syn region rustCommentBlock    matchgroup=rustCommentBlock    start="/\*\%(!\|\*[*/]\@!\)\@!" end="\*/" contains=rustTodo,@rustComment,@Spell keepend extend
-syn region rustCommentBlockDoc matchgroup=rustCommentBlockDoc start="/\*\%(!\|\*[*/]\@!\)"    end="\*/" contains=rustTodo,@rustComment,@Spell keepend extend
+syn region rustCommentLine                                    start="//"                      end="$"   contains=rustTodo
+syn region rustCommentLineDoc                                 start="//\%(//\@!\|!\)"         end="$"   contains=rustTodo
+syn region rustCommentBlock    matchgroup=rustCommentBlock    start="/\*\%(!\|\*[*/]\@!\)\@!" end="\*/" contains=rustTodo,@rustComment keepend extend
+syn region rustCommentBlockDoc matchgroup=rustCommentBlockDoc start="/\*\%(!\|\*[*/]\@!\)"    end="\*/" contains=rustTodo,@rustComment keepend extend
 " FIXME: this is a really ugly and not fully correct implementation. Most
 " importantly, a case like ``/* */*`` should have the final ``*`` not being in
 " a comment, but in practice at present it leaves comments open two levels

branches/snap-stage3/src/libextra/bitv.rs

@@ -269,23 +269,14 @@ impl Bitv {
 
 impl Bitv {
     pub fn new(nbits: uint, init: bool) -> Bitv {
-        let rep = if nbits < uint::bits {
-            Small(SmallBitv::new(if init {(1<<nbits)-1} else {0}))
-        } else if nbits == uint::bits {
+        let rep = if nbits <= uint::bits {
             Small(SmallBitv::new(if init {!0} else {0}))
-        } else {
-            let exact = nbits % uint::bits == 0;
-            let nelems = nbits/uint::bits + if exact {0} else {1};
-            let s =
-                if init {
-                    if exact {
-                        vec::from_elem(nelems, !0u)
-                    } else {
-                        let mut v = vec::from_elem(nelems-1, !0u);
-                        v.push((1<<nbits % uint::bits)-1);
-                        v
-                    }
-                } else { vec::from_elem(nelems, 0u)};
+        }
+        else {
+            let nelems = nbits/uint::bits +
+                         if nbits % uint::bits == 0 {0} else {1};
+            let elem = if init {!0u} else {0u};
+            let s = vec::from_elem(nelems, elem);
             Big(BigBitv::new(s))
         };
         Bitv {rep: rep, nbits: nbits}
@@ -1338,20 +1329,6 @@ mod tests {
         assert_eq!(idxs, ~[0, 2, 3]);
     }
 
-    #[test]
-    fn test_bitv_set_frombitv_init() {
-        let bools = [true, false];
-        let lengths = [10, 64, 100];
-        for &b in bools.iter() {
-            for &l in lengths.iter() {
-                let bitset = BitvSet::from_bitv(Bitv::new(l, b));
-                assert_eq!(bitset.contains(&1u), b)
-                assert_eq!(bitset.contains(&(l-1u)), b)
-                assert!(!bitset.contains(&l))
-            }
-        }
-    }
-
     #[test]
     fn test_small_difference() {
         let mut b1 = Bitv::new(3, false);

branches/snap-stage3/src/librustc/front/feature_gate.rs

@@ -45,7 +45,6 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("link_args", Active),
     ("phase", Active),
     ("macro_registrar", Active),
-    ("log_syntax", Active),
 
     // These are used to test this portion of the compiler, they don't actually
     // mean anything
@@ -188,11 +187,6 @@ impl Visitor<()> for Context {
             self.gate_feature("asm", path.span, "inline assembly is not \
                 stable enough for use and is subject to change");
         }
-
-        else if path.segments.last().identifier == self.sess.ident_of("log_syntax") {
-            self.gate_feature("log_syntax", path.span, "`log_syntax!` is not \
-                stable enough for use and is subject to change");
-        }
     }
 
     fn visit_ty(&mut self, t: &ast::Ty, _: ()) {

branches/snap-stage3/src/librustc/metadata/encoder.rs

@@ -496,9 +496,8 @@ fn encode_reexported_static_methods(ecx: &EncodeContext,
                                     ebml_w: &mut writer::Encoder,
                                     mod_path: &[ast_map::PathElem],
                                     exp: &middle::resolve::Export2) {
-    let items = ecx.tcx.items.borrow();
-    match items.get().find(&exp.def_id.node) {
-        Some(&ast_map::NodeItem(item, path)) => {
+    match ecx.tcx.items.find(exp.def_id.node) {
+        Some(ast_map::NodeItem(item, path)) => {
             let original_name = ecx.tcx.sess.str_of(item.ident);
 
             //
@@ -1347,8 +1346,7 @@ fn my_visit_item(i: &Item,
                  ebml_w: &mut writer::Encoder,
                  ecx_ptr: *int,
                  index: @RefCell<~[entry<i64>]>) {
-    let items = items.borrow();
-    match items.get().get_copy(&i.id) {
+    match items.get(i.id) {
         ast_map::NodeItem(_, pt) => {
             let mut ebml_w = unsafe {
                 ebml_w.unsafe_clone()
@@ -1366,8 +1364,7 @@ fn my_visit_foreign_item(ni: &ForeignItem,
                          ebml_w: &mut writer::Encoder,
                          ecx_ptr:*int,
                          index: @RefCell<~[entry<i64>]>) {
-    let items = items.borrow();
-    match items.get().get_copy(&ni.id) {
+    match items.get(ni.id) {
         ast_map::NodeForeignItem(_, abi, _, pt) => {
             debug!("writing foreign item {}::{}",
                    ast_map::path_to_str(

branches/snap-stage3/src/librustc/middle/borrowck/mod.rs

@@ -550,9 +550,8 @@ impl BorrowckCtxt {
             move_data::Declared => {}
 
             move_data::MoveExpr => {
-                let items = self.tcx.items.borrow();
-                let (expr_ty, expr_span) = match items.get().find(&move.id) {
-                    Some(&ast_map::NodeExpr(expr)) => {
+                let (expr_ty, expr_span) = match self.tcx.items.find(move.id) {
+                    Some(ast_map::NodeExpr(expr)) => {
                         (ty::expr_ty_adjusted(self.tcx, expr), expr.span)
                     }
                     r => self.tcx.sess.bug(format!("MoveExpr({:?}) maps to {:?}, not Expr",
@@ -578,9 +577,8 @@ impl BorrowckCtxt {
             }
 
             move_data::Captured => {
-                let items = self.tcx.items.borrow();
-                let (expr_ty, expr_span) = match items.get().find(&move.id) {
-                    Some(&ast_map::NodeExpr(expr)) => {
+                let (expr_ty, expr_span) = match self.tcx.items.find(move.id) {
+                    Some(ast_map::NodeExpr(expr)) => {
                         (ty::expr_ty_adjusted(self.tcx, expr), expr.span)
                     }
                     r => self.tcx.sess.bug(format!("Captured({:?}) maps to {:?}, not Expr",
@@ -768,9 +766,8 @@ impl BorrowckCtxt {
                                    out: &mut ~str) {
         match *loan_path {
             LpVar(id) => {
-                let items = self.tcx.items.borrow();
-                match items.get().find(&id) {
-                    Some(&ast_map::NodeLocal(ref ident, _)) => {
+                match self.tcx.items.find(id) {
+                    Some(ast_map::NodeLocal(ref ident, _)) => {
                         out.push_str(token::ident_to_str(ident));
                     }
                     r => {

branches/snap-stage3/src/librustc/middle/check_const.rs

@@ -250,8 +250,7 @@ impl<'a> Visitor<()> for CheckItemRecursionVisitor<'a> {
                 match def_map.get().find(&e.id) {
                     Some(&DefStatic(def_id, _)) if
                             ast_util::is_local(def_id) => {
-                        let ast_map = self.ast_map.borrow();
-                        match ast_map.get().get_copy(&def_id.node) {
+                        match self.ast_map.get(def_id.node) {
                             ast_map::NodeItem(it, _) => {
                                 self.visit_item(it, ());
                             }

branches/snap-stage3/src/librustc/middle/const_eval.rs

@@ -108,10 +108,9 @@ pub fn lookup_variant_by_id(tcx: ty::ctxt,
 
     if ast_util::is_local(enum_def) {
         {
-            let items = tcx.items.borrow();
-            match items.get().find(&enum_def.node) {
+            match tcx.items.find(enum_def.node) {
                 None => None,
-                Some(&ast_map::NodeItem(it, _)) => match it.node {
+                Some(ast_map::NodeItem(it, _)) => match it.node {
                     ItemEnum(ast::EnumDef { variants: ref variants }, _) => {
                         variant_expr(*variants, variant_def.node)
                     }
@@ -161,10 +160,9 @@ pub fn lookup_const_by_id(tcx: ty::ctxt, def_id: ast::DefId)
                           -> Option<@Expr> {
     if ast_util::is_local(def_id) {
         {
-            let items = tcx.items.borrow();
-            match items.get().find(&def_id.node) {
+            match tcx.items.find(def_id.node) {
                 None => None,
-                Some(&ast_map::NodeItem(it, _)) => match it.node {
+                Some(ast_map::NodeItem(it, _)) => match it.node {
                     ItemStatic(_, ast::MutImmutable, const_expr) => {
                         Some(const_expr)
                     }

branches/snap-stage3/src/librustc/middle/dead.rs

@@ -38,12 +38,11 @@ fn should_explore(tcx: ty::ctxt, def_id: ast::DefId) -> bool {
         return false;
     }
 
-    let items = tcx.items.borrow();
-    match items.get().find(&def_id.node) {
-        Some(&ast_map::NodeItem(..))
-        | Some(&ast_map::NodeMethod(..))
-        | Some(&ast_map::NodeForeignItem(..))
-        | Some(&ast_map::NodeTraitMethod(..)) => true,
+    match tcx.items.find(def_id.node) {
+        Some(ast_map::NodeItem(..))
+        | Some(ast_map::NodeMethod(..))
+        | Some(ast_map::NodeForeignItem(..))
+        | Some(ast_map::NodeTraitMethod(..)) => true,
         _ => false
     }
 }
@@ -136,9 +135,8 @@ impl MarkSymbolVisitor {
             }
             scanned.insert(id);
 
-            let items = self.tcx.items.borrow();
-            match items.get().find(&id) {
-                Some(node) => {
+            match self.tcx.items.find(id) {
+                Some(ref node) => {
                     self.live_symbols.insert(id);
                     self.visit_node(node);
                 }

branches/snap-stage3/src/librustc/middle/entry.rs

@@ -75,9 +75,8 @@ fn find_item(item: &Item, ctxt: &mut EntryContext) {
         ItemFn(..) => {
             if item.ident.name == special_idents::main.name {
                 {
-                    let ast_map = ctxt.ast_map.borrow();
-                    match ast_map.get().find(&item.id) {
-                        Some(&ast_map::NodeItem(_, path)) => {
+                    match ctxt.ast_map.find(item.id) {
+                        Some(ast_map::NodeItem(_, path)) => {
                             if path.len() == 0 {
                                 // This is a top-level function so can be 'main'
                                 if ctxt.main_fn.is_none() {

branches/snap-stage3/src/librustc/middle/lint.rs

@@ -1330,8 +1330,7 @@ fn check_stability(cx: &Context, e: &ast::Expr) {
 
     let stability = if ast_util::is_local(id) {
         // this crate
-        let items = cx.tcx.items.borrow();
-        match items.get().find(&id.node) {
+        match cx.tcx.items.find(id.node) {
             Some(ast_node) => {
                 let s = ast_node.with_attrs(|attrs| {
                     attrs.map(|a| {

branches/snap-stage3/src/librustc/middle/privacy.rs

@@ -431,8 +431,7 @@ impl<'a> PrivacyVisitor<'a> {
         let mut closest_private_id = did.node;
         loop {
             debug!("privacy - examining {}", self.nodestr(closest_private_id));
-            let items = self.tcx.items.borrow();
-            let vis = match items.get().find(&closest_private_id) {
+            let vis = match self.tcx.items.find(closest_private_id) {
                 // If this item is a method, then we know for sure that it's an
                 // actual method and not a static method. The reason for this is
                 // that these cases are only hit in the ExprMethodCall
@@ -449,22 +448,22 @@ impl<'a> PrivacyVisitor<'a> {
                 // invocation.
                 // FIXME(#10573) is this the right behavior? Why not consider
                 //               where the method was defined?
-                Some(&ast_map::NodeMethod(ref m, imp, _)) => {
+                Some(ast_map::NodeMethod(ref m, imp, _)) => {
                     match ty::impl_trait_ref(self.tcx, imp) {
                         Some(..) => return Allowable,
                         _ if m.vis == ast::Public => return Allowable,
                         _ => m.vis
                     }
                 }
-                Some(&ast_map::NodeTraitMethod(..)) => {
+                Some(ast_map::NodeTraitMethod(..)) => {
                     return Allowable;
                 }
 
                 // This is not a method call, extract the visibility as one
                 // would normally look at it
-                Some(&ast_map::NodeItem(it, _)) => it.vis,
-                Some(&ast_map::NodeForeignItem(_, _, v, _)) => v,
-                Some(&ast_map::NodeVariant(ref v, _, _)) => {
+                Some(ast_map::NodeItem(it, _)) => it.vis,
+                Some(ast_map::NodeForeignItem(_, _, v, _)) => v,
+                Some(ast_map::NodeVariant(ref v, _, _)) => {
                     // sadly enum variants still inherit visibility, so only
                     // break out of this is explicitly private
                     if v.node.vis == ast::Private { break }
@@ -538,9 +537,8 @@ impl<'a> PrivacyVisitor<'a> {
                     self.tcx.sess.span_err(span, format!("{} is inaccessible",
                                                          msg));
                 }
-                let items = self.tcx.items.borrow();
-                match items.get().find(&id) {
-                    Some(&ast_map::NodeItem(item, _)) => {
+                match self.tcx.items.find(id) {
+                    Some(ast_map::NodeItem(item, _)) => {
                         let desc = match item.node {
                             ast::ItemMod(..) => "module",
                             ast::ItemTrait(..) => "trait",