rustc: Rename parser.err to parser.fatal

brson · brson · commit a6e188f8bf30 · 2011-06-22T12:55:26.000-07:00
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
@@ -28,7 +28,7 @@ type parser =
     obj {
         fn peek() -> token::token ;
         fn bump() ;
-        fn err(str) -> !  ;
+        fn fatal(str) -> !  ;
         fn restrict(restriction) ;
         fn get_restriction() -> restriction ;
         fn get_file_type() -> file_type ;
@@ -74,7 +74,7 @@ fn new_parser(session::session sess, eval::env env,
             lo = rdr.get_mark_chpos();
             hi = rdr.get_chpos();
         }
-        fn err(str m) -> ! { sess.span_fatal(rec(lo=lo, hi=hi), m); }
+        fn fatal(str m) -> ! { sess.span_fatal(rec(lo=lo, hi=hi), m); }
         fn restrict(restriction r) { res = r; }
         fn get_restriction() -> restriction { ret res; }
         fn get_session() -> session::session { ret sess; }
@@ -164,7 +164,7 @@ fn bad_expr_word_table() -> hashmap[str, ()] {
 fn unexpected(&parser p, token::token t) -> ! {
     let str s = "unexpected token: ";
     s += token::to_str(p.get_reader(), t);
-    p.err(s);
+    p.fatal(s);
 }
 
 fn expect(&parser p, token::token t) {
@@ -175,7 +175,7 @@ fn expect(&parser p, token::token t) {
         s += token::to_str(p.get_reader(), t);
         s += ", found ";
         s += token::to_str(p.get_reader(), p.peek());
-        p.err(s);
+        p.fatal(s);
     }
 }
 
@@ -186,7 +186,7 @@ fn spanned[T](uint lo, uint hi, &T node) -> common::spanned[T] {
 fn parse_ident(&parser p) -> ast::ident {
     alt (p.peek()) {
         case (token::IDENT(?i, _)) { p.bump(); ret p.get_str(i); }
-        case (_) { p.err("expecting ident"); fail; }
+        case (_) { p.fatal("expecting ident"); fail; }
     }
 }
 
@@ -209,12 +209,12 @@ fn parse_str_lit_or_env_ident(&parser p) -> ast::ident {
                 eval::lookup(p.get_session(), p.get_env(), p.get_span(),
                              p.get_str(i));
             if (!eval::val_is_str(v)) {
-                p.err("expecting string-valued variable");
+                p.fatal("expecting string-valued variable");
             }
             p.bump();
             ret eval::val_as_str(v);
         }
-        case (_) { p.err("expecting string literal"); fail; }
+        case (_) { p.fatal("expecting string literal"); fail; }
     }
 }
 
@@ -239,7 +239,7 @@ fn eat_word(&parser p, &str word) -> bool {
 
 fn expect_word(&parser p, &str word) {
     if (!eat_word(p, word)) {
-        p.err("expecting " + word + ", found " +
+        p.fatal("expecting " + word + ", found " +
                   token::to_str(p.get_reader(), p.peek()));
     }
 }
@@ -249,7 +249,7 @@ fn check_bad_word(&parser p) {
         case (token::IDENT(?sid, false)) {
             auto w = p.get_str(sid);
             if (p.get_bad_expr_words().contains_key(w)) {
-                p.err("found " + w + " in expression position");
+                p.fatal("found " + w + " in expression position");
             }
         }
         case (_) { }
@@ -436,7 +436,7 @@ fn parse_ty_postfix(@ast::ty orig_t, &parser p) -> @ast::ty {
                                               ann));
                 }
                 case (_) {
-                    p.err("type parameter instantiation only allowed for " +
+                    p.fatal("type parameter instantiation only allowed for " +
                           "paths");
                 }
             }
@@ -572,7 +572,7 @@ fn parse_ty(&parser p) -> @ast::ty {
         auto path = parse_path(p);
         t = ast::ty_path(path, p.get_id());
         hi = path.span.hi;
-    } else { p.err("expecting type"); t = ast::ty_nil; fail; }
+    } else { p.fatal("expecting type"); t = ast::ty_nil; fail; }
     ret parse_ty_postfix(@spanned(lo, hi, t), p);
 }
 
@@ -917,7 +917,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
         if (/*check*/ast::is_call_expr(e)) {
             hi = e.span.hi;
             ex = ast::expr_be(e);
-        } else { p.err("Non-call expression in tail call"); }
+        } else { p.fatal("Non-call expression in tail call"); }
     } else if (eat_word(p, "port")) {
         expect(p, token::LPAREN);
         expect(p, token::RPAREN);
@@ -982,7 +982,7 @@ fn expand_syntax_ext(&parser p, common::span sp, &ast::path path,
     assert (vec::len(path.node.idents) > 0u);
     auto extname = path.node.idents.(0);
     alt (p.get_syntax_expanders().find(extname)) {
-        case (none) { p.err("unknown syntax expander: '" + extname + "'"); }
+        case (none) { p.fatal("unknown syntax expander: '" + extname + "'"); }
         case (some(ext::x(?ext))) {
             auto ext_cx = ext::mk_ctxt(p);
             ret ast::expr_ext(path, args, body, ext(ext_cx, sp, args, body));
@@ -1313,7 +1313,7 @@ fn parse_alt_expr(&parser p) -> @ast::expr {
             /* empty */
 
         } else {
-            p.err("expected 'case' or '}' when parsing 'alt' statement " +
+            p.fatal("expected 'case' or '}' when parsing 'alt' statement " +
                       "but found " + token::to_str(p.get_reader(), p.peek()));
         }
     }
@@ -1391,7 +1391,7 @@ fn parse_pat(&parser p) -> @ast::pat {
                         ast::pat_bind(p.get_str(id), p.get_id());
                 }
                 case (?tok) {
-                    p.err("expected identifier after '?' in pattern but " +
+                    p.fatal("expected identifier after '?' in pattern but " +
                               "found " + token::to_str(p.get_reader(), tok));
                     fail;
                 }
@@ -1503,7 +1503,7 @@ fn parse_source_stmt(&parser p) -> @ast::stmt {
             alt (maybe_item) {
                 case (got_item(_)) { /* fallthrough */ }
                 case (_) {
-                    ret p.err("expected item");
+                    ret p.fatal("expected item");
                 }
             }
         }
@@ -1528,7 +1528,7 @@ fn parse_source_stmt(&parser p) -> @ast::stmt {
             }
         }
     }
-    p.err("expected statement");
+    p.fatal("expected statement");
     fail;
 }
 
@@ -1612,7 +1612,7 @@ fn parse_block(&parser p) -> ast::block {
                             case (token::RBRACE) { expr = some(e); }
                             case (?t) {
                                 if (stmt_ends_with_semi(*stmt)) {
-                                    p.err("expected ';' or '}' after " +
+                                    p.fatal("expected ';' or '}' after " +
                                               "expression but found " +
                                               token::to_str(p.get_reader(),
                                                             t));
@@ -1798,7 +1798,7 @@ fn parse_mod_items(&parser p, token::token term,
         alt (parse_item(p, attrs)) {
             case (got_item(?i)) { vec::push(items, i); }
             case (_) {
-                p.err("expected item but found " +
+                p.fatal("expected item but found " +
                           token::to_str(p.get_reader(), p.peek()));
             }
         }
@@ -1903,7 +1903,7 @@ fn parse_item_native_mod(&parser p, vec[ast::attribute] attrs) -> @ast::item {
             abi = ast::native_abi_llvm;
         } else if (str::eq(t, "rust-intrinsic")) {
             abi = ast::native_abi_rust_intrinsic;
-        } else { p.err("unsupported abi: " + t); fail; }
+        } else { p.fatal("unsupported abi: " + t); fail; }
     }
     expect_word(p, "mod");
     auto id = parse_ident(p);
@@ -1971,7 +1971,7 @@ fn parse_item_tag(&parser p, vec[ast::attribute] attrs) -> @ast::item {
             }
             case (token::RBRACE) {/* empty */ }
             case (_) {
-                p.err("expected name of variant or '}' but found " +
+                p.fatal("expected name of variant or '}' but found " +
                           token::to_str(p.get_reader(), tok));
             }
         }
@@ -2104,7 +2104,7 @@ fn parse_inner_attrs_and_next(&parser p) -> tup(vec[ast::attribute],
 fn parse_inner_attrs(&parser p) -> vec[ast::attribute] {
     auto attrs_and_next = parse_inner_attrs_and_next(p);
     if (vec::len(attrs_and_next._1) > 0u) {
-        ret p.err("expected crate directive but found " +
+        ret p.fatal("expected crate directive but found " +
                   token::to_str(p.get_reader(), p.peek()));
     }
     ret attrs_and_next._0;
@@ -2120,7 +2120,7 @@ fn parse_meta_item(&parser p) -> @ast::meta_item {
             p.bump();
             ret @spanned(lo, hi, rec(key=ident, value=p.get_str(s)));
         }
-        case (_) { p.err("Metadata items must be string literals"); }
+        case (_) { p.fatal("Metadata items must be string literals"); }
     }
     fail;
 }
@@ -2158,10 +2158,10 @@ fn parse_rest_import_name(&parser p, ast::ident first,
         alt (p.peek()) {
             case (token::SEMI) { p.bump(); break; }
             case (token::MOD_SEP) {
-                if (glob) { p.err("cannot path into a glob"); }
+                if (glob) { p.fatal("cannot path into a glob"); }
                 p.bump();
             }
-            case (_) { p.err("expecting '::' or ';'"); }
+            case (_) { p.fatal("expecting '::' or ';'"); }
         }
         alt (p.peek()) {
             case (token::IDENT(_, _)) { identifiers += [parse_ident(p)]; }
@@ -2171,14 +2171,14 @@ fn parse_rest_import_name(&parser p, ast::ident first,
                 glob = true;
                 p.bump();
             }
-            case (_) { p.err("expecting an identifier, or '*'"); }
+            case (_) { p.fatal("expecting an identifier, or '*'"); }
         }
     }
     auto hi = p.get_hi_pos();
     auto import_decl;
     alt (def_ident) {
         case (some(?i)) {
-            if (glob) { p.err("globbed imports can't be renamed"); }
+            if (glob) { p.fatal("globbed imports can't be renamed"); }
             import_decl =
                 ast::view_item_import(i, identifiers, p.get_id());
         }
@@ -2204,7 +2204,7 @@ fn parse_full_import_name(&parser p, ast::ident def_ident) ->
             p.bump();
             ret parse_rest_import_name(p, p.get_str(i), some(def_ident));
         }
-        case (_) { p.err("expecting an identifier"); }
+        case (_) { p.fatal("expecting an identifier"); }
     }
     fail;
 }
@@ -2223,7 +2223,7 @@ fn parse_import(&parser p) -> @ast::view_item {
                 }
             }
         }
-        case (_) { p.err("expecting an identifier"); }
+        case (_) { p.fatal("expecting an identifier"); }
     }
     fail;
 }

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ type parser =`
`28`	`28`	`obj {`
`29`	`29`	`fn peek() -> token::token ;`
`30`	`30`	`fn bump() ;`
`31`		`- fn err(str) -> ! ;`
	`31`	`+ fn fatal(str) -> ! ;`
`32`	`32`	`fn restrict(restriction) ;`
`33`	`33`	`fn get_restriction() -> restriction ;`
`34`	`34`	`fn get_file_type() -> file_type ;`
`@@ -74,7 +74,7 @@ fn new_parser(session::session sess, eval::env env,`
`74`	`74`	`lo = rdr.get_mark_chpos();`
`75`	`75`	`hi = rdr.get_chpos();`
`76`	`76`	`}`
`77`		`- fn err(str m) -> ! { sess.span_fatal(rec(lo=lo, hi=hi), m); }`
	`77`	`+ fn fatal(str m) -> ! { sess.span_fatal(rec(lo=lo, hi=hi), m); }`
`78`	`78`	`fn restrict(restriction r) { res = r; }`
`79`	`79`	`fn get_restriction() -> restriction { ret res; }`
`80`	`80`	`fn get_session() -> session::session { ret sess; }`
`@@ -164,7 +164,7 @@ fn bad_expr_word_table() -> hashmap[str, ()] {`
`164`	`164`	`fn unexpected(&parser p, token::token t) -> ! {`
`165`	`165`	`let str s = "unexpected token: ";`
`166`	`166`	`s += token::to_str(p.get_reader(), t);`
`167`		`- p.err(s);`
	`167`	`+ p.fatal(s);`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`fn expect(&parser p, token::token t) {`
`@@ -175,7 +175,7 @@ fn expect(&parser p, token::token t) {`
`175`	`175`	`s += token::to_str(p.get_reader(), t);`
`176`	`176`	`s += ", found ";`
`177`	`177`	`s += token::to_str(p.get_reader(), p.peek());`
`178`		`- p.err(s);`
	`178`	`+ p.fatal(s);`
`179`	`179`	`}`
`180`	`180`	`}`
`181`	`181`
`@@ -186,7 +186,7 @@ fn spanned[T](uint lo, uint hi, &T node) -> common::spanned[T] {`
`186`	`186`	`fn parse_ident(&parser p) -> ast::ident {`
`187`	`187`	`alt (p.peek()) {`
`188`	`188`	`case (token::IDENT(?i, _)) { p.bump(); ret p.get_str(i); }`
`189`		`- case (_) { p.err("expecting ident"); fail; }`
	`189`	`+ case (_) { p.fatal("expecting ident"); fail; }`
`190`	`190`	`}`
`191`	`191`	`}`
`192`	`192`
`@@ -209,12 +209,12 @@ fn parse_str_lit_or_env_ident(&parser p) -> ast::ident {`
`209`	`209`	`eval::lookup(p.get_session(), p.get_env(), p.get_span(),`
`210`	`210`	`p.get_str(i));`
`211`	`211`	`if (!eval::val_is_str(v)) {`
`212`		`- p.err("expecting string-valued variable");`
	`212`	`+ p.fatal("expecting string-valued variable");`
`213`	`213`	`}`
`214`	`214`	`p.bump();`
`215`	`215`	`ret eval::val_as_str(v);`
`216`	`216`	`}`
`217`		`- case (_) { p.err("expecting string literal"); fail; }`
	`217`	`+ case (_) { p.fatal("expecting string literal"); fail; }`
`218`	`218`	`}`
`219`	`219`	`}`
`220`	`220`
`@@ -239,7 +239,7 @@ fn eat_word(&parser p, &str word) -> bool {`
`239`	`239`
`240`	`240`	`fn expect_word(&parser p, &str word) {`
`241`	`241`	`if (!eat_word(p, word)) {`
`242`		`- p.err("expecting " + word + ", found " +`
	`242`	`+ p.fatal("expecting " + word + ", found " +`
`243`	`243`	`token::to_str(p.get_reader(), p.peek()));`
`244`	`244`	`}`
`245`	`245`	`}`
`@@ -249,7 +249,7 @@ fn check_bad_word(&parser p) {`
`249`	`249`	`case (token::IDENT(?sid, false)) {`
`250`	`250`	`auto w = p.get_str(sid);`
`251`	`251`	`if (p.get_bad_expr_words().contains_key(w)) {`
`252`		`- p.err("found " + w + " in expression position");`
	`252`	`+ p.fatal("found " + w + " in expression position");`
`253`	`253`	`}`
`254`	`254`	`}`
`255`	`255`	`case (_) { }`
`@@ -436,7 +436,7 @@ fn parse_ty_postfix(@ast::ty orig_t, &parser p) -> @ast::ty {`
`436`	`436`	`ann));`
`437`	`437`	`}`
`438`	`438`	`case (_) {`
`439`		`- p.err("type parameter instantiation only allowed for " +`
	`439`	`+ p.fatal("type parameter instantiation only allowed for " +`
`440`	`440`	`"paths");`
`441`	`441`	`}`
`442`	`442`	`}`
`@@ -572,7 +572,7 @@ fn parse_ty(&parser p) -> @ast::ty {`
`572`	`572`	`auto path = parse_path(p);`
`573`	`573`	`t = ast::ty_path(path, p.get_id());`
`574`	`574`	`hi = path.span.hi;`
`575`		`- } else { p.err("expecting type"); t = ast::ty_nil; fail; }`
	`575`	`+ } else { p.fatal("expecting type"); t = ast::ty_nil; fail; }`
`576`	`576`	`ret parse_ty_postfix(@spanned(lo, hi, t), p);`
`577`	`577`	`}`
`578`	`578`
`@@ -917,7 +917,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {`
`917`	`917`	`if (/check/ast::is_call_expr(e)) {`
`918`	`918`	`hi = e.span.hi;`
`919`	`919`	`ex = ast::expr_be(e);`
`920`		`- } else { p.err("Non-call expression in tail call"); }`
	`920`	`+ } else { p.fatal("Non-call expression in tail call"); }`
`921`	`921`	`} else if (eat_word(p, "port")) {`
`922`	`922`	`expect(p, token::LPAREN);`
`923`	`923`	`expect(p, token::RPAREN);`
`@@ -982,7 +982,7 @@ fn expand_syntax_ext(&parser p, common::span sp, &ast::path path,`
`982`	`982`	`assert (vec::len(path.node.idents) > 0u);`
`983`	`983`	`auto extname = path.node.idents.(0);`
`984`	`984`	`alt (p.get_syntax_expanders().find(extname)) {`
`985`		`- case (none) { p.err("unknown syntax expander: '" + extname + "'"); }`
	`985`	`+ case (none) { p.fatal("unknown syntax expander: '" + extname + "'"); }`
`986`	`986`	`case (some(ext::x(?ext))) {`
`987`	`987`	`auto ext_cx = ext::mk_ctxt(p);`
`988`	`988`	`ret ast::expr_ext(path, args, body, ext(ext_cx, sp, args, body));`
`@@ -1313,7 +1313,7 @@ fn parse_alt_expr(&parser p) -> @ast::expr {`
`1313`	`1313`	`/* empty */`
`1314`	`1314`
`1315`	`1315`	`} else {`
`1316`		`- p.err("expected 'case' or '}' when parsing 'alt' statement " +`
	`1316`	`+ p.fatal("expected 'case' or '}' when parsing 'alt' statement " +`
`1317`	`1317`	`"but found " + token::to_str(p.get_reader(), p.peek()));`
`1318`	`1318`	`}`
`1319`	`1319`	`}`
`@@ -1391,7 +1391,7 @@ fn parse_pat(&parser p) -> @ast::pat {`
`1391`	`1391`	`ast::pat_bind(p.get_str(id), p.get_id());`
`1392`	`1392`	`}`
`1393`	`1393`	`case (?tok) {`
`1394`		`- p.err("expected identifier after '?' in pattern but " +`
	`1394`	`+ p.fatal("expected identifier after '?' in pattern but " +`
`1395`	`1395`	`"found " + token::to_str(p.get_reader(), tok));`
`1396`	`1396`	`fail;`
`1397`	`1397`	`}`
`@@ -1503,7 +1503,7 @@ fn parse_source_stmt(&parser p) -> @ast::stmt {`
`1503`	`1503`	`alt (maybe_item) {`
`1504`	`1504`	`case (got_item(_)) { /* fallthrough */ }`
`1505`	`1505`	`case (_) {`
`1506`		`- ret p.err("expected item");`
	`1506`	`+ ret p.fatal("expected item");`
`1507`	`1507`	`}`
`1508`	`1508`	`}`
`1509`	`1509`	`}`
`@@ -1528,7 +1528,7 @@ fn parse_source_stmt(&parser p) -> @ast::stmt {`
`1528`	`1528`	`}`
`1529`	`1529`	`}`
`1530`	`1530`	`}`
`1531`		`- p.err("expected statement");`
	`1531`	`+ p.fatal("expected statement");`
`1532`	`1532`	`fail;`
`1533`	`1533`	`}`
`1534`	`1534`
`@@ -1612,7 +1612,7 @@ fn parse_block(&parser p) -> ast::block {`
`1612`	`1612`	`case (token::RBRACE) { expr = some(e); }`
`1613`	`1613`	`case (?t) {`
`1614`	`1614`	`if (stmt_ends_with_semi(*stmt)) {`
`1615`		`- p.err("expected ';' or '}' after " +`
	`1615`	`+ p.fatal("expected ';' or '}' after " +`
`1616`	`1616`	`"expression but found " +`
`1617`	`1617`	`token::to_str(p.get_reader(),`
`1618`	`1618`	`t));`
`@@ -1798,7 +1798,7 @@ fn parse_mod_items(&parser p, token::token term,`
`1798`	`1798`	`alt (parse_item(p, attrs)) {`
`1799`	`1799`	`case (got_item(?i)) { vec::push(items, i); }`
`1800`	`1800`	`case (_) {`
`1801`		`- p.err("expected item but found " +`
	`1801`	`+ p.fatal("expected item but found " +`
`1802`	`1802`	`token::to_str(p.get_reader(), p.peek()));`
`1803`	`1803`	`}`
`1804`	`1804`	`}`
`@@ -1903,7 +1903,7 @@ fn parse_item_native_mod(&parser p, vec[ast::attribute] attrs) -> @ast::item {`
`1903`	`1903`	`abi = ast::native_abi_llvm;`
`1904`	`1904`	`} else if (str::eq(t, "rust-intrinsic")) {`
`1905`	`1905`	`abi = ast::native_abi_rust_intrinsic;`
`1906`		`- } else { p.err("unsupported abi: " + t); fail; }`
	`1906`	`+ } else { p.fatal("unsupported abi: " + t); fail; }`
`1907`	`1907`	`}`
`1908`	`1908`	`expect_word(p, "mod");`
`1909`	`1909`	`auto id = parse_ident(p);`
`@@ -1971,7 +1971,7 @@ fn parse_item_tag(&parser p, vec[ast::attribute] attrs) -> @ast::item {`
`1971`	`1971`	`}`
`1972`	`1972`	`case (token::RBRACE) {/* empty */ }`
`1973`	`1973`	`case (_) {`
`1974`		`- p.err("expected name of variant or '}' but found " +`
	`1974`	`+ p.fatal("expected name of variant or '}' but found " +`
`1975`	`1975`	`token::to_str(p.get_reader(), tok));`
`1976`	`1976`	`}`
`1977`	`1977`	`}`
`@@ -2104,7 +2104,7 @@ fn parse_inner_attrs_and_next(&parser p) -> tup(vec[ast::attribute],`
`2104`	`2104`	`fn parse_inner_attrs(&parser p) -> vec[ast::attribute] {`
`2105`	`2105`	`auto attrs_and_next = parse_inner_attrs_and_next(p);`
`2106`	`2106`	`if (vec::len(attrs_and_next._1) > 0u) {`
`2107`		`- ret p.err("expected crate directive but found " +`
	`2107`	`+ ret p.fatal("expected crate directive but found " +`
`2108`	`2108`	`token::to_str(p.get_reader(), p.peek()));`
`2109`	`2109`	`}`
`2110`	`2110`	`ret attrs_and_next._0;`
`@@ -2120,7 +2120,7 @@ fn parse_meta_item(&parser p) -> @ast::meta_item {`
`2120`	`2120`	`p.bump();`
`2121`	`2121`	`ret @spanned(lo, hi, rec(key=ident, value=p.get_str(s)));`
`2122`	`2122`	`}`
`2123`		`- case (_) { p.err("Metadata items must be string literals"); }`
	`2123`	`+ case (_) { p.fatal("Metadata items must be string literals"); }`
`2124`	`2124`	`}`
`2125`	`2125`	`fail;`
`2126`	`2126`	`}`
`@@ -2158,10 +2158,10 @@ fn parse_rest_import_name(&parser p, ast::ident first,`
`2158`	`2158`	`alt (p.peek()) {`
`2159`	`2159`	`case (token::SEMI) { p.bump(); break; }`
`2160`	`2160`	`case (token::MOD_SEP) {`
`2161`		`- if (glob) { p.err("cannot path into a glob"); }`
	`2161`	`+ if (glob) { p.fatal("cannot path into a glob"); }`
`2162`	`2162`	`p.bump();`
`2163`	`2163`	`}`
`2164`		`- case (_) { p.err("expecting '::' or ';'"); }`
	`2164`	`+ case (_) { p.fatal("expecting '::' or ';'"); }`
`2165`	`2165`	`}`
`2166`	`2166`	`alt (p.peek()) {`
`2167`	`2167`	`case (token::IDENT(_, _)) { identifiers += [parse_ident(p)]; }`
`@@ -2171,14 +2171,14 @@ fn parse_rest_import_name(&parser p, ast::ident first,`
`2171`	`2171`	`glob = true;`
`2172`	`2172`	`p.bump();`
`2173`	`2173`	`}`
`2174`		`- case (_) { p.err("expecting an identifier, or '*'"); }`
	`2174`	`+ case (_) { p.fatal("expecting an identifier, or '*'"); }`
`2175`	`2175`	`}`
`2176`	`2176`	`}`
`2177`	`2177`	`auto hi = p.get_hi_pos();`
`2178`	`2178`	`auto import_decl;`
`2179`	`2179`	`alt (def_ident) {`
`2180`	`2180`	`case (some(?i)) {`
`2181`		`- if (glob) { p.err("globbed imports can't be renamed"); }`
	`2181`	`+ if (glob) { p.fatal("globbed imports can't be renamed"); }`
`2182`	`2182`	`import_decl =`
`2183`	`2183`	`ast::view_item_import(i, identifiers, p.get_id());`
`2184`	`2184`	`}`
`@@ -2204,7 +2204,7 @@ fn parse_full_import_name(&parser p, ast::ident def_ident) ->`
`2204`	`2204`	`p.bump();`
`2205`	`2205`	`ret parse_rest_import_name(p, p.get_str(i), some(def_ident));`
`2206`	`2206`	`}`
`2207`		`- case (_) { p.err("expecting an identifier"); }`
	`2207`	`+ case (_) { p.fatal("expecting an identifier"); }`
`2208`	`2208`	`}`
`2209`	`2209`	`fail;`
`2210`	`2210`	`}`
`@@ -2223,7 +2223,7 @@ fn parse_import(&parser p) -> @ast::view_item {`
`2223`	`2223`	`}`
`2224`	`2224`	`}`
`2225`	`2225`	`}`
`2226`		`- case (_) { p.err("expecting an identifier"); }`
	`2226`	`+ case (_) { p.fatal("expecting an identifier"); }`
`2227`	`2227`	`}`
`2228`	`2228`	`fail;`
`2229`	`2229`	`}`