Move src/comp to src/rustc

1 files changed, 0 insertions, 2747 deletions

diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
deleted file mode 100644
index 5837baf1ff9..00000000000
--- a/src/comp/syntax/parse/parser.rs
+++ /dev/null
@@ -1,2747 +0,0 @@
-import std::{io, fs};
-import either::{left, right};
-import std::map::{hashmap, new_str_hash};
-import token::can_begin_expr;
-import codemap::{span,fss_none};
-import util::interner;
-import ast::{node_id, spanned};
-import ast_util::{mk_sp, ident_to_path};
-import front::attr;
-import lexer::reader;
-import driver::diagnostic;
-
-enum restriction {
-    UNRESTRICTED,
-    RESTRICT_STMT_EXPR,
-    RESTRICT_NO_CALL_EXPRS,
-    RESTRICT_NO_BAR_OP,
-}
-
-enum file_type { CRATE_FILE, SOURCE_FILE, }
-
-type parse_sess = @{
-    cm: codemap::codemap,
-    mutable next_id: node_id,
-    span_diagnostic: diagnostic::span_handler,
-    // these two must be kept up to date
-    mutable chpos: uint,
-    mutable byte_pos: uint
-};
-
-fn next_node_id(sess: parse_sess) -> 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;
-    ret rv;
-}
-
-type parser = @{
-    sess: parse_sess,
-    cfg: ast::crate_cfg,
-    file_type: file_type,
-    mutable token: token::token,
-    mutable span: span,
-    mutable last_span: span,
-    mutable buffer: [{tok: token::token, span: span}],
-    mutable restriction: restriction,
-    reader: reader,
-    precs: @[op_spec],
-    bad_expr_words: hashmap<str, ()>
-};
-
-impl parser for parser {
-    fn bump() {
-        self.last_span = self.span;
-        if vec::len(self.buffer) == 0u {
-            let next = lexer::next_token(self.reader);
-            self.token = next.tok;
-            self.span = ast_util::mk_sp(next.chpos, self.reader.chpos);
-        } else {
-            let next = vec::pop(self.buffer);
-            self.token = next.tok;
-            self.span = next.span;
-        }
-    }
-    fn swap(next: token::token, lo: uint, hi: uint) {
-        self.token = next;
-        self.span = ast_util::mk_sp(lo, hi);
-    }
-    fn look_ahead(distance: uint) -> token::token {
-        while vec::len(self.buffer) < distance {
-            let next = lexer::next_token(self.reader);
-            let sp = ast_util::mk_sp(next.chpos, self.reader.chpos);
-            self.buffer = [{tok: next.tok, span: sp}] + self.buffer;
-        }
-        ret self.buffer[distance - 1u].tok;
-    }
-    fn fatal(m: str) -> ! {
-        self.sess.span_diagnostic.span_fatal(self.span, m)
-    }
-    fn span_fatal(sp: span, m: str) -> ! {
-        self.sess.span_diagnostic.span_fatal(sp, m)
-    }
-    fn warn(m: str) {
-        self.sess.span_diagnostic.span_warn(self.span, m)
-    }
-    fn get_str(i: token::str_num) -> str {
-        interner::get(*self.reader.interner, i)
-    }
-    fn get_id() -> node_id { next_node_id(self.sess) }
-}
-
-fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
-                        ftype: file_type) ->
-   parser {
-    let src = alt io::read_whole_file_str(path) {
-      result::ok(src) {
-        // FIXME: This copy is unfortunate
-        @src
-      }
-      result::err(e) {
-        sess.span_diagnostic.handler().fatal(e)
-      }
-    };
-    let filemap = codemap::new_filemap(path, src,
-                                       sess.chpos, sess.byte_pos);
-    sess.cm.files += [filemap];
-    let itr = @interner::mk(str::hash, str::eq);
-    let rdr = lexer::new_reader(sess.cm, sess.span_diagnostic, filemap, itr);
-    ret new_parser(sess, cfg, rdr, ftype);
-}
-
-fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
-                              name: str, ss: codemap::file_substr,
-                              source: @str) -> parser {
-    let ftype = SOURCE_FILE;
-    let filemap = codemap::new_filemap_w_substr
-        (name, ss, source, sess.chpos, sess.byte_pos);
-    sess.cm.files += [filemap];
-    let itr = @interner::mk(str::hash, str::eq);
-    let rdr = lexer::new_reader(sess.cm, sess.span_diagnostic,
-                                filemap, itr);
-    ret new_parser(sess, cfg, rdr, ftype);
-}
-
-fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader,
-              ftype: file_type) -> parser {
-    let tok0 = lexer::next_token(rdr);
-    let span0 = ast_util::mk_sp(tok0.chpos, rdr.chpos);
-    @{sess: sess,
-      cfg: cfg,
-      file_type: ftype,
-      mutable token: tok0.tok,
-      mutable span: span0,
-      mutable last_span: span0,
-      mutable buffer: [],
-      mutable restriction: UNRESTRICTED,
-      reader: rdr,
-      precs: prec_table(),
-      bad_expr_words: bad_expr_word_table()}
-}
-
-// These are the words that shouldn't be allowed as value identifiers,
-// because, if used at the start of a line, they will cause the line to be
-// interpreted as a specific kind of statement, which would be confusing.
-fn bad_expr_word_table() -> hashmap<str, ()> {
-    let words = new_str_hash();
-    for word in ["alt", "assert", "be", "break", "check", "claim",
-                 "class", "const", "cont", "copy", "do", "else", "enum",
-                 "export", "fail", "fn", "for", "if",  "iface", "impl",
-                 "import", "let", "log", "mod", "mutable", "native", "pure",
-                 "resource", "ret", "trait", "type", "unchecked", "unsafe",
-                 "while", "crust", "mut"] {
-        words.insert(word, ());
-    }
-    words
-}
-
-fn unexpected(p: parser, t: token::token) -> ! {
-    let s: str = "unexpected token: '" + token::to_str(p.reader, t) +
-        "'";
-    p.fatal(s);
-}
-
-fn expect(p: parser, t: token::token) {
-    if p.token == t {
-        p.bump();
-    } else {
-        let s: str = "expecting '";
-        s += token::to_str(p.reader, t);
-        s += "' but found '";
-        s += token::to_str(p.reader, p.token);
-        p.fatal(s + "'");
-    }
-}
-
-fn expect_gt(p: parser) {
-    if p.token == token::GT {
-        p.bump();
-    } else if p.token == token::BINOP(token::LSR) {
-        p.swap(token::GT, p.span.lo + 1u, p.span.hi);
-    } else if p.token == token::BINOP(token::ASR) {
-        p.swap(token::BINOP(token::LSR), p.span.lo + 1u, p.span.hi);
-    } else {
-        let s: str = "expecting ";
-        s += token::to_str(p.reader, token::GT);
-        s += ", found ";
-        s += token::to_str(p.reader, p.token);
-        p.fatal(s);
-    }
-}
-
-fn spanned<T: copy>(lo: uint, hi: uint, node: T) -> spanned<T> {
-    ret {node: node, span: ast_util::mk_sp(lo, hi)};
-}
-
-fn parse_ident(p: parser) -> ast::ident {
-    alt p.token {
-      token::IDENT(i, _) { p.bump(); ret p.get_str(i); }
-      _ { p.fatal("expecting ident, found "
-                  + token::to_str(p.reader, p.token)); }
-    }
-}
-
-fn parse_path_list_ident(p: parser) -> ast::path_list_ident {
-    let lo = p.span.lo;
-    let ident = parse_ident(p);
-    let hi = p.span.hi;
-    ret spanned(lo, hi, {name: ident, id: p.get_id()});
-}
-
-fn parse_value_ident(p: parser) -> ast::ident {
-    check_bad_word(p);
-    ret parse_ident(p);
-}
-
-fn eat(p: parser, tok: token::token) -> bool {
-    ret if p.token == tok { p.bump(); true } else { false };
-}
-
-fn is_word(p: parser, word: str) -> bool {
-    ret alt p.token {
-          token::IDENT(sid, false) { str::eq(word, p.get_str(sid)) }
-          _ { false }
-        };
-}
-
-fn eat_word(p: parser, word: str) -> bool {
-    alt p.token {
-      token::IDENT(sid, false) {
-        if str::eq(word, p.get_str(sid)) {
-            p.bump();
-            ret true;
-        } else { ret false; }
-      }
-      _ { ret false; }
-    }
-}
-
-fn expect_word(p: parser, word: str) {
-    if !eat_word(p, word) {
-        p.fatal("expecting " + word + ", found " +
-                    token::to_str(p.reader, p.token));
-    }
-}
-
-fn check_bad_word(p: parser) {
-    alt p.token {
-      token::IDENT(sid, false) {
-        let w = p.get_str(sid);
-        if p.bad_expr_words.contains_key(w) {
-            p.fatal("found " + w + " in expression position");
-        }
-      }
-      _ { }
-    }
-}
-
-fn parse_ty_fn(p: parser) -> ast::fn_decl {
-    fn parse_fn_input_ty(p: parser) -> ast::arg {
-        let mode = parse_arg_mode(p);
-        let name = if is_plain_ident(p) && p.look_ahead(1u) == token::COLON {
-            let name = parse_value_ident(p);
-            p.bump();
-            name
-        } else { "" };
-        ret {mode: mode, ty: parse_ty(p, false), ident: name, id: p.get_id()};
-    }
-    let inputs =
-        parse_seq(token::LPAREN, token::RPAREN, seq_sep(token::COMMA),
-                  parse_fn_input_ty, p);
-    // FIXME: there's no syntax for this right now anyway
-    //  auto constrs = parse_constrs(~[], p);
-    let constrs: [@ast::constr] = [];
-    let (ret_style, ret_ty) = parse_ret_ty(p);
-    ret {inputs: inputs.node, output: ret_ty,
-         purity: ast::impure_fn, cf: ret_style,
-         constraints: constrs};
-}
-
-fn parse_ty_methods(p: parser) -> [ast::ty_method] {
-    parse_seq(token::LBRACE, token::RBRACE, seq_sep_none(), {|p|
-        let attrs = parse_outer_attributes(p);
-        let flo = p.span.lo;
-        let pur = parse_fn_purity(p);
-        let ident = parse_method_name(p);
-        let tps = parse_ty_params(p);
-        let d = parse_ty_fn(p), fhi = p.last_span.hi;
-        expect(p, token::SEMI);
-        {ident: ident, attrs: attrs, decl: {purity: pur with d}, tps: tps,
-         span: ast_util::mk_sp(flo, fhi)}
-    }, p).node
-}
-
-fn parse_mt(p: parser) -> ast::mt {
-    let mutbl = parse_mutability(p);
-    let t = parse_ty(p, false);
-    ret {ty: t, mutbl: mutbl};
-}
-
-fn parse_ty_field(p: parser) -> ast::ty_field {
-    let lo = p.span.lo;
-    let mutbl = parse_mutability(p);
-    let id = parse_ident(p);
-    expect(p, token::COLON);
-    let ty = parse_ty(p, false);
-    ret spanned(lo, ty.span.hi, {ident: id, mt: {ty: ty, mutbl: mutbl}});
-}
-
-// if i is the jth ident in args, return j
-// otherwise, fail
-fn ident_index(p: parser, args: [ast::arg], i: ast::ident) -> uint {
-    let j = 0u;
-    for a: ast::arg in args { if a.ident == i { ret j; } j += 1u; }
-    p.fatal("Unbound variable " + i + " in constraint arg");
-}
-
-fn parse_type_constr_arg(p: parser) -> @ast::ty_constr_arg {
-    let sp = p.span;
-    let carg = ast::carg_base;
-    expect(p, token::BINOP(token::STAR));
-    if p.token == token::DOT {
-        // "*..." notation for record fields
-        p.bump();
-        let pth = parse_path(p);
-        carg = ast::carg_ident(pth);
-    }
-    // No literals yet, I guess?
-    ret @{node: carg, span: sp};
-}
-
-fn parse_constr_arg(args: [ast::arg], p: parser) -> @ast::constr_arg {
-    let sp = p.span;
-    let carg = ast::carg_base;
-    if p.token == token::BINOP(token::STAR) {
-        p.bump();
-    } else {
-        let i: ast::ident = parse_value_ident(p);
-        carg = ast::carg_ident(ident_index(p, args, i));
-    }
-    ret @{node: carg, span: sp};
-}
-
-fn parse_ty_constr(fn_args: [ast::arg], p: parser) -> @ast::constr {
-    let lo = p.span.lo;
-    let path = parse_path(p);
-    let args: {node: [@ast::constr_arg], span: span} =
-        parse_seq(token::LPAREN, token::RPAREN, seq_sep(token::COMMA),
-                  {|p| parse_constr_arg(fn_args, p)}, p);
-    ret @spanned(lo, args.span.hi,
-                 {path: path, args: args.node, id: p.get_id()});
-}
-
-fn parse_constr_in_type(p: parser) -> @ast::ty_constr {
-    let lo = p.span.lo;
-    let path = parse_path(p);
-    let args: [@ast::ty_constr_arg] =
-        parse_seq(token::LPAREN, token::RPAREN, seq_sep(token::COMMA),
-                  parse_type_constr_arg, p).node;
-    let hi = p.span.lo;
-    let tc: ast::ty_constr_ = {path: path, args: args, id: p.get_id()};
-    ret @spanned(lo, hi, tc);
-}
-
-
-fn parse_constrs<T: copy>(pser: fn(parser) -> @ast::constr_general<T>,
-                         p: parser) ->
-   [@ast::constr_general<T>] {
-    let constrs: [@ast::constr_general<T>] = [];
-    while true {
-        let constr = pser(p);
-        constrs += [constr];
-        if p.token == token::COMMA { p.bump(); } else { break; }
-    }
-    constrs
-}
-
-fn parse_type_constraints(p: parser) -> [@ast::ty_constr] {
-    ret parse_constrs(parse_constr_in_type, p);
-}
-
-fn parse_ty_postfix(orig_t: ast::ty_, p: parser, colons_before_params: bool,
-                    lo: uint) -> @ast::ty {
-    if colons_before_params && p.token == token::MOD_SEP {
-        p.bump();
-        expect(p, token::LT);
-    } else if !colons_before_params && p.token == token::LT {
-        p.bump();
-    } else { ret @spanned(lo, p.last_span.hi, orig_t); }
-
-    // If we're here, we have explicit type parameter instantiation.
-    let seq = parse_seq_to_gt(some(token::COMMA), {|p| parse_ty(p, false)},
-                              p);
-
-    alt orig_t {
-      ast::ty_path(pth, ann) {
-        ret @spanned(lo, p.last_span.hi,
-                     ast::ty_path(@spanned(lo, p.last_span.hi,
-                                           {global: pth.node.global,
-                                            idents: pth.node.idents,
-                                            types: seq}), ann));
-      }
-      _ { p.fatal("type parameter instantiation only allowed for paths"); }
-    }
-}
-
-fn parse_ret_ty(p: parser) -> (ast::ret_style, @ast::ty) {
-    ret if eat(p, token::RARROW) {
-        let lo = p.span.lo;
-        if eat(p, token::NOT) {
-            (ast::noreturn, @spanned(lo, p.last_span.hi, ast::ty_bot))
-        } else { (ast::return_val, parse_ty(p, false)) }
-    } else {
-        let pos = p.span.lo;
-        (ast::return_val, @spanned(pos, pos, ast::ty_nil))
-    }
-}
-
-fn parse_ty(p: parser, colons_before_params: bool) -> @ast::ty {
-    let lo = p.span.lo;
-
-    alt have_dollar(p) {
-      some(e) {ret @spanned(lo, p.span.hi,
-                            ast::ty_mac(spanned(lo, p.span.hi, e)))}
-      none {}
-    }
-
-    let t = if p.token == token::LPAREN {
-        p.bump();
-        if p.token == token::RPAREN {
-            p.bump();
-            ast::ty_nil
-        } else {
-            let ts = [parse_ty(p, false)];
-            while p.token == token::COMMA {
-                p.bump();
-                ts += [parse_ty(p, false)];
-            }
-            let t = if vec::len(ts) == 1u { ts[0].node }
-                    else { ast::ty_tup(ts) };
-            expect(p, token::RPAREN);
-            t
-        }
-    } else if p.token == token::AT {
-        p.bump();
-        ast::ty_box(parse_mt(p))
-    } else if p.token == token::TILDE {
-        p.bump();
-        ast::ty_uniq(parse_mt(p))
-    } else if p.token == token::BINOP(token::STAR) {
-        p.bump();
-        ast::ty_ptr(parse_mt(p))
-    } else if p.token == token::LBRACE {
-        let elems =
-            parse_seq(token::LBRACE, token::RBRACE, seq_sep_opt(token::COMMA),
-                      parse_ty_field, p);
-        if vec::len(elems.node) == 0u { unexpected(p, token::RBRACE); }
-        let hi = elems.span.hi;
-
-        let t = ast::ty_rec(elems.node);
-        if p.token == token::COLON {
-            p.bump();
-            ast::ty_constr(@spanned(lo, hi, t), parse_type_constraints(p))
-        } else { t }
-    } else if p.token == token::LBRACKET {
-        expect(p, token::LBRACKET);
-        let t = ast::ty_vec(parse_mt(p));
-        expect(p, token::RBRACKET);
-        t
-    } else if eat_word(p, "fn") {
-        let proto = parse_fn_ty_proto(p);
-        alt proto {
-          ast::proto_bare { p.warn("fn is deprecated, use native fn"); }
-          _ { /* fallthrough */ }
-        }
-        ast::ty_fn(proto, parse_ty_fn(p))
-    } else if eat_word(p, "native") {
-        expect_word(p, "fn");
-        ast::ty_fn(ast::proto_bare, parse_ty_fn(p))
-    } else if p.token == token::MOD_SEP || is_ident(p.token) {
-        let path = parse_path(p);
-        ast::ty_path(path, p.get_id())
-    } else { p.fatal("expecting type"); };
-    ret parse_ty_postfix(t, p, colons_before_params, lo);
-}
-
-fn parse_arg_mode(p: parser) -> ast::mode {
-    if eat(p, token::BINOP(token::AND)) {
-        ast::expl(ast::by_mutbl_ref)
-    } else if eat(p, token::BINOP(token::MINUS)) {
-        ast::expl(ast::by_move)
-    } else if eat(p, token::ANDAND) {
-        ast::expl(ast::by_ref)
-    } else if eat(p, token::BINOP(token::PLUS)) {
-        if eat(p, token::BINOP(token::PLUS)) {
-            ast::expl(ast::by_val)
-        } else {
-            ast::expl(ast::by_copy)
-        }
-    } else { ast::infer(p.get_id()) }
-}
-
-fn parse_arg(p: parser) -> ast::arg {
-    let m = parse_arg_mode(p);
-    let i = parse_value_ident(p);
-    expect(p, token::COLON);
-    let t = parse_ty(p, false);
-    ret {mode: m, ty: t, ident: i, id: p.get_id()};
-}
-
-fn parse_fn_block_arg(p: parser) -> ast::arg {
-    let m = parse_arg_mode(p);
-    let i = parse_value_ident(p);
-    let t = if eat(p, token::COLON) {
-                parse_ty(p, false)
-            } else {
-                @spanned(p.span.lo, p.span.hi, ast::ty_infer)
-            };
-    ret {mode: m, ty: t, ident: i, id: p.get_id()};
-}
-
-fn parse_seq_to_before_gt<T: copy>(sep: option<token::token>,
-                                  f: fn(parser) -> T,
-                                  p: parser) -> [T] {
-    let first = true;
-    let v = [];
-    while p.token != token::GT && p.token != token::BINOP(token::LSR) &&
-              p.token != token::BINOP(token::ASR) {
-        alt sep {
-          some(t) { if first { first = false; } else { expect(p, t); } }
-          _ { }
-        }
-        v += [f(p)];
-    }
-
-    ret v;
-}
-
-fn parse_seq_to_gt<T: copy>(sep: option<token::token>,
-                           f: fn(parser) -> T, p: parser) -> [T] {
-    let v = parse_seq_to_before_gt(sep, f, p);
-    expect_gt(p);
-
-    ret v;
-}
-
-fn parse_seq_lt_gt<T: copy>(sep: option<token::token>,
-                           f: fn(parser) -> T,
-                           p: parser) -> spanned<[T]> {
-    let lo = p.span.lo;
-    expect(p, token::LT);
-    let result = parse_seq_to_before_gt::<T>(sep, f, p);
-    let hi = p.span.hi;
-    expect_gt(p);
-    ret spanned(lo, hi, result);
-}
-
-fn parse_seq_to_end<T: copy>(ket: token::token, sep: seq_sep,
-                            f: fn(parser) -> T, p: parser) -> [T] {
-    let val = parse_seq_to_before_end(ket, sep, f, p);
-    p.bump();
-    ret val;
-}
-
-type seq_sep = {
-    sep: option<token::token>,
-    trailing_opt: bool   // is trailing separator optional?
-};
-
-fn seq_sep(t: token::token) -> seq_sep {
-    ret {sep: option::some(t), trailing_opt: false};
-}
-fn seq_sep_opt(t: token::token) -> seq_sep {
-    ret {sep: option::some(t), trailing_opt: true};
-}
-fn seq_sep_none() -> seq_sep {
-    ret {sep: option::none, trailing_opt: false};
-}
-
-fn parse_seq_to_before_end<T: copy>(ket: token::token,
-                                   sep: seq_sep,
-                                   f: fn(parser) -> T, p: parser) -> [T] {
-    let first: bool = true;
-    let v: [T] = [];
-    while p.token != ket {
-        alt sep.sep {
-          some(t) { if first { first = false; } else { expect(p, t); } }
-          _ { }
-        }
-        if sep.trailing_opt && p.token == ket { break; }
-        v += [f(p)];
-    }
-    ret v;
-}
-
-
-fn parse_seq<T: copy>(bra: token::token, ket: token::token,
-                     sep: seq_sep, f: fn(parser) -> T,
-                     p: parser) -> spanned<[T]> {
-    let lo = p.span.lo;
-    expect(p, bra);
-    let result = parse_seq_to_before_end::<T>(ket, sep, f, p);
-    let hi = p.span.hi;
-    p.bump();
-    ret spanned(lo, hi, result);
-}
-
-fn have_dollar(p: parser) -> option::t<ast::mac_> {
-    alt p.token {
-      token::DOLLAR_NUM(num) {
-        p.bump();
-        some(ast::mac_var(num))
-      }
-      token::DOLLAR_LPAREN {
-        let lo = p.span.lo;
-        p.bump();
-        let e = parse_expr(p);
-        expect(p, token::RPAREN);
-        let hi = p.last_span.hi;
-        some(ast::mac_aq(ast_util::mk_sp(lo,hi), e))
-      }
-      _ {none}
-    }
-}
-
-fn lit_from_token(p: parser, tok: token::token) -> ast::lit_ {
-    alt tok {
-      token::LIT_INT(i, it) { ast::lit_int(i, it) }
-      token::LIT_UINT(u, ut) { ast::lit_uint(u, ut) }
-      token::LIT_FLOAT(s, ft) { ast::lit_float(p.get_str(s), ft) }
-      token::LIT_STR(s) { ast::lit_str(p.get_str(s)) }
-      token::LPAREN { expect(p, token::RPAREN); ast::lit_nil }
-      _ { unexpected(p, tok); }
-    }
-}
-
-fn parse_lit(p: parser) -> ast::lit {
-    let sp = p.span;
-    let lit = if eat_word(p, "true") {
-        ast::lit_bool(true)
-    } else if eat_word(p, "false") {
-        ast::lit_bool(false)
-    } else {
-        let tok = p.token;
-        p.bump();
-        lit_from_token(p, tok)
-    };
-    ret {node: lit, span: sp};
-}
-
-fn is_ident(t: token::token) -> bool {
-    alt t { token::IDENT(_, _) { ret true; } _ { } }
-    ret false;
-}
-
-fn is_plain_ident(p: parser) -> bool {
-    ret alt p.token { token::IDENT(_, false) { true } _ { false } };
-}
-
-fn parse_path(p: parser) -> @ast::path {
-    let lo = p.span.lo;
-    let global = eat(p, token::MOD_SEP), ids = [parse_ident(p)];
-    while p.look_ahead(1u) != token::LT && eat(p, token::MOD_SEP) {
-        ids += [parse_ident(p)];
-    }
-    ret @spanned(lo, p.last_span.hi,
-                 {global: global, idents: ids, types: []});
-}
-
-fn parse_value_path(p: parser) -> @ast::path {
-    let pt = parse_path(p);
-    let last_word = pt.node.idents[vec::len(pt.node.idents)-1u];
-    if p.bad_expr_words.contains_key(last_word) {
-        p.fatal("found " + last_word + " in expression position");
-    }
-    pt
-}
-
-fn parse_path_and_ty_param_substs(p: parser, colons: bool) -> @ast::path {
-    let lo = p.span.lo;
-    let path = parse_path(p);
-    let b = if colons {
-                eat(p, token::MOD_SEP)
-            } else {
-                p.token == token::LT
-            };
-    if b {
-        let seq = parse_seq_lt_gt(some(token::COMMA),
-                                  {|p| parse_ty(p, false)}, p);
-        @spanned(lo, seq.span.hi, {types: seq.node with path.node})
-    } else { path }
-}
-
-fn parse_mutability(p: parser) -> ast::mutability {
-    if eat_word(p, "mutable") {
-        ast::m_mutbl
-    } else if eat_word(p, "mut") {
-        ast::m_mutbl
-    } else if eat_word(p, "const") {
-        ast::m_const
-    } else {
-        ast::m_imm
-    }
-}
-
-fn parse_field(p: parser, sep: token::token) -> ast::field {
-    let lo = p.span.lo;
-    let m = parse_mutability(p);
-    let i = parse_ident(p);
-    expect(p, sep);
-    let e = parse_expr(p);
-    ret spanned(lo, e.span.hi, {mutbl: m, ident: i, expr: e});
-}
-
-fn mk_expr(p: parser, lo: uint, hi: uint, node: ast::expr_) -> @ast::expr {
-    ret @{id: p.get_id(), node: node, span: ast_util::mk_sp(lo, hi)};
-}
-
-fn mk_mac_expr(p: parser, lo: uint, hi: uint, m: ast::mac_) -> @ast::expr {
-    ret @{id: p.get_id(),
-          node: ast::expr_mac({node: m, span: ast_util::mk_sp(lo, hi)}),
-          span: ast_util::mk_sp(lo, hi)};
-}
-
-fn is_bar(t: token::token) -> bool {
-    alt t { token::BINOP(token::OR) | token::OROR { true } _ { false } }
-}
-
-fn mk_lit_u32(p: parser, i: u32) -> @ast::expr {
-    let span = p.span;
-    let lv_lit = @{node: ast::lit_uint(i as u64, ast::ty_u32),
-                   span: span};
-
-    ret @{id: p.get_id(), node: ast::expr_lit(lv_lit), span: span};
-}
-
-// We don't allow single-entry tuples in the true AST; that indicates a
-// parenthesized expression.  However, we preserve them temporarily while
-// parsing because `(while{...})+3` parses differently from `while{...}+3`.
-//
-// To reflect the fact that the @ast::expr is not a true expr that should be
-// part of the AST, we wrap such expressions in the pexpr enum.  They
-// can then be converted to true expressions by a call to `to_expr()`.
-enum pexpr {
-    pexpr(@ast::expr),
-}
-
-fn mk_pexpr(p: parser, lo: uint, hi: uint, node: ast::expr_) -> pexpr {
-    ret pexpr(mk_expr(p, lo, hi, node));
-}
-
-fn to_expr(e: pexpr) -> @ast::expr {
-    alt e.node {
-      ast::expr_tup(es) if vec::len(es) == 1u { es[0u] }
-      _ { *e }
-    }
-}
-
-fn parse_bottom_expr(p: parser) -> pexpr {
-    let lo = p.span.lo;
-    let hi = p.span.hi;
-
-    let ex: ast::expr_;
-
-    alt have_dollar(p) {
-      some(x) {ret pexpr(mk_mac_expr(p, lo, p.span.hi, x));}
-      _ {}
-    }
-
-    if p.token == token::LPAREN {
-        p.bump();
-        if p.token == token::RPAREN {
-            hi = p.span.hi;
-            p.bump();
-            let lit = @spanned(lo, hi, ast::lit_nil);
-            ret mk_pexpr(p, lo, hi, ast::expr_lit(lit));
-        }
-        let es = [parse_expr(p)];
-        while p.token == token::COMMA { p.bump(); es += [parse_expr(p)]; }
-        hi = p.span.hi;
-        expect(p, token::RPAREN);
-
-        // Note: we retain the expr_tup() even for simple
-        // parenthesized expressions, but only for a "little while".
-        // This is so that wrappers around parse_bottom_expr()
-        // can tell whether the expression was parenthesized or not,
-        // which affects expr_is_complete().
-        ret mk_pexpr(p, lo, hi, ast::expr_tup(es));
-    } else if p.token == token::LBRACE {
-        p.bump();
-        if is_word(p, "mut") || is_word(p, "mutable") ||
-               is_plain_ident(p) && p.look_ahead(1u) == token::COLON {
-            let fields = [parse_field(p, token::COLON)];
-            let base = none;
-            while p.token != token::RBRACE {
-                if eat_word(p, "with") { base = some(parse_expr(p)); break; }
-                expect(p, token::COMMA);
-                if p.token == token::RBRACE {
-                    // record ends by an optional trailing comma
-                    break;
-                }
-                fields += [parse_field(p, token::COLON)];
-            }
-            hi = p.span.hi;
-            expect(p, token::RBRACE);
-            ex = ast::expr_rec(fields, base);
-        } else if is_bar(p.token) {
-            ret pexpr(parse_fn_block_expr(p));
-        } else {
-            let blk = parse_block_tail(p, lo, ast::default_blk);
-            ret mk_pexpr(p, blk.span.lo, blk.span.hi, ast::expr_block(blk));
-        }
-    } else if eat_word(p, "if") {
-        ret pexpr(parse_if_expr(p));
-    } else if eat_word(p, "for") {
-        ret pexpr(parse_for_expr(p));
-    } else if eat_word(p, "while") {
-        ret pexpr(parse_while_expr(p));
-    } else if eat_word(p, "do") {
-        ret pexpr(parse_do_while_expr(p));
-    } else if eat_word(p, "alt") {
-        ret pexpr(parse_alt_expr(p));
-    } else if eat_word(p, "fn") {
-        let proto = parse_fn_ty_proto(p);
-        alt proto {
-          ast::proto_bare { p.fatal("fn expr are deprecated, use fn@"); }
-          ast::proto_any { p.fatal("fn* cannot be used in an expression"); }
-          _ { /* fallthrough */ }
-        }
-        ret pexpr(parse_fn_expr(p, proto));
-    } else if eat_word(p, "unchecked") {
-        ret pexpr(parse_block_expr(p, lo, ast::unchecked_blk));
-    } else if eat_word(p, "unsafe") {
-        ret pexpr(parse_block_expr(p, lo, ast::unsafe_blk));
-    } else if p.token == token::LBRACKET {
-        p.bump();
-        let mutbl = parse_mutability(p);
-        let es =
-            parse_seq_to_end(token::RBRACKET, seq_sep(token::COMMA),
-                             parse_expr, p);
-        ex = ast::expr_vec(es, mutbl);
-    } else if p.token == token::POUND_LT {
-        p.bump();
-        let ty = parse_ty(p, false);
-        expect(p, token::GT);
-
-        /* hack: early return to take advantage of specialized function */
-        ret pexpr(mk_mac_expr(p, lo, p.span.hi,
-                              ast::mac_embed_type(ty)));
-    } else if p.token == token::POUND_LBRACE {
-        p.bump();
-        let blk = ast::mac_embed_block(
-            parse_block_tail(p, lo, ast::default_blk));
-        ret pexpr(mk_mac_expr(p, lo, p.span.hi, blk));
-    } else if p.token == token::ELLIPSIS {
-        p.bump();
-        ret pexpr(mk_mac_expr(p, lo, p.span.hi, ast::mac_ellipsis));
-    } else if eat_word(p, "bind") {
-        let e = parse_expr_res(p, RESTRICT_NO_CALL_EXPRS);
-        let es =
-            parse_seq(token::LPAREN, token::RPAREN, seq_sep(token::COMMA),
-                      parse_expr_or_hole, p);
-        hi = es.span.hi;
-        ex = ast::expr_bind(e, es.node);
-    } else if p.token == token::POUND {
-        let ex_ext = parse_syntax_ext(p);
-        hi = ex_ext.span.hi;
-        ex = ex_ext.node;
-    } else if eat_word(p, "fail") {
-        if can_begin_expr(p.token) {
-            let e = parse_expr(p);
-            hi = e.span.hi;
-            ex = ast::expr_fail(some(e));
-        } else { ex = ast::expr_fail(none); }
-    } else if eat_word(p, "log") {
-        expect(p, token::LPAREN);
-        let lvl = parse_expr(p);
-        expect(p, token::COMMA);
-        let e = parse_expr(p);
-        ex = ast::expr_log(2, lvl, e);
-        hi = p.span.hi;
-        expect(p, token::RPAREN);
-    } else if eat_word(p, "assert") {
-        let e = parse_expr(p);
-        ex = ast::expr_assert(e);
-        hi = e.span.hi;
-    } else if eat_word(p, "check") {
-        /* Should be a predicate (pure boolean function) applied to
-           arguments that are all either slot variables or literals.
-           but the typechecker enforces that. */
-        let e = parse_expr(p);
-        hi = e.span.hi;
-        ex = ast::expr_check(ast::checked_expr, e);
-    } else if eat_word(p, "claim") {
-        /* Same rules as check, except that if check-claims
-         is enabled (a command-line flag), then the parser turns
-        claims into check */
-
-        let e = parse_expr(p);
-        hi = e.span.hi;
-        ex = ast::expr_check(ast::claimed_expr, e);
-    } else if eat_word(p, "ret") {
-        if can_begin_expr(p.token) {
-            let e = parse_expr(p);
-            hi = e.span.hi;
-            ex = ast::expr_ret(some(e));
-        } else { ex = ast::expr_ret(none); }
-    } else if eat_word(p, "break") {
-        ex = ast::expr_break;
-        hi = p.span.hi;
-    } else if eat_word(p, "cont") {
-        ex = ast::expr_cont;
-        hi = p.span.hi;
-    } else if eat_word(p, "be") {
-        let e = parse_expr(p);
-
-        // FIXME: Is this the right place for this check?
-        if /*check*/ast_util::is_call_expr(e) {
-            hi = e.span.hi;
-            ex = ast::expr_be(e);
-        } else { p.fatal("Non-call expression in tail call"); }
-    } else if eat_word(p, "copy") {
-        let e = parse_expr(p);
-        ex = ast::expr_copy(e);
-        hi = e.span.hi;
-    } else if p.token == token::MOD_SEP ||
-                  is_ident(p.token) && !is_word(p, "true") &&
-                      !is_word(p, "false") {
-        check_bad_word(p);
-        let pth = parse_path_and_ty_param_substs(p, true);
-        hi = pth.span.hi;
-        ex = ast::expr_path(pth);
-    } else {
-        let lit = parse_lit(p);
-        hi = lit.span.hi;
-        ex = ast::expr_lit(@lit);
-    }
-    ret mk_pexpr(p, lo, hi, ex);
-}
-
-fn parse_block_expr(p: parser,
-                    lo: uint,
-                    blk_mode: ast::blk_check_mode) -> @ast::expr {
-    expect(p, token::LBRACE);
-    let blk = parse_block_tail(p, lo, blk_mode);
-    ret mk_expr(p, blk.span.lo, blk.span.hi, ast::expr_block(blk));
-}
-
-fn parse_syntax_ext(p: parser) -> @ast::expr {
-    let lo = p.span.lo;
-    expect(p, token::POUND);
-    ret parse_syntax_ext_naked(p, lo);
-}
-
-fn parse_syntax_ext_naked(p: parser, lo: uint) -> @ast::expr {
-    alt p.token {
-      token::IDENT(_, _) {}
-      _ { p.fatal("expected a syntax expander name"); }
-    }
-    let pth = parse_path(p);
-    //temporary for a backwards-compatible cycle:
-    let sep = seq_sep(token::COMMA);
-    let e = none;
-    if (p.token == token::LPAREN || p.token == token::LBRACKET) {
-        let es =
-            if p.token == token::LPAREN {
-                parse_seq(token::LPAREN, token::RPAREN,
-                          sep, parse_expr, p)
-            } else {
-                parse_seq(token::LBRACKET, token::RBRACKET,
-                          sep, parse_expr, p)
-            };
-        let hi = es.span.hi;
-        e = some(mk_expr(p, es.span.lo, hi,
-                         ast::expr_vec(es.node, ast::m_imm)));
-    }
-    let b = none;
-    if p.token == token::LBRACE {
-        p.bump();
-        let lo = p.span.lo;
-        let depth = 1u;
-        while (depth > 0u) {
-            alt (p.token) {
-              token::LBRACE {depth += 1u;}
-              token::RBRACE {depth -= 1u;}
-              token::EOF {p.fatal("unexpected EOF in macro body");}
-              _ {}
-            }
-            p.bump();
-        }
-        let hi = p.last_span.lo;
-        b = some({span: mk_sp(lo,hi)});
-    }
-    ret mk_mac_expr(p, lo, p.span.hi, ast::mac_invoc(pth, e, b));
-}
-
-fn parse_dot_or_call_expr(p: parser) -> pexpr {
-    let b = parse_bottom_expr(p);
-    parse_dot_or_call_expr_with(p, b)
-}
-
-fn permits_call(p: parser) -> bool {
-    ret p.restriction != RESTRICT_NO_CALL_EXPRS;
-}
-
-fn parse_dot_or_call_expr_with(p: parser, e0: pexpr) -> pexpr {
-    let e = e0;
-    let lo = e.span.lo;
-    let hi = e.span.hi;
-    while true {
-        // expr.f
-        if eat(p, token::DOT) {
-            alt p.token {
-              token::IDENT(i, _) {
-                hi = p.span.hi;
-                p.bump();
-                let tys = if eat(p, token::MOD_SEP) {
-                    expect(p, token::LT);
-                    parse_seq_to_gt(some(token::COMMA),
-                                    {|p| parse_ty(p, false)}, p)
-                } else { [] };
-                e = mk_pexpr(p, lo, hi,
-                             ast::expr_field(to_expr(e),
-                                             p.get_str(i),
-                                             tys));
-              }
-              t { unexpected(p, t); }
-            }
-            cont;
-        }
-        if expr_is_complete(p, e) { break; }
-        alt p.token {
-          // expr(...)
-          token::LPAREN if permits_call(p) {
-            let es_opt =
-                parse_seq(token::LPAREN, token::RPAREN,
-                          seq_sep(token::COMMA), parse_expr_or_hole, p);
-            hi = es_opt.span.hi;
-
-            let nd =
-                if vec::any(es_opt.node, {|e| option::is_none(e) }) {
-                    ast::expr_bind(to_expr(e), es_opt.node)
-                } else {
-                    let es = vec::map(es_opt.node) {|e| option::get(e) };
-                    ast::expr_call(to_expr(e), es, false)
-                };
-            e = mk_pexpr(p, lo, hi, nd);
-          }
-
-          // expr {|| ... }
-          token::LBRACE if is_bar(p.look_ahead(1u)) && permits_call(p) {
-            p.bump();
-            let blk = parse_fn_block_expr(p);
-            alt e.node {
-              ast::expr_call(f, args, false) {
-                e = pexpr(@{node: ast::expr_call(f, args + [blk], true)
-                            with *to_expr(e)});
-              }
-              _ {
-                e = mk_pexpr(p, lo, p.last_span.hi,
-                            ast::expr_call(to_expr(e), [blk], true));
-              }
-            }
-          }
-
-          // expr[...]
-          token::LBRACKET {
-            p.bump();
-            let ix = parse_expr(p);
-            hi = ix.span.hi;
-            expect(p, token::RBRACKET);
-            p.get_id(); // see ast_util::op_expr_callee_id
-            e = mk_pexpr(p, lo, hi, ast::expr_index(to_expr(e), ix));
-          }
-
-          _ { ret e; }
-        }
-    }
-    ret e;
-}
-
-fn parse_prefix_expr(p: parser) -> pexpr {
-    let lo = p.span.lo;
-    let hi = p.span.hi;
-
-    let ex;
-    alt p.token {
-      token::NOT {
-        p.bump();
-        let e = to_expr(parse_prefix_expr(p));
-        hi = e.span.hi;
-        p.get_id(); // see ast_util::op_expr_callee_id
-        ex = ast::expr_unary(ast::not, e);
-      }
-      token::BINOP(b) {
-        alt b {
-          token::MINUS {
-            p.bump();
-            let e = to_expr(parse_prefix_expr(p));
-            hi = e.span.hi;
-            p.get_id(); // see ast_util::op_expr_callee_id
-            ex = ast::expr_unary(ast::neg, e);
-          }
-          token::STAR {
-            p.bump();
-            let e = to_expr(parse_prefix_expr(p));
-            hi = e.span.hi;
-            ex = ast::expr_unary(ast::deref, e);
-          }
-          _ { ret parse_dot_or_call_expr(p); }
-        }
-      }
-      token::AT {
-        p.bump();
-        let m = parse_mutability(p);
-        let e = to_expr(parse_prefix_expr(p));
-        hi = e.span.hi;
-        ex = ast::expr_unary(ast::box(m), e);
-      }
-      token::TILDE {
-        p.bump();
-        let m = parse_mutability(p);
-        let e = to_expr(parse_prefix_expr(p));
-        hi = e.span.hi;
-        ex = ast::expr_unary(ast::uniq(m), e);
-      }
-      _ { ret parse_dot_or_call_expr(p); }
-    }
-    ret mk_pexpr(p, lo, hi, ex);
-}
-
-type op_spec = {tok: token::token, op: ast::binop, prec: int};
-
-
-// FIXME make this a const, don't store it in parser state
-fn prec_table() -> @[op_spec] {
-    ret @[// 'as' sits between here with 12
-          {tok: token::BINOP(token::STAR), op: ast::mul, prec: 11},
-          {tok: token::BINOP(token::SLASH), op: ast::div, prec: 11},
-          {tok: token::BINOP(token::PERCENT), op: ast::rem, prec: 11},
-          {tok: token::BINOP(token::PLUS), op: ast::add, prec: 10},
-          {tok: token::BINOP(token::MINUS), op: ast::subtract, prec: 10},
-          {tok: token::BINOP(token::LSL), op: ast::lsl, prec: 9},
-          {tok: token::BINOP(token::LSR), op: ast::lsr, prec: 9},
-          {tok: token::BINOP(token::ASR), op: ast::asr, prec: 9},
-          {tok: token::BINOP(token::AND), op: ast::bitand, prec: 8},
-          {tok: token::BINOP(token::CARET), op: ast::bitxor, prec: 7},
-          {tok: token::BINOP(token::OR), op: ast::bitor, prec: 6},
-          {tok: token::LT, op: ast::lt, prec: 4},
-          {tok: token::LE, op: ast::le, prec: 4},
-          {tok: token::GE, op: ast::ge, prec: 4},
-          {tok: token::GT, op: ast::gt, prec: 4},
-          {tok: token::EQEQ, op: ast::eq, prec: 3},
-          {tok: token::NE, op: ast::ne, prec: 3},
-          {tok: token::ANDAND, op: ast::and, prec: 2},
-          {tok: token::OROR, op: ast::or, prec: 1}];
-}
-
-fn parse_binops(p: parser) -> @ast::expr {
-    ret parse_more_binops(p, parse_prefix_expr(p), 0);
-}
-
-const unop_prec: int = 100;
-
-const as_prec: int = 12;
-
-fn parse_more_binops(p: parser, plhs: pexpr, min_prec: int) ->
-   @ast::expr {
-    let lhs = to_expr(plhs);
-    if expr_is_complete(p, plhs) { ret lhs; }
-    let peeked = p.token;
-    if peeked == token::BINOP(token::OR) &&
-       p.restriction == RESTRICT_NO_BAR_OP { ret lhs; }
-    for cur: op_spec in *p.precs {
-        if cur.prec > min_prec && cur.tok == peeked {
-            p.bump();
-            let expr = parse_prefix_expr(p);
-            let rhs = parse_more_binops(p, expr, cur.prec);
-            p.get_id(); // see ast_util::op_expr_callee_id
-            let bin = mk_pexpr(p, lhs.span.lo, rhs.span.hi,
-                              ast::expr_binary(cur.op, lhs, rhs));
-            ret parse_more_binops(p, bin, min_prec);
-        }
-    }
-    if as_prec > min_prec && eat_word(p, "as") {
-        let rhs = parse_ty(p, true);
-        let _as =
-            mk_pexpr(p, lhs.span.lo, rhs.span.hi, ast::expr_cast(lhs, rhs));
-        ret parse_more_binops(p, _as, min_prec);
-    }
-    ret lhs;
-}
-
-fn parse_assign_expr(p: parser) -> @ast::expr {
-    let lo = p.span.lo;
-    let lhs = parse_binops(p);
-    alt p.token {
-      token::EQ {
-        p.bump();
-        let rhs = parse_expr(p);
-        ret mk_expr(p, lo, rhs.span.hi, ast::expr_assign(lhs, rhs));
-      }
-      token::BINOPEQ(op) {
-        p.bump();
-        let rhs = parse_expr(p);
-        let aop = ast::add;
-        alt op {
-          token::PLUS { aop = ast::add; }
-          token::MINUS { aop = ast::subtract; }
-          token::STAR { aop = ast::mul; }
-          token::SLASH { aop = ast::div; }
-          token::PERCENT { aop = ast::rem; }
-          token::CARET { aop = ast::bitxor; }
-          token::AND { aop = ast::bitand; }
-          token::OR { aop = ast::bitor; }
-          token::LSL { aop = ast::lsl; }
-          token::LSR { aop = ast::lsr; }
-          token::ASR { aop = ast::asr; }
-        }
-        p.get_id(); // see ast_util::op_expr_callee_id
-        ret mk_expr(p, lo, rhs.span.hi, ast::expr_assign_op(aop, lhs, rhs));
-      }
-      token::LARROW {
-        p.bump();
-        let rhs = parse_expr(p);
-        ret mk_expr(p, lo, rhs.span.hi, ast::expr_move(lhs, rhs));
-      }
-      token::DARROW {
-        p.bump();
-        let rhs = parse_expr(p);
-        ret mk_expr(p, lo, rhs.span.hi, ast::expr_swap(lhs, rhs));
-      }
-      _ {/* fall through */ }
-    }
-    ret lhs;
-}
-
-fn parse_if_expr_1(p: parser) ->
-   {cond: @ast::expr,
-    then: ast::blk,
-    els: option<@ast::expr>,
-    lo: uint,
-    hi: uint} {
-    let lo = p.last_span.lo;
-    let cond = parse_expr(p);
-    let thn = parse_block(p);
-    let els: option<@ast::expr> = none;
-    let hi = thn.span.hi;
-    if eat_word(p, "else") {
-        let elexpr = parse_else_expr(p);
-        els = some(elexpr);
-        hi = elexpr.span.hi;
-    }
-    ret {cond: cond, then: thn, els: els, lo: lo, hi: hi};
-}
-
-fn parse_if_expr(p: parser) -> @ast::expr {
-    if eat_word(p, "check") {
-        let q = parse_if_expr_1(p);
-        ret mk_expr(p, q.lo, q.hi, ast::expr_if_check(q.cond, q.then, q.els));
-    } else {
-        let q = parse_if_expr_1(p);
-        ret mk_expr(p, q.lo, q.hi, ast::expr_if(q.cond, q.then, q.els));
-    }
-}
-
-// Parses:
-//
-//   CC := [copy ID*; move ID*]
-//
-// where any part is optional and trailing ; is permitted.
-fn parse_capture_clause(p: parser) -> @ast::capture_clause {
-    fn expect_opt_trailing_semi(p: parser) {
-        if !eat(p, token::SEMI) {
-            if p.token != token::RBRACKET {
-                p.fatal("expecting ; or ]");
-            }
-        }
-    }
-
-    fn eat_ident_list(p: parser) -> [@ast::capture_item] {
-        let res = [];
-        while true {
-            alt p.token {
-              token::IDENT(_, _) {
-                let id = p.get_id();
-                let sp = ast_util::mk_sp(p.span.lo, p.span.hi);
-                let ident = parse_ident(p);
-                res += [@{id:id, name:ident, span:sp}];
-                if !eat(p, token::COMMA) {
-                    ret res;
-                }
-              }
-
-              _ { ret res; }
-            }
-        }
-        std::util::unreachable();
-    }
-
-    let copies = [];
-    let moves = [];
-
-    if eat(p, token::LBRACKET) {
-        while !eat(p, token::RBRACKET) {
-            if eat_word(p, "copy") {
-                copies += eat_ident_list(p);
-                expect_opt_trailing_semi(p);
-            } else if eat_word(p, "move") {
-                moves += eat_ident_list(p);
-                expect_opt_trailing_semi(p);
-            } else {
-                let s: str = "expecting send, copy, or move clause";
-                p.fatal(s);
-            }
-        }
-    }
-
-    ret @{copies: copies, moves: moves};
-}
-
-fn parse_fn_expr(p: parser, proto: ast::proto) -> @ast::expr {
-    let lo = p.last_span.lo;
-    let capture_clause = parse_capture_clause(p);
-    let decl = parse_fn_decl(p, ast::impure_fn);
-    let body = parse_block(p);
-    ret mk_expr(p, lo, body.span.hi,
-                ast::expr_fn(proto, decl, body, capture_clause));
-}
-
-fn parse_fn_block_expr(p: parser) -> @ast::expr {
-    let lo = p.last_span.lo;
-    let decl = parse_fn_block_decl(p);
-    let body = parse_block_tail(p, lo, ast::default_blk);
-    ret mk_expr(p, lo, body.span.hi, ast::expr_fn_block(decl, body));
-}
-
-fn parse_else_expr(p: parser) -> @ast::expr {
-    if eat_word(p, "if") {
-        ret parse_if_expr(p);
-    } else {
-        let blk = parse_block(p);
-        ret mk_expr(p, blk.span.lo, blk.span.hi, ast::expr_block(blk));
-    }
-}
-
-fn parse_for_expr(p: parser) -> @ast::expr {
-    let lo = p.last_span.lo;
-    let decl = parse_local(p, false, false);
-    expect_word(p, "in");
-    let seq = parse_expr(p);
-    let body = parse_block_no_value(p);
-    let hi = body.span.hi;
-    ret mk_expr(p, lo, hi, ast::expr_for(decl, seq, body));
-}
-
-fn parse_while_expr(p: parser) -> @ast::expr {
-    let lo = p.last_span.lo;
-    let cond = parse_expr(p);
-    let body = parse_block_no_value(p);
-    let hi = body.span.hi;
-    ret mk_expr(p, lo, hi, ast::expr_while(cond, body));
-}
-
-fn parse_do_while_expr(p: parser) -> @ast::expr {
-    let lo = p.last_span.lo;
-    let body = parse_block_no_value(p);
-    expect_word(p, "while");
-    let cond = parse_expr(p);
-    let hi = cond.span.hi;
-    ret mk_expr(p, lo, hi, ast::expr_do_while(body, cond));
-}
-
-fn parse_alt_expr(p: parser) -> @ast::expr {
-    let lo = p.last_span.lo;
-    let mode = if eat_word(p, "check") { ast::alt_check }
-               else { ast::alt_exhaustive };
-    let discriminant = parse_expr(p);
-    expect(p, token::LBRACE);
-    let arms: [ast::arm] = [];
-    while p.token != token::RBRACE {
-        let pats = parse_pats(p);
-        let guard = none;
-        if eat_word(p, "if") { guard = some(parse_expr(p)); }
-        let blk = parse_block(p);
-        arms += [{pats: pats, guard: guard, body: blk}];
-    }
-    let hi = p.span.hi;
-    p.bump();
-    ret mk_expr(p, lo, hi, ast::expr_alt(discriminant, arms, mode));
-}
-
-fn parse_expr(p: parser) -> @ast::expr {
-    ret parse_expr_res(p, UNRESTRICTED);
-}
-
-fn parse_expr_or_hole(p: parser) -> option<@ast::expr> {
-    alt p.token {
-      token::UNDERSCORE { p.bump(); ret none; }
-      _ { ret some(parse_expr(p)); }
-    }
-}
-
-fn parse_expr_res(p: parser, r: restriction) -> @ast::expr {
-    let old = p.restriction;
-    p.restriction = r;
-    let e = parse_assign_expr(p);
-    p.restriction = old;
-    ret e;
-}
-
-fn parse_initializer(p: parser) -> option<ast::initializer> {
-    alt p.token {
-      token::EQ {
-        p.bump();
-        ret some({op: ast::init_assign, expr: parse_expr(p)});
-      }
-      token::LARROW {
-        p.bump();
-        ret some({op: ast::init_move, expr: parse_expr(p)});
-      }
-      // Now that the the channel is the first argument to receive,
-      // combining it with an initializer doesn't really make sense.
-      // case (token::RECV) {
-      //     p.bump();
-      //     ret some(rec(op = ast::init_recv,
-      //                  expr = parse_expr(p)));
-      // }
-      _ {
-        ret none;
-      }
-    }
-}
-
-fn parse_pats(p: parser) -> [@ast::pat] {
-    let pats = [];
-    while true {
-        pats += [parse_pat(p)];
-        if p.token == token::BINOP(token::OR) { p.bump(); } else { break; }
-    }
-    ret pats;
-}
-
-fn parse_pat(p: parser) -> @ast::pat {
-    let lo = p.span.lo;
-    let hi = p.span.hi;
-    let pat;
-    alt p.token {
-      token::UNDERSCORE { p.bump(); pat = ast::pat_wild; }
-      token::AT {
-        p.bump();
-        let sub = parse_pat(p);
-        pat = ast::pat_box(sub);
-        hi = sub.span.hi;
-      }
-      token::TILDE {
-        p.bump();
-        let sub = parse_pat(p);
-        pat = ast::pat_uniq(sub);
-        hi = sub.span.hi;
-      }
-      token::LBRACE {
-        p.bump();
-        let fields = [];
-        let etc = false;
-        let first = true;
-        while p.token != token::RBRACE {
-            if first { first = false; } else { expect(p, token::COMMA); }
-
-            if p.token == token::UNDERSCORE {
-                p.bump();
-                if p.token != token::RBRACE {
-                    p.fatal("expecting }, found " +
-                                token::to_str(p.reader, p.token));
-                }
-                etc = true;
-                break;
-            }
-
-            let lo1 = p.last_span.lo;
-            let fieldname = parse_ident(p);
-            let hi1 = p.last_span.lo;
-            let fieldpath = ast_util::ident_to_path(ast_util::mk_sp(lo1, hi1),
-                                          fieldname);
-            let subpat;
-            if p.token == token::COLON {
-                p.bump();
-                subpat = parse_pat(p);
-            } else {
-                if p.bad_expr_words.contains_key(fieldname) {
-                    p.fatal("found " + fieldname + " in binding position");
-                }
-                subpat = @{id: p.get_id(),
-                           node: ast::pat_ident(fieldpath, none),
-                           span: ast_util::mk_sp(lo, hi)};
-            }
-            fields += [{ident: fieldname, pat: subpat}];
-        }
-        hi = p.span.hi;
-        p.bump();
-        pat = ast::pat_rec(fields, etc);
-      }
-      token::LPAREN {
-        p.bump();
-        if p.token == token::RPAREN {
-            hi = p.span.hi;
-            p.bump();
-            let lit = @{node: ast::lit_nil, span: ast_util::mk_sp(lo, hi)};
-            let expr = mk_expr(p, lo, hi, ast::expr_lit(lit));
-            pat = ast::pat_lit(expr);
-        } else {
-            let fields = [parse_pat(p)];
-            while p.token == token::COMMA {
-                p.bump();
-                fields += [parse_pat(p)];
-            }
-            if vec::len(fields) == 1u { expect(p, token::COMMA); }
-            hi = p.span.hi;
-            expect(p, token::RPAREN);
-            pat = ast::pat_tup(fields);
-        }
-      }
-      tok {
-        if !is_ident(tok) || is_word(p, "true") || is_word(p, "false") {
-            let val = parse_expr_res(p, RESTRICT_NO_BAR_OP);
-            if eat_word(p, "to") {
-                let end = parse_expr_res(p, RESTRICT_NO_BAR_OP);
-                hi = end.span.hi;
-                pat = ast::pat_range(val, end);
-            } else {
-                hi = val.span.hi;
-                pat = ast::pat_lit(val);
-            }
-        } else if is_plain_ident(p) &&
-            alt p.look_ahead(1u) {
-              token::LPAREN | token::LBRACKET | token::LT { false }
-              _ { true }
-            } {
-            let name = parse_value_path(p);
-            let sub = if eat(p, token::AT) { some(parse_pat(p)) }
-                      else { none };
-            pat = ast::pat_ident(name, sub);
-        } else {
-            let enum_path = parse_path_and_ty_param_substs(p, true);
-            hi = enum_path.span.hi;
-            let args: [@ast::pat];
-            alt p.token {
-              token::LPAREN {
-                let a =
-                    parse_seq(token::LPAREN, token::RPAREN,
-                              seq_sep(token::COMMA), parse_pat, p);
-                args = a.node;
-                hi = a.span.hi;
-              }
-              _ { args = []; }
-            }
-            // at this point, we're not sure whether it's a enum or a bind
-            if vec::len(args) == 0u &&
-               vec::len(enum_path.node.idents) == 1u {
-                pat = ast::pat_ident(enum_path, none);
-            }
-            else {
-                pat = ast::pat_enum(enum_path, args);
-            }
-        }
-      }
-    }
-    ret @{id: p.get_id(), node: pat, span: ast_util::mk_sp(lo, hi)};
-}
-
-fn parse_local(p: parser, is_mutbl: bool,
-               allow_init: bool) -> @ast::local {
-    let lo = p.span.lo;
-    let pat = parse_pat(p);
-    let ty = @spanned(lo, lo, ast::ty_infer);
-    if eat(p, token::COLON) { ty = parse_ty(p, false); }
-    let init = if allow_init { parse_initializer(p) } else { none };
-    ret @spanned(lo, p.last_span.hi,
-                 {is_mutbl: is_mutbl, ty: ty, pat: pat,
-                  init: init, id: p.get_id()});
-}
-
-fn parse_let(p: parser) -> @ast::decl {
-    let is_mutbl = eat_word(p, "mut");
-    let lo = p.span.lo;
-    let locals = [parse_local(p, is_mutbl, true)];
-    while eat(p, token::COMMA) {
-        locals += [parse_local(p, is_mutbl, true)];
-    }
-    ret @spanned(lo, p.last_span.hi, ast::decl_local(locals));
-}
-
-fn parse_instance_var(p:parser) -> ast::class_member {
-    let is_mutbl = ast::class_immutable;
-    expect_word(p, "let");
-    if eat_word(p, "mut") || eat_word(p, "mutable") {
-            is_mutbl = ast::class_mutable;
-    }
-    if !is_plain_ident(p) {
-        p.fatal("expecting ident");
-    }
-    let name = parse_ident(p);
-    expect(p, token::COLON);
-    let ty = parse_ty(p, false);
-    ret ast::instance_var(name, ty, is_mutbl, p.get_id());
-}
-
-fn parse_stmt(p: parser, first_item_attrs: [ast::attribute]) -> @ast::stmt {
-    fn check_expected_item(p: parser, current_attrs: [ast::attribute]) {
-        // If we have attributes then we should have an item
-        if vec::is_not_empty(current_attrs) {
-            p.fatal("expected item");
-        }
-    }
-
-    let lo = p.span.lo;
-    if is_word(p, "let") {
-        check_expected_item(p, first_item_attrs);
-        expect_word(p, "let");
-        let decl = parse_let(p);
-        ret @spanned(lo, decl.span.hi, ast::stmt_decl(decl, p.get_id()));
-    } else {
-        let item_attrs;
-        alt parse_outer_attrs_or_ext(p, first_item_attrs) {
-          none { item_attrs = []; }
-          some(left(attrs)) { item_attrs = attrs; }
-          some(right(ext)) {
-            ret @spanned(lo, ext.span.hi, ast::stmt_expr(ext, p.get_id()));
-          }
-        }
-
-        let item_attrs = first_item_attrs + item_attrs;
-
-        alt parse_item(p, item_attrs) {
-          some(i) {
-            let hi = i.span.hi;
-            let decl = @spanned(lo, hi, ast::decl_item(i));
-            ret @spanned(lo, hi, ast::stmt_decl(decl, p.get_id()));
-          }
-          none() { /* fallthrough */ }
-        }
-
-        check_expected_item(p, item_attrs);
-
-        // Remainder are line-expr stmts.
-        let e = parse_expr_res(p, RESTRICT_STMT_EXPR);
-        ret @spanned(lo, e.span.hi, ast::stmt_expr(e, p.get_id()));
-    }
-}
-
-fn expr_is_complete(p: parser, e: pexpr) -> bool {
-    log(debug, ("expr_is_complete", p.restriction,
-                print::pprust::expr_to_str(*e),
-                expr_requires_semi_to_be_stmt(*e)));
-    ret p.restriction == RESTRICT_STMT_EXPR &&
-        !expr_requires_semi_to_be_stmt(*e);
-}
-
-fn expr_requires_semi_to_be_stmt(e: @ast::expr) -> bool {
-    alt e.node {
-      ast::expr_if(_, _, _) | ast::expr_if_check(_, _, _)
-      | ast::expr_alt(_, _, _) | ast::expr_block(_)
-      | ast::expr_do_while(_, _) | ast::expr_while(_, _)
-      | ast::expr_for(_, _, _)
-      | ast::expr_call(_, _, true) {
-        false
-      }
-      _ { true }
-    }
-}
-
-fn stmt_ends_with_semi(stmt: ast::stmt) -> bool {
-    alt stmt.node {
-      ast::stmt_decl(d, _) {
-        ret alt d.node {
-              ast::decl_local(_) { true }
-              ast::decl_item(_) { false }
-            }
-      }
-      ast::stmt_expr(e, _) {
-        ret expr_requires_semi_to_be_stmt(e);
-      }
-      ast::stmt_semi(e, _) {
-        ret false;
-      }
-    }
-}
-
-fn parse_block(p: parser) -> ast::blk {
-    let (attrs, blk) = parse_inner_attrs_and_block(p, false);
-    assert vec::is_empty(attrs);
-    ret blk;
-}
-
-fn parse_inner_attrs_and_block(
-    p: parser, parse_attrs: bool) -> ([ast::attribute], ast::blk) {
-
-    fn maybe_parse_inner_attrs_and_next(
-        p: parser, parse_attrs: bool) ->
-        {inner: [ast::attribute], next: [ast::attribute]} {
-        if parse_attrs {
-            parse_inner_attrs_and_next(p)
-        } else {
-            {inner: [], next: []}
-        }
-    }
-
-    let lo = p.span.lo;
-    if eat_word(p, "unchecked") {
-        expect(p, token::LBRACE);
-        let {inner, next} = maybe_parse_inner_attrs_and_next(p, parse_attrs);
-        ret (inner, parse_block_tail_(p, lo, ast::unchecked_blk, next));
-    } else if eat_word(p, "unsafe") {
-        expect(p, token::LBRACE);
-        let {inner, next} = maybe_parse_inner_attrs_and_next(p, parse_attrs);
-        ret (inner, parse_block_tail_(p, lo, ast::unsafe_blk, next));
-    } else {
-        expect(p, token::LBRACE);
-        let {inner, next} = maybe_parse_inner_attrs_and_next(p, parse_attrs);
-        ret (inner, parse_block_tail_(p, lo, ast::default_blk, next));
-    }
-}
-
-fn parse_block_no_value(p: parser) -> ast::blk {
-    // We parse blocks that cannot have a value the same as any other block;
-    // the type checker will make sure that the tail expression (if any) has
-    // unit type.
-    ret parse_block(p);
-}
-
-// Precondition: already parsed the '{' or '#{'
-// I guess that also means "already parsed the 'impure'" if
-// necessary, and this should take a qualifier.
-// some blocks start with "#{"...
-fn parse_block_tail(p: parser, lo: uint, s: ast::blk_check_mode) -> ast::blk {
-    parse_block_tail_(p, lo, s, [])
-}
-
-fn parse_block_tail_(p: parser, lo: uint, s: ast::blk_check_mode,
-                     first_item_attrs: [ast::attribute]) -> ast::blk {
-    let stmts = [];
-    let expr = none;
-    let view_items = maybe_parse_view_import_only(p, first_item_attrs);
-    let initial_attrs = first_item_attrs;
-
-    if p.token == token::RBRACE && !vec::is_empty(initial_attrs) {
-        p.fatal("expected item");
-    }
-
-    while p.token != token::RBRACE {
-        alt p.token {
-          token::SEMI {
-            p.bump(); // empty
-          }
-          _ {
-            let stmt = parse_stmt(p, initial_attrs);
-            initial_attrs = [];
-            alt stmt.node {
-              ast::stmt_expr(e, stmt_id) { // Expression without semicolon:
-                alt p.token {
-                  token::SEMI {
-                    p.bump();
-                    stmts += [@{node: ast::stmt_semi(e, stmt_id) with *stmt}];
-                  }
-                  token::RBRACE {
-                    expr = some(e);
-                  }
-                  t {
-                    if stmt_ends_with_semi(*stmt) {
-                        p.fatal("expected ';' or '}' after expression but \
-                                 found '" + token::to_str(p.reader, t) +
-                                "'");
-                    }
-                    stmts += [stmt];
-                  }
-                }
-              }
-
-              _ { // All other kinds of statements:
-                stmts += [stmt];
-
-                if stmt_ends_with_semi(*stmt) {
-                    expect(p, token::SEMI);
-                }
-              }
-            }
-          }
-        }
-    }
-    let hi = p.span.hi;
-    p.bump();
-    let bloc = {view_items: view_items, stmts: stmts, expr: expr,
-                id: p.get_id(), rules: s};
-    ret spanned(lo, hi, bloc);
-}
-
-fn parse_ty_param(p: parser) -> ast::ty_param {
-    let bounds = [];
-    let ident = parse_ident(p);
-    if eat(p, token::COLON) {
-        while p.token != token::COMMA && p.token != token::GT {
-            if eat_word(p, "send") { bounds += [ast::bound_send]; }
-            else if eat_word(p, "copy") { bounds += [ast::bound_copy]; }
-            else { bounds += [ast::bound_iface(parse_ty(p, false))]; }
-        }
-    }
-    ret {ident: ident, id: p.get_id(), bounds: @bounds};
-}
-
-fn parse_ty_params(p: parser) -> [ast::ty_param] {
-    if eat(p, token::LT) {
-        parse_seq_to_gt(some(token::COMMA), parse_ty_param, p)
-    } else { [] }
-}
-
-fn parse_fn_decl(p: parser, purity: ast::purity)
-    -> ast::fn_decl {
-    let inputs: ast::spanned<[ast::arg]> =
-        parse_seq(token::LPAREN, token::RPAREN, seq_sep(token::COMMA),
-                  parse_arg, p);
-    // Use the args list to translate each bound variable
-    // mentioned in a constraint to an arg index.
-    // Seems weird to do this in the parser, but I'm not sure how else to.
-    let constrs = [];
-    if p.token == token::COLON {
-        p.bump();
-        constrs = parse_constrs({|x| parse_ty_constr(inputs.node, x) }, p);
-    }
-    let (ret_style, ret_ty) = parse_ret_ty(p);
-    ret {inputs: inputs.node,
-         output: ret_ty,
-         purity: purity,
-         cf: ret_style,
-         constraints: constrs};
-}
-
-fn parse_fn_block_decl(p: parser) -> ast::fn_decl {
-    let inputs = if eat(p, token::OROR) {
-                     []
-                 } else {
-                     parse_seq(token::BINOP(token::OR),
-                               token::BINOP(token::OR),
-                               seq_sep(token::COMMA),
-                               parse_fn_block_arg, p).node
-                 };
-    let output = if eat(p, token::RARROW) {
-                     parse_ty(p, false)
-                 } else {
-                     @spanned(p.span.lo, p.span.hi, ast::ty_infer)
-                 };
-    ret {inputs: inputs,
-         output: output,
-         purity: ast::impure_fn,
-         cf: ast::return_val,
-         constraints: []};
-}
-
-fn parse_fn_header(p: parser) -> {ident: ast::ident, tps: [ast::ty_param]} {
-    let id = parse_value_ident(p);
-    let ty_params = parse_ty_params(p);
-    ret {ident: id, tps: ty_params};
-}
-
-fn mk_item(p: parser, lo: uint, hi: uint, ident: ast::ident, node: ast::item_,
-           attrs: [ast::attribute]) -> @ast::item {
-    ret @{ident: ident,
-          attrs: attrs,
-          id: p.get_id(),
-          node: node,
-          span: ast_util::mk_sp(lo, hi)};
-}
-
-fn parse_item_fn(p: parser, purity: ast::purity,
-                 attrs: [ast::attribute]) -> @ast::item {
-    let lo = p.last_span.lo;
-    let t = parse_fn_header(p);
-    let decl = parse_fn_decl(p, purity);
-    let (inner_attrs, body) = parse_inner_attrs_and_block(p, true);
-    let attrs = attrs + inner_attrs;
-    ret mk_item(p, lo, body.span.hi, t.ident,
-                ast::item_fn(decl, t.tps, body), attrs);
-}
-
-fn parse_method_name(p: parser) -> ast::ident {
-    alt p.token {
-      token::BINOP(op) { p.bump(); token::binop_to_str(op) }
-      token::NOT { p.bump(); "!" }
-      token::LBRACKET { p.bump(); expect(p, token::RBRACKET); "[]" }
-      _ {
-          let id = parse_value_ident(p);
-          if id == "unary" && eat(p, token::BINOP(token::MINUS)) { "unary-" }
-          else { id }
-      }
-    }
-}
-
-fn parse_method(p: parser) -> @ast::method {
-    let attrs = parse_outer_attributes(p);
-    let lo = p.span.lo, pur = parse_fn_purity(p);
-    let ident = parse_method_name(p);
-    let tps = parse_ty_params(p);
-    let decl = parse_fn_decl(p, pur);
-    let (inner_attrs, body) = parse_inner_attrs_and_block(p, true);
-    let attrs = attrs + inner_attrs;
-    @{ident: ident, attrs: attrs, tps: tps, decl: decl, body: body,
-      id: p.get_id(), span: ast_util::mk_sp(lo, body.span.hi)}
-}
-
-fn parse_item_iface(p: parser, attrs: [ast::attribute]) -> @ast::item {
-    let lo = p.last_span.lo, ident = parse_ident(p),
-        tps = parse_ty_params(p), meths = parse_ty_methods(p);
-    ret mk_item(p, lo, p.last_span.hi, ident,
-                ast::item_iface(tps, meths), attrs);
-}
-
-// Parses three variants (with the initial params always optional):
-//    impl <T: copy> of to_str for [T] { ... }
-//    impl name<T> of to_str for [T] { ... }
-//    impl name<T> for [T] { ... }
-fn parse_item_impl(p: parser, attrs: [ast::attribute]) -> @ast::item {
-    let lo = p.last_span.lo;
-    fn wrap_path(p: parser, pt: @ast::path) -> @ast::ty {
-        @{node: ast::ty_path(pt, p.get_id()), span: pt.span}
-    }
-    let (ident, tps) = if !is_word(p, "of") {
-        if p.token == token::LT { (none, parse_ty_params(p)) }
-        else { (some(parse_ident(p)), parse_ty_params(p)) }
-    } else { (none, []) };
-    let ifce = if eat_word(p, "of") {
-        let path = parse_path_and_ty_param_substs(p, false);
-        if option::is_none(ident) {
-            ident = some(path.node.idents[vec::len(path.node.idents) - 1u]);
-        }
-        some(wrap_path(p, path))
-    } else { none };
-    let ident = alt ident {
-        some(name) { name }
-        none { expect_word(p, "of"); fail; }
-    };
-    expect_word(p, "for");
-    let ty = parse_ty(p, false), meths = [];
-    expect(p, token::LBRACE);
-    while !eat(p, token::RBRACE) { meths += [parse_method(p)]; }
-    ret mk_item(p, lo, p.last_span.hi, ident,
-                ast::item_impl(tps, ifce, ty, meths), attrs);
-}
-
-fn parse_item_res(p: parser, attrs: [ast::attribute]) -> @ast::item {
-    let lo = p.last_span.lo;
-    let ident = parse_value_ident(p);
-    let ty_params = parse_ty_params(p);
-    expect(p, token::LPAREN);
-    let arg_ident = parse_value_ident(p);
-    expect(p, token::COLON);
-    let t = parse_ty(p, false);
-    expect(p, token::RPAREN);
-    let dtor = parse_block_no_value(p);
-    let decl =
-        {inputs:
-             [{mode: ast::expl(ast::by_ref), ty: t,
-               ident: arg_ident, id: p.get_id()}],
-         output: @spanned(lo, lo, ast::ty_nil),
-         purity: ast::impure_fn,
-         cf: ast::return_val,
-         constraints: []};
-    ret mk_item(p, lo, dtor.span.hi, ident,
-                ast::item_res(decl, ty_params, dtor, p.get_id(), p.get_id()),
-                attrs);
-}
-
-fn parse_item_class(p: parser, attrs: [ast::attribute]) -> @ast::item {
-    let lo = p.last_span.lo;
-    let class_name = parse_value_ident(p);
-    let class_path = ident_to_path(p.last_span, class_name);
-    let ty_params = parse_ty_params(p);
-    expect(p, token::LBRACE);
-    let items: [@ast::class_item] = [];
-    let ctor_id = p.get_id();
-    let the_ctor : option<(ast::fn_decl, ast::blk)> = none;
-    while p.token != token::RBRACE {
-        alt parse_class_item(p, class_path) {
-            ctor_decl(a_fn_decl, blk) {
-                the_ctor = some((a_fn_decl, blk));
-            }
-            plain_decl(a_decl) {
-                items += [@{node: {privacy: ast::pub, decl: a_decl},
-                            span: p.last_span}];
-            }
-            priv_decls(some_decls) {
-                items += vec::map(some_decls, {|d|
-                            @{node: {privacy: ast::priv, decl: d},
-                                span: p.last_span}});
-            }
-       }
-    }
-    p.bump();
-    alt the_ctor {
-       some((ct_d, ct_b)) { ret mk_item(p, lo, p.last_span.hi, class_name,
-         ast::item_class(ty_params, items, ctor_id, ct_d, ct_b), attrs); }
-       /*
-         Is it strange for the parser to check this?
-       */
-       none { /* parse error */ fail "Class with no ctor"; }
-    }
-}
-
-// lets us identify the constructor declaration at
-// parse time
-// we don't really want just the fn_decl...
-enum class_contents { ctor_decl(ast::fn_decl, ast::blk),
-                      // assumed to be public
-                      plain_decl(ast::class_member),
-                      // contents of a priv section --
-                      // parse_class_item ensures that
-                      // none of these are a ctor decl
-                      priv_decls([ast::class_member])}
-
-    fn parse_class_item(p:parser, class_name:@ast::path) -> class_contents {
-    if eat_word(p, "new") {
-        // Can ctors have attrs?
-            // result type is always the type of the class
-        let decl_ = parse_fn_decl(p, ast::impure_fn);
-        let decl = {output: @{node: ast::ty_path(class_name, p.get_id()),
-                                  span: decl_.output.span}
-                    with decl_};
-        let body = parse_block(p);
-        ret ctor_decl(decl, body);
-    }
-    // FIXME: refactor
-    else if eat_word(p, "priv") {
-            expect(p, token::LBRACE);
-            let results = [];
-            while p.token != token::RBRACE {
-               alt parse_item(p, []) {
-                 some(i) {
-                     results += [ast::class_method(i)];
-                 }
-                 _ {
-                     let a_var = parse_instance_var(p);
-                     expect(p, token::SEMI);
-                     results += [a_var];
-                 }
-               }
-            }
-            p.bump();
-            ret priv_decls(results);
-    }
-    else {
-        // Probably need to parse attrs
-        alt parse_item(p, []) {
-         some(i) {
-             ret plain_decl(ast::class_method(i));
-         }
-         _ {
-             let a_var = parse_instance_var(p);
-             expect(p, token::SEMI);
-             ret plain_decl(a_var);
-         }
-        }
-    }
-}
-
-fn parse_mod_items(p: parser, term: token::token,
-                   first_item_attrs: [ast::attribute]) -> ast::_mod {
-    // Shouldn't be any view items since we've already parsed an item attr
-    let view_items = maybe_parse_view(p, first_item_attrs);
-    let items: [@ast::item] = [];
-    let initial_attrs = first_item_attrs;
-    while p.token != term {
-        let attrs = initial_attrs + parse_outer_attributes(p);
-        #debug["parse_mod_items: parse_item(attrs=%?)", attrs];
-        alt parse_item(p, attrs) {
-          some(i) { items += [i]; }
-          _ {
-            p.fatal("expected item but found '" +
-                    token::to_str(p.reader, p.token) + "'");
-          }
-        }
-        #debug["parse_mod_items: attrs=%?", attrs];
-        initial_attrs = [];
-    }
-
-    if vec::is_not_empty(initial_attrs) {
-        // We parsed attributes for the first item but didn't find the item
-        p.fatal("expected item");
-    }
-
-    ret {view_items: view_items, items: items};
-}
-
-fn parse_item_const(p: parser, attrs: [ast::attribute]) -> @ast::item {
-    let lo = p.last_span.lo;
-    let id = parse_value_ident(p);
-    expect(p, token::COLON);
-    let ty = parse_ty(p, false);
-    expect(p, token::EQ);
-    let e = parse_expr(p);
-    let hi = p.span.hi;
-    expect(p, token::SEMI);
-    ret mk_item(p, lo, hi, id, ast::item_const(ty, e), attrs);
-}
-
-fn parse_item_mod(p: parser, attrs: [ast::attribute]) -> @ast::item {
-    let lo = p.last_span.lo;
-    let id = parse_ident(p);
-    expect(p, token::LBRACE);
-    let inner_attrs = parse_inner_attrs_and_next(p);
-    let first_item_outer_attrs = inner_attrs.next;
-    let m = parse_mod_items(p, token::RBRACE, first_item_outer_attrs);
-    let hi = p.span.hi;
-    expect(p, token::RBRACE);
-    ret mk_item(p, lo, hi, id, ast::item_mod(m), attrs + inner_attrs.inner);
-}
-
-fn parse_item_native_fn(p: parser, attrs: [ast::attribute],
-                        purity: ast::purity) -> @ast::native_item {
-    let lo = p.last_span.lo;
-    let t = parse_fn_header(p);
-    let decl = parse_fn_decl(p, purity);
-    let hi = p.span.hi;
-    expect(p, token::SEMI);
-    ret @{ident: t.ident,
-          attrs: attrs,
-          node: ast::native_item_fn(decl, t.tps),
-          id: p.get_id(),
-          span: ast_util::mk_sp(lo, hi)};
-}
-
-fn parse_fn_purity(p: parser) -> ast::purity {
-    if eat_word(p, "fn") { ast::impure_fn }
-    else if eat_word(p, "pure") { expect_word(p, "fn"); ast::pure_fn }
-    else if eat_word(p, "unsafe") { expect_word(p, "fn"); ast::unsafe_fn }
-    else { unexpected(p, p.token); }
-}
-
-fn parse_native_item(p: parser, attrs: [ast::attribute]) ->
-   @ast::native_item {
-    parse_item_native_fn(p, attrs, parse_fn_purity(p))
-}
-
-fn parse_native_mod_items(p: parser, first_item_attrs: [ast::attribute]) ->
-   ast::native_mod {
-    // Shouldn't be any view items since we've already parsed an item attr
-    let view_items =
-        if vec::len(first_item_attrs) == 0u {
-            parse_native_view(p)
-        } else { [] };
-    let items: [@ast::native_item] = [];
-    let initial_attrs = first_item_attrs;
-    while p.token != token::RBRACE {
-        let attrs = initial_attrs + parse_outer_attributes(p);
-        initial_attrs = [];
-        items += [parse_native_item(p, attrs)];
-    }
-    ret {view_items: view_items,
-         items: items};
-}
-
-fn parse_item_native_mod(p: parser, attrs: [ast::attribute]) -> @ast::item {
-    let lo = p.last_span.lo;
-    expect_word(p, "mod");
-    let id = parse_ident(p);
-    expect(p, token::LBRACE);
-    let more_attrs = parse_inner_attrs_and_next(p);
-    let inner_attrs = more_attrs.inner;
-    let first_item_outer_attrs = more_attrs.next;
-    let m = parse_native_mod_items(p, first_item_outer_attrs);
-    let hi = p.span.hi;
-    expect(p, token::RBRACE);
-    ret mk_item(p, lo, hi, id, ast::item_native_mod(m), attrs + inner_attrs);
-}
-
-fn parse_type_decl(p: parser) -> {lo: uint, ident: ast::ident} {
-    let lo = p.last_span.lo;
-    let id = parse_ident(p);
-    ret {lo: lo, ident: id};
-}
-
-fn parse_item_type(p: parser, attrs: [ast::attribute]) -> @ast::item {
-    let t = parse_type_decl(p);
-    let tps = parse_ty_params(p);
-    expect(p, token::EQ);
-    let ty = parse_ty(p, false);
-    let hi = p.span.hi;
-    expect(p, token::SEMI);
-    ret mk_item(p, t.lo, hi, t.ident, ast::item_ty(ty, tps), attrs);
-}
-
-fn parse_item_enum(p: parser, attrs: [ast::attribute]) -> @ast::item {
-    let lo = p.last_span.lo;
-    let id = parse_ident(p);
-    let ty_params = parse_ty_params(p);
-    let variants: [ast::variant] = [];
-    // Newtype syntax
-    if p.token == token::EQ {
-        if p.bad_expr_words.contains_key(id) {
-            p.fatal("found " + id + " in enum constructor position");
-        }
-        p.bump();
-        let ty = parse_ty(p, false);
-        expect(p, token::SEMI);
-        let variant =
-            spanned(ty.span.lo, ty.span.hi,
-                    {name: id,
-                     attrs: [],
-                     args: [{ty: ty, id: p.get_id()}],
-                     id: p.get_id(),
-                     disr_expr: none});
-        ret mk_item(p, lo, ty.span.hi, id,
-                    ast::item_enum([variant], ty_params), attrs);
-    }
-    expect(p, token::LBRACE);
-
-    let all_nullary = true, have_disr = false;
-
-    while p.token != token::RBRACE {
-        let variant_attrs = parse_outer_attributes(p);
-        let vlo = p.span.lo;
-        let ident = parse_value_ident(p);
-        let args = [], disr_expr = none;
-        if p.token == token::LPAREN {
-            all_nullary = false;
-            let arg_tys = parse_seq(token::LPAREN, token::RPAREN,
-                                    seq_sep(token::COMMA),
-                                    {|p| parse_ty(p, false)}, p);
-            for ty in arg_tys.node {
-                args += [{ty: ty, id: p.get_id()}];
-            }
-        } else if eat(p, token::EQ) {
-            have_disr = true;
-            disr_expr = some(parse_expr(p));
-        }
-
-        let vr = {name: ident, attrs: variant_attrs,
-                  args: args, id: p.get_id(),
-                  disr_expr: disr_expr};
-        variants += [spanned(vlo, p.last_span.hi, vr)];
-
-        if !eat(p, token::COMMA) { break; }
-    }
-    expect(p, token::RBRACE);
-    if (have_disr && !all_nullary) {
-        p.fatal("discriminator values can only be used with a c-like enum");
-    }
-    ret mk_item(p, lo, p.last_span.hi, id,
-                ast::item_enum(variants, ty_params), attrs);
-}
-
-fn parse_fn_ty_proto(p: parser) -> ast::proto {
-    alt p.token {
-      token::AT {
-        p.bump();
-        ast::proto_box
-      }
-      token::TILDE {
-        p.bump();
-        ast::proto_uniq
-      }
-      token::BINOP(token::AND) {
-        p.bump();
-        ast::proto_block
-      }
-      _ {
-        ast::proto_any
-      }
-    }
-}
-
-fn fn_expr_lookahead(tok: token::token) -> bool {
-    alt tok {
-      token::LPAREN | token::AT | token::TILDE | token::BINOP(_) {
-        true
-      }
-      _ {
-        false
-      }
-    }
-}
-
-fn parse_item(p: parser, attrs: [ast::attribute]) -> option<@ast::item> {
-    if eat_word(p, "const") {
-        ret some(parse_item_const(p, attrs));
-    } else if is_word(p, "fn") && !fn_expr_lookahead(p.look_ahead(1u)) {
-        p.bump();
-        ret some(parse_item_fn(p, ast::impure_fn, attrs));
-    } else if eat_word(p, "pure") {
-        expect_word(p, "fn");
-        ret some(parse_item_fn(p, ast::pure_fn, attrs));
-    } else if is_word(p, "unsafe") && p.look_ahead(1u) != token::LBRACE {
-        p.bump();
-        expect_word(p, "fn");
-        ret some(parse_item_fn(p, ast::unsafe_fn, attrs));
-    } else if eat_word(p, "crust") {
-        expect_word(p, "fn");
-        ret some(parse_item_fn(p, ast::crust_fn, attrs));
-    } else if eat_word(p, "mod") {
-        ret some(parse_item_mod(p, attrs));
-    } else if eat_word(p, "native") {
-        ret some(parse_item_native_mod(p, attrs));
-    } if eat_word(p, "type") {
-        ret some(parse_item_type(p, attrs));
-    } else if eat_word(p, "enum") {
-        ret some(parse_item_enum(p, attrs));
-    } else if eat_word(p, "iface") {
-        ret some(parse_item_iface(p, attrs));
-    } else if eat_word(p, "impl") {
-        ret some(parse_item_impl(p, attrs));
-    } else if eat_word(p, "resource") {
-        ret some(parse_item_res(p, attrs));
-    } else if eat_word(p, "class") {
-        ret some(parse_item_class(p, attrs));
-    }
-else { ret none; }
-}
-
-// A type to distingush between the parsing of item attributes or syntax
-// extensions, which both begin with token.POUND
-type attr_or_ext = option<either::t<[ast::attribute], @ast::expr>>;
-
-fn parse_outer_attrs_or_ext(
-    p: parser,
-    first_item_attrs: [ast::attribute]) -> attr_or_ext {
-    let expect_item_next = vec::is_not_empty(first_item_attrs);
-    if p.token == token::POUND {
-        let lo = p.span.lo;
-        if p.look_ahead(1u) == token::LBRACKET {
-            p.bump();
-            let first_attr = parse_attribute_naked(p, ast::attr_outer, lo);
-            ret some(left([first_attr] + parse_outer_attributes(p)));
-        } else if !(p.look_ahead(1u) == token::LT
-                    || p.look_ahead(1u) == token::LBRACKET
-                    || expect_item_next) {
-            p.bump();
-            ret some(right(parse_syntax_ext_naked(p, lo)));
-        } else { ret none; }
-    } else { ret none; }
-}
-
-// Parse attributes that appear before an item
-fn parse_outer_attributes(p: parser) -> [ast::attribute] {
-    let attrs: [ast::attribute] = [];
-    while p.token == token::POUND {
-        attrs += [parse_attribute(p, ast::attr_outer)];
-    }
-    ret attrs;
-}
-
-fn parse_attribute(p: parser, style: ast::attr_style) -> ast::attribute {
-    let lo = p.span.lo;
-    expect(p, token::POUND);
-    ret parse_attribute_naked(p, style, lo);
-}
-
-fn parse_attribute_naked(p: parser, style: ast::attr_style, lo: uint) ->
-   ast::attribute {
-    expect(p, token::LBRACKET);
-    let meta_item = parse_meta_item(p);
-    expect(p, token::RBRACKET);
-    let hi = p.span.hi;
-    ret spanned(lo, hi, {style: style, value: *meta_item});
-}
-
-// Parse attributes that appear after the opening of an item, each terminated
-// by a semicolon. In addition to a vector of inner attributes, this function
-// also returns a vector that may contain the first outer attribute of the
-// next item (since we can't know whether the attribute is an inner attribute
-// of the containing item or an outer attribute of the first contained item
-// until we see the semi).
-fn parse_inner_attrs_and_next(p: parser) ->
-   {inner: [ast::attribute], next: [ast::attribute]} {
-    let inner_attrs: [ast::attribute] = [];
-    let next_outer_attrs: [ast::attribute] = [];
-    while p.token == token::POUND {
-        if p.look_ahead(1u) != token::LBRACKET {
-            // This is an extension
-            break;
-        }
-        let attr = parse_attribute(p, ast::attr_inner);
-        if p.token == token::SEMI {
-            p.bump();
-            inner_attrs += [attr];
-        } else {
-            // It's not really an inner attribute
-            let outer_attr =
-                spanned(attr.span.lo, attr.span.hi,
-                        {style: ast::attr_outer, value: attr.node.value});
-            next_outer_attrs += [outer_attr];
-            break;
-        }
-    }
-    ret {inner: inner_attrs, next: next_outer_attrs};
-}
-
-fn parse_meta_item(p: parser) -> @ast::meta_item {
-    let lo = p.span.lo;
-    let ident = parse_ident(p);
-    alt p.token {
-      token::EQ {
-        p.bump();
-        let lit = parse_lit(p);
-        let hi = p.span.hi;
-        ret @spanned(lo, hi, ast::meta_name_value(ident, lit));
-      }
-      token::LPAREN {
-        let inner_items = parse_meta_seq(p);
-        let hi = p.span.hi;
-        ret @spanned(lo, hi, ast::meta_list(ident, inner_items));
-      }
-      _ {
-        let hi = p.span.hi;
-        ret @spanned(lo, hi, ast::meta_word(ident));
-      }
-    }
-}
-
-fn parse_meta_seq(p: parser) -> [@ast::meta_item] {
-    ret parse_seq(token::LPAREN, token::RPAREN, seq_sep(token::COMMA),
-                  parse_meta_item, p).node;
-}
-
-fn parse_optional_meta(p: parser) -> [@ast::meta_item] {
-    alt p.token { token::LPAREN { ret parse_meta_seq(p); } _ { ret []; } }
-}
-
-fn parse_use(p: parser) -> ast::view_item_ {
-    let ident = parse_ident(p);
-    let metadata = parse_optional_meta(p);
-    ret ast::view_item_use(ident, metadata, p.get_id());
-}
-
-fn parse_view_path(p: parser) -> @ast::view_path {
-    let lo = p.span.lo;
-    let first_ident = parse_ident(p);
-    let path = [first_ident];
-    #debug("parsed view_path: %s", first_ident);
-    alt p.token {
-      token::EQ {
-        // x = foo::bar
-        p.bump();
-        path = [parse_ident(p)];
-        while p.token == token::MOD_SEP {
-            p.bump();
-            let id = parse_ident(p);
-            path += [id];
-        }
-        let hi = p.span.hi;
-        ret @spanned(lo, hi,
-                     ast::view_path_simple(first_ident,
-                                           @path, p.get_id()));
-      }
-
-      token::MOD_SEP {
-        // foo::bar or foo::{a,b,c} or foo::*
-        while p.token == token::MOD_SEP {
-            p.bump();
-
-            alt p.token {
-
-              token::IDENT(i, _) {
-                p.bump();
-                path += [p.get_str(i)];
-              }
-
-              // foo::bar::{a,b,c}
-              token::LBRACE {
-                let idents =
-                    parse_seq(token::LBRACE, token::RBRACE,
-                              seq_sep(token::COMMA),
-                              parse_path_list_ident, p).node;
-                let hi = p.span.hi;
-                ret @spanned(lo, hi,
-                             ast::view_path_list(@path, idents,
-                                                 p.get_id()));
-              }
-
-              // foo::bar::*
-              token::BINOP(token::STAR) {
-                p.bump();
-                let hi = p.span.hi;
-                ret @spanned(lo, hi,
-                             ast::view_path_glob(@path,
-                                                 p.get_id()));
-              }
-
-              _ { break; }
-            }
-        }
-      }
-      _ { }
-    }
-    let hi = p.span.hi;
-    let last = path[vec::len(path) - 1u];
-    ret @spanned(lo, hi,
-                 ast::view_path_simple(last, @path,
-                                       p.get_id()));
-}
-
-fn parse_view_paths(p: parser) -> [@ast::view_path] {
-    let vp = [parse_view_path(p)];
-    while p.token == token::COMMA {
-        p.bump();
-        vp += [parse_view_path(p)];
-    }
-    ret vp;
-}
-
-fn parse_view_item(p: parser) -> @ast::view_item {
-    let lo = p.span.lo;
-    let the_item =
-        if eat_word(p, "use") {
-            parse_use(p)
-        } else if eat_word(p, "import") {
-            ast::view_item_import(parse_view_paths(p))
-        } else if eat_word(p, "export") {
-            ast::view_item_export(parse_view_paths(p))
-        } else {
-            fail
-    };
-    let hi = p.span.lo;
-    expect(p, token::SEMI);
-    ret @spanned(lo, hi, the_item);
-}
-
-fn is_view_item(p: parser) -> bool {
-    alt p.token {
-      token::IDENT(sid, false) {
-        let st = p.get_str(sid);
-        ret str::eq(st, "use") || str::eq(st, "import") ||
-                str::eq(st, "export");
-      }
-      _ { ret false; }
-    }
-}
-
-fn maybe_parse_view(
-    p: parser,
-    first_item_attrs: [ast::attribute]) -> [@ast::view_item] {
-
-    maybe_parse_view_while(p, first_item_attrs, is_view_item)
-}
-
-fn maybe_parse_view_import_only(
-    p: parser,
-    first_item_attrs: [ast::attribute]) -> [@ast::view_item] {
-
-    maybe_parse_view_while(p, first_item_attrs, bind is_word(_, "import"))
-}
-
-fn maybe_parse_view_while(
-    p: parser,
-    first_item_attrs: [ast::attribute],
-    f: fn@(parser) -> bool) -> [@ast::view_item] {
-
-    if vec::len(first_item_attrs) == 0u {
-        let items = [];
-        while f(p) { items += [parse_view_item(p)]; }
-        ret items;
-    } else {
-        // Shouldn't be any view items since we've already parsed an item attr
-        ret [];
-    }
-}
-
-fn parse_native_view(p: parser) -> [@ast::view_item] {
-    maybe_parse_view_while(p, [], is_view_item)
-}
-
-fn parse_crate_from_source_file(input: str, cfg: ast::crate_cfg,
-                                sess: parse_sess) -> @ast::crate {
-    let p = new_parser_from_file(sess, cfg, input, SOURCE_FILE);
-    let r = parse_crate_mod(p, cfg);
-    sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
-    ret r;
-}
-
-
-fn parse_expr_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
-                              sess: parse_sess) -> @ast::expr {
-    let p = new_parser_from_source_str(sess, cfg, name, fss_none, source);
-    let r = parse_expr(p);
-    sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
-    ret r;
-}
-
-fn parse_from_source_str<T>(f: fn (p: parser) -> T,
-                            name: str, ss: codemap::file_substr,
-                            source: @str, cfg: ast::crate_cfg,
-                            sess: parse_sess)
-    -> T
-{
-    let p = new_parser_from_source_str(sess, cfg, name, ss, source);
-    let r = f(p);
-    if !p.reader.is_eof() {
-        p.reader.fatal("expected end-of-string");
-    }
-    sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
-    ret r;
-}
-
-fn parse_crate_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
-                               sess: parse_sess) -> @ast::crate {
-    let p = new_parser_from_source_str(sess, cfg, name, fss_none, source);
-    let r = parse_crate_mod(p, cfg);
-    sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
-    ret r;
-}
-
-// Parses a source module as a crate
-fn parse_crate_mod(p: parser, _cfg: ast::crate_cfg) -> @ast::crate {
-    let lo = p.span.lo;
-    let crate_attrs = parse_inner_attrs_and_next(p);
-    let first_item_outer_attrs = crate_attrs.next;
-    let m = parse_mod_items(p, token::EOF, first_item_outer_attrs);
-    ret @spanned(lo, p.span.lo,
-                 {directives: [],
-                  module: m,
-                  attrs: crate_attrs.inner,
-                  config: p.cfg});
-}
-
-fn parse_str(p: parser) -> str {
-    alt p.token {
-      token::LIT_STR(s) { p.bump(); p.get_str(s) }
-      _ {
-        p.fatal("expected string literal")
-      }
-    }
-}
-
-// Logic for parsing crate files (.rc)
-//
-// Each crate file is a sequence of directives.
-//
-// Each directive imperatively extends its environment with 0 or more items.
-fn parse_crate_directive(p: parser, first_outer_attr: [ast::attribute]) ->
-   ast::crate_directive {
-
-    // Collect the next attributes
-    let outer_attrs = first_outer_attr + parse_outer_attributes(p);
-    // In a crate file outer attributes are only going to apply to mods
-    let expect_mod = vec::len(outer_attrs) > 0u;
-
-    let lo = p.span.lo;
-    if expect_mod || is_word(p, "mod") {
-        expect_word(p, "mod");
-        let id = parse_ident(p);
-        alt p.token {
-          // mod x = "foo.rs";
-          token::SEMI {
-            let hi = p.span.hi;
-            p.bump();
-            ret spanned(lo, hi, ast::cdir_src_mod(id, outer_attrs));
-          }
-          // mod x = "foo_dir" { ...directives... }
-          token::LBRACE {
-            p.bump();
-            let inner_attrs = parse_inner_attrs_and_next(p);
-            let mod_attrs = outer_attrs + inner_attrs.inner;
-            let next_outer_attr = inner_attrs.next;
-            let cdirs =
-                parse_crate_directives(p, token::RBRACE, next_outer_attr);
-            let hi = p.span.hi;
-            expect(p, token::RBRACE);
-            ret spanned(lo, hi,
-                        ast::cdir_dir_mod(id, cdirs, mod_attrs));
-          }
-          t { unexpected(p, t); }
-        }
-    } else if is_view_item(p) {
-        let vi = parse_view_item(p);
-        ret spanned(lo, vi.span.hi, ast::cdir_view_item(vi));
-    } else { ret p.fatal("expected crate directive"); }
-}
-
-fn parse_crate_directives(p: parser, term: token::token,
-                          first_outer_attr: [ast::attribute]) ->
-   [@ast::crate_directive] {
-
-    // This is pretty ugly. If we have an outer attribute then we can't accept
-    // seeing the terminator next, so if we do see it then fail the same way
-    // parse_crate_directive would
-    if vec::len(first_outer_attr) > 0u && p.token == term {
-        expect_word(p, "mod");
-    }
-
-    let cdirs: [@ast::crate_directive] = [];
-    let first_outer_attr = first_outer_attr;
-    while p.token != term {
-        let cdir = @parse_crate_directive(p, first_outer_attr);
-        cdirs += [cdir];
-        first_outer_attr = [];
-    }
-    ret cdirs;
-}
-
-fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg,
-                               sess: parse_sess) -> @ast::crate {
-    let p = new_parser_from_file(sess, cfg, input, CRATE_FILE);
-    let lo = p.span.lo;
-    let prefix = std::fs::dirname(p.reader.filemap.name);
-    let leading_attrs = parse_inner_attrs_and_next(p);
-    let crate_attrs = leading_attrs.inner;
-    let first_cdir_attr = leading_attrs.next;
-    let cdirs = parse_crate_directives(p, token::EOF, first_cdir_attr);
-    sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
-    let cx =
-        @{p: p,
-          sess: sess,
-          cfg: p.cfg};
-    let (companionmod, _) = fs::splitext(fs::basename(input));
-    let (m, attrs) = eval::eval_crate_directives_to_mod(
-        cx, cdirs, prefix, option::some(companionmod));
-    let hi = p.span.hi;
-    expect(p, token::EOF);
-    ret @spanned(lo, hi,
-                 {directives: cdirs,
-                  module: m,
-                  attrs: crate_attrs + attrs,
-                  config: p.cfg});
-}
-
-fn parse_crate_from_file(input: str, cfg: ast::crate_cfg, sess: parse_sess) ->
-   @ast::crate {
-    if str::ends_with(input, ".rc") {
-        parse_crate_from_crate_file(input, cfg, sess)
-    } else if str::ends_with(input, ".rs") {
-        parse_crate_from_source_file(input, cfg, sess)
-    } else {
-        sess.span_diagnostic.handler().fatal("unknown input file type: " +
-                                             input)
-    }
-}
-
-//
-// Local Variables:
-// mode: rust
-// fill-column: 78;
-// indent-tabs-mode: nil
-// c-basic-offset: 4
-// buffer-file-coding-system: utf-8-unix
-// End:
-//