---

yaml
---
r: 42971
b: refs/heads/try
c: 80cd485
h: refs/heads/master
i:
  42969: 0936581
  42967: 0e9891e
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 19dfec2aaf746535de1521f68421f9980dbf25de
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
-refs/heads/try: 61827a70205c0be48badf09eced0e0d5dc6a4e02
+refs/heads/try: 80cd485b494556c6bcdc3793acfa52bcd8faab8d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/src/librustc/middle/ty.rs

@@ -2435,7 +2435,7 @@ pub fn type_structurally_contains_uniques(cx: ctxt, ty: t) -> bool {
 
 pub fn type_is_integral(ty: t) -> bool {
     match get(ty).sty {
-      ty_infer(IntVar(_)) | ty_int(_) | ty_uint(_) | ty_bool => true,
+      ty_infer(IntVar(_)) | ty_int(_) | ty_uint(_) => true,
       _ => false
     }
 }

branches/try/src/libstd/bitv.rs

@@ -156,7 +156,7 @@ impl BigBitv {
      fn each_storage(op: fn(v: &mut uint) -> bool) {
         for uint::range(0, self.storage.len()) |i| {
             let mut w = self.storage[i];
-            let b = !op(&mut w);
+            let b = op(&mut w);
             self.storage[i] = w;
             if !b { break; }
         }
@@ -981,6 +981,24 @@ mod tests {
       assert !b1[40];
       assert !b1[80];
     }
+
+    #[test]
+    pub fn test_small_clear() {
+      let b = Bitv(14, true);
+      b.clear();
+      for b.ones |i| {
+          die!(fmt!("found 1 at %?", i));
+      }
+    }
+
+    #[test]
+    pub fn test_big_clear() {
+      let b = Bitv(140, true);
+      b.clear();
+      for b.ones |i| {
+          die!(fmt!("found 1 at %?", i));
+      }
+    }
 }
 
 //

branches/try/src/libsyntax/ext/tt/transcribe.rs

@@ -39,8 +39,7 @@ type tt_frame = @{
     up: tt_frame_up,
 };
 
-pub type tt_reader = @tt_reader_;
-pub type tt_reader_ = {
+pub type tt_reader = @{
     sp_diag: span_handler,
     interner: @ident_interner,
     mut cur: tt_frame,
@@ -88,7 +87,7 @@ pure fn dup_tt_frame(&&f: tt_frame) -> tt_frame {
      }
 }
 
-pub pure fn dup_tt_reader(r: &tt_reader_) -> tt_reader {
+pub pure fn dup_tt_reader(&&r: tt_reader) -> tt_reader {
     @{sp_diag: r.sp_diag, interner: r.interner,
       mut cur: dup_tt_frame(r.cur),
       interpolations: r.interpolations,
@@ -97,7 +96,7 @@ pub pure fn dup_tt_reader(r: &tt_reader_) -> tt_reader {
 }
 
 
-pure fn lookup_cur_matched_by_matched(r: &tt_reader_,
+pure fn lookup_cur_matched_by_matched(r: tt_reader,
                                       start: @named_match) -> @named_match {
     pure fn red(+ad: @named_match, idx: &uint) -> @named_match {
         match *ad {
@@ -111,15 +110,15 @@ pure fn lookup_cur_matched_by_matched(r: &tt_reader_,
     vec::foldl(start, r.repeat_idx, red)
 }
 
-fn lookup_cur_matched(r: &tt_reader_, name: ident) -> @named_match {
+fn lookup_cur_matched(r: tt_reader, name: ident) -> @named_match {
     lookup_cur_matched_by_matched(r, r.interpolations.get(&name))
 }
 enum lis {
     lis_unconstrained, lis_constraint(uint, ident), lis_contradiction(~str)
 }
 
-fn lockstep_iter_size(t: token_tree, r: &tt_reader_) -> lis {
-    fn lis_merge(lhs: lis, rhs: lis, r: &tt_reader_) -> lis {
+fn lockstep_iter_size(t: token_tree, r: tt_reader) -> lis {
+    fn lis_merge(lhs: lis, rhs: lis, r: tt_reader) -> lis {
         match lhs {
           lis_unconstrained => rhs,
           lis_contradiction(_) => lhs,
@@ -151,7 +150,7 @@ fn lockstep_iter_size(t: token_tree, r: &tt_reader_) -> lis {
 }
 
 
-pub fn tt_next_token(r: &tt_reader_) -> TokenAndSpan {
+pub fn tt_next_token(&&r: tt_reader) -> TokenAndSpan {
     let ret_val = TokenAndSpan { tok: r.cur_tok, sp: r.cur_span };
     while r.cur.idx >= r.cur.readme.len() {
         /* done with this set; pop or repeat? */
@@ -200,26 +199,25 @@ pub fn tt_next_token(r: &tt_reader_) -> TokenAndSpan {
             return ret_val;
           }
           tt_seq(sp, ref tts, ref sep, zerok) => {
-              match lockstep_iter_size(tt_seq(sp, (*tts), (*sep), zerok), r) {
-                lis_unconstrained => {
-                  r.sp_diag.span_fatal(
+            match lockstep_iter_size(tt_seq(sp, (*tts), (*sep), zerok), r) {
+              lis_unconstrained => {
+                r.sp_diag.span_fatal(
                     sp, /* blame macro writer */
-                      ~"attempted to repeat an expression \
-                        containing no syntax \
-                        variables matched as repeating at this depth");
-                  }
-                  lis_contradiction(ref msg) => {
-                      /* FIXME #2887 blame macro invoker instead*/
-                      r.sp_diag.span_fatal(sp, (*msg));
-                  }
-                  lis_constraint(len, _) => {
-                    if len == 0 {
-                      if !zerok {
+                    ~"attempted to repeat an expression containing no syntax \
+                     variables matched as repeating at this depth");
+              }
+              lis_contradiction(ref msg) => {
+                /* FIXME #2887 blame macro invoker instead*/
+                r.sp_diag.span_fatal(sp, (*msg));
+              }
+              lis_constraint(len, _) => {
+                if len == 0 {
+                    if !zerok {
                         r.sp_diag.span_fatal(sp, /* FIXME #2887 blame invoker
-                        */
+                                                  */
                                              ~"this must repeat at least \
-                                               once");
-                          }
+                                              once");
+                    }
 
                     r.cur.idx += 1u;
                     return tt_next_token(r);

branches/try/src/libsyntax/parse/lexer.rs

@@ -24,25 +24,24 @@ use core::either;
 use core::str;
 use core::u64;
 
-pub use ext::tt::transcribe::{tt_reader, tt_reader_, new_tt_reader};
+pub use ext::tt::transcribe::{tt_reader, new_tt_reader};
 
-//use std;
+use std;
 
 pub trait reader {
-    fn is_eof(&self) -> bool;
-    fn next_token(&self) -> TokenAndSpan;
-    fn fatal(&self,~str) -> !;
-    fn span_diag(&self) -> span_handler;
-    pure fn interner(&self) -> @token::ident_interner;
-    fn peek(&self) -> TokenAndSpan;
-    fn dup(&self) -> reader;
+    fn is_eof() -> bool;
+    fn next_token() -> TokenAndSpan;
+    fn fatal(~str) -> !;
+    fn span_diag() -> span_handler;
+    pure fn interner() -> @token::ident_interner;
+    fn peek() -> TokenAndSpan;
+    fn dup() -> reader;
 }
 
 #[deriving_eq]
 pub struct TokenAndSpan {tok: token::Token, sp: span}
 
-pub type string_reader = @string_reader_;
-pub type string_reader_ = {
+pub type string_reader = @{
     span_diagnostic: span_handler,
     src: @~str,
     // The absolute offset within the codemap of the next character to read
@@ -91,7 +90,7 @@ pub fn new_low_level_string_reader(span_diagnostic: span_handler,
 // duplicating the string reader is probably a bad idea, in
 // that using them will cause interleaved pushes of line
 // offsets to the underlying filemap...
-fn dup_string_reader(r: &string_reader_) -> string_reader {
+fn dup_string_reader(&&r: string_reader) -> string_reader {
     @{span_diagnostic: r.span_diagnostic, src: r.src,
       mut pos: r.pos,
       mut last_pos: r.last_pos,
@@ -100,28 +99,28 @@ fn dup_string_reader(r: &string_reader_) -> string_reader {
       mut peek_tok: r.peek_tok, mut peek_span: r.peek_span}
 }
 
-impl string_reader_: reader {
-    fn is_eof(&self) -> bool { is_eof(self) }
+impl string_reader: reader {
+    fn is_eof() -> bool { is_eof(self) }
     // return the next token. EFFECT: advances the string_reader.
-    fn next_token(&self) -> TokenAndSpan {
+    fn next_token() -> TokenAndSpan {
         let ret_val = TokenAndSpan {tok: self.peek_tok, sp: self.peek_span};
         string_advance_token(self);
         return ret_val;
     }
-    fn fatal(&self, m: ~str) -> ! {
+    fn fatal(m: ~str) -> ! {
         self.span_diagnostic.span_fatal(copy self.peek_span, m)
     }
-    fn span_diag(&self) -> span_handler { self.span_diagnostic }
-    pure fn interner(&self) -> @token::ident_interner { self.interner }
-    fn peek(&self) -> TokenAndSpan {
+    fn span_diag() -> span_handler { self.span_diagnostic }
+    pure fn interner() -> @token::ident_interner { self.interner }
+    fn peek() -> TokenAndSpan {
         TokenAndSpan {tok: self.peek_tok, sp: self.peek_span}
     }
-    fn dup(&self) -> reader { dup_string_reader(self) as reader }
+    fn dup() -> reader { dup_string_reader(self) as reader }
 }
 
-pub impl tt_reader_: reader {
-    fn is_eof(&self) -> bool { self.cur_tok == token::EOF }
-    fn next_token(&self) -> TokenAndSpan {
+pub impl tt_reader: reader {
+    fn is_eof() -> bool { self.cur_tok == token::EOF }
+    fn next_token() -> TokenAndSpan {
         /* weird resolve bug: if the following `if`, or any of its
         statements are removed, we get resolution errors */
         if false {
@@ -130,19 +129,19 @@ pub impl tt_reader_: reader {
         }
         tt_next_token(self)
     }
-    fn fatal(&self, m: ~str) -> ! {
+    fn fatal(m: ~str) -> ! {
         self.sp_diag.span_fatal(copy self.cur_span, m);
     }
-    fn span_diag(&self) -> span_handler { self.sp_diag }
-    pure fn interner(&self) -> @token::ident_interner { self.interner }
-    fn peek(&self) -> TokenAndSpan {
+    fn span_diag() -> span_handler { self.sp_diag }
+    pure fn interner() -> @token::ident_interner { self.interner }
+    fn peek() -> TokenAndSpan {
         TokenAndSpan { tok: self.cur_tok, sp: self.cur_span }
     }
-    fn dup(&self) -> reader { dup_tt_reader(self) as reader }
+    fn dup() -> reader { dup_tt_reader(self) as reader }
 }
 
 // EFFECT: advance peek_tok and peek_span to refer to the next token.
-fn string_advance_token(r: &string_reader_) {
+fn string_advance_token(&&r: string_reader) {
     match (consume_whitespace_and_comments(r)) {
         Some(comment) => {
             r.peek_tok = comment.tok;
@@ -160,11 +159,11 @@ fn string_advance_token(r: &string_reader_) {
     }
 }
 
-fn byte_offset(rdr: &string_reader_) -> BytePos {
+fn byte_offset(rdr: string_reader) -> BytePos {
     (rdr.pos - rdr.filemap.start_pos)
 }
 
-pub fn get_str_from(rdr: &string_reader_, start: BytePos) -> ~str {
+pub fn get_str_from(rdr: string_reader, start: BytePos) -> ~str {
     unsafe {
         // I'm pretty skeptical about this subtraction. What if there's a
         // multi-byte character before the mark?
@@ -175,7 +174,7 @@ pub fn get_str_from(rdr: &string_reader_, start: BytePos) -> ~str {
 
 // EFFECT: advance the StringReader by one character. If a newline is
 // discovered, add it to the FileMap's list of line start offsets.
-pub fn bump(rdr: &string_reader_) {
+pub fn bump(rdr: string_reader) {
     rdr.last_pos = rdr.pos;
     let current_byte_offset = byte_offset(rdr).to_uint();;
     if current_byte_offset < (*rdr.src).len() {
@@ -199,10 +198,10 @@ pub fn bump(rdr: &string_reader_) {
         rdr.curr = -1 as char;
     }
 }
-pub fn is_eof(rdr: &string_reader_) -> bool {
+pub fn is_eof(rdr: string_reader) -> bool {
     rdr.curr == -1 as char
 }
-pub fn nextch(rdr: &string_reader_) -> char {
+pub fn nextch(rdr: string_reader) -> char {
     let offset = byte_offset(rdr).to_uint();
     if offset < (*rdr.src).len() {
         return str::char_at(*rdr.src, offset);
@@ -247,7 +246,7 @@ fn is_bin_digit(c: char) -> bool { return c == '0' || c == '1'; }
 
 // EFFECT: eats whitespace and comments.
 // returns a Some(sugared-doc-attr) if one exists, None otherwise.
-fn consume_whitespace_and_comments(rdr: &string_reader_)
+fn consume_whitespace_and_comments(rdr: string_reader)
     -> Option<TokenAndSpan> {
     while is_whitespace(rdr.curr) { bump(rdr); }
     return consume_any_line_comment(rdr);
@@ -256,7 +255,7 @@ fn consume_whitespace_and_comments(rdr: &string_reader_)
 // PRECONDITION: rdr.curr is not whitespace
 // EFFECT: eats any kind of comment.
 // returns a Some(sugared-doc-attr) if one exists, None otherwise
-fn consume_any_line_comment(rdr: &string_reader_)
+fn consume_any_line_comment(rdr: string_reader)
                                 -> Option<TokenAndSpan> {
     if rdr.curr == '/' {
         match nextch(rdr) {
@@ -299,7 +298,7 @@ fn consume_any_line_comment(rdr: &string_reader_)
 }
 
 // might return a sugared-doc-attr
-fn consume_block_comment(rdr: &string_reader_)
+fn consume_block_comment(rdr: string_reader)
                                 -> Option<TokenAndSpan> {
 
     // block comments starting with "/**" or "/*!" are doc-comments
@@ -338,7 +337,7 @@ fn consume_block_comment(rdr: &string_reader_)
     return consume_whitespace_and_comments(rdr);
 }
 
-fn scan_exponent(rdr: &string_reader_) -> Option<~str> {
+fn scan_exponent(rdr: string_reader) -> Option<~str> {
     let mut c = rdr.curr;
     let mut rslt = ~"";
     if c == 'e' || c == 'E' {
@@ -356,7 +355,7 @@ fn scan_exponent(rdr: &string_reader_) -> Option<~str> {
     } else { return None::<~str>; }
 }
 
-fn scan_digits(rdr: &string_reader_, radix: uint) -> ~str {
+fn scan_digits(rdr: string_reader, radix: uint) -> ~str {
     let mut rslt = ~"";
     loop {
         let c = rdr.curr;
@@ -371,7 +370,7 @@ fn scan_digits(rdr: &string_reader_, radix: uint) -> ~str {
     };
 }
 
-fn scan_number(c: char, rdr: &string_reader_) -> token::Token {
+fn scan_number(c: char, rdr: string_reader) -> token::Token {
     let mut num_str, base = 10u, c = c, n = nextch(rdr);
     if c == '0' && n == 'x' {
         bump(rdr);
@@ -480,7 +479,7 @@ fn scan_number(c: char, rdr: &string_reader_) -> token::Token {
     }
 }
 
-fn scan_numeric_escape(rdr: &string_reader_, n_hex_digits: uint) -> char {
+fn scan_numeric_escape(rdr: string_reader, n_hex_digits: uint) -> char {
     let mut accum_int = 0, i = n_hex_digits;
     while i != 0u {
         let n = rdr.curr;
@@ -495,7 +494,7 @@ fn scan_numeric_escape(rdr: &string_reader_, n_hex_digits: uint) -> char {
     return accum_int as char;
 }
 
-fn next_token_inner(rdr: &string_reader_) -> token::Token {
+fn next_token_inner(rdr: string_reader) -> token::Token {
     let mut accum_str = ~"";
     let mut c = rdr.curr;
     if (c >= 'a' && c <= 'z')
@@ -520,7 +519,7 @@ fn next_token_inner(rdr: &string_reader_) -> token::Token {
     if is_dec_digit(c) {
         return scan_number(c, rdr);
     }
-    fn binop(rdr: &string_reader_, op: token::binop) -> token::Token {
+    fn binop(rdr: string_reader, op: token::binop) -> token::Token {
         bump(rdr);
         if rdr.curr == '=' {
             bump(rdr);
@@ -713,7 +712,7 @@ fn next_token_inner(rdr: &string_reader_) -> token::Token {
     }
 }
 
-fn consume_whitespace(rdr: &string_reader_) {
+fn consume_whitespace(rdr: string_reader) {
     while is_whitespace(rdr.curr) && !is_eof(rdr) { bump(rdr); }
 }
 
@@ -724,7 +723,7 @@ pub mod test {
     use util::interner;
     use diagnostic;
     use util::testing::{check_equal, check_equal_ptr};
-    #[tetst] fn t1 () {
+    #[test] fn t1 () {
         let teststr =
             @~"/* my source file */
 fn main() { io::println(~\"zebra\"); }\n";