librustc: Convert all uses of `assert` over to `fail_unless!`

11 files changed, 55 insertions, 55 deletions

diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs
index 1038982d353..a525c0df5fa 100644
--- a/src/libsyntax/codemap.rs
+++ b/src/libsyntax/codemap.rs
@@ -253,7 +253,7 @@ pub impl FileMap {
     // about what ends a line between this file and parse.rs
     fn next_line(&self, +pos: BytePos) {
         // the new charpos must be > the last one (or it's the first one).
-        assert ((self.lines.len() == 0)
+        fail_unless!((self.lines.len() == 0)
                 || (self.lines[self.lines.len() - 1] < pos));
         self.lines.push(pos);
     }
@@ -272,7 +272,7 @@ pub impl FileMap {
     }
 
     pub fn record_multibyte_char(&self, pos: BytePos, bytes: uint) {
-        assert bytes >=2 && bytes <= 4;
+        fail_unless!(bytes >=2 && bytes <= 4);
         let mbc = MultiByteChar {
             pos: pos,
             bytes: bytes,
@@ -393,7 +393,7 @@ pub impl CodeMap {
     pub fn span_to_snippet(&self, sp: span) -> ~str {
         let begin = self.lookup_byte_offset(sp.lo);
         let end = self.lookup_byte_offset(sp.hi);
-        assert begin.fm.start_pos == end.fm.start_pos;
+        fail_unless!(begin.fm.start_pos == end.fm.start_pos);
         return str::slice(*begin.fm.src,
                           begin.pos.to_uint(), end.pos.to_uint());
     }
@@ -453,7 +453,7 @@ priv impl CodeMap {
         debug!("codemap: char pos %? is on the line at char pos %?",
                chpos, linechpos);
         debug!("codemap: byte is on line: %?", line);
-        assert chpos >= linechpos;
+        fail_unless!(chpos >= linechpos);
         return Loc {
             file: f,
             line: line,
@@ -492,8 +492,8 @@ priv impl CodeMap {
                 total_extra_bytes += mbc.bytes;
                 // We should never see a byte position in the middle of a
                 // character
-                assert bpos == mbc.pos
-                    || bpos.to_uint() >= mbc.pos.to_uint() + mbc.bytes;
+                fail_unless!(bpos == mbc.pos
+                    || bpos.to_uint() >= mbc.pos.to_uint() + mbc.bytes);
             } else {
                 break;
             }
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 7b4f92ab3ca..f76f10f3de1 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -430,7 +430,7 @@ pub fn core_macros() -> ~str {
     macro_rules! fail_unless(
         ($cond:expr) => {
             if !$cond {
-                fail!(~\"assertion failed: \" + stringify!($cond))
+                ::core::sys::fail_assert(stringify!($cond), file!(), line!())
             }
         }
     )
diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs
index 5ea9257d583..eafe871a288 100644
--- a/src/libsyntax/ext/pipes/pipec.rs
+++ b/src/libsyntax/ext/pipes/pipec.rs
@@ -54,7 +54,7 @@ impl gen_send for message {
           message(ref _id, span, ref tys, this, Some(ref next_state)) => {
             debug!("pipec: next state exists");
             let next = this.proto.get_state(next_state.state);
-            assert next_state.tys.len() == next.generics.ty_params.len();
+            fail_unless!(next_state.tys.len() == next.generics.ty_params.len());
             let arg_names = tys.mapi(|i, _ty| cx.ident_of(~"x_"+i.to_str()));
             let args_ast = vec::map2(arg_names, *tys, |n, t| cx.arg(*n, *t));
 
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index 0e63ea3278e..c66e726bbf7 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -410,7 +410,7 @@ pub fn parse(
             }
         }
 
-        assert cur_eis.len() > 0u;
+        fail_unless!(cur_eis.len() > 0u);
     }
 }
 
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index ca5c4564dd9..494ef3a81a0 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -57,7 +57,7 @@ pub fn is_doc_comment(s: &str) -> bool {
 }
 
 pub fn doc_comment_style(comment: &str) -> ast::attr_style {
-    assert is_doc_comment(comment);
+    fail_unless!(is_doc_comment(comment));
     if comment.starts_with(~"//!") || comment.starts_with(~"/*!") {
         ast::attr_inner
     } else {
@@ -136,8 +136,8 @@ fn read_to_eol(rdr: @mut StringReader) -> ~str {
 
 fn read_one_line_comment(rdr: @mut StringReader) -> ~str {
     let val = read_to_eol(rdr);
-    assert ((val[0] == '/' as u8 && val[1] == '/' as u8) ||
-            (val[0] == '#' as u8 && val[1] == '!' as u8));
+    fail_unless!((val[0] == '/' as u8 && val[1] == '/' as u8) ||
+                 (val[0] == '#' as u8 && val[1] == '!' as u8));
     return val;
 }
 
@@ -249,7 +249,7 @@ fn read_block_comment(rdr: @mut StringReader,
             bump(rdr);
         }
         if !is_block_non_doc_comment(curr_line) { return; }
-        assert !curr_line.contains_char('\n');
+        fail_unless!(!curr_line.contains_char('\n'));
         lines.push(curr_line);
     } else {
         let mut level: int = 1;
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
index 524f9b48dd5..ab57d177112 100644
--- a/src/libsyntax/parse/lexer.rs
+++ b/src/libsyntax/parse/lexer.rs
@@ -187,7 +187,7 @@ pub fn bump(rdr: @mut StringReader) {
     rdr.last_pos = rdr.pos;
     let current_byte_offset = byte_offset(rdr).to_uint();;
     if current_byte_offset < (*rdr.src).len() {
-        assert rdr.curr != -1 as char;
+        fail_unless!(rdr.curr != -1 as char);
         let last_char = rdr.curr;
         let next = str::char_range_at(*rdr.src, current_byte_offset);
         let byte_offset_diff = next.next - current_byte_offset;
@@ -314,7 +314,7 @@ fn consume_any_line_comment(rdr: @mut StringReader)
 }
 
 pub pure fn is_block_non_doc_comment(s: &str) -> bool {
-    assert s.len() >= 1u;
+    fail_unless!(s.len() >= 1u);
     str::all_between(s, 1u, s.len() - 1u, |ch| ch == '*')
 }
 
@@ -872,21 +872,21 @@ pub mod test {
         let env = setup(~"'a'");
         let TokenAndSpan {tok, sp: _} =
             env.string_reader.next_token();
-        assert tok == token::LIT_INT('a' as i64, ast::ty_char);
+        fail_unless!(tok == token::LIT_INT('a' as i64, ast::ty_char));
     }
 
     #[test] fn character_space() {
         let env = setup(~"' '");
         let TokenAndSpan {tok, sp: _} =
             env.string_reader.next_token();
-        assert tok == token::LIT_INT(' ' as i64, ast::ty_char);
+        fail_unless!(tok == token::LIT_INT(' ' as i64, ast::ty_char));
     }
 
     #[test] fn character_escaped() {
         let env = setup(~"'\n'");
         let TokenAndSpan {tok, sp: _} =
             env.string_reader.next_token();
-        assert tok == token::LIT_INT('\n' as i64, ast::ty_char);
+        fail_unless!(tok == token::LIT_INT('\n' as i64, ast::ty_char));
     }
 
     #[test] fn lifetime_name() {
@@ -894,7 +894,7 @@ pub mod test {
         let TokenAndSpan {tok, sp: _} =
             env.string_reader.next_token();
         let id = env.interner.intern(@~"abc");
-        assert tok == token::LIFETIME(id);
+        fail_unless!(tok == token::LIFETIME(id));
     }
 }
 
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index 96a8f780934..48d3fbe8889 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -197,7 +197,7 @@ pub fn next_node_id(sess: @mut ParseSess) -> node_id {
     let rv = sess.next_id;
     sess.next_id += 1;
     // ID 0 is reserved for the crate and doesn't actually exist in the AST
-    assert rv != 0;
+    fail_unless!(rv != 0);
     return rv;
 }
 
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 2a113c44612..0dba2bd45e1 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2499,7 +2499,7 @@ pub impl Parser {
 
     fn parse_block(&self) -> blk {
         let (attrs, blk) = self.parse_inner_attrs_and_block(false);
-        assert vec::is_empty(attrs);
+        fail_unless!(vec::is_empty(attrs));
         return blk;
     }
 
@@ -3846,7 +3846,7 @@ pub impl Parser {
         foreign_items_allowed: bool,
         macros_allowed: bool
     ) -> item_or_view_item {
-        assert items_allowed != foreign_items_allowed;
+        fail_unless!(items_allowed != foreign_items_allowed);
 
         maybe_whole!(iovi self, nt_item);
         let lo = self.span.lo;
@@ -4215,11 +4215,11 @@ pub impl Parser {
                     view_items.push(view_item);
                 }
                 iovi_item(item) => {
-                    assert items_allowed;
+                    fail_unless!(items_allowed);
                     items.push(item)
                 }
                 iovi_foreign_item(foreign_item) => {
-                    assert foreign_items_allowed;
+                    fail_unless!(foreign_items_allowed);
                     foreign_items.push(foreign_item);
                 }
             }
diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs
index 60e6e4dc87e..df658b96d7b 100644
--- a/src/libsyntax/print/pp.rs
+++ b/src/libsyntax/print/pp.rs
@@ -117,7 +117,7 @@ pub fn tok_str(++t: token) -> ~str {
 pub fn buf_str(toks: ~[token], szs: ~[int], left: uint, right: uint,
                lim: uint) -> ~str {
     let n = vec::len(toks);
-    assert (n == vec::len(szs));
+    fail_unless!((n == vec::len(szs)));
     let mut i = left;
     let mut L = lim;
     let mut s = ~"[";
@@ -369,12 +369,12 @@ pub impl Printer {
         } else {
             self.top += 1u;
             self.top %= self.buf_len;
-            assert (self.top != self.bottom);
+            fail_unless!((self.top != self.bottom));
         }
         self.scan_stack[self.top] = x;
     }
     fn scan_pop(&mut self) -> uint {
-        assert (!self.scan_stack_empty);
+        fail_unless!((!self.scan_stack_empty));
         let x = self.scan_stack[self.top];
         if self.top == self.bottom {
             self.scan_stack_empty = true;
@@ -382,11 +382,11 @@ pub impl Printer {
         return x;
     }
     fn scan_top(&mut self) -> uint {
-        assert (!self.scan_stack_empty);
+        fail_unless!((!self.scan_stack_empty));
         return self.scan_stack[self.top];
     }
     fn scan_pop_bottom(&mut self) -> uint {
-        assert (!self.scan_stack_empty);
+        fail_unless!((!self.scan_stack_empty));
         let x = self.scan_stack[self.bottom];
         if self.top == self.bottom {
             self.scan_stack_empty = true;
@@ -396,7 +396,7 @@ pub impl Printer {
     fn advance_right(&mut self) {
         self.right += 1u;
         self.right %= self.buf_len;
-        assert (self.right != self.left);
+        fail_unless!((self.right != self.left));
     }
     fn advance_left(&mut self, ++x: token, L: int) {
         debug!("advnce_left ~[%u,%u], sizeof(%u)=%d", self.left, self.right,
@@ -405,7 +405,7 @@ pub impl Printer {
             self.print(x, L);
             match x {
               BREAK(b) => self.left_total += b.blank_space,
-              STRING(_, len) => { assert (len == L); self.left_total += len; }
+              STRING(_, len) => { fail_unless!((len == L)); self.left_total += len; }
               _ => ()
             }
             if self.left != self.right {
@@ -494,7 +494,7 @@ pub impl Printer {
           }
           END => {
             debug!("print END -> pop END");
-            assert (self.print_stack.len() != 0u);
+            fail_unless!((self.print_stack.len() != 0u));
             self.print_stack.pop();
           }
           BREAK(b) => {
@@ -528,8 +528,8 @@ pub impl Printer {
           }
           STRING(s, len) => {
             debug!("print STRING(%s)", *s);
-            assert (L == len);
-            // assert L <= space;
+            fail_unless!((L == len));
+            // fail_unless!(L <= space);
             self.space -= len;
             self.print_str(*s);
           }
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index c0ce8ec45aa..d87238c720e 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -1327,8 +1327,8 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) {
         print_fn_block_args(s, decl);
         space(s.s);
         // }
-        assert body.node.stmts.is_empty();
-        assert body.node.expr.is_some();
+        fail_unless!(body.node.stmts.is_empty());
+        fail_unless!(body.node.expr.is_some());
         // we extract the block, so as not to create another set of boxes
         match body.node.expr.get().node {
             ast::expr_block(ref blk) => {
@@ -1460,7 +1460,7 @@ pub fn print_decl(s: @ps, decl: @ast::decl) {
 
         // if any are mut, all are mut
         if vec::any(locs, |l| l.node.is_mutbl) {
-            assert vec::all(locs, |l| l.node.is_mutbl);
+            fail_unless!(vec::all(locs, |l| l.node.is_mutbl));
             word_nbsp(s, ~"mut");
         }
 
@@ -2086,7 +2086,7 @@ pub fn maybe_print_comment(s: @ps, pos: BytePos) {
 pub fn print_comment(s: @ps, cmnt: comments::cmnt) {
     match cmnt.style {
       comments::mixed => {
-        assert (vec::len(cmnt.lines) == 1u);
+        fail_unless!((vec::len(cmnt.lines) == 1u));
         zerobreak(s.s);
         word(s.s, cmnt.lines[0]);
         zerobreak(s.s);
diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs
index 5fc93412c50..2c852084aa7 100644
--- a/src/libsyntax/util/interner.rs
+++ b/src/libsyntax/util/interner.rs
@@ -74,32 +74,32 @@ pub fn i1 () {
 pub fn i2 () {
     let i : Interner<@~str> = Interner::new();
     // first one is zero:
-    assert i.intern (@~"dog") == 0;
+    fail_unless!(i.intern (@~"dog") == 0);
     // re-use gets the same entry:
-    assert i.intern (@~"dog") == 0;
+    fail_unless!(i.intern (@~"dog") == 0);
     // different string gets a different #:
-    assert i.intern (@~"cat") == 1;
-    assert i.intern (@~"cat") == 1;
+    fail_unless!(i.intern (@~"cat") == 1);
+    fail_unless!(i.intern (@~"cat") == 1);
     // dog is still at zero
-    assert i.intern (@~"dog") == 0;
+    fail_unless!(i.intern (@~"dog") == 0);
     // gensym gets 3
-    assert i.gensym (@~"zebra" ) == 2;
+    fail_unless!(i.gensym (@~"zebra" ) == 2);
     // gensym of same string gets new number :
-    assert i.gensym (@~"zebra" ) == 3;
+    fail_unless!(i.gensym (@~"zebra" ) == 3);
     // gensym of *existing* string gets new number:
-    assert i.gensym (@~"dog") == 4;
-    assert i.get(0) == @~"dog";
-    assert i.get(1) == @~"cat";
-    assert i.get(2) == @~"zebra";
-    assert i.get(3) == @~"zebra";
-    assert i.get(4) == @~"dog";
+    fail_unless!(i.gensym (@~"dog") == 4);
+    fail_unless!(i.get(0) == @~"dog");
+    fail_unless!(i.get(1) == @~"cat");
+    fail_unless!(i.get(2) == @~"zebra");
+    fail_unless!(i.get(3) == @~"zebra");
+    fail_unless!(i.get(4) == @~"dog");
 }
 
 #[test]
 pub fn i3 () {
     let i : Interner<@~str> = Interner::prefill([@~"Alan",@~"Bob",@~"Carol"]);
-    assert i.get(0) == @~"Alan";
-    assert i.get(1) == @~"Bob";
-    assert i.get(2) == @~"Carol";
-    assert i.intern(@~"Bob") == 1;
+    fail_unless!(i.get(0) == @~"Alan");
+    fail_unless!(i.get(1) == @~"Bob");
+    fail_unless!(i.get(2) == @~"Carol");
+    fail_unless!(i.intern(@~"Bob") == 1);
 }