src/comp/syntax/parse/parser.rs

   1
   2 import std::io;
   3 import std::vec;
   4 import std::str;
   5 import std::option;
   6 import std::option::some;
   7 import std::option::none;
   8 import std::either;
   9 import std::either::left;
  10 import std::either::right;
  11 import std::map::hashmap;
  12 import token::can_begin_expr;
  13 import ex = ext::base;
  14 import codemap::span;
  15 import std::map::new_str_hash;
  16 import util::interner;
  17 import ast::node_id;
  18 import ast::spanned;
  19
  20 tag restriction { UNRESTRICTED; RESTRICT_NO_CALL_EXPRS; }
  21
  22 tag file_type { CRATE_FILE; SOURCE_FILE; }
  23
  24 tag ty_or_bang { a_ty(@ast::ty); a_bang; }
  25
  26 type parse_sess = @{cm: codemap::codemap, mutable next_id: node_id};
  27
  28 fn next_node_id(sess: &parse_sess) -> node_id {
  29     let rv = sess.next_id;
  30     sess.next_id += 1;
  31     ret rv;
  32 }
  33
  34 type parser =
  35     obj {
  36         fn peek() -> token::token;
  37         fn bump();
  38         fn swap(token::token, uint, uint);
  39         fn look_ahead(uint) -> token::token;
  40         fn fatal(&str) -> ! ;
  41         fn warn(&str);
  42         fn restrict(restriction);
  43         fn get_restriction() -> restriction;
  44         fn get_file_type() -> file_type;
  45         fn get_cfg() -> ast::crate_cfg;
  46         fn get_span() -> span;
  47         fn get_lo_pos() -> uint;
  48         fn get_hi_pos() -> uint;
  49         fn get_last_lo_pos() -> uint;
  50         fn get_last_hi_pos() -> uint;
  51         fn get_prec_table() -> @[op_spec];
  52         fn get_str(token::str_num) -> str;
  53         fn get_reader() -> lexer::reader;
  54         fn get_filemap() -> codemap::filemap;
  55         fn get_bad_expr_words() -> hashmap<str, ()>;
  56         fn get_chpos() -> uint;
  57         fn get_byte_pos() -> uint;
  58         fn get_id() -> node_id;
  59         fn get_sess() -> parse_sess;
  60     };
  61
  62 fn new_parser_from_file(sess: parse_sess, cfg: &ast::crate_cfg, path: &str,
  63                         chpos: uint, byte_pos: uint, ftype: file_type) ->
  64    parser {
  65     let src = io::read_whole_file_str(path);
  66     let filemap = codemap::new_filemap(path, chpos, byte_pos);
  67     sess.cm.files += [filemap];
  68     let itr = @interner::mk(str::hash, str::eq);
  69     let rdr = lexer::new_reader(sess.cm, src, filemap, itr);
  70     ret new_parser(sess, cfg, rdr, ftype);
  71 }
  72
  73 fn new_parser(sess: parse_sess, cfg: &ast::crate_cfg, rdr: lexer::reader,
  74               ftype: file_type) -> parser {
  75     obj stdio_parser(sess: parse_sess,
  76                      cfg: ast::crate_cfg,
  77                      ftype: file_type,
  78                      mutable tok: token::token,
  79                      mutable tok_span: span,
  80                      mutable last_tok_span: span,
  81                      mutable buffer: [{tok: token::token, span: span}],
  82                      mutable restr: restriction,
  83                      rdr: lexer::reader,
  84                      precs: @[op_spec],
  85                      bad_words: hashmap<str, ()>) {
  86         fn peek() -> token::token { ret tok; }
  87         fn bump() {
  88             last_tok_span = tok_span;
  89             if vec::len(buffer) == 0u {
  90                 let next = lexer::next_token(rdr);
  91                 tok = next.tok;
  92                 tok_span = ast_util::mk_sp(next.chpos, rdr.get_chpos());
  93             } else {
  94                 let next = vec::pop(buffer);
  95                 tok = next.tok;
  96                 tok_span = next.span;
  97             }
  98         }
  99         fn swap(next: token::token, lo: uint, hi: uint) {
 100             tok = next;
 101             tok_span = ast_util::mk_sp(lo, hi);
 102         }
 103         fn look_ahead(distance: uint) -> token::token {
 104             while vec::len(buffer) < distance {
 105                 let next = lexer::next_token(rdr);
 106                 let sp = ast_util::mk_sp(next.chpos, rdr.get_chpos());
 107                 buffer = [{tok: next.tok, span: sp}] + buffer;
 108             }
 109             ret buffer[distance - 1u].tok;
 110         }
 111         fn fatal(m: &str) -> ! {
 112             codemap::emit_error(some(self.get_span()), m, sess.cm);
 113             fail;
 114         }
 115         fn warn(m: &str) {
 116             codemap::emit_warning(some(self.get_span()), m, sess.cm);
 117         }
 118         fn restrict(r: restriction) { restr = r; }
 119         fn get_restriction() -> restriction { ret restr; }
 120         fn get_span() -> span { ret tok_span; }
 121         fn get_lo_pos() -> uint { ret tok_span.lo; }
 122         fn get_hi_pos() -> uint { ret tok_span.hi; }
 123         fn get_last_lo_pos() -> uint { ret last_tok_span.lo; }
 124         fn get_last_hi_pos() -> uint { ret last_tok_span.hi; }
 125         fn get_file_type() -> file_type { ret ftype; }
 126         fn get_cfg() -> ast::crate_cfg { ret cfg; }
 127         fn get_prec_table() -> @[op_spec] { ret precs; }
 128         fn get_str(i: token::str_num) -> str {
 129             ret interner::get(*rdr.get_interner(), i);
 130         }
 131         fn get_reader() -> lexer::reader { ret rdr; }
 132         fn get_filemap() -> codemap::filemap { ret rdr.get_filemap(); }
 133         fn get_bad_expr_words() -> hashmap<str, ()> { ret bad_words; }
 134         fn get_chpos() -> uint { ret rdr.get_chpos(); }
 135         fn get_byte_pos() -> uint { ret rdr.get_byte_pos(); }
 136         fn get_id() -> node_id { ret next_node_id(sess); }
 137         fn get_sess() -> parse_sess { ret sess; }
 138     }
 139     let tok0 = lexer::next_token(rdr);
 140     let span0 = ast_util::mk_sp(tok0.chpos, rdr.get_chpos());
 141     ret stdio_parser(sess, cfg, ftype, tok0.tok, span0, span0, [],
 142                      UNRESTRICTED, rdr, prec_table(), bad_expr_word_table());
 143 }
 144
 145 // These are the words that shouldn't be allowed as value identifiers,
 146 // because, if used at the start of a line, they will cause the line to be
 147 // interpreted as a specific kind of statement, which would be confusing.
 148 fn bad_expr_word_table() -> hashmap<str, ()> {
 149     let words = new_str_hash();
 150     words.insert("mod", ());
 151     words.insert("if", ());
 152     words.insert("else", ());
 153     words.insert("while", ());
 154     words.insert("do", ());
 155     words.insert("alt", ());
 156     words.insert("for", ());
 157     words.insert("each", ());
 158     words.insert("break", ());
 159     words.insert("cont", ());
 160     words.insert("put", ());
 161     words.insert("ret", ());
 162     words.insert("be", ());
 163     words.insert("fail", ());
 164     words.insert("type", ());
 165     words.insert("resource", ());
 166     words.insert("check", ());
 167     words.insert("assert", ());
 168     words.insert("claim", ());
 169     words.insert("prove", ());
 170     words.insert("native", ());
 171     words.insert("fn", ());
 172     words.insert("lambda", ());
 173     words.insert("pure", ());
 174     words.insert("iter", ());
 175     words.insert("block", ());
 176     words.insert("import", ());
 177     words.insert("export", ());
 178     words.insert("let", ());
 179     words.insert("const", ());
 180     words.insert("log", ());
 181     words.insert("log_err", ());
 182     words.insert("tag", ());
 183     words.insert("obj", ());
 184     words.insert("copy", ());
 185     ret words;
 186 }
 187
 188 fn unexpected(p: &parser, t: token::token) -> ! {
 189     let s: str = "unexpected token: ";
 190     s += token::to_str(p.get_reader(), t);
 191     p.fatal(s);
 192 }
 193
 194 fn expect(p: &parser, t: token::token) {
 195     if p.peek() == t {
 196         p.bump();
 197     } else {
 198         let s: str = "expecting ";
 199         s += token::to_str(p.get_reader(), t);
 200         s += ", found ";
 201         s += token::to_str(p.get_reader(), p.peek());
 202         p.fatal(s);
 203     }
 204 }
 205
 206 fn expect_gt(p: &parser) {
 207     if p.peek() == token::GT {
 208         p.bump();
 209     } else if p.peek() == token::BINOP(token::LSR) {
 210         p.swap(token::GT, p.get_lo_pos() + 1u, p.get_hi_pos());
 211     } else if p.peek() == token::BINOP(token::ASR) {
 212         p.swap(token::BINOP(token::LSR), p.get_lo_pos() + 1u, p.get_hi_pos());
 213     } else {
 214         let s: str = "expecting ";
 215         s += token::to_str(p.get_reader(), token::GT);
 216         s += ", found ";
 217         s += token::to_str(p.get_reader(), p.peek());
 218         p.fatal(s);
 219     }
 220 }
 221
 222 fn spanned<@T>(lo: uint, hi: uint, node: &T) -> spanned<T> {
 223     ret {node: node, span: ast_util::mk_sp(lo, hi)};
 224 }
 225
 226 fn parse_ident(p: &parser) -> ast::ident {
 227     alt p.peek() {
 228       token::IDENT(i, _) { p.bump(); ret p.get_str(i); }
 229       _ { p.fatal("expecting ident"); }
 230     }
 231 }
 232
 233 fn parse_value_ident(p: &parser) -> ast::ident {
 234     check_bad_word(p);
 235     ret parse_ident(p);
 236 }
 237
 238 fn eat(p: &parser, tok: &token::token) -> bool {
 239     ret if p.peek() == tok { p.bump(); true } else { false };
 240 }
 241
 242 fn is_word(p: &parser, word: &str) -> bool {
 243     ret alt p.peek() {
 244           token::IDENT(sid, false) { str::eq(word, p.get_str(sid)) }
 245           _ { false }
 246         };
 247 }
 248
 249 fn eat_word(p: &parser, word: &str) -> bool {
 250     alt p.peek() {
 251       token::IDENT(sid, false) {
 252         if str::eq(word, p.get_str(sid)) {
 253             p.bump();
 254             ret true;
 255         } else { ret false; }
 256       }
 257       _ { ret false; }
 258     }
 259 }
 260
 261 fn expect_word(p: &parser, word: &str) {
 262     if !eat_word(p, word) {
 263         p.fatal("expecting " + word + ", found " +
 264                     token::to_str(p.get_reader(), p.peek()));
 265     }
 266 }
 267
 268 fn check_bad_word(p: &parser) {
 269     alt p.peek() {
 270       token::IDENT(sid, false) {
 271         let w = p.get_str(sid);
 272         if p.get_bad_expr_words().contains_key(w) {
 273             p.fatal("found " + w + " in expression position");
 274         }
 275       }
 276       _ { }
 277     }
 278 }
 279
 280 fn parse_ty_fn(proto: ast::proto, p: &parser) -> ast::ty_ {
 281     fn parse_fn_input_ty(p: &parser) -> ast::ty_arg {
 282         let lo = p.get_lo_pos();
 283         // Ignore arg name, if present
 284         if is_plain_ident(p) && p.look_ahead(1u) == token::COLON {
 285             p.bump();
 286             p.bump();
 287         }
 288         let mode = ast::val;
 289         if p.peek() == token::BINOP(token::AND) {
 290             p.bump();
 291             mode = ast::alias(eat_word(p, "mutable"));
 292         }
 293         let t = parse_ty(p, false);
 294         ret spanned(lo, t.span.hi, {mode: mode, ty: t});
 295     }
 296     let lo = p.get_lo_pos();
 297     let inputs =
 298         parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
 299                   parse_fn_input_ty, p);
 300     // FIXME: there's no syntax for this right now anyway
 301     //  auto constrs = parse_constrs(~[], p);
 302     let constrs: [@ast::constr] = [];
 303     let output: @ast::ty;
 304     let cf = ast::return;
 305     if p.peek() == token::RARROW {
 306         p.bump();
 307         let tmp = parse_ty_or_bang(p);
 308         alt tmp {
 309           a_ty(t) { output = t; }
 310           a_bang. {
 311             output = @spanned(lo, inputs.span.hi, ast::ty_bot);
 312             cf = ast::noreturn;
 313           }
 314         }
 315     } else { output = @spanned(lo, inputs.span.hi, ast::ty_nil); }
 316     ret ast::ty_fn(proto, inputs.node, output, cf, constrs);
 317 }
 318
 319 fn parse_proto(p: &parser) -> ast::proto {
 320     if eat_word(p, "iter") {
 321         ret ast::proto_iter;
 322     } else if eat_word(p, "fn") {
 323         ret ast::proto_fn;
 324     } else if eat_word(p, "block") {
 325         ret ast::proto_block;
 326     } else { unexpected(p, p.peek()); }
 327 }
 328
 329 fn parse_ty_obj(p: &parser, hi: &mutable uint) -> ast::ty_ {
 330     fn parse_method_sig(p: &parser) -> ast::ty_method {
 331         let flo = p.get_lo_pos();
 332         let proto: ast::proto = parse_proto(p);
 333         let ident = parse_value_ident(p);
 334         let f = parse_ty_fn(proto, p);
 335         expect(p, token::SEMI);
 336         alt f {
 337           ast::ty_fn(proto, inputs, output, cf, constrs) {
 338             ret spanned(flo, output.span.hi,
 339                         {proto: proto,
 340                          ident: ident,
 341                          inputs: inputs,
 342                          output: output,
 343                          cf: cf,
 344                          constrs: constrs});
 345           }
 346         }
 347     }
 348     let meths =
 349         parse_seq(token::LBRACE, token::RBRACE, none, parse_method_sig, p);
 350     hi = meths.span.hi;
 351     ret ast::ty_obj(meths.node);
 352 }
 353
 354 fn parse_mt(p: &parser) -> ast::mt {
 355     let mut = parse_mutability(p);
 356     let t = parse_ty(p, false);
 357     ret {ty: t, mut: mut};
 358 }
 359
 360 fn parse_ty_field(p: &parser) -> ast::ty_field {
 361     let lo = p.get_lo_pos();
 362     let mut = parse_mutability(p);
 363     let id = parse_ident(p);
 364     expect(p, token::COLON);
 365     let ty = parse_ty(p, false);
 366     ret spanned(lo, ty.span.hi, {ident: id, mt: {ty: ty, mut: mut}});
 367 }
 368
 369 // if i is the jth ident in args, return j
 370 // otherwise, fail
 371 fn ident_index(p: &parser, args: &[ast::arg], i: &ast::ident) -> uint {
 372     let j = 0u;
 373     for a: ast::arg in args { if a.ident == i { ret j; } j += 1u; }
 374     p.fatal("Unbound variable " + i + " in constraint arg");
 375 }
 376
 377 fn parse_type_constr_arg(p: &parser) -> @ast::ty_constr_arg {
 378     let sp = p.get_span();
 379     let carg = ast::carg_base;
 380     expect(p, token::BINOP(token::STAR));
 381     if p.peek() == token::DOT {
 382         // "*..." notation for record fields
 383         p.bump();
 384         let pth: ast::path = parse_path(p);
 385         carg = ast::carg_ident(pth);
 386     }
 387     // No literals yet, I guess?
 388     ret @{node: carg, span: sp};
 389 }
 390
 391 fn parse_constr_arg(args: &[ast::arg], p: &parser) -> @ast::constr_arg {
 392     let sp = p.get_span();
 393     let carg = ast::carg_base;
 394     if p.peek() == token::BINOP(token::STAR) {
 395         p.bump();
 396     } else {
 397         let i: ast::ident = parse_value_ident(p);
 398         carg = ast::carg_ident(ident_index(p, args, i));
 399     }
 400     ret @{node: carg, span: sp};
 401 }
 402
 403 fn parse_ty_constr(fn_args: &[ast::arg], p: &parser) -> @ast::constr {
 404     let lo = p.get_lo_pos();
 405     let path = parse_path(p);
 406     let pf = bind parse_constr_arg(fn_args, _);
 407     let args: {node: [@ast::constr_arg], span: span} =
 408         parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), pf, p);
 409     ret @spanned(lo, args.span.hi,
 410                  {path: path, args: args.node, id: p.get_id()});
 411 }
 412
 413 fn parse_constr_in_type(p: &parser) -> @ast::ty_constr {
 414     let lo = p.get_lo_pos();
 415     let path = parse_path(p);
 416     let args: [@ast::ty_constr_arg] =
 417         parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
 418                   parse_type_constr_arg, p).node;
 419     let hi = p.get_lo_pos();
 420     let tc: ast::ty_constr_ = {path: path, args: args, id: p.get_id()};
 421     ret @spanned(lo, hi, tc);
 422 }
 423
 424
 425 fn parse_constrs<T>(pser: fn(&parser) -> @ast::constr_general<T>, p: &parser)
 426    -> [@ast::constr_general<T>] {
 427     let constrs: [@ast::constr_general<T>] = [];
 428     while true {
 429         let constr = pser(p);
 430         constrs += [constr];
 431         if p.peek() == token::COMMA { p.bump(); } else { break; }
 432     }
 433     constrs
 434 }
 435
 436 fn parse_type_constraints(p: &parser) -> [@ast::ty_constr] {
 437     ret parse_constrs(parse_constr_in_type, p);
 438 }
 439
 440 fn parse_ty_postfix(orig_t: ast::ty_, p: &parser, colons_before_params: bool)
 441    -> @ast::ty {
 442     let lo = p.get_lo_pos();
 443
 444     if colons_before_params && p.peek() == token::MOD_SEP {
 445         p.bump();
 446         expect(p, token::LT);
 447     } else if !colons_before_params && p.peek() == token::LT {
 448         p.bump();
 449     } else { ret @spanned(lo, p.get_lo_pos(), orig_t); }
 450
 451     // If we're here, we have explicit type parameter instantiation.
 452     let seq = parse_seq_to_gt(some(token::COMMA), bind parse_ty(_, false), p);
 453
 454     alt orig_t {
 455       ast::ty_path(pth, ann) {
 456         let hi = p.get_hi_pos();
 457         ret @spanned(lo, hi,
 458                      ast::ty_path(spanned(lo, hi,
 459                                           {global: pth.node.global,
 460                                            idents: pth.node.idents,
 461                                            types: seq}), ann));
 462       }
 463       _ { p.fatal("type parameter instantiation only allowed for paths"); }
 464     }
 465 }
 466
 467 fn parse_ty_or_bang(p: &parser) -> ty_or_bang {
 468     alt p.peek() {
 469       token::NOT. { p.bump(); ret a_bang; }
 470       _ { ret a_ty(parse_ty(p, false)); }
 471     }
 472 }
 473
 474 fn parse_ty(p: &parser, colons_before_params: bool) -> @ast::ty {
 475     let lo = p.get_lo_pos();
 476     let hi = lo;
 477     let t: ast::ty_;
 478     // FIXME: do something with this
 479
 480     if eat_word(p, "bool") {
 481         t = ast::ty_bool;
 482     } else if eat_word(p, "int") {
 483         t = ast::ty_int;
 484     } else if eat_word(p, "uint") {
 485         t = ast::ty_uint;
 486     } else if eat_word(p, "float") {
 487         t = ast::ty_float;
 488     } else if eat_word(p, "str") {
 489         t = ast::ty_str;
 490     } else if eat_word(p, "char") {
 491         t = ast::ty_char;
 492         /*
 493             } else if (eat_word(p, "task")) {
 494                 t = ast::ty_task;
 495         */
 496     } else if eat_word(p, "i8") {
 497         t = ast::ty_machine(ast::ty_i8);
 498     } else if eat_word(p, "i16") {
 499         t = ast::ty_machine(ast::ty_i16);
 500     } else if eat_word(p, "i32") {
 501         t = ast::ty_machine(ast::ty_i32);
 502     } else if eat_word(p, "i64") {
 503         t = ast::ty_machine(ast::ty_i64);
 504     } else if eat_word(p, "u8") {
 505         t = ast::ty_machine(ast::ty_u8);
 506     } else if eat_word(p, "u16") {
 507         t = ast::ty_machine(ast::ty_u16);
 508     } else if eat_word(p, "u32") {
 509         t = ast::ty_machine(ast::ty_u32);
 510     } else if eat_word(p, "u64") {
 511         t = ast::ty_machine(ast::ty_u64);
 512     } else if eat_word(p, "f32") {
 513         t = ast::ty_machine(ast::ty_f32);
 514     } else if eat_word(p, "f64") {
 515         t = ast::ty_machine(ast::ty_f64);
 516     } else if p.peek() == token::LPAREN {
 517         p.bump();
 518         if p.peek() == token::RPAREN {
 519             hi = p.get_hi_pos();
 520             p.bump();
 521             t = ast::ty_nil;
 522         } else {
 523             let ts = [parse_ty(p, false)];
 524             while p.peek() == token::COMMA {
 525                 p.bump();
 526                 ts += [parse_ty(p, false)];
 527             }
 528             if vec::len(ts) == 1u {
 529                 t = ts[0].node;
 530             } else { t = ast::ty_tup(ts); }
 531             hi = p.get_hi_pos();
 532             expect(p, token::RPAREN);
 533         }
 534     } else if p.peek() == token::AT {
 535         p.bump();
 536         let mt = parse_mt(p);
 537         hi = mt.ty.span.hi;
 538         t = ast::ty_box(mt);
 539     } else if p.peek() == token::BINOP(token::STAR) {
 540         p.bump();
 541         let mt = parse_mt(p);
 542         hi = mt.ty.span.hi;
 543         t = ast::ty_ptr(mt);
 544     } else if p.peek() == token::LBRACE {
 545         let elems =
 546             parse_seq(token::LBRACE, token::RBRACE, some(token::COMMA),
 547                       parse_ty_field, p);
 548         hi = elems.span.hi;
 549         t = ast::ty_rec(elems.node);
 550         if p.peek() == token::COLON {
 551             p.bump();
 552             t =
 553                 ast::ty_constr(@spanned(lo, hi, t),
 554                                parse_type_constraints(p));
 555         }
 556     } else if p.peek() == token::LBRACKET {
 557         expect(p, token::LBRACKET);
 558         t = ast::ty_vec(parse_mt(p));
 559         hi = p.get_hi_pos();
 560         expect(p, token::RBRACKET);
 561     } else if eat_word(p, "fn") {
 562         t = parse_ty_fn(ast::proto_fn, p);
 563         alt t { ast::ty_fn(_, _, out, _, _) { hi = out.span.hi; } }
 564     } else if eat_word(p, "block") {
 565         t = parse_ty_fn(ast::proto_block, p);
 566         alt t { ast::ty_fn(_, _, out, _, _) { hi = out.span.hi; } }
 567     } else if eat_word(p, "iter") {
 568         t = parse_ty_fn(ast::proto_iter, p);
 569         alt t { ast::ty_fn(_, _, out, _, _) { hi = out.span.hi; } }
 570     } else if eat_word(p, "obj") {
 571         t = parse_ty_obj(p, hi);
 572     } else if eat_word(p, "mutable") {
 573         p.warn("ignoring deprecated 'mutable' type constructor");
 574         let typ = parse_ty(p, false);
 575         t = typ.node;
 576         hi = typ.span.hi;
 577     } else if p.peek() == token::MOD_SEP || is_ident(p.peek()) {
 578         let path = parse_path(p);
 579         t = ast::ty_path(path, p.get_id());
 580         hi = path.span.hi;
 581     } else { p.fatal("expecting type"); }
 582     ret parse_ty_postfix(t, p, colons_before_params);
 583 }
 584
 585 fn parse_arg_mode(p: &parser) -> ast::mode {
 586     if eat(p, token::BINOP(token::AND)) {
 587         ast::alias(eat_word(p, "mutable"))
 588     } else if eat(p, token::BINOP(token::MINUS)) {
 589         ast::move
 590     } else { ast::val }
 591 }
 592
 593 fn parse_arg(p: &parser) -> ast::arg {
 594     let i = parse_value_ident(p);
 595     expect(p, token::COLON);
 596     let m = parse_arg_mode(p);
 597     let t = parse_ty(p, false);
 598     ret {mode: m, ty: t, ident: i, id: p.get_id()};
 599 }
 600
 601 fn parse_fn_block_arg(p: &parser) -> ast::arg {
 602     let m = parse_arg_mode(p);
 603     let i = parse_value_ident(p);
 604     let t = @spanned(p.get_lo_pos(), p.get_hi_pos(), ast::ty_infer);
 605     ret {mode: m, ty: t, ident: i, id: p.get_id()};
 606 }
 607
 608 fn parse_seq_to_before_gt<T>(sep: option::t<token::token>,
 609                              f: fn(&parser) -> T, p: &parser) -> [T] {
 610     let first = true;
 611     let v = [];
 612     while p.peek() != token::GT && p.peek() != token::BINOP(token::LSR) &&
 613               p.peek() != token::BINOP(token::ASR) {
 614         alt sep {
 615           some(t) { if first { first = false; } else { expect(p, t); } }
 616           _ { }
 617         }
 618         v += [f(p)];
 619     }
 620
 621     ret v;
 622 }
 623
 624 fn parse_seq_to_gt<T>(sep: option::t<token::token>, f: fn(&parser) -> T,
 625                       p: &parser) -> [T] {
 626     let v = parse_seq_to_before_gt(sep, f, p);
 627     expect_gt(p);
 628
 629     ret v;
 630 }
 631
 632 fn parse_seq_lt_gt<T>(sep: option::t<token::token>, f: fn(&parser) -> T,
 633                       p: &parser) -> spanned<[T]> {
 634     let lo = p.get_lo_pos();
 635     expect(p, token::LT);
 636     let result = parse_seq_to_before_gt::<T>(sep, f, p);
 637     let hi = p.get_hi_pos();
 638     expect_gt(p);
 639     ret spanned(lo, hi, result);
 640 }
 641
 642 fn parse_seq_to_end<T>(ket: token::token, sep: option::t<token::token>,
 643                        f: fn(&parser) -> T, p: &parser) -> [T] {
 644     let val = parse_seq_to_before_end(ket, sep, f, p);
 645     p.bump();
 646     ret val;
 647 }
 648
 649 fn parse_seq_to_before_end<T>(ket: token::token, sep: option::t<token::token>,
 650                               f: fn(&parser) -> T, p: &parser) -> [T] {
 651     let first: bool = true;
 652     let v: [T] = [];
 653     while p.peek() != ket {
 654         alt sep {
 655           some(t) { if first { first = false; } else { expect(p, t); } }
 656           _ { }
 657         }
 658         v += [f(p)];
 659     }
 660     ret v;
 661 }
 662
 663
 664 fn parse_seq<T>(bra: token::token, ket: token::token,
 665                 sep: option::t<token::token>, f: fn(&parser) -> T, p: &parser)
 666    -> spanned<[T]> {
 667     let lo = p.get_lo_pos();
 668     expect(p, bra);
 669     let result = parse_seq_to_before_end::<T>(ket, sep, f, p);
 670     let hi = p.get_hi_pos();
 671     p.bump();
 672     ret spanned(lo, hi, result);
 673 }
 674
 675
 676 fn parse_lit(p: &parser) -> ast::lit {
 677     let sp = p.get_span();
 678     let lit: ast::lit_ = ast::lit_nil;
 679     if eat_word(p, "true") {
 680         lit = ast::lit_bool(true);
 681     } else if eat_word(p, "false") {
 682         lit = ast::lit_bool(false);
 683     } else {
 684         alt p.peek() {
 685           token::LIT_INT(i) { p.bump(); lit = ast::lit_int(i); }
 686           token::LIT_UINT(u) { p.bump(); lit = ast::lit_uint(u); }
 687           token::LIT_FLOAT(s) {
 688             p.bump();
 689             lit = ast::lit_float(p.get_str(s));
 690           }
 691           token::LIT_MACH_INT(tm, i) {
 692             p.bump();
 693             lit = ast::lit_mach_int(tm, i);
 694           }
 695           token::LIT_MACH_FLOAT(tm, s) {
 696             p.bump();
 697             lit = ast::lit_mach_float(tm, p.get_str(s));
 698           }
 699           token::LIT_CHAR(c) { p.bump(); lit = ast::lit_char(c); }
 700           token::LIT_STR(s) { p.bump(); lit = ast::lit_str(p.get_str(s)); }
 701           token::LPAREN. {
 702             p.bump();
 703             expect(p, token::RPAREN);
 704             lit = ast::lit_nil;
 705           }
 706           t { unexpected(p, t); }
 707         }
 708     }
 709     ret {node: lit, span: sp};
 710 }
 711
 712 fn is_ident(t: token::token) -> bool {
 713     alt t { token::IDENT(_, _) { ret true; } _ { } }
 714     ret false;
 715 }
 716
 717 fn is_plain_ident(p: &parser) -> bool {
 718     ret alt p.peek() { token::IDENT(_, false) { true } _ { false } };
 719 }
 720
 721 fn parse_path(p: &parser) -> ast::path {
 722     let lo = p.get_lo_pos();
 723     let hi = lo;
 724
 725     let global;
 726     if p.peek() == token::MOD_SEP {
 727         global = true;
 728         p.bump();
 729     } else { global = false; }
 730
 731     let ids: [ast::ident] = [];
 732     while true {
 733         alt p.peek() {
 734           token::IDENT(i, _) {
 735             hi = p.get_hi_pos();
 736             ids += [p.get_str(i)];
 737             hi = p.get_hi_pos();
 738             p.bump();
 739             if p.peek() == token::MOD_SEP && p.look_ahead(1u) != token::LT {
 740                 p.bump();
 741             } else { break; }
 742           }
 743           _ { break; }
 744         }
 745     }
 746     ret spanned(lo, hi, {global: global, idents: ids, types: []});
 747 }
 748
 749 fn parse_path_and_ty_param_substs(p: &parser) -> ast::path {
 750     let lo = p.get_lo_pos();
 751     let path = parse_path(p);
 752     if p.peek() == token::MOD_SEP {
 753         p.bump();
 754
 755         let seq =
 756             parse_seq_lt_gt(some(token::COMMA), bind parse_ty(_, false), p);
 757         let hi = seq.span.hi;
 758         path =
 759             spanned(lo, hi,
 760                     {global: path.node.global,
 761                      idents: path.node.idents,
 762                      types: seq.node});
 763     }
 764     ret path;
 765 }
 766
 767 fn parse_mutability(p: &parser) -> ast::mutability {
 768     if eat_word(p, "mutable") {
 769         if p.peek() == token::QUES { p.bump(); ret ast::maybe_mut; }
 770         ret ast::mut;
 771     }
 772     ret ast::imm;
 773 }
 774
 775 fn parse_field(p: &parser, sep: &token::token) -> ast::field {
 776     let lo = p.get_lo_pos();
 777     let m = parse_mutability(p);
 778     let i = parse_ident(p);
 779     expect(p, sep);
 780     let e = parse_expr(p);
 781     ret spanned(lo, e.span.hi, {mut: m, ident: i, expr: e});
 782 }
 783
 784 fn mk_expr(p: &parser, lo: uint, hi: uint, node: &ast::expr_) -> @ast::expr {
 785     ret @{id: p.get_id(), node: node, span: ast_util::mk_sp(lo, hi)};
 786 }
 787
 788 fn mk_mac_expr(p: &parser, lo: uint, hi: uint, m: &ast::mac_) -> @ast::expr {
 789     ret @{id: p.get_id(),
 790           node: ast::expr_mac({node: m, span: ast_util::mk_sp(lo, hi)}),
 791           span: ast_util::mk_sp(lo, hi)};
 792 }
 793
 794 fn parse_bottom_expr(p: &parser) -> @ast::expr {
 795     let lo = p.get_lo_pos();
 796     let hi = p.get_hi_pos();
 797
 798     let ex: ast::expr_;
 799     if p.peek() == token::LPAREN {
 800         p.bump();
 801         if p.peek() == token::RPAREN {
 802             hi = p.get_hi_pos();
 803             p.bump();
 804             let lit = @spanned(lo, hi, ast::lit_nil);
 805             ret mk_expr(p, lo, hi, ast::expr_lit(lit));
 806         }
 807         let es = [parse_expr(p)];
 808         while p.peek() == token::COMMA { p.bump(); es += [parse_expr(p)]; }
 809         hi = p.get_hi_pos();
 810         expect(p, token::RPAREN);
 811         if vec::len(es) == 1u {
 812             ret mk_expr(p, lo, hi, es[0].node);
 813         } else { ret mk_expr(p, lo, hi, ast::expr_tup(es)); }
 814     } else if p.peek() == token::LBRACE {
 815         p.bump();
 816         if is_word(p, "mutable") ||
 817                is_plain_ident(p) && p.look_ahead(1u) == token::COLON {
 818             let fields = [parse_field(p, token::COLON)];
 819             let base = none;
 820             while p.peek() != token::RBRACE {
 821                 if eat_word(p, "with") { base = some(parse_expr(p)); break; }
 822                 expect(p, token::COMMA);
 823                 fields += [parse_field(p, token::COLON)];
 824             }
 825             hi = p.get_hi_pos();
 826             expect(p, token::RBRACE);
 827             ex = ast::expr_rec(fields, base);
 828         } else if p.peek() == token::BINOP(token::OR) {
 829             ret parse_fn_block_expr(p);
 830         } else {
 831             let blk = parse_block_tail(p, lo, ast::checked);
 832             ret mk_expr(p, blk.span.lo, blk.span.hi, ast::expr_block(blk));
 833         }
 834     } else if eat_word(p, "if") {
 835         ret parse_if_expr(p);
 836     } else if eat_word(p, "for") {
 837         ret parse_for_expr(p);
 838     } else if eat_word(p, "while") {
 839         ret parse_while_expr(p);
 840     } else if eat_word(p, "do") {
 841         ret parse_do_while_expr(p);
 842     } else if eat_word(p, "alt") {
 843         ret parse_alt_expr(p);
 844         /*
 845             } else if (eat_word(p, "spawn")) {
 846                 ret parse_spawn_expr(p);
 847         */
 848     } else if eat_word(p, "fn") {
 849         ret parse_fn_expr(p, ast::proto_fn);
 850     } else if eat_word(p, "block") {
 851         ret parse_fn_expr(p, ast::proto_block);
 852     } else if eat_word(p, "lambda") {
 853         ret parse_fn_expr(p, ast::proto_closure);
 854     } else if eat_word(p, "unchecked") {
 855         expect(p, token::LBRACE);
 856         let blk = parse_block_tail(p, lo, ast::unchecked);
 857         ret mk_expr(p, blk.span.lo, blk.span.hi, ast::expr_block(blk));
 858     } else if p.peek() == token::LBRACKET {
 859         p.bump();
 860         let mut = parse_mutability(p);
 861         let es =
 862             parse_seq_to_end(token::RBRACKET, some(token::COMMA), parse_expr,
 863                              p);
 864         ex = ast::expr_vec(es, mut);
 865     } else if p.peek() == token::POUND_LT {
 866         p.bump();
 867         let ty = parse_ty(p, false);
 868         expect(p, token::GT);
 869
 870         /* hack: early return to take advantage of specialized function */
 871         ret mk_mac_expr(p, lo, p.get_hi_pos(), ast::mac_embed_type(ty))
 872     } else if p.peek() == token::POUND_LBRACE {
 873         p.bump();
 874         let blk = ast::mac_embed_block(parse_block_tail(p, lo, ast::checked));
 875         ret mk_mac_expr(p, lo, p.get_hi_pos(), blk);
 876     } else if p.peek() == token::ELLIPSIS {
 877         p.bump();
 878         ret mk_mac_expr(p, lo, p.get_hi_pos(), ast::mac_ellipsis)
 879     } else if p.peek() == token::TILDE {
 880         p.bump();
 881         ex = ast::expr_uniq(parse_expr(p));
 882     } else if eat_word(p, "obj") {
 883         // Anonymous object
 884
 885         // Only make people type () if they're actually adding new fields
 886         let fields: option::t<[ast::anon_obj_field]> = none;
 887         if p.peek() == token::LPAREN {
 888             p.bump();
 889             fields =
 890                 some(parse_seq_to_end(token::RPAREN, some(token::COMMA),
 891                                       parse_anon_obj_field, p));
 892         }
 893         let meths: [@ast::method] = [];
 894         let inner_obj: option::t<@ast::expr> = none;
 895         expect(p, token::LBRACE);
 896         while p.peek() != token::RBRACE {
 897             if eat_word(p, "with") {
 898                 inner_obj = some(parse_expr(p));
 899             } else { meths += [parse_method(p)]; }
 900         }
 901         hi = p.get_hi_pos();
 902         expect(p, token::RBRACE);
 903         // fields and methods may be *additional* or *overriding* fields
 904         // and methods if there's a inner_obj, or they may be the *only*
 905         // fields and methods if there's no inner_obj.
 906
 907         // We don't need to pull ".node" out of fields because it's not a
 908         // "spanned".
 909         let ob = {fields: fields, methods: meths, inner_obj: inner_obj};
 910         ex = ast::expr_anon_obj(ob);
 911     } else if eat_word(p, "bind") {
 912         let e = parse_expr_res(p, RESTRICT_NO_CALL_EXPRS);
 913         fn parse_expr_opt(p: &parser) -> option::t<@ast::expr> {
 914             alt p.peek() {
 915               token::UNDERSCORE. { p.bump(); ret none; }
 916               _ { ret some(parse_expr(p)); }
 917             }
 918         }
 919         let es =
 920             parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
 921                       parse_expr_opt, p);
 922         hi = es.span.hi;
 923         ex = ast::expr_bind(e, es.node);
 924     } else if p.peek() == token::POUND {
 925         let ex_ext = parse_syntax_ext(p);
 926         hi = ex_ext.span.hi;
 927         ex = ex_ext.node;
 928     } else if eat_word(p, "fail") {
 929         if can_begin_expr(p.peek()) {
 930             let e = parse_expr(p);
 931             hi = e.span.hi;
 932             ex = ast::expr_fail(some(e));
 933         } else { ex = ast::expr_fail(none); }
 934     } else if eat_word(p, "log") {
 935         let e = parse_expr(p);
 936         ex = ast::expr_log(1, e);
 937         hi = e.span.hi;
 938     } else if eat_word(p, "log_err") {
 939         let e = parse_expr(p);
 940         ex = ast::expr_log(0, e);
 941         hi = e.span.hi;
 942     } else if eat_word(p, "assert") {
 943         let e = parse_expr(p);
 944         ex = ast::expr_assert(e);
 945         hi = e.span.hi;
 946     } else if eat_word(p, "check") {
 947         /* Should be a predicate (pure boolean function) applied to
 948            arguments that are all either slot variables or literals.
 949            but the typechecker enforces that. */
 950
 951         let e = parse_expr(p);
 952         hi = e.span.hi;
 953         ex = ast::expr_check(ast::checked, e);
 954     } else if eat_word(p, "claim") {
 955         /* Same rules as check, except that if check-claims
 956          is enabled (a command-line flag), then the parser turns
 957         claims into check */
 958
 959         let e = parse_expr(p);
 960         hi = e.span.hi;
 961         ex = ast::expr_check(ast::unchecked, e);
 962     } else if eat_word(p, "ret") {
 963         if can_begin_expr(p.peek()) {
 964             let e = parse_expr(p);
 965             hi = e.span.hi;
 966             ex = ast::expr_ret(some(e));
 967         } else { ex = ast::expr_ret(none); }
 968     } else if eat_word(p, "break") {
 969         ex = ast::expr_break;
 970         hi = p.get_hi_pos();
 971     } else if eat_word(p, "cont") {
 972         ex = ast::expr_cont;
 973         hi = p.get_hi_pos();
 974     } else if eat_word(p, "put") {
 975         alt p.peek() {
 976           token::SEMI. { ex = ast::expr_put(none); }
 977           _ {
 978             let e = parse_expr(p);
 979             hi = e.span.hi;
 980             ex = ast::expr_put(some(e));
 981           }
 982         }
 983     } else if eat_word(p, "be") {
 984         let e = parse_expr(p);
 985
 986         // FIXME: Is this the right place for this check?
 987         if /*check*/ast_util::is_call_expr(e) {
 988             hi = e.span.hi;
 989             ex = ast::expr_be(e);
 990         } else { p.fatal("Non-call expression in tail call"); }
 991     } else if eat_word(p, "copy") {
 992         let e = parse_expr(p);
 993         ex = ast::expr_copy(e);
 994         hi = e.span.hi;
 995     } else if eat_word(p, "self") {
 996         expect(p, token::DOT);
 997         // The rest is a call expression.
 998         let f: @ast::expr = parse_self_method(p);
 999         let es =
1000             parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
1001                       parse_expr, p);
1002         hi = es.span.hi;
1003         ex = ast::expr_call(f, es.node);
1004     } else if p.peek() == token::MOD_SEP ||
1005                   is_ident(p.peek()) && !is_word(p, "true") &&
1006                       !is_word(p, "false") {
1007         check_bad_word(p);
1008         let pth = parse_path_and_ty_param_substs(p);
1009         hi = pth.span.hi;
1010         ex = ast::expr_path(pth);
1011     } else {
1012         let lit = parse_lit(p);
1013         hi = lit.span.hi;
1014         ex = ast::expr_lit(@lit);
1015     }
1016     ret mk_expr(p, lo, hi, ex);
1017 }
1018
1019 fn parse_syntax_ext(p: &parser) -> @ast::expr {
1020     let lo = p.get_lo_pos();
1021     expect(p, token::POUND);
1022     ret parse_syntax_ext_naked(p, lo);
1023 }
1024
1025 fn parse_syntax_ext_naked(p: &parser, lo: uint) -> @ast::expr {
1026     let pth = parse_path(p);
1027     if vec::len(pth.node.idents) == 0u {
1028         p.fatal("expected a syntax expander name");
1029     }
1030     //temporary for a backwards-compatible cycle:
1031     let es =
1032         if p.peek() == token::LPAREN {
1033             parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
1034                       parse_expr, p)
1035         } else {
1036             parse_seq(token::LBRACKET, token::RBRACKET, some(token::COMMA),
1037                       parse_expr, p)
1038         };
1039     let hi = es.span.hi;
1040     let e = mk_expr(p, es.span.lo, hi, ast::expr_vec(es.node, ast::imm));
1041     ret mk_mac_expr(p, lo, hi, ast::mac_invoc(pth, e, none));
1042 }
1043
1044 fn parse_self_method(p: &parser) -> @ast::expr {
1045     let sp = p.get_span();
1046     let f_name: ast::ident = parse_ident(p);
1047     ret mk_expr(p, sp.lo, sp.hi, ast::expr_self_method(f_name));
1048 }
1049
1050 fn parse_dot_or_call_expr(p: &parser) -> @ast::expr {
1051     ret parse_dot_or_call_expr_with(p, parse_bottom_expr(p));
1052 }
1053
1054 fn parse_dot_or_call_expr_with(p: &parser, e: @ast::expr) -> @ast::expr {
1055     let lo = e.span.lo;
1056     let hi = e.span.hi;
1057     while true {
1058         alt p.peek() {
1059           token::LPAREN. {
1060             if p.get_restriction() == RESTRICT_NO_CALL_EXPRS {
1061                 ret e;
1062             } else {
1063                 // Call expr.
1064
1065                 let es =
1066                     parse_seq(token::LPAREN, token::RPAREN,
1067                               some(token::COMMA), parse_expr, p);
1068                 hi = es.span.hi;
1069                 let nd = ast::expr_call(e, es.node);
1070                 e = mk_expr(p, lo, hi, nd);
1071             }
1072           }
1073           token::LBRACKET. {
1074             p.bump();
1075             let ix = parse_expr(p);
1076             hi = ix.span.hi;
1077             expect(p, token::RBRACKET);
1078             e = mk_expr(p, lo, hi, ast::expr_index(e, ix));
1079           }
1080           token::DOT. {
1081             p.bump();
1082             alt p.peek() {
1083               token::IDENT(i, _) {
1084                 hi = p.get_hi_pos();
1085                 p.bump();
1086                 e = mk_expr(p, lo, hi, ast::expr_field(e, p.get_str(i)));
1087               }
1088               t { unexpected(p, t); }
1089             }
1090           }
1091           _ { ret e; }
1092         }
1093     }
1094     ret e;
1095 }
1096
1097 fn parse_prefix_expr(p: &parser) -> @ast::expr {
1098     if eat_word(p, "mutable") {
1099         p.warn("ignoring deprecated 'mutable' prefix operator");
1100     }
1101     let lo = p.get_lo_pos();
1102     let hi = p.get_hi_pos();
1103
1104     let ex;
1105     alt p.peek() {
1106       token::NOT. {
1107         p.bump();
1108         let e = parse_prefix_expr(p);
1109         hi = e.span.hi;
1110         ex = ast::expr_unary(ast::not, e);
1111       }
1112       token::BINOP(b) {
1113         alt b {
1114           token::MINUS. {
1115             p.bump();
1116             let e = parse_prefix_expr(p);
1117             hi = e.span.hi;
1118             ex = ast::expr_unary(ast::neg, e);
1119           }
1120           token::STAR. {
1121             p.bump();
1122             let e = parse_prefix_expr(p);
1123             hi = e.span.hi;
1124             ex = ast::expr_unary(ast::deref, e);
1125           }
1126           _ { ret parse_dot_or_call_expr(p); }
1127         }
1128       }
1129       token::AT. {
1130         p.bump();
1131         let m = parse_mutability(p);
1132         let e = parse_prefix_expr(p);
1133         hi = e.span.hi;
1134         ex = ast::expr_unary(ast::box(m), e);
1135       }
1136       _ { ret parse_dot_or_call_expr(p); }
1137     }
1138     ret mk_expr(p, lo, hi, ex);
1139 }
1140
1141 fn parse_ternary(p: &parser) -> @ast::expr {
1142     let cond_expr = parse_binops(p);
1143     if p.peek() == token::QUES {
1144         p.bump();
1145         let then_expr = parse_expr(p);
1146         expect(p, token::COLON);
1147         let else_expr = parse_expr(p);
1148         ret mk_expr(p, cond_expr.span.lo, else_expr.span.hi,
1149                     ast::expr_ternary(cond_expr, then_expr, else_expr));
1150     } else { ret cond_expr; }
1151 }
1152
1153 type op_spec = {tok: token::token, op: ast::binop, prec: int};
1154
1155
1156 // FIXME make this a const, don't store it in parser state
1157 fn prec_table() -> @[op_spec] {
1158     ret @[{tok: token::BINOP(token::STAR), op: ast::mul, prec: 11},
1159           {tok: token::BINOP(token::SLASH), op: ast::div, prec: 11},
1160           {tok: token::BINOP(token::PERCENT), op: ast::rem, prec: 11},
1161           {tok: token::BINOP(token::PLUS), op: ast::add, prec: 10},
1162           {tok: token::BINOP(token::MINUS), op: ast::sub, prec: 10},
1163           {tok: token::BINOP(token::LSL), op: ast::lsl, prec: 9},
1164           {tok: token::BINOP(token::LSR), op: ast::lsr, prec: 9},
1165           {tok: token::BINOP(token::ASR), op: ast::asr, prec: 9},
1166           {tok: token::BINOP(token::AND), op: ast::bitand, prec: 8},
1167           {tok: token::BINOP(token::CARET), op: ast::bitxor, prec: 6},
1168           {tok: token::BINOP(token::OR), op: ast::bitor, prec: 6},
1169           // 'as' sits between here with 5
1170           {tok: token::LT, op: ast::lt, prec: 4},
1171           {tok: token::LE, op: ast::le, prec: 4},
1172           {tok: token::GE, op: ast::ge, prec: 4},
1173           {tok: token::GT, op: ast::gt, prec: 4},
1174           {tok: token::EQEQ, op: ast::eq, prec: 3},
1175           {tok: token::NE, op: ast::ne, prec: 3},
1176           {tok: token::ANDAND, op: ast::and, prec: 2},
1177           {tok: token::OROR, op: ast::or, prec: 1}];
1178 }
1179
1180 fn parse_binops(p: &parser) -> @ast::expr {
1181     ret parse_more_binops(p, parse_prefix_expr(p), 0);
1182 }
1183
1184 const unop_prec: int = 100;
1185
1186 const as_prec: int = 5;
1187 const ternary_prec: int = 0;
1188
1189 fn parse_more_binops(p: &parser, lhs: @ast::expr, min_prec: int) ->
1190    @ast::expr {
1191     let peeked = p.peek();
1192     for cur: op_spec in *p.get_prec_table() {
1193         if cur.prec > min_prec && cur.tok == peeked {
1194             p.bump();
1195             let rhs = parse_more_binops(p, parse_prefix_expr(p), cur.prec);
1196             let bin =
1197                 mk_expr(p, lhs.span.lo, rhs.span.hi,
1198                         ast::expr_binary(cur.op, lhs, rhs));
1199             ret parse_more_binops(p, bin, min_prec);
1200         }
1201     }
1202     if as_prec > min_prec && eat_word(p, "as") {
1203         let rhs = parse_ty(p, true);
1204         let _as =
1205             mk_expr(p, lhs.span.lo, rhs.span.hi, ast::expr_cast(lhs, rhs));
1206         ret parse_more_binops(p, _as, min_prec);
1207     }
1208     ret lhs;
1209 }
1210
1211 fn parse_assign_expr(p: &parser) -> @ast::expr {
1212     let lo = p.get_lo_pos();
1213     let lhs = parse_ternary(p);
1214     alt p.peek() {
1215       token::EQ. {
1216         p.bump();
1217         let rhs = parse_expr(p);
1218         ret mk_expr(p, lo, rhs.span.hi, ast::expr_assign(lhs, rhs));
1219       }
1220       token::BINOPEQ(op) {
1221         p.bump();
1222         let rhs = parse_expr(p);
1223         let aop = ast::add;
1224         alt op {
1225           token::PLUS. { aop = ast::add; }
1226           token::MINUS. { aop = ast::sub; }
1227           token::STAR. { aop = ast::mul; }
1228           token::SLASH. { aop = ast::div; }
1229           token::PERCENT. { aop = ast::rem; }
1230           token::CARET. { aop = ast::bitxor; }
1231           token::AND. { aop = ast::bitand; }
1232           token::OR. { aop = ast::bitor; }
1233           token::LSL. { aop = ast::lsl; }
1234           token::LSR. { aop = ast::lsr; }
1235           token::ASR. { aop = ast::asr; }
1236         }
1237         ret mk_expr(p, lo, rhs.span.hi, ast::expr_assign_op(aop, lhs, rhs));
1238       }
1239       token::LARROW. {
1240         p.bump();
1241         let rhs = parse_expr(p);
1242         ret mk_expr(p, lo, rhs.span.hi, ast::expr_move(lhs, rhs));
1243       }
1244       token::DARROW. {
1245         p.bump();
1246         let rhs = parse_expr(p);
1247         ret mk_expr(p, lo, rhs.span.hi, ast::expr_swap(lhs, rhs));
1248       }
1249       _ {/* fall through */ }
1250     }
1251     ret lhs;
1252 }
1253
1254 fn parse_if_expr_1(p: &parser) ->
1255    {cond: @ast::expr,
1256     then: ast::blk,
1257     els: option::t<@ast::expr>,
1258     lo: uint,
1259     hi: uint} {
1260     let lo = p.get_last_lo_pos();
1261     let cond = parse_expr(p);
1262     let thn = parse_block(p);
1263     let els: option::t<@ast::expr> = none;
1264     let hi = thn.span.hi;
1265     if eat_word(p, "else") {
1266         let elexpr = parse_else_expr(p);
1267         els = some(elexpr);
1268         hi = elexpr.span.hi;
1269     }
1270     ret {cond: cond, then: thn, els: els, lo: lo, hi: hi};
1271 }
1272
1273 fn parse_if_expr(p: &parser) -> @ast::expr {
1274     if eat_word(p, "check") {
1275         let q = parse_if_expr_1(p);
1276         ret mk_expr(p, q.lo, q.hi, ast::expr_if_check(q.cond, q.then, q.els));
1277     } else {
1278         let q = parse_if_expr_1(p);
1279         ret mk_expr(p, q.lo, q.hi, ast::expr_if(q.cond, q.then, q.els));
1280     }
1281 }
1282
1283 fn parse_fn_expr(p: &parser, proto: ast::proto) -> @ast::expr {
1284     let lo = p.get_last_lo_pos();
1285     let decl = parse_fn_decl(p, ast::impure_fn, ast::il_normal);
1286     let body = parse_block(p);
1287     let _fn = {decl: decl, proto: proto, body: body};
1288     ret mk_expr(p, lo, body.span.hi, ast::expr_fn(_fn));
1289 }
1290
1291 fn parse_fn_block_expr(p: &parser) -> @ast::expr {
1292     let lo = p.get_last_lo_pos();
1293     let decl = parse_fn_block_decl(p);
1294     let body = parse_block_tail(p, lo, ast::checked);
1295     let _fn = {decl: decl, proto: ast::proto_block, body: body};
1296     ret mk_expr(p, lo, body.span.hi, ast::expr_fn(_fn));
1297 }
1298
1299 fn parse_else_expr(p: &parser) -> @ast::expr {
1300     if eat_word(p, "if") {
1301         ret parse_if_expr(p);
1302     } else {
1303         let blk = parse_block(p);
1304         ret mk_expr(p, blk.span.lo, blk.span.hi, ast::expr_block(blk));
1305     }
1306 }
1307
1308 fn parse_for_expr(p: &parser) -> @ast::expr {
1309     let lo = p.get_last_lo_pos();
1310     let is_each = eat_word(p, "each");
1311     let decl = parse_local(p, false);
1312     expect_word(p, "in");
1313     let seq = parse_expr(p);
1314     let body = parse_block(p);
1315     let hi = body.span.hi;
1316     if is_each {
1317         ret mk_expr(p, lo, hi, ast::expr_for_each(decl, seq, body));
1318     } else { ret mk_expr(p, lo, hi, ast::expr_for(decl, seq, body)); }
1319 }
1320
1321 fn parse_while_expr(p: &parser) -> @ast::expr {
1322     let lo = p.get_last_lo_pos();
1323     let cond = parse_expr(p);
1324     let body = parse_block(p);
1325     let hi = body.span.hi;
1326     ret mk_expr(p, lo, hi, ast::expr_while(cond, body));
1327 }
1328
1329 fn parse_do_while_expr(p: &parser) -> @ast::expr {
1330     let lo = p.get_last_lo_pos();
1331     let body = parse_block(p);
1332     expect_word(p, "while");
1333     let cond = parse_expr(p);
1334     let hi = cond.span.hi;
1335     ret mk_expr(p, lo, hi, ast::expr_do_while(body, cond));
1336 }
1337
1338 fn parse_alt_expr(p: &parser) -> @ast::expr {
1339     let lo = p.get_last_lo_pos();
1340     let discriminant = parse_expr(p);
1341     expect(p, token::LBRACE);
1342     let arms: [ast::arm] = [];
1343     while p.peek() != token::RBRACE {
1344         let pats = parse_pats(p);
1345         let guard = none;
1346         if eat_word(p, "when") { guard = some(parse_expr(p)); }
1347         let blk = parse_block(p);
1348         arms += [{pats: pats, guard: guard, body: blk}];
1349     }
1350     let hi = p.get_hi_pos();
1351     p.bump();
1352     ret mk_expr(p, lo, hi, ast::expr_alt(discriminant, arms));
1353 }
1354
1355 fn parse_expr(p: &parser) -> @ast::expr {
1356     ret parse_expr_res(p, UNRESTRICTED);
1357 }
1358
1359 fn parse_expr_res(p: &parser, r: restriction) -> @ast::expr {
1360     let old = p.get_restriction();
1361     p.restrict(r);
1362     let e = parse_assign_expr(p);
1363     p.restrict(old);
1364     ret e;
1365 }
1366
1367 fn parse_initializer(p: &parser) -> option::t<ast::initializer> {
1368     alt p.peek() {
1369       token::EQ. {
1370         p.bump();
1371         ret some({op: ast::init_assign, expr: parse_expr(p)});
1372       }
1373       token::LARROW. {
1374         p.bump();
1375         ret some({op: ast::init_move, expr: parse_expr(p)});
1376       }
1377
1378
1379
1380       // Now that the the channel is the first argument to receive,
1381       // combining it with an initializer doesn't really make sense.
1382       // case (token::RECV) {
1383       //     p.bump();
1384       //     ret some(rec(op = ast::init_recv,
1385       //                  expr = parse_expr(p)));
1386       // }
1387       _ {
1388         ret none;
1389       }
1390     }
1391 }
1392
1393 fn parse_pats(p: &parser) -> [@ast::pat] {
1394     let pats = [];
1395     while true {
1396         pats += [parse_pat(p)];
1397         if p.peek() == token::BINOP(token::OR) { p.bump(); } else { break; }
1398     }
1399     ret pats;
1400 }
1401
1402 fn parse_pat(p: &parser) -> @ast::pat {
1403     let lo = p.get_lo_pos();
1404     let hi = p.get_hi_pos();
1405     let pat;
1406     alt p.peek() {
1407       token::UNDERSCORE. { p.bump(); pat = ast::pat_wild; }
1408       token::AT. {
1409         p.bump();
1410         let sub = parse_pat(p);
1411         pat = ast::pat_box(sub);
1412         hi = sub.span.hi;
1413       }
1414       token::LBRACE. {
1415         p.bump();
1416         let fields = [];
1417         let etc = false;
1418         let first = true;
1419         while p.peek() != token::RBRACE {
1420             if first { first = false; } else { expect(p, token::COMMA); }
1421
1422             if p.peek() == token::UNDERSCORE {
1423                 p.bump();
1424                 if p.peek() != token::RBRACE {
1425                     p.fatal("expecting }, found " +
1426                                 token::to_str(p.get_reader(), p.peek()));
1427                 }
1428                 etc = true;
1429                 break;
1430             }
1431
1432             let fieldname = parse_ident(p);
1433             let subpat;
1434             if p.peek() == token::COLON {
1435                 p.bump();
1436                 subpat = parse_pat(p);
1437             } else {
1438                 if p.get_bad_expr_words().contains_key(fieldname) {
1439                     p.fatal("found " + fieldname + " in binding position");
1440                 }
1441                 subpat =
1442                     @{id: p.get_id(),
1443                       node: ast::pat_bind(fieldname),
1444                       span: ast_util::mk_sp(lo, hi)};
1445             }
1446             fields += [{ident: fieldname, pat: subpat}];
1447         }
1448         hi = p.get_hi_pos();
1449         p.bump();
1450         pat = ast::pat_rec(fields, etc);
1451       }
1452       token::LPAREN. {
1453         p.bump();
1454         if p.peek() == token::RPAREN {
1455             hi = p.get_hi_pos();
1456             p.bump();
1457             pat =
1458                 ast::pat_lit(@{node: ast::lit_nil,
1459                                span: ast_util::mk_sp(lo, hi)});
1460         } else {
1461             let fields = [parse_pat(p)];
1462             while p.peek() == token::COMMA {
1463                 p.bump();
1464                 fields += [parse_pat(p)];
1465             }
1466             if vec::len(fields) == 1u { expect(p, token::COMMA); }
1467             hi = p.get_hi_pos();
1468             expect(p, token::RPAREN);
1469             pat = ast::pat_tup(fields);
1470         }
1471       }
1472       tok {
1473         if !is_ident(tok) || is_word(p, "true") || is_word(p, "false") {
1474             let lit = parse_lit(p);
1475             hi = lit.span.hi;
1476             pat = ast::pat_lit(@lit);
1477         } else if is_plain_ident(p) &&
1478                       alt p.look_ahead(1u) {
1479                         token::DOT. | token::LPAREN. | token::LBRACKET. {
1480                           false
1481                         }
1482                         _ { true }
1483                       } {
1484             hi = p.get_hi_pos();
1485             pat = ast::pat_bind(parse_value_ident(p));
1486         } else {
1487             let tag_path = parse_path_and_ty_param_substs(p);
1488             hi = tag_path.span.hi;
1489             let args: [@ast::pat];
1490             alt p.peek() {
1491               token::LPAREN. {
1492                 let a =
1493                     parse_seq(token::LPAREN, token::RPAREN,
1494                               some(token::COMMA), parse_pat, p);
1495                 args = a.node;
1496                 hi = a.span.hi;
1497               }
1498               token::DOT. { args = []; p.bump(); }
1499               _ { expect(p, token::LPAREN); fail; }
1500             }
1501             pat = ast::pat_tag(tag_path, args);
1502         }
1503       }
1504     }
1505     ret @{id: p.get_id(), node: pat, span: ast_util::mk_sp(lo, hi)};
1506 }
1507
1508 fn parse_local(p: &parser, allow_init: bool) -> @ast::local {
1509     let lo = p.get_lo_pos();
1510     let pat = parse_pat(p);
1511     let ty = @spanned(lo, lo, ast::ty_infer);
1512     if eat(p, token::COLON) { ty = parse_ty(p, false); }
1513     let init = if allow_init { parse_initializer(p) } else { none };
1514     ret @spanned(lo, p.get_last_hi_pos(),
1515                  {ty: ty, pat: pat, init: init, id: p.get_id()});
1516 }
1517
1518 fn parse_let(p: &parser) -> @ast::decl {
1519     let lo = p.get_lo_pos();
1520     let locals = [parse_local(p, true)];
1521     while p.peek() == token::COMMA {
1522         p.bump();
1523         locals += [parse_local(p, true)];
1524     }
1525     ret @spanned(lo, p.get_last_hi_pos(), ast::decl_local(locals));
1526 }
1527
1528 fn parse_stmt(p: &parser) -> @ast::stmt {
1529     if p.get_file_type() == SOURCE_FILE {
1530         ret parse_source_stmt(p);
1531     } else { ret parse_crate_stmt(p); }
1532 }
1533
1534 fn parse_crate_stmt(p: &parser) -> @ast::stmt {
1535     let cdir = parse_crate_directive(p, []);
1536     ret @spanned(cdir.span.lo, cdir.span.hi,
1537                  ast::stmt_crate_directive(@cdir));
1538 }
1539
1540 fn parse_source_stmt(p: &parser) -> @ast::stmt {
1541     let lo = p.get_lo_pos();
1542     if eat_word(p, "let") {
1543         let decl = parse_let(p);
1544         ret @spanned(lo, decl.span.hi, ast::stmt_decl(decl, p.get_id()));
1545     } else {
1546
1547         let item_attrs;
1548         alt parse_outer_attrs_or_ext(p) {
1549           none. { item_attrs = []; }
1550           some(left(attrs)) { item_attrs = attrs; }
1551           some(right(ext)) {
1552             ret @spanned(lo, ext.span.hi, ast::stmt_expr(ext, p.get_id()));
1553           }
1554         }
1555
1556         let maybe_item = parse_item(p, item_attrs);
1557
1558         // If we have attributes then we should have an item
1559         if vec::len(item_attrs) > 0u {
1560             alt maybe_item {
1561               some(_) {/* fallthrough */ }
1562               _ { ret p.fatal("expected item"); }
1563             }
1564         }
1565
1566
1567         alt maybe_item {
1568           some(i) {
1569             let hi = i.span.hi;
1570             let decl = @spanned(lo, hi, ast::decl_item(i));
1571             ret @spanned(lo, hi, ast::stmt_decl(decl, p.get_id()));
1572           }
1573           none. {
1574             // Remainder are line-expr stmts.
1575             let e = parse_expr(p);
1576             ret @spanned(lo, e.span.hi, ast::stmt_expr(e, p.get_id()));
1577           }
1578           _ { p.fatal("expected statement"); }
1579         }
1580     }
1581 }
1582
1583 fn stmt_to_expr(stmt: @ast::stmt) -> option::t<@ast::expr> {
1584     ret alt stmt.node { ast::stmt_expr(e, _) { some(e) } _ { none } };
1585 }
1586
1587 fn stmt_ends_with_semi(stmt: &ast::stmt) -> bool {
1588     alt stmt.node {
1589       ast::stmt_decl(d, _) {
1590         ret alt d.node {
1591               ast::decl_local(_) { true }
1592               ast::decl_item(_) { false }
1593             }
1594       }
1595       ast::stmt_expr(e, _) {
1596         ret alt e.node {
1597               ast::expr_vec(_, _) { true }
1598               ast::expr_rec(_, _) { true }
1599               ast::expr_tup(_) { true }
1600               ast::expr_call(_, _) { true }
1601               ast::expr_self_method(_) { false }
1602               ast::expr_bind(_, _) { true }
1603               ast::expr_binary(_, _, _) { true }
1604               ast::expr_unary(_, _) { true }
1605               ast::expr_lit(_) { true }
1606               ast::expr_cast(_, _) { true }
1607               ast::expr_if(_, _, _) { false }
1608               ast::expr_ternary(_, _, _) { true }
1609               ast::expr_for(_, _, _) { false }
1610               ast::expr_for_each(_, _, _) { false }
1611               ast::expr_while(_, _) { false }
1612               ast::expr_do_while(_, _) { false }
1613               ast::expr_alt(_, _) { false }
1614               ast::expr_fn(_) { false }
1615               ast::expr_block(_) { false }
1616               ast::expr_copy(_) { true }
1617               ast::expr_move(_, _) { true }
1618               ast::expr_assign(_, _) { true }
1619               ast::expr_swap(_, _) { true }
1620               ast::expr_assign_op(_, _, _) { true }
1621               ast::expr_field(_, _) { true }
1622               ast::expr_index(_, _) { true }
1623               ast::expr_path(_) { true }
1624               ast::expr_mac(_) { true }
1625               ast::expr_fail(_) { true }
1626               ast::expr_break. { true }
1627               ast::expr_cont. { true }
1628               ast::expr_ret(_) { true }
1629               ast::expr_put(_) { true }
1630               ast::expr_be(_) { true }
1631               ast::expr_log(_, _) { true }
1632               ast::expr_check(_, _) { true }
1633               ast::expr_if_check(_, _, _) { false }
1634               ast::expr_anon_obj(_) { false }
1635               ast::expr_assert(_) { true }
1636             }
1637       }
1638
1639
1640
1641       // We should not be calling this on a cdir.
1642       ast::stmt_crate_directive(cdir) {
1643         fail;
1644       }
1645     }
1646 }
1647
1648 fn parse_block(p: &parser) -> ast::blk {
1649     let lo = p.get_lo_pos();
1650     if eat_word(p, "unchecked") {
1651         be parse_block_tail(p, lo, ast::unchecked);
1652     } else {
1653         expect(p, token::LBRACE);
1654         be parse_block_tail(p, lo, ast::checked);
1655     }
1656 }
1657
1658 // Precondition: already parsed the '{' or '#{'
1659 // I guess that also means "already parsed the 'impure'" if
1660 // necessary, and this should take a qualifier.
1661 // some blocks start with "#{"...
1662 fn parse_block_tail(p: &parser, lo: uint, s: ast::check_mode) -> ast::blk {
1663     let stmts: [@ast::stmt] = [];
1664     let expr: option::t<@ast::expr> = none;
1665     while p.peek() != token::RBRACE {
1666         alt p.peek() {
1667           token::SEMI. {
1668             p.bump(); // empty
1669           }
1670           _ {
1671             let stmt = parse_stmt(p);
1672             alt stmt_to_expr(stmt) {
1673               some(e) {
1674                 alt p.peek() {
1675                   token::SEMI. { p.bump(); stmts += [stmt]; }
1676                   token::RBRACE. { expr = some(e); }
1677                   t {
1678                     if stmt_ends_with_semi(*stmt) {
1679                         p.fatal("expected ';' or '}' after " +
1680                                     "expression but found " +
1681                                     token::to_str(p.get_reader(), t));
1682                     }
1683                     stmts += [stmt];
1684                   }
1685                 }
1686               }
1687               none. {
1688                 // Not an expression statement.
1689                 stmts += [stmt];
1690
1691
1692                 if p.get_file_type() == SOURCE_FILE &&
1693                        stmt_ends_with_semi(*stmt) {
1694                     expect(p, token::SEMI);
1695                 }
1696               }
1697             }
1698           }
1699         }
1700     }
1701     let hi = p.get_hi_pos();
1702     p.bump();
1703     let bloc = {stmts: stmts, expr: expr, id: p.get_id(), rules: s};
1704     ret spanned(lo, hi, bloc);
1705 }
1706
1707 fn parse_ty_param(p: &parser) -> ast::ty_param {
1708     let k =
1709         alt p.peek() {
1710           token::TILDE. { p.bump(); ast::kind_unique }
1711           token::AT. { p.bump(); ast::kind_shared }
1712           _ { ast::kind_pinned }
1713         };
1714     ret {ident: parse_ident(p), kind: k};
1715 }
1716
1717 fn parse_ty_params(p: &parser) -> [ast::ty_param] {
1718     let ty_params: [ast::ty_param] = [];
1719     if p.peek() == token::LT {
1720         p.bump();
1721         ty_params = parse_seq_to_gt(some(token::COMMA), parse_ty_param, p);
1722     }
1723     if p.peek() == token::LT {
1724         ty_params =
1725             parse_seq(token::LT, token::GT, some(token::COMMA),
1726                       parse_ty_param, p).node;
1727     }
1728     ret ty_params;
1729 }
1730
1731 fn parse_fn_decl(p: &parser, purity: ast::purity, il: ast::inlineness) ->
1732    ast::fn_decl {
1733     let inputs: ast::spanned<[ast::arg]> =
1734         parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_arg,
1735                   p);
1736     let rslt: ty_or_bang;
1737     // Use the args list to translate each bound variable
1738     // mentioned in a constraint to an arg index.
1739     // Seems weird to do this in the parser, but I'm not sure how else to.
1740     let constrs = [];
1741     if p.peek() == token::COLON {
1742         p.bump();
1743         constrs = parse_constrs(bind parse_ty_constr(inputs.node, _), p);
1744     }
1745     if p.peek() == token::RARROW {
1746         p.bump();
1747         rslt = parse_ty_or_bang(p);
1748     } else {
1749         rslt = a_ty(@spanned(inputs.span.lo, inputs.span.hi, ast::ty_nil));
1750     }
1751     alt rslt {
1752       a_ty(t) {
1753         ret {inputs: inputs.node,
1754              output: t,
1755              purity: purity,
1756              il: il,
1757              cf: ast::return,
1758              constraints: constrs};
1759       }
1760       a_bang. {
1761         ret {inputs: inputs.node,
1762              output: @spanned(p.get_lo_pos(), p.get_hi_pos(), ast::ty_bot),
1763              purity: purity,
1764              il: il,
1765              cf: ast::noreturn,
1766              constraints: constrs};
1767       }
1768     }
1769 }
1770
1771 fn parse_fn_block_decl(p: &parser) -> ast::fn_decl {
1772     let inputs: ast::spanned<[ast::arg]> =
1773         parse_seq(token::BINOP(token::OR), token::BINOP(token::OR),
1774                   some(token::COMMA), parse_fn_block_arg, p);
1775     ret {inputs: inputs.node,
1776          output: @spanned(p.get_lo_pos(), p.get_hi_pos(), ast::ty_infer),
1777          purity: ast::impure_fn,
1778          il: ast::il_normal,
1779          cf: ast::return,
1780          constraints: []};
1781 }
1782
1783 fn parse_fn(p: &parser, proto: ast::proto, purity: ast::purity,
1784             il: ast::inlineness) -> ast::_fn {
1785     let decl = parse_fn_decl(p, purity, il);
1786     let body = parse_block(p);
1787     ret {decl: decl, proto: proto, body: body};
1788 }
1789
1790 fn parse_fn_header(p: &parser) -> {ident: ast::ident, tps: [ast::ty_param]} {
1791     let id = parse_value_ident(p);
1792     let ty_params = parse_ty_params(p);
1793     ret {ident: id, tps: ty_params};
1794 }
1795
1796 fn mk_item(p: &parser, lo: uint, hi: uint, ident: &ast::ident,
1797            node: &ast::item_, attrs: &[ast::attribute]) -> @ast::item {
1798     ret @{ident: ident,
1799           attrs: attrs,
1800           id: p.get_id(),
1801           node: node,
1802           span: ast_util::mk_sp(lo, hi)};
1803 }
1804
1805 fn parse_item_fn_or_iter(p: &parser, purity: ast::purity, proto: ast::proto,
1806                          attrs: &[ast::attribute], il: ast::inlineness) ->
1807    @ast::item {
1808     let lo = p.get_last_lo_pos();
1809     let t = parse_fn_header(p);
1810     let f = parse_fn(p, proto, purity, il);
1811     ret mk_item(p, lo, f.body.span.hi, t.ident, ast::item_fn(f, t.tps),
1812                 attrs);
1813 }
1814
1815 fn parse_obj_field(p: &parser) -> ast::obj_field {
1816     let mut = parse_mutability(p);
1817     let ident = parse_value_ident(p);
1818     expect(p, token::COLON);
1819     let ty = parse_ty(p, false);
1820     ret {mut: mut, ty: ty, ident: ident, id: p.get_id()};
1821 }
1822
1823 fn parse_anon_obj_field(p: &parser) -> ast::anon_obj_field {
1824     let mut = parse_mutability(p);
1825     let ident = parse_value_ident(p);
1826     expect(p, token::COLON);
1827     let ty = parse_ty(p, false);
1828     expect(p, token::EQ);
1829     let expr = parse_expr(p);
1830     ret {mut: mut, ty: ty, expr: expr, ident: ident, id: p.get_id()};
1831 }
1832
1833 fn parse_method(p: &parser) -> @ast::method {
1834     let lo = p.get_lo_pos();
1835     let proto = parse_proto(p);
1836     let ident = parse_value_ident(p);
1837     let f = parse_fn(p, proto, ast::impure_fn, ast::il_normal);
1838     let meth = {ident: ident, meth: f, id: p.get_id()};
1839     ret @spanned(lo, f.body.span.hi, meth);
1840 }
1841
1842 fn parse_item_obj(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
1843     let lo = p.get_last_lo_pos();
1844     let ident = parse_value_ident(p);
1845     let ty_params = parse_ty_params(p);
1846     let fields: ast::spanned<[ast::obj_field]> =
1847         parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
1848                   parse_obj_field, p);
1849     let meths: [@ast::method] = [];
1850     expect(p, token::LBRACE);
1851     while p.peek() != token::RBRACE { meths += [parse_method(p)]; }
1852     let hi = p.get_hi_pos();
1853     expect(p, token::RBRACE);
1854     let ob: ast::_obj = {fields: fields.node, methods: meths};
1855     ret mk_item(p, lo, hi, ident, ast::item_obj(ob, ty_params, p.get_id()),
1856                 attrs);
1857 }
1858
1859 fn parse_item_res(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
1860     let lo = p.get_last_lo_pos();
1861     let ident = parse_value_ident(p);
1862     let ty_params = parse_ty_params(p);
1863     expect(p, token::LPAREN);
1864     let arg_ident = parse_value_ident(p);
1865     expect(p, token::COLON);
1866     let t = parse_ty(p, false);
1867     expect(p, token::RPAREN);
1868     let dtor = parse_block(p);
1869     let decl =
1870         {inputs:
1871              [{mode: ast::alias(false),
1872                ty: t,
1873                ident: arg_ident,
1874                id: p.get_id()}],
1875          output: @spanned(lo, lo, ast::ty_nil),
1876          purity: ast::impure_fn,
1877          il: ast::il_normal,
1878          cf: ast::return,
1879          constraints: []};
1880     let f = {decl: decl, proto: ast::proto_fn, body: dtor};
1881     ret mk_item(p, lo, dtor.span.hi, ident,
1882                 ast::item_res(f, p.get_id(), ty_params, p.get_id()), attrs);
1883 }
1884
1885 fn parse_mod_items(p: &parser, term: token::token,
1886                    first_item_attrs: &[ast::attribute]) -> ast::_mod {
1887     // Shouldn't be any view items since we've already parsed an item attr
1888     let view_items =
1889         if vec::len(first_item_attrs) == 0u { parse_view(p) } else { [] };
1890     let items: [@ast::item] = [];
1891     let initial_attrs = first_item_attrs;
1892     while p.peek() != term {
1893         let attrs = initial_attrs + parse_outer_attributes(p);
1894         initial_attrs = [];
1895         alt parse_item(p, attrs) {
1896           some(i) { items += [i]; }
1897           _ {
1898             p.fatal("expected item but found " +
1899                         token::to_str(p.get_reader(), p.peek()));
1900           }
1901         }
1902     }
1903     ret {view_items: view_items, items: items};
1904 }
1905
1906 fn parse_item_const(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
1907     let lo = p.get_last_lo_pos();
1908     let id = parse_value_ident(p);
1909     expect(p, token::COLON);
1910     let ty = parse_ty(p, false);
1911     expect(p, token::EQ);
1912     let e = parse_expr(p);
1913     let hi = p.get_hi_pos();
1914     expect(p, token::SEMI);
1915     ret mk_item(p, lo, hi, id, ast::item_const(ty, e), attrs);
1916 }
1917
1918 fn parse_item_mod(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
1919     let lo = p.get_last_lo_pos();
1920     let id = parse_ident(p);
1921     expect(p, token::LBRACE);
1922     let inner_attrs = parse_inner_attrs_and_next(p);
1923     let first_item_outer_attrs = inner_attrs.next;
1924     let m = parse_mod_items(p, token::RBRACE, first_item_outer_attrs);
1925     let hi = p.get_hi_pos();
1926     expect(p, token::RBRACE);
1927     ret mk_item(p, lo, hi, id, ast::item_mod(m), attrs + inner_attrs.inner);
1928 }
1929
1930 fn parse_item_native_type(p: &parser, attrs: &[ast::attribute]) ->
1931    @ast::native_item {
1932     let t = parse_type_decl(p);
1933     let hi = p.get_hi_pos();
1934     expect(p, token::SEMI);
1935     ret @{ident: t.ident,
1936           attrs: attrs,
1937           node: ast::native_item_ty,
1938           id: p.get_id(),
1939           span: ast_util::mk_sp(t.lo, hi)};
1940 }
1941
1942 fn parse_item_native_fn(p: &parser, attrs: &[ast::attribute]) ->
1943    @ast::native_item {
1944     let lo = p.get_last_lo_pos();
1945     let t = parse_fn_header(p);
1946     let decl = parse_fn_decl(p, ast::impure_fn, ast::il_normal);
1947     let link_name = none;
1948     if p.peek() == token::EQ { p.bump(); link_name = some(parse_str(p)); }
1949     let hi = p.get_hi_pos();
1950     expect(p, token::SEMI);
1951     ret @{ident: t.ident,
1952           attrs: attrs,
1953           node: ast::native_item_fn(link_name, decl, t.tps),
1954           id: p.get_id(),
1955           span: ast_util::mk_sp(lo, hi)};
1956 }
1957
1958 fn parse_native_item(p: &parser, attrs: &[ast::attribute]) ->
1959    @ast::native_item {
1960     if eat_word(p, "type") {
1961         ret parse_item_native_type(p, attrs);
1962     } else if eat_word(p, "fn") {
1963         ret parse_item_native_fn(p, attrs);
1964     } else { unexpected(p, p.peek()); }
1965 }
1966
1967 fn parse_native_mod_items(p: &parser, native_name: &str, abi: ast::native_abi,
1968                           first_item_attrs: &[ast::attribute]) ->
1969    ast::native_mod {
1970     // Shouldn't be any view items since we've already parsed an item attr
1971     let view_items =
1972         if vec::len(first_item_attrs) == 0u {
1973             parse_native_view(p)
1974         } else { [] };
1975     let items: [@ast::native_item] = [];
1976     let initial_attrs = first_item_attrs;
1977     while p.peek() != token::RBRACE {
1978         let attrs = initial_attrs + parse_outer_attributes(p);
1979         initial_attrs = [];
1980         items += [parse_native_item(p, attrs)];
1981     }
1982     ret {native_name: native_name,
1983          abi: abi,
1984          view_items: view_items,
1985          items: items};
1986 }
1987
1988 fn parse_item_native_mod(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
1989     let lo = p.get_last_lo_pos();
1990     let abi = ast::native_abi_cdecl;
1991     if !is_word(p, "mod") {
1992         let t = parse_str(p);
1993         if str::eq(t, "cdecl") {
1994         } else if str::eq(t, "rust") {
1995             abi = ast::native_abi_rust;
1996         } else if str::eq(t, "llvm") {
1997             abi = ast::native_abi_llvm;
1998         } else if str::eq(t, "rust-intrinsic") {
1999             abi = ast::native_abi_rust_intrinsic;
2000         } else if str::eq(t, "x86stdcall") {
2001             abi = ast::native_abi_x86stdcall;
2002         } else { p.fatal("unsupported abi: " + t); }
2003     }
2004     expect_word(p, "mod");
2005     let id = parse_ident(p);
2006     let native_name;
2007     if p.peek() == token::EQ {
2008         expect(p, token::EQ);
2009         native_name = parse_str(p);
2010     } else { native_name = id; }
2011     expect(p, token::LBRACE);
2012     let more_attrs = parse_inner_attrs_and_next(p);
2013     let inner_attrs = more_attrs.inner;
2014     let first_item_outer_attrs = more_attrs.next;
2015     let m =
2016         parse_native_mod_items(p, native_name, abi, first_item_outer_attrs);
2017     let hi = p.get_hi_pos();
2018     expect(p, token::RBRACE);
2019     ret mk_item(p, lo, hi, id, ast::item_native_mod(m), attrs + inner_attrs);
2020 }
2021
2022 fn parse_type_decl(p: &parser) -> {lo: uint, ident: ast::ident} {
2023     let lo = p.get_last_lo_pos();
2024     let id = parse_ident(p);
2025     ret {lo: lo, ident: id};
2026 }
2027
2028 fn parse_item_type(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
2029     let t = parse_type_decl(p);
2030     let tps = parse_ty_params(p);
2031     expect(p, token::EQ);
2032     let ty = parse_ty(p, false);
2033     let hi = p.get_hi_pos();
2034     expect(p, token::SEMI);
2035     ret mk_item(p, t.lo, hi, t.ident, ast::item_ty(ty, tps), attrs);
2036 }
2037
2038 fn parse_item_tag(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
2039     let lo = p.get_last_lo_pos();
2040     let id = parse_ident(p);
2041     let ty_params = parse_ty_params(p);
2042     let variants: [ast::variant] = [];
2043     // Newtype syntax
2044     if p.peek() == token::EQ {
2045         if p.get_bad_expr_words().contains_key(id) {
2046             p.fatal("found " + id + " in tag constructor position");
2047         }
2048         p.bump();
2049         let ty = parse_ty(p, false);
2050         expect(p, token::SEMI);
2051         let variant =
2052             spanned(ty.span.lo, ty.span.hi,
2053                     {name: id,
2054                      args: [{ty: ty, id: p.get_id()}],
2055                      id: p.get_id()});
2056         ret mk_item(p, lo, ty.span.hi, id,
2057                     ast::item_tag([variant], ty_params), attrs);
2058     }
2059     expect(p, token::LBRACE);
2060     while p.peek() != token::RBRACE {
2061         let tok = p.peek();
2062         alt tok {
2063           token::IDENT(name, _) {
2064             check_bad_word(p);
2065             let vlo = p.get_lo_pos();
2066             p.bump();
2067             let args: [ast::variant_arg] = [];
2068             let vhi = p.get_hi_pos();
2069             alt p.peek() {
2070               token::LPAREN. {
2071                 let arg_tys =
2072                     parse_seq(token::LPAREN, token::RPAREN,
2073                               some(token::COMMA), bind parse_ty(_, false), p);
2074                 for ty: @ast::ty in arg_tys.node {
2075                     args += [{ty: ty, id: p.get_id()}];
2076                 }
2077                 vhi = arg_tys.span.hi;
2078               }
2079               _ {/* empty */ }
2080             }
2081             expect(p, token::SEMI);
2082             p.get_id();
2083             let vr = {name: p.get_str(name), args: args, id: p.get_id()};
2084             variants += [spanned(vlo, vhi, vr)];
2085           }
2086           token::RBRACE. {/* empty */ }
2087           _ {
2088             p.fatal("expected name of variant or '}' but found " +
2089                         token::to_str(p.get_reader(), tok));
2090           }
2091         }
2092     }
2093     let hi = p.get_hi_pos();
2094     p.bump();
2095     ret mk_item(p, lo, hi, id, ast::item_tag(variants, ty_params), attrs);
2096 }
2097
2098 fn parse_auth(p: &parser) -> ast::_auth {
2099     if eat_word(p, "unsafe") {
2100         ret ast::auth_unsafe;
2101     } else { unexpected(p, p.peek()); }
2102 }
2103
2104 fn parse_item(p: &parser, attrs: &[ast::attribute]) -> option::t<@ast::item> {
2105     if eat_word(p, "const") {
2106         ret some(parse_item_const(p, attrs));
2107     } else if eat_word(p, "inline") {
2108         expect_word(p, "fn");
2109         ret some(parse_item_fn_or_iter(p, ast::impure_fn, ast::proto_fn,
2110                                        attrs, ast::il_inline));
2111     } else if is_word(p, "fn") && p.look_ahead(1u) != token::LPAREN {
2112         p.bump();
2113         ret some(parse_item_fn_or_iter(p, ast::impure_fn, ast::proto_fn,
2114                                        attrs, ast::il_normal));
2115     } else if eat_word(p, "pure") {
2116         expect_word(p, "fn");
2117         ret some(parse_item_fn_or_iter(p, ast::pure_fn, ast::proto_fn, attrs,
2118                                        ast::il_normal));
2119     } else if eat_word(p, "iter") {
2120         ret some(parse_item_fn_or_iter(p, ast::impure_fn, ast::proto_iter,
2121                                        attrs, ast::il_normal));
2122     } else if eat_word(p, "mod") {
2123         ret some(parse_item_mod(p, attrs));
2124     } else if eat_word(p, "native") {
2125         ret some(parse_item_native_mod(p, attrs));
2126     }
2127     if eat_word(p, "type") {
2128         ret some(parse_item_type(p, attrs));
2129     } else if eat_word(p, "tag") {
2130         ret some(parse_item_tag(p, attrs));
2131     } else if is_word(p, "obj") && p.look_ahead(1u) != token::LPAREN {
2132         p.bump();
2133         ret some(parse_item_obj(p, attrs));
2134     } else if eat_word(p, "resource") {
2135         ret some(parse_item_res(p, attrs));
2136     } else { ret none; }
2137 }
2138
2139 // A type to distingush between the parsing of item attributes or syntax
2140 // extensions, which both begin with token.POUND
2141 type attr_or_ext = option::t<either::t<[ast::attribute], @ast::expr>>;
2142
2143 fn parse_outer_attrs_or_ext(p: &parser) -> attr_or_ext {
2144     if p.peek() == token::POUND {
2145         let lo = p.get_lo_pos();
2146         p.bump();
2147         if p.peek() == token::LBRACKET {
2148             let first_attr = parse_attribute_naked(p, ast::attr_outer, lo);
2149             ret some(left([first_attr] + parse_outer_attributes(p)));
2150         } else if !(p.peek() == token::LT || p.peek() == token::LBRACKET) {
2151             ret some(right(parse_syntax_ext_naked(p, lo)));
2152         } else { ret none; }
2153     } else { ret none; }
2154 }
2155
2156 // Parse attributes that appear before an item
2157 fn parse_outer_attributes(p: &parser) -> [ast::attribute] {
2158     let attrs: [ast::attribute] = [];
2159     while p.peek() == token::POUND {
2160         attrs += [parse_attribute(p, ast::attr_outer)];
2161     }
2162     ret attrs;
2163 }
2164
2165 fn parse_attribute(p: &parser, style: ast::attr_style) -> ast::attribute {
2166     let lo = p.get_lo_pos();
2167     expect(p, token::POUND);
2168     ret parse_attribute_naked(p, style, lo);
2169 }
2170
2171 fn parse_attribute_naked(p: &parser, style: ast::attr_style, lo: uint) ->
2172    ast::attribute {
2173     expect(p, token::LBRACKET);
2174     let meta_item = parse_meta_item(p);
2175     expect(p, token::RBRACKET);
2176     let hi = p.get_hi_pos();
2177     ret spanned(lo, hi, {style: style, value: *meta_item});
2178 }
2179
2180 // Parse attributes that appear after the opening of an item, each terminated
2181 // by a semicolon. In addition to a vector of inner attributes, this function
2182 // also returns a vector that may contain the first outer attribute of the
2183 // next item (since we can't know whether the attribute is an inner attribute
2184 // of the containing item or an outer attribute of the first contained item
2185 // until we see the semi).
2186 fn parse_inner_attrs_and_next(p: &parser) ->
2187    {inner: [ast::attribute], next: [ast::attribute]} {
2188     let inner_attrs: [ast::attribute] = [];
2189     let next_outer_attrs: [ast::attribute] = [];
2190     while p.peek() == token::POUND {
2191         let attr = parse_attribute(p, ast::attr_inner);
2192         if p.peek() == token::SEMI {
2193             p.bump();
2194             inner_attrs += [attr];
2195         } else {
2196             // It's not really an inner attribute
2197             let outer_attr =
2198                 spanned(attr.span.lo, attr.span.hi,
2199                         {style: ast::attr_outer, value: attr.node.value});
2200             next_outer_attrs += [outer_attr];
2201             break;
2202         }
2203     }
2204     ret {inner: inner_attrs, next: next_outer_attrs};
2205 }
2206
2207 fn parse_meta_item(p: &parser) -> @ast::meta_item {
2208     let lo = p.get_lo_pos();
2209     let ident = parse_ident(p);
2210     alt p.peek() {
2211       token::EQ. {
2212         p.bump();
2213         let lit = parse_lit(p);
2214         let hi = p.get_hi_pos();
2215         ret @spanned(lo, hi, ast::meta_name_value(ident, lit));
2216       }
2217       token::LPAREN. {
2218         let inner_items = parse_meta_seq(p);
2219         let hi = p.get_hi_pos();
2220         ret @spanned(lo, hi, ast::meta_list(ident, inner_items));
2221       }
2222       _ {
2223         let hi = p.get_hi_pos();
2224         ret @spanned(lo, hi, ast::meta_word(ident));
2225       }
2226     }
2227 }
2228
2229 fn parse_meta_seq(p: &parser) -> [@ast::meta_item] {
2230     ret parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
2231                   parse_meta_item, p).node;
2232 }
2233
2234 fn parse_optional_meta(p: &parser) -> [@ast::meta_item] {
2235     alt p.peek() { token::LPAREN. { ret parse_meta_seq(p); } _ { ret []; } }
2236 }
2237
2238 fn parse_use(p: &parser) -> ast::view_item_ {
2239     let ident = parse_ident(p);
2240     let metadata = parse_optional_meta(p);
2241     ret ast::view_item_use(ident, metadata, p.get_id());
2242 }
2243
2244 fn parse_rest_import_name(p: &parser, first: &ast::ident,
2245                           def_ident: option::t<ast::ident>) ->
2246    ast::view_item_ {
2247     let identifiers: [ast::ident] = [first];
2248     let glob: bool = false;
2249     let from_idents = option::none::<[ast::import_ident]>;
2250     while true {
2251         alt p.peek() {
2252           token::SEMI. { break; }
2253           token::MOD_SEP. {
2254             if glob { p.fatal("cannot path into a glob"); }
2255             if option::is_some(from_idents) {
2256                 p.fatal("cannot path into import list");
2257             }
2258             p.bump();
2259           }
2260           _ { p.fatal("expecting '::' or ';'"); }
2261         }
2262         alt p.peek() {
2263           token::IDENT(_, _) { identifiers += [parse_ident(p)]; }
2264
2265
2266
2267           //the lexer can't tell the different kinds of stars apart ) :
2268           token::BINOP(token::STAR.) {
2269             glob = true;
2270             p.bump();
2271           }
2272
2273
2274
2275           token::LBRACE. {
2276             fn parse_import_ident(p: &parser) -> ast::import_ident {
2277                 let lo = p.get_lo_pos();
2278                 let ident = parse_ident(p);
2279                 let hi = p.get_hi_pos();
2280                 ret spanned(lo, hi, {name: ident, id: p.get_id()});
2281             }
2282             let from_idents_ =
2283                 parse_seq(token::LBRACE, token::RBRACE, some(token::COMMA),
2284                           parse_import_ident, p).node;
2285             if vec::is_empty(from_idents_) {
2286                 p.fatal("at least one import is required");
2287             }
2288             from_idents = some(from_idents_);
2289           }
2290
2291
2292
2293           _ {
2294             p.fatal("expecting an identifier, or '*'");
2295           }
2296         }
2297     }
2298     alt def_ident {
2299       some(i) {
2300         if glob { p.fatal("globbed imports can't be renamed"); }
2301         if option::is_some(from_idents) {
2302             p.fatal("can't rename import list");
2303         }
2304         ret ast::view_item_import(i, identifiers, p.get_id());
2305       }
2306       _ {
2307         if glob {
2308             ret ast::view_item_import_glob(identifiers, p.get_id());
2309         } else if option::is_some(from_idents) {
2310             ret ast::view_item_import_from(identifiers,
2311                                            option::get(from_idents),
2312                                            p.get_id());
2313         } else {
2314             let len = vec::len(identifiers);
2315             ret ast::view_item_import(identifiers[len - 1u], identifiers,
2316                                       p.get_id());
2317         }
2318       }
2319     }
2320 }
2321
2322 fn parse_full_import_name(p: &parser, def_ident: &ast::ident) ->
2323    ast::view_item_ {
2324     alt p.peek() {
2325       token::IDENT(i, _) {
2326         p.bump();
2327         ret parse_rest_import_name(p, p.get_str(i), some(def_ident));
2328       }
2329       _ { p.fatal("expecting an identifier"); }
2330     }
2331 }
2332
2333 fn parse_import(p: &parser) -> ast::view_item_ {
2334     alt p.peek() {
2335       token::IDENT(i, _) {
2336         p.bump();
2337         alt p.peek() {
2338           token::EQ. {
2339             p.bump();
2340             ret parse_full_import_name(p, p.get_str(i));
2341           }
2342           _ { ret parse_rest_import_name(p, p.get_str(i), none); }
2343         }
2344       }
2345       _ { p.fatal("expecting an identifier"); }
2346     }
2347 }
2348
2349 fn parse_export(p: &parser) -> ast::view_item_ {
2350     let ids =
2351         parse_seq_to_before_end(token::SEMI, option::some(token::COMMA),
2352                                 parse_ident, p);
2353     ret ast::view_item_export(ids, p.get_id());
2354 }
2355
2356 fn parse_view_item(p: &parser) -> @ast::view_item {
2357     let lo = p.get_lo_pos();
2358     let the_item =
2359         if eat_word(p, "use") {
2360             parse_use(p)
2361         } else if eat_word(p, "import") {
2362             parse_import(p)
2363         } else if eat_word(p, "export") { parse_export(p) } else { fail };
2364     let hi = p.get_lo_pos();
2365     expect(p, token::SEMI);
2366     ret @spanned(lo, hi, the_item);
2367 }
2368
2369 fn is_view_item(p: &parser) -> bool {
2370     alt p.peek() {
2371       token::IDENT(sid, false) {
2372         let st = p.get_str(sid);
2373         ret str::eq(st, "use") || str::eq(st, "import") ||
2374                 str::eq(st, "export");
2375       }
2376       _ { ret false; }
2377     }
2378 }
2379
2380 fn parse_view(p: &parser) -> [@ast::view_item] {
2381     let items: [@ast::view_item] = [];
2382     while is_view_item(p) { items += [parse_view_item(p)]; }
2383     ret items;
2384 }
2385
2386 fn parse_native_view(p: &parser) -> [@ast::view_item] {
2387     let items: [@ast::view_item] = [];
2388     while is_view_item(p) { items += [parse_view_item(p)]; }
2389     ret items;
2390 }
2391
2392 fn parse_crate_from_source_file(input: &str, cfg: &ast::crate_cfg,
2393                                 sess: &parse_sess) -> @ast::crate {
2394     let p = new_parser_from_file(sess, cfg, input, 0u, 0u, SOURCE_FILE);
2395     ret parse_crate_mod(p, cfg);
2396 }
2397
2398 fn parse_crate_from_source_str(name: &str, source: &str, cfg: &ast::crate_cfg,
2399                                sess: &parse_sess) -> @ast::crate {
2400     let ftype = SOURCE_FILE;
2401     let filemap = codemap::new_filemap(name, 0u, 0u);
2402     sess.cm.files += [filemap];
2403     let itr = @interner::mk(str::hash, str::eq);
2404     let rdr = lexer::new_reader(sess.cm, source, filemap, itr);
2405     let p = new_parser(sess, cfg, rdr, ftype);
2406     ret parse_crate_mod(p, cfg);
2407 }
2408
2409 // Parses a source module as a crate
2410 fn parse_crate_mod(p: &parser, _cfg: &ast::crate_cfg) -> @ast::crate {
2411     let lo = p.get_lo_pos();
2412     let crate_attrs = parse_inner_attrs_and_next(p);
2413     let first_item_outer_attrs = crate_attrs.next;
2414     let m = parse_mod_items(p, token::EOF, first_item_outer_attrs);
2415     ret @spanned(lo, p.get_lo_pos(),
2416                  {directives: [],
2417                   module: m,
2418                   attrs: crate_attrs.inner,
2419                   config: p.get_cfg()});
2420 }
2421
2422 fn parse_str(p: &parser) -> str {
2423     alt p.peek() {
2424       token::LIT_STR(s) { p.bump(); ret p.get_str(s); }
2425       _ { fail; }
2426     }
2427 }
2428
2429 // Logic for parsing crate files (.rc)
2430 //
2431 // Each crate file is a sequence of directives.
2432 //
2433 // Each directive imperatively extends its environment with 0 or more items.
2434 fn parse_crate_directive(p: &parser, first_outer_attr: &[ast::attribute]) ->
2435    ast::crate_directive {
2436
2437     // Collect the next attributes
2438     let outer_attrs = first_outer_attr + parse_outer_attributes(p);
2439     // In a crate file outer attributes are only going to apply to mods
2440     let expect_mod = vec::len(outer_attrs) > 0u;
2441
2442     let lo = p.get_lo_pos();
2443     if expect_mod || is_word(p, "mod") {
2444         expect_word(p, "mod");
2445         let id = parse_ident(p);
2446         let file_opt =
2447             alt p.peek() {
2448               token::EQ. { p.bump(); some(parse_str(p)) }
2449               _ { none }
2450             };
2451         alt p.peek() {
2452
2453
2454
2455           // mod x = "foo.rs";
2456           token::SEMI. {
2457             let hi = p.get_hi_pos();
2458             p.bump();
2459             ret spanned(lo, hi, ast::cdir_src_mod(id, file_opt, outer_attrs));
2460           }
2461
2462
2463
2464           // mod x = "foo_dir" { ...directives... }
2465           token::LBRACE. {
2466             p.bump();
2467             let inner_attrs = parse_inner_attrs_and_next(p);
2468             let mod_attrs = outer_attrs + inner_attrs.inner;
2469             let next_outer_attr = inner_attrs.next;
2470             let cdirs =
2471                 parse_crate_directives(p, token::RBRACE, next_outer_attr);
2472             let hi = p.get_hi_pos();
2473             expect(p, token::RBRACE);
2474             ret spanned(lo, hi,
2475                         ast::cdir_dir_mod(id, file_opt, cdirs, mod_attrs));
2476           }
2477           t { unexpected(p, t); }
2478         }
2479     } else if eat_word(p, "auth") {
2480         let n = parse_path(p);
2481         expect(p, token::EQ);
2482         let a = parse_auth(p);
2483         let hi = p.get_hi_pos();
2484         expect(p, token::SEMI);
2485         ret spanned(lo, hi, ast::cdir_auth(n, a));
2486     } else if is_view_item(p) {
2487         let vi = parse_view_item(p);
2488         ret spanned(lo, vi.span.hi, ast::cdir_view_item(vi));
2489     } else { ret p.fatal("expected crate directive"); }
2490 }
2491
2492 fn parse_crate_directives(p: &parser, term: token::token,
2493                           first_outer_attr: &[ast::attribute]) ->
2494    [@ast::crate_directive] {
2495
2496     // This is pretty ugly. If we have an outer attribute then we can't accept
2497     // seeing the terminator next, so if we do see it then fail the same way
2498     // parse_crate_directive would
2499     if vec::len(first_outer_attr) > 0u && p.peek() == term {
2500         expect_word(p, "mod");
2501     }
2502
2503     let cdirs: [@ast::crate_directive] = [];
2504     while p.peek() != term {
2505         let cdir = @parse_crate_directive(p, first_outer_attr);
2506         cdirs += [cdir];
2507     }
2508     ret cdirs;
2509 }
2510
2511 fn parse_crate_from_crate_file(input: &str, cfg: &ast::crate_cfg,
2512                                sess: &parse_sess) -> @ast::crate {
2513     let p = new_parser_from_file(sess, cfg, input, 0u, 0u, CRATE_FILE);
2514     let lo = p.get_lo_pos();
2515     let prefix = std::fs::dirname(p.get_filemap().name);
2516     let leading_attrs = parse_inner_attrs_and_next(p);
2517     let crate_attrs = leading_attrs.inner;
2518     let first_cdir_attr = leading_attrs.next;
2519     let cdirs = parse_crate_directives(p, token::EOF, first_cdir_attr);
2520     let deps: [str] = [];
2521     let cx =
2522         @{p: p,
2523           mode: eval::mode_parse,
2524           mutable deps: deps,
2525           sess: sess,
2526           mutable chpos: p.get_chpos(),
2527           mutable byte_pos: p.get_byte_pos(),
2528           cfg: p.get_cfg()};
2529     let m = eval::eval_crate_directives_to_mod(cx, cdirs, prefix);
2530     let hi = p.get_hi_pos();
2531     expect(p, token::EOF);
2532     ret @spanned(lo, hi,
2533                  {directives: cdirs,
2534                   module: m,
2535                   attrs: crate_attrs,
2536                   config: p.get_cfg()});
2537 }
2538
2539 fn parse_crate_from_file(input: &str, cfg: &ast::crate_cfg, sess: &parse_sess)
2540    -> @ast::crate {
2541     if str::ends_with(input, ".rc") {
2542         parse_crate_from_crate_file(input, cfg, sess)
2543     } else if str::ends_with(input, ".rs") {
2544         parse_crate_from_source_file(input, cfg, sess)
2545     } else {
2546         codemap::emit_error(none, "unknown input file type: " + input,
2547                             sess.cm);
2548         fail
2549     }
2550 }
2551
2552 //
2553 // Local Variables:
2554 // mode: rust
2555 // fill-column: 78;
2556 // indent-tabs-mode: nil
2557 // c-basic-offset: 4
2558 // buffer-file-coding-system: utf-8-unix
2559 // compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
2560 // End:
2561 //