diff options
Diffstat (limited to 'src/librustsyntax/parse/parser.rs')
| -rw-r--r-- | src/librustsyntax/parse/parser.rs | 2557 |
1 files changed, 0 insertions, 2557 deletions
diff --git a/src/librustsyntax/parse/parser.rs b/src/librustsyntax/parse/parser.rs deleted file mode 100644 index 8594aed9776..00000000000 --- a/src/librustsyntax/parse/parser.rs +++ /dev/null @@ -1,2557 +0,0 @@ -import result::result; -import either::{either, left, right}; -import std::map::{hashmap, str_hash}; -import token::{can_begin_expr, is_ident, is_plain_ident}; -import codemap::{span,fss_none}; -import util::interner; -import ast_util::{spanned, mk_sp, ident_to_path, operator_prec}; -import ast::*; -import lexer::reader; -import prec::{as_prec, token_to_binop}; -import attr::parser_attr; -import common::*; -import dvec::{dvec, extensions}; - -export file_type; -export parser; -export parse_expr; -export parse_pat; - -// FIXME: #ast expects to find this here but it's actually defined in `parse` -// Fixing this will be easier when we have export decls on individual items -- -// then parse can export this publicly, and everything else crate-visibly. -// (See #1893) -import parse_from_source_str; -export parse_from_source_str; - -// TODO: remove these once we go around a snapshot cycle. -// These are here for the old way that #ast (qquote.rs) worked -fn parse_expr(p: parser) -> @ast::expr { p.parse_expr() } -fn parse_pat(p: parser) -> @ast::pat { p.parse_pat() } - - -enum restriction { - UNRESTRICTED, - RESTRICT_STMT_EXPR, - RESTRICT_NO_CALL_EXPRS, - RESTRICT_NO_BAR_OP, -} - -enum file_type { CRATE_FILE, SOURCE_FILE, } - - -// We don't allow single-entry tuples in the true AST; that indicates a -// parenthesized expression. However, we preserve them temporarily while -// parsing because `(while{...})+3` parses differently from `while{...}+3`. -// -// To reflect the fact that the @expr is not a true expr that should be -// part of the AST, we wrap such expressions in the pexpr enum. They -// can then be converted to true expressions by a call to `to_expr()`. -enum pexpr { - pexpr(@expr), -} - -/* - So that we can distinguish a class ctor or dtor - from other class members - */ -enum class_contents { ctor_decl(fn_decl, blk, codemap::span), - dtor_decl(blk, codemap::span), - members([@class_member]) } - -type arg_or_capture_item = either<arg, capture_item>; -type item_info = (ident, item_, option<[attribute]>); - -class parser { - let sess: parse_sess; - let cfg: crate_cfg; - let file_type: file_type; - let mut token: token::token; - let mut span: span; - let mut last_span: span; - let buffer: dvec<{tok: token::token, span: span}>; - let mut restriction: restriction; - let reader: reader; - let keywords: hashmap<str, ()>; - let restricted_keywords: hashmap<str, ()>; - - new(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, - ftype: file_type) { - let tok0 = lexer::next_token(rdr); - let span0 = ast_util::mk_sp(tok0.chpos, rdr.chpos); - self.sess = sess; - self.cfg = cfg; - self.file_type = ftype; - self.token = tok0.tok; - self.span = span0; - self.last_span = span0; - self.buffer = dvec::dvec(); - self.restriction = UNRESTRICTED; - self.reader = rdr; - self.keywords = token::keyword_table(); - self.restricted_keywords = token::restricted_keyword_table(); - } - - //TODO: uncomment when destructors workd - //drop {} /* do not copy the parser; its state is tied to outside state */ - - fn bump() { - self.last_span = self.span; - if self.buffer.len() == 0u { - let next = lexer::next_token(self.reader); - self.token = next.tok; - self.span = mk_sp(next.chpos, self.reader.chpos); - } else { - let next = self.buffer.shift(); - self.token = next.tok; - self.span = next.span; - } - } - fn swap(next: token::token, lo: uint, hi: uint) { - self.token = next; - self.span = mk_sp(lo, hi); - } - fn look_ahead(distance: uint) -> token::token { - while self.buffer.len() < distance { - let next = lexer::next_token(self.reader); - let sp = mk_sp(next.chpos, self.reader.chpos); - self.buffer.push({tok: next.tok, span: sp}); - } - ret self.buffer[distance - 1u].tok; - } - fn fatal(m: str) -> ! { - self.sess.span_diagnostic.span_fatal(self.span, m) - } - fn span_fatal(sp: span, m: str) -> ! { - self.sess.span_diagnostic.span_fatal(sp, m) - } - fn bug(m: str) -> ! { - self.sess.span_diagnostic.span_bug(self.span, m) - } - fn warn(m: str) { - self.sess.span_diagnostic.span_warn(self.span, m) - } - fn get_str(i: token::str_num) -> str { - interner::get(*self.reader.interner, i) - } - fn get_id() -> node_id { next_node_id(self.sess) } - - fn parse_ty_fn(purity: ast::purity) -> ty_ { - let proto = if self.eat_keyword("native") { - self.expect_keyword("fn"); - ast::proto_bare - } else { - self.expect_keyword("fn"); - self.parse_fn_ty_proto() - }; - ty_fn(proto, self.parse_ty_fn_decl(purity)) - } - - fn parse_ty_fn_decl(purity: ast::purity) -> fn_decl { - let inputs = - self.parse_seq(token::LPAREN, token::RPAREN, - seq_sep(token::COMMA)) { |p| - let mode = p.parse_arg_mode(); - let name = if is_plain_ident(p.token) - && p.look_ahead(1u) == token::COLON { - - let name = self.parse_value_ident(); - p.bump(); - name - } else { "" }; - - {mode: mode, ty: p.parse_ty(false), ident: name, - id: p.get_id()} - }; - // FIXME: constrs is empty because right now, higher-order functions - // can't have constrained types. - // Not sure whether that would be desirable anyway. See #34 for the - // story on constrained types. - let constrs: [@constr] = []; - let (ret_style, ret_ty) = self.parse_ret_ty(); - ret {inputs: inputs.node, output: ret_ty, - purity: purity, cf: ret_style, - constraints: constrs}; - } - - fn parse_ty_methods() -> [ty_method] { - (self.parse_seq(token::LBRACE, token::RBRACE, seq_sep_none()) { |p| - let attrs = p.parse_outer_attributes(); - let flo = p.span.lo; - let pur = p.parse_fn_purity(); - let ident = p.parse_method_name(); - let tps = p.parse_ty_params(); - let d = p.parse_ty_fn_decl(pur), fhi = p.last_span.hi; - self.expect(token::SEMI); - {ident: ident, attrs: attrs, decl: {purity: pur with d}, tps: tps, - span: mk_sp(flo, fhi)} - }).node - } - - fn parse_mt() -> mt { - let mutbl = self.parse_mutability(); - let t = self.parse_ty(false); - ret {ty: t, mutbl: mutbl}; - } - - fn parse_ty_field() -> ty_field { - let lo = self.span.lo; - let mutbl = self.parse_mutability(); - let id = self.parse_ident(); - self.expect(token::COLON); - let ty = self.parse_ty(false); - ret spanned(lo, ty.span.hi, {ident: id, mt: {ty: ty, mutbl: mutbl}}); - } - - // if i is the jth ident in args, return j - // otherwise, fail - fn ident_index(args: [arg], i: ident) -> uint { - let mut j = 0u; - for args.each {|a| if a.ident == i { ret j; } j += 1u; } - self.fatal("unbound variable `" + i + "` in constraint arg"); - } - - fn parse_type_constr_arg() -> @ty_constr_arg { - let sp = self.span; - let mut carg = carg_base; - self.expect(token::BINOP(token::STAR)); - if self.token == token::DOT { - // "*..." notation for record fields - self.bump(); - let pth = self.parse_path_without_tps(); - carg = carg_ident(pth); - } - // No literals yet, I guess? - ret @{node: carg, span: sp}; - } - - fn parse_constr_arg(args: [arg]) -> @constr_arg { - let sp = self.span; - let mut carg = carg_base; - if self.token == token::BINOP(token::STAR) { - self.bump(); - } else { - let i: ident = self.parse_value_ident(); - carg = carg_ident(self.ident_index(args, i)); - } - ret @{node: carg, span: sp}; - } - - fn parse_ty_constr(fn_args: [arg]) -> @constr { - let lo = self.span.lo; - let path = self.parse_path_without_tps(); - let args: {node: [@constr_arg], span: span} = - self.parse_seq(token::LPAREN, token::RPAREN, - seq_sep(token::COMMA), - {|p| p.parse_constr_arg(fn_args)}); - ret @spanned(lo, args.span.hi, - {path: path, args: args.node, id: self.get_id()}); - } - - fn parse_constr_in_type() -> @ty_constr { - let lo = self.span.lo; - let path = self.parse_path_without_tps(); - let args: [@ty_constr_arg] = - self.parse_seq(token::LPAREN, token::RPAREN, - seq_sep(token::COMMA), - {|p| p.parse_type_constr_arg()}).node; - let hi = self.span.lo; - let tc: ty_constr_ = {path: path, args: args, id: self.get_id()}; - ret @spanned(lo, hi, tc); - } - - - fn parse_constrs<T: copy>(pser: fn(parser) -> @constr_general<T>) -> - [@constr_general<T>] { - let mut constrs: [@constr_general<T>] = []; - loop { - let constr = pser(self); - constrs += [constr]; - if self.token == token::COMMA { self.bump(); } - else { ret constrs; } - }; - } - - fn parse_type_constraints() -> [@ty_constr] { - ret self.parse_constrs({|p| p.parse_constr_in_type()}); - } - - fn parse_ret_ty() -> (ret_style, @ty) { - ret if self.eat(token::RARROW) { - let lo = self.span.lo; - if self.eat(token::NOT) { - (noreturn, @{id: self.get_id(), - node: ty_bot, - span: mk_sp(lo, self.last_span.hi)}) - } else { - (return_val, self.parse_ty(false)) - } - } else { - let pos = self.span.lo; - (return_val, @{id: self.get_id(), - node: ty_nil, - span: mk_sp(pos, pos)}) - } - } - - fn region_from_name(s: option<str>) -> @region { - let r = alt s { - some (string) { re_named(string) } - none { re_anon } - }; - - @{id: self.get_id(), node: r} - } - - // Parses something like "&x" - fn parse_region() -> @region { - self.expect(token::BINOP(token::AND)); - alt self.token { - token::IDENT(sid, _) { - self.bump(); - let n = self.get_str(sid); - self.region_from_name(some(n)) - } - _ { - self.region_from_name(none) - } - } - } - - // Parses something like "&x." (note the trailing dot) - fn parse_region_dot() -> @region { - let name = - alt self.token { - token::IDENT(sid, _) if self.look_ahead(1u) == token::DOT { - self.bump(); self.bump(); - some(self.get_str(sid)) - } - _ { none } - }; - self.region_from_name(name) - } - - fn parse_ty(colons_before_params: bool) -> @ty { - let lo = self.span.lo; - - alt self.maybe_parse_dollar_mac() { - some(e) { - ret @{id: self.get_id(), - node: ty_mac(spanned(lo, self.span.hi, e)), - span: mk_sp(lo, self.span.hi)}; - } - none {} - } - - let t = if self.token == token::LPAREN { - self.bump(); - if self.token == token::RPAREN { - self.bump(); - ty_nil - } else { - let mut ts = [self.parse_ty(false)]; - while self.token == token::COMMA { - self.bump(); - ts += [self.parse_ty(false)]; - } - let t = if vec::len(ts) == 1u { ts[0].node } - else { ty_tup(ts) }; - self.expect(token::RPAREN); - t - } - } else if self.token == token::AT { - self.bump(); - ty_box(self.parse_mt()) - } else if self.token == token::TILDE { - self.bump(); - ty_uniq(self.parse_mt()) - } else if self.token == token::BINOP(token::STAR) { - self.bump(); - ty_ptr(self.parse_mt()) - } else if self.token == token::LBRACE { - let elems = self.parse_seq(token::LBRACE, token::RBRACE, - seq_sep_opt(token::COMMA), - {|p| p.parse_ty_field()}); - if vec::len(elems.node) == 0u { - self.unexpected_last(token::RBRACE); - } - let hi = elems.span.hi; - - let t = ty_rec(elems.node); - if self.token == token::COLON { - self.bump(); - ty_constr(@{id: self.get_id(), - node: t, - span: mk_sp(lo, hi)}, - self.parse_type_constraints()) - } else { t } - } else if self.token == token::LBRACKET { - self.expect(token::LBRACKET); - let t = ty_vec(self.parse_mt()); - self.expect(token::RBRACKET); - t - } else if self.token == token::BINOP(token::AND) { - self.bump(); - let region = self.parse_region_dot(); - let mt = self.parse_mt(); - ty_rptr(region, mt) - } else if self.eat_keyword("pure") { - self.parse_ty_fn(ast::pure_fn) - } else if self.eat_keyword("unsafe") { - self.parse_ty_fn(ast::unsafe_fn) - } else if self.is_keyword("fn") { - self.parse_ty_fn(ast::impure_fn) - } else if self.eat_keyword("native") { - self.expect_keyword("fn"); - ty_fn(proto_bare, self.parse_ty_fn_decl(ast::impure_fn)) - } else if self.token == token::MOD_SEP || is_ident(self.token) { - let path = self.parse_path_with_tps(colons_before_params); - ty_path(path, self.get_id()) - } else { self.fatal("expecting type"); }; - - let sp = mk_sp(lo, self.last_span.hi); - ret @{id: self.get_id(), - node: alt self.maybe_parse_vstore() { - // Consider a vstore suffix like /@ or /~ - none { t } - some(v) { - ty_vstore(@{id: self.get_id(), node:t, span: sp}, v) - } }, - span: sp} - } - - fn parse_arg_mode() -> mode { - if self.eat(token::BINOP(token::AND)) { - expl(by_mutbl_ref) - } else if self.eat(token::BINOP(token::MINUS)) { - expl(by_move) - } else if self.eat(token::ANDAND) { - expl(by_ref) - } else if self.eat(token::BINOP(token::PLUS)) { - if self.eat(token::BINOP(token::PLUS)) { - expl(by_val) - } else { - expl(by_copy) - } - } else { infer(self.get_id()) } - } - - fn parse_capture_item_or(parse_arg_fn: fn(parser) -> arg_or_capture_item) - -> arg_or_capture_item { - - fn parse_capture_item(p:parser, is_move: bool) -> capture_item { - let sp = mk_sp(p.span.lo, p.span.hi); - let ident = p.parse_ident(); - @{id: p.get_id(), is_move: is_move, name: ident, span: sp} - } - - if self.eat_keyword("move") { - either::right(parse_capture_item(self, true)) - } else if self.eat_keyword("copy") { - either::right(parse_capture_item(self, false)) - } else { - parse_arg_fn(self) - } - } - - fn parse_arg() -> arg_or_capture_item { - let m = self.parse_arg_mode(); - let i = self.parse_value_ident(); - self.expect(token::COLON); - let t = self.parse_ty(false); - either::left({mode: m, ty: t, ident: i, id: self.get_id()}) - } - - fn parse_arg_or_capture_item() -> arg_or_capture_item { - self.parse_capture_item_or() {|p| p.parse_arg() } - } - - fn parse_fn_block_arg() -> arg_or_capture_item { - self.parse_capture_item_or() {|p| - let m = p.parse_arg_mode(); - let i = p.parse_value_ident(); - let t = if p.eat(token::COLON) { - p.parse_ty(false) - } else { - @{id: p.get_id(), - node: ty_infer, - span: mk_sp(p.span.lo, p.span.hi)} - }; - either::left({mode: m, ty: t, ident: i, id: p.get_id()}) - } - } - - fn maybe_parse_dollar_mac() -> option<mac_> { - alt self.token { - token::DOLLAR { - let lo = self.span.lo; - self.bump(); - alt self.token { - token::LIT_INT(num, ty_i) { - self.bump(); - some(mac_var(num as uint)) - } - token::LPAREN { - self.bump(); - let e = self.parse_expr(); - self.expect(token::RPAREN); - let hi = self.last_span.hi; - some(mac_aq(mk_sp(lo,hi), e)) - } - _ { - self.fatal("expected `(` or integer literal"); - } - } - } - _ {none} - } - } - - fn maybe_parse_vstore() -> option<vstore> { - if self.token == token::BINOP(token::SLASH) { - self.bump(); - alt self.token { - token::AT { - self.bump(); some(vstore_box) - } - token::TILDE { - self.bump(); some(vstore_uniq) - } - token::UNDERSCORE { - self.bump(); some(vstore_fixed(none)) - } - token::LIT_INT(i, ty_i) if i >= 0i64 { - self.bump(); some(vstore_fixed(some(i as uint))) - } - token::BINOP(token::AND) { - some(vstore_slice(self.parse_region())) - } - _ { - none - } - } - } else { - none - } - } - - fn lit_from_token(tok: token::token) -> lit_ { - alt tok { - token::LIT_INT(i, it) { lit_int(i, it) } - token::LIT_UINT(u, ut) { lit_uint(u, ut) } - token::LIT_FLOAT(s, ft) { lit_float(self.get_str(s), ft) } - token::LIT_STR(s) { lit_str(self.get_str(s)) } - token::LPAREN { self.expect(token::RPAREN); lit_nil } - _ { self.unexpected_last(tok); } - } - } - - fn parse_lit() -> lit { - let lo = self.span.lo; - let lit = if self.eat_keyword("true") { - lit_bool(true) - } else if self.eat_keyword("false") { - lit_bool(false) - } else { - let tok = self.token; - self.bump(); - self.lit_from_token(tok) - }; - ret {node: lit, span: mk_sp(lo, self.last_span.hi)}; - } - - fn parse_path_without_tps() -> @path { - self.parse_path_without_tps_({|p| p.parse_ident()}, - {|p| p.parse_ident()}) - } - - fn parse_path_without_tps_( - parse_ident: fn(parser) -> ident, - parse_last_ident: fn(parser) -> ident) -> @path { - - let lo = self.span.lo; - let global = self.eat(token::MOD_SEP); - let mut ids = []; - loop { - let is_not_last = - self.look_ahead(2u) != token::LT - && self.look_ahead(1u) == token::MOD_SEP; - - if is_not_last { - ids += [parse_ident(self)]; - self.expect(token::MOD_SEP); - } else { - ids += [parse_last_ident(self)]; - break; - } - } - @{span: mk_sp(lo, self.last_span.hi), global: global, - idents: ids, rp: none, types: []} - } - - fn parse_value_path() -> @path { - self.parse_path_without_tps_({|p| p.parse_ident()}, - {|p| p.parse_value_ident()}) - } - - fn parse_path_with_tps(colons: bool) -> @path { - #debug["parse_path_with_tps(colons=%b)", colons]; - - let lo = self.span.lo; - let path = self.parse_path_without_tps(); - if colons && !self.eat(token::MOD_SEP) { - ret path; - } - - // Parse the region parameter, if any, which will - // be written "foo/&x" - let rp = { - // Hack: avoid parsing vstores like /@ and /~. This is painful - // because the notation for region bounds and the notation for - // vstores is... um... the same. I guess that's my fault. This - // is still not ideal as for str/& we end up parsing more than we - // ought to and have to sort it out later. - if self.token == token::BINOP(token::SLASH) - && self.look_ahead(1u) == token::BINOP(token::AND) { - - self.expect(token::BINOP(token::SLASH)); - some(self.parse_region()) - } else { - none - } - }; - - // Parse any type parameters which may appear: - let tps = { - if self.token == token::LT { - self.parse_seq_lt_gt(some(token::COMMA), - {|p| p.parse_ty(false)}) - } else { - {node: [], span: path.span} - } - }; - - ret @{span: mk_sp(lo, tps.span.hi), - rp: rp, - types: tps.node with *path}; - } - - fn parse_mutability() -> mutability { - if self.eat_keyword("mut") { - m_mutbl - } else if self.eat_keyword("mut") { - m_mutbl - } else if self.eat_keyword("const") { - m_const - } else { - m_imm - } - } - - fn parse_field(sep: token::token) -> field { - let lo = self.span.lo; - let m = self.parse_mutability(); - let i = self.parse_ident(); - self.expect(sep); - let e = self.parse_expr(); - ret spanned(lo, e.span.hi, {mutbl: m, ident: i, expr: e}); - } - - fn mk_expr(lo: uint, hi: uint, +node: expr_) -> @expr { - ret @{id: self.get_id(), node: node, span: mk_sp(lo, hi)}; - } - - fn mk_mac_expr(lo: uint, hi: uint, m: mac_) -> @expr { - ret @{id: self.get_id(), - node: expr_mac({node: m, span: mk_sp(lo, hi)}), - span: mk_sp(lo, hi)}; - } - - fn mk_lit_u32(i: u32) -> @expr { - let span = self.span; - let lv_lit = @{node: lit_uint(i as u64, ty_u32), - span: span}; - - ret @{id: self.get_id(), node: expr_lit(lv_lit), span: span}; - } - - fn mk_pexpr(lo: uint, hi: uint, node: expr_) -> pexpr { - ret pexpr(self.mk_expr(lo, hi, node)); - } - - fn to_expr(e: pexpr) -> @expr { - alt e.node { - expr_tup(es) if vec::len(es) == 1u { es[0u] } - _ { *e } - } - } - - fn parse_bottom_expr() -> pexpr { - let lo = self.span.lo; - let mut hi = self.span.hi; - - let mut ex: expr_; - - alt self.maybe_parse_dollar_mac() { - some(x) {ret pexpr(self.mk_mac_expr(lo, self.span.hi, x));} - _ {} - } - - if self.token == token::LPAREN { - self.bump(); - if self.token == token::RPAREN { - hi = self.span.hi; - self.bump(); - let lit = @spanned(lo, hi, lit_nil); - ret self.mk_pexpr(lo, hi, expr_lit(lit)); - } - let mut es = [self.parse_expr()]; - while self.token == token::COMMA { - self.bump(); es += [self.parse_expr()]; - } - hi = self.span.hi; - self.expect(token::RPAREN); - - // Note: we retain the expr_tup() even for simple - // parenthesized expressions, but only for a "little while". - // This is so that wrappers around parse_bottom_expr() - // can tell whether the expression was parenthesized or not, - // which affects expr_is_complete(). - ret self.mk_pexpr(lo, hi, expr_tup(es)); - } else if self.token == token::LBRACE { - self.bump(); - if self.is_keyword("mut") || - is_plain_ident(self.token) - && self.look_ahead(1u) == token::COLON { - let mut fields = [self.parse_field(token::COLON)]; - let mut base = none; - while self.token != token::RBRACE { - if self.eat_keyword("with") { - base = some(self.parse_expr()); break; - } - self.expect(token::COMMA); - if self.token == token::RBRACE { - // record ends by an optional trailing comma - break; - } - fields += [self.parse_field(token::COLON)]; - } - hi = self.span.hi; - self.expect(token::RBRACE); - ex = expr_rec(fields, base); - } else if token::is_bar(self.token) { - ret pexpr(self.parse_fn_block_expr()); - } else { - let blk = self.parse_block_tail(lo, default_blk); - ret self.mk_pexpr(blk.span.lo, blk.span.hi, expr_block(blk)); - } - } else if self.eat_keyword("new") { - self.expect(token::LPAREN); - let r = self.parse_expr(); - self.expect(token::RPAREN); - let v = self.parse_expr(); - ret self.mk_pexpr(lo, self.span.hi, - expr_new(r, self.get_id(), v)); - } else if self.eat_keyword("if") { - ret pexpr(self.parse_if_expr()); - } else if self.eat_keyword("for") { - ret pexpr(self.parse_for_expr()); - } else if self.eat_keyword("while") { - ret pexpr(self.parse_while_expr()); - } else if self.eat_keyword("loop") { - ret pexpr(self.parse_loop_expr()); - } else if self.eat_keyword("alt") { - ret pexpr(self.parse_alt_expr()); - } else if self.eat_keyword("fn") { - let proto = self.parse_fn_ty_proto(); - alt proto { - proto_bare { self.fatal("fn expr are deprecated, use fn@"); } - proto_any { self.fatal("fn* cannot be used in an expression"); } - _ { /* fallthrough */ } - } - ret pexpr(self.parse_fn_expr(proto)); - } else if self.eat_keyword("unchecked") { - ret pexpr(self.parse_block_expr(lo, unchecked_blk)); - } else if self.eat_keyword("unsafe") { - ret pexpr(self.parse_block_expr(lo, unsafe_blk)); - } else if self.token == token::LBRACKET { - self.bump(); - let mutbl = self.parse_mutability(); - let es = - self.parse_seq_to_end(token::RBRACKET, seq_sep(token::COMMA), - {|p| p.parse_expr()}); - hi = self.span.hi; - ex = expr_vec(es, mutbl); - } else if self.token == token::POUND - && self.look_ahead(1u) == token::LT { - self.bump(); - self.bump(); - let ty = self.parse_ty(false); - self.expect(token::GT); - - /* hack: early return to take advantage of specialized function */ - ret pexpr(self.mk_mac_expr(lo, self.span.hi, - mac_embed_type(ty))); - } else if self.token == token::POUND - && self.look_ahead(1u) == token::LBRACE { - self.bump(); - self.bump(); - let blk = mac_embed_block( - self.parse_block_tail(lo, default_blk)); - ret pexpr(self.mk_mac_expr(lo, self.span.hi, blk)); - } else if self.token == token::ELLIPSIS { - self.bump(); - ret pexpr(self.mk_mac_expr(lo, self.span.hi, mac_ellipsis)); - } else if self.token == token::POUND { - let ex_ext = self.parse_syntax_ext(); - hi = ex_ext.span.hi; - ex = ex_ext.node; - } else if self.eat_keyword("bind") { - let e = self.parse_expr_res(RESTRICT_NO_CALL_EXPRS); - let es = self.parse_seq(token::LPAREN, token::RPAREN, - seq_sep(token::COMMA), - {|p| p.parse_expr_or_hole()}); - hi = es.span.hi; - ex = expr_bind(e, es.node); - } else if self.eat_keyword("fail") { - if can_begin_expr(self.token) { - let e = self.parse_expr(); - hi = e.span.hi; - ex = expr_fail(some(e)); - } else { ex = expr_fail(none); } - } else if self.eat_keyword("log") { - self.expect(token::LPAREN); - let lvl = self.parse_expr(); - self.expect(token::COMMA); - let e = self.parse_expr(); - ex = expr_log(2, lvl, e); - hi = self.span.hi; - self.expect(token::RPAREN); - } else if self.eat_keyword("assert") { - let e = self.parse_expr(); - ex = expr_assert(e); - hi = e.span.hi; - } else if self.eat_keyword("check") { - /* Should be a predicate (pure boolean function) applied to - arguments that are all either slot variables or literals. - but the typechecker enforces that. */ - let e = self.parse_expr(); - hi = e.span.hi; - ex = expr_check(checked_expr, e); - } else if self.eat_keyword("claim") { - /* Same rules as check, except that if check-claims - is enabled (a command-line flag), then the parser turns - claims into check */ - - let e = self.parse_expr(); - hi = e.span.hi; - ex = expr_check(claimed_expr, e); - } else if self.eat_keyword("ret") { - if can_begin_expr(self.token) { - let e = self.parse_expr(); - hi = e.span.hi; - ex = expr_ret(some(e)); - } else { ex = expr_ret(none); } - } else if self.eat_keyword("break") { - ex = expr_break; - hi = self.span.hi; - } else if self.eat_keyword("cont") { - ex = expr_cont; - hi = self.span.hi; - } else if self.eat_keyword("copy") { - let e = self.parse_expr(); - ex = expr_copy(e); - hi = e.span.hi; - } else if self.token == token::MOD_SEP || - is_ident(self.token) && !self.is_keyword("true") && - !self.is_keyword("false") { - let pth = self.parse_path_with_tps(true); - hi = pth.span.hi; - ex = expr_path(pth); - } else { - let lit = self.parse_lit(); - hi = lit.span.hi; - ex = expr_lit(@lit); - } - - // Vstore is legal following expr_lit(lit_str(...)) and expr_vec(...) - // only. - alt ex { - expr_lit(@{node: lit_str(_), span: _}) | - expr_vec(_, _) { - alt self.maybe_parse_vstore() { - none { } - some(v) { - hi = self.span.hi; - ex = expr_vstore(self.mk_expr(lo, hi, ex), v); - } - } - } - _ { } - } - - ret self.mk_pexpr(lo, hi, ex); - } - - fn parse_block_expr(lo: uint, blk_mode: blk_check_mode) -> @expr { - self.expect(token::LBRACE); - let blk = self.parse_block_tail(lo, blk_mode); - ret self.mk_expr(blk.span.lo, blk.span.hi, expr_block(blk)); - } - - fn parse_syntax_ext() -> @expr { - let lo = self.span.lo; - self.expect(token::POUND); - ret self.parse_syntax_ext_naked(lo); - } - - fn parse_syntax_ext_naked(lo: uint) -> @expr { - alt self.token { - token::IDENT(_, _) {} - _ { self.fatal("expected a syntax expander name"); } - } - let pth = self.parse_path_without_tps(); - //temporary for a backwards-compatible cycle: - let sep = seq_sep(token::COMMA); - let mut e = none; - if (self.token == token::LPAREN || self.token == token::LBRACKET) { - let es = - if self.token == token::LPAREN { - self.parse_seq(token::LPAREN, token::RPAREN, - sep, {|p| p.parse_expr()}) - } else { - self.parse_seq(token::LBRACKET, token::RBRACKET, - sep, {|p| p.parse_expr()}) - }; - let hi = es.span.hi; - e = some(self.mk_expr(es.span.lo, hi, - expr_vec(es.node, m_imm))); - } - let mut b = none; - if self.token == token::LBRACE { - self.bump(); - let lo = self.span.lo; - let mut depth = 1u; - while (depth > 0u) { - alt (self.token) { - token::LBRACE {depth += 1u;} - token::RBRACE {depth -= 1u;} - token::EOF {self.fatal("unexpected EOF in macro body");} - _ {} - } - self.bump(); - } - let hi = self.last_span.lo; - b = some({span: mk_sp(lo,hi)}); - } - ret self.mk_mac_expr(lo, self.span.hi, mac_invoc(pth, e, b)); -} - - fn parse_dot_or_call_expr() -> pexpr { - let b = self.parse_bottom_expr(); - self.parse_dot_or_call_expr_with(b) - } - - fn permits_call() -> bool { - ret self.restriction != RESTRICT_NO_CALL_EXPRS; - } - - fn parse_dot_or_call_expr_with(e0: pexpr) -> pexpr { - let mut e = e0; - let lo = e.span.lo; - let mut hi; - loop { - // expr.f - if self.eat(token::DOT) { - alt self.token { - token::IDENT(i, _) { - hi = self.span.hi; - self.bump(); - let tys = if self.eat(token::MOD_SEP) { - self.expect(token::LT); - self.parse_seq_to_gt(some(token::COMMA), - {|p| p.parse_ty(false)}) - } else { [] }; - e = self.mk_pexpr(lo, hi, expr_field(self.to_expr(e), - self.get_str(i), - tys)); - } - _ { self.unexpected(); } - } - cont; - } - if self.expr_is_complete(e) { break; } - alt self.token { - // expr(...) - token::LPAREN if self.permits_call() { - let es_opt = self.parse_seq(token::LPAREN, token::RPAREN, - seq_sep(token::COMMA), - {|p| p.parse_expr_or_hole()}); - hi = es_opt.span.hi; - - let nd = - if vec::any(es_opt.node, {|e| option::is_none(e) }) { - expr_bind(self.to_expr(e), es_opt.node) - } else { - let es = vec::map(es_opt.node) {|e| option::get(e) }; - expr_call(self.to_expr(e), es, false) - }; - e = self.mk_pexpr(lo, hi, nd); - } - - // expr {|| ... } - token::LBRACE if (token::is_bar(self.look_ahead(1u)) - && self.permits_call()) { - self.bump(); - let blk = self.parse_fn_block_expr(); - alt e.node { - expr_call(f, args, false) { - e = pexpr(@{node: expr_call(f, args + [blk], true) - with *self.to_expr(e)}); - } - _ { - e = self.mk_pexpr(lo, self.last_span.hi, - expr_call(self.to_expr(e), [blk], true)); - } - } - } - - // expr[...] - token::LBRACKET { - self.bump(); - let ix = self.parse_expr(); - hi = ix.span.hi; - self.expect(token::RBRACKET); - self.get_id(); // see ast_util::op_expr_callee_id - e = self.mk_pexpr(lo, hi, expr_index(self.to_expr(e), ix)); - } - - _ { ret e; } - } - } - ret e; -} - - fn parse_prefix_expr() -> pexpr { - let lo = self.span.lo; - let mut hi; - - let mut ex; - alt self.token { - token::NOT { - self.bump(); - let e = self.to_expr(self.parse_prefix_expr()); - hi = e.span.hi; - self.get_id(); // see ast_util::op_expr_callee_id - ex = expr_unary(not, e); - } - token::BINOP(b) { - alt b { - token::MINUS { - self.bump(); - let e = self.to_expr(self.parse_prefix_expr()); - hi = e.span.hi; - self.get_id(); // see ast_util::op_expr_callee_id - ex = expr_unary(neg, e); - } - token::STAR { - self.bump(); - let e = self.to_expr(self.parse_prefix_expr()); - hi = e.span.hi; - ex = expr_unary(deref, e); - } - token::AND { - self.bump(); - let m = self.parse_mutability(); - let e = self.to_expr(self.parse_prefix_expr()); - hi = e.span.hi; - ex = expr_addr_of(m, e); - } - _ { ret self.parse_dot_or_call_expr(); } - } - } - token::AT { - self.bump(); - let m = self.parse_mutability(); - let e = self.to_expr(self.parse_prefix_expr()); - hi = e.span.hi; - ex = expr_unary(box(m), e); - } - token::TILDE { - self.bump(); - let m = self.parse_mutability(); - let e = self.to_expr(self.parse_prefix_expr()); - hi = e.span.hi; - ex = expr_unary(uniq(m), e); - } - _ { ret self.parse_dot_or_call_expr(); } - } - ret self.mk_pexpr(lo, hi, ex); - } - - - fn parse_binops() -> @expr { - ret self.parse_more_binops(self.parse_prefix_expr(), 0u); - } - - fn parse_more_binops(plhs: pexpr, min_prec: uint) -> - @expr { - let lhs = self.to_expr(plhs); - if self.expr_is_complete(plhs) { ret lhs; } - let peeked = self.token; - if peeked == token::BINOP(token::OR) && - self.restriction == RESTRICT_NO_BAR_OP { ret lhs; } - let cur_opt = token_to_binop(peeked); - alt cur_opt { - some(cur_op) { - let cur_prec = operator_prec(cur_op); - if cur_prec > min_prec { - self.bump(); - let expr = self.parse_prefix_expr(); - let rhs = self.parse_more_binops(expr, cur_prec); - self.get_id(); // see ast_util::op_expr_callee_id - let bin = self.mk_pexpr(lhs.span.lo, rhs.span.hi, - expr_binary(cur_op, lhs, rhs)); - ret self.parse_more_binops(bin, min_prec); - } - } - _ {} - } - if as_prec > min_prec && self.eat_keyword("as") { - let rhs = self.parse_ty(true); - let _as = - self.mk_pexpr(lhs.span.lo, rhs.span.hi, expr_cast(lhs, rhs)); - ret self.parse_more_binops(_as, min_prec); - } - ret lhs; - } - - fn parse_assign_expr() -> @expr { - let lo = self.span.lo; - let lhs = self.parse_binops(); - alt self.token { - token::EQ { - self.bump(); - let rhs = self.parse_expr(); - ret self.mk_expr(lo, rhs.span.hi, expr_assign(lhs, rhs)); - } - token::BINOPEQ(op) { - self.bump(); - let rhs = self.parse_expr(); - let mut aop; - alt op { - token::PLUS { aop = add; } - token::MINUS { aop = subtract; } - token::STAR { aop = mul; } - token::SLASH { aop = div; } - token::PERCENT { aop = rem; } - token::CARET { aop = bitxor; } - token::AND { aop = bitand; } - token::OR { aop = bitor; } - token::SHL { aop = shl; } - token::SHR { aop = shr; } - } - self.get_id(); // see ast_util::op_expr_callee_id - ret self.mk_expr(lo, rhs.span.hi, expr_assign_op(aop, lhs, rhs)); - } - token::LARROW { - self.bump(); - let rhs = self.parse_expr(); - ret self.mk_expr(lo, rhs.span.hi, expr_move(lhs, rhs)); - } - token::DARROW { - self.bump(); - let rhs = self.parse_expr(); - ret self.mk_expr(lo, rhs.span.hi, expr_swap(lhs, rhs)); - } - _ {/* fall through */ } - } - ret lhs; - } - - fn parse_if_expr_1() -> - {cond: @expr, - then: blk, - els: option<@expr>, - lo: uint, - hi: uint} { - let lo = self.last_span.lo; - let cond = self.parse_expr(); - let thn = self.parse_block(); - let mut els: option<@expr> = none; - let mut hi = thn.span.hi; - if self.eat_keyword("else") { - let elexpr = self.parse_else_expr(); - els = some(elexpr); - hi = elexpr.span.hi; - } - ret {cond: cond, then: thn, els: els, lo: lo, hi: hi}; - } - - fn parse_if_expr() -> @expr { - if self.eat_keyword("check") { - let q = self.parse_if_expr_1(); - ret self.mk_expr(q.lo, q.hi, - expr_if_check(q.cond, q.then, q.els)); - } else { - let q = self.parse_if_expr_1(); - ret self.mk_expr(q.lo, q.hi, expr_if(q.cond, q.then, q.els)); - } - } - - fn parse_fn_expr(proto: proto) -> @expr { - let lo = self.last_span.lo; - - let cc_old = self.parse_old_skool_capture_clause(); - - // if we want to allow fn expression argument types to be inferred in - // the future, just have to change parse_arg to parse_fn_block_arg. - let (decl, capture_clause) = - self.parse_fn_decl(impure_fn, - {|p| p.parse_arg_or_capture_item()}); - - let body = self.parse_block(); - ret self.mk_expr(lo, body.span.hi, - expr_fn(proto, decl, body, - @(*capture_clause + cc_old))); - } - - fn parse_fn_block_expr() -> @expr { - let lo = self.last_span.lo; - let (decl, captures) = self.parse_fn_block_decl(); - let body = self.parse_block_tail(lo, default_blk); - ret self.mk_expr(lo, body.span.hi, - expr_fn_block(decl, body, captures)); - } - - fn parse_else_expr() -> @expr { - if self.eat_keyword("if") { - ret self.parse_if_expr(); - } else { - let blk = self.parse_block(); - ret self.mk_expr(blk.span.lo, blk.span.hi, expr_block(blk)); - } - } - - fn parse_for_expr() -> @expr { - let lo = self.last_span; - let call = self.parse_expr_res(RESTRICT_STMT_EXPR); - alt call.node { - expr_call(f, args, true) { - let b_arg = vec::last(args); - let last = self.mk_expr(b_arg.span.lo, b_arg.span.hi, - expr_loop_body(b_arg)); - @{node: expr_call(f, vec::init(args) + [last], true) - with *call} - } - _ { - self.span_fatal(lo, "`for` must be followed by a block call"); - } - } - } - - fn parse_while_expr() -> @expr { - let lo = self.last_span.lo; - let cond = self.parse_expr(); - let body = self.parse_block_no_value(); - let mut hi = body.span.hi; - ret self.mk_expr(lo, hi, expr_while(cond, body)); - } - - fn parse_loop_expr() -> @expr { - let lo = self.last_span.lo; - let body = self.parse_block_no_value(); - let mut hi = body.span.hi; - ret self.mk_expr(lo, hi, expr_loop(body)); - } - - fn parse_alt_expr() -> @expr { - let lo = self.last_span.lo; - let mode = if self.eat_keyword("check") { alt_check } - else { alt_exhaustive }; - let discriminant = self.parse_expr(); - self.expect(token::LBRACE); - let mut arms: [arm] = []; - while self.token != token::RBRACE { - let pats = self.parse_pats(); - let mut guard = none; - if self.eat_keyword("if") { guard = some(self.parse_expr()); } - let blk = self.parse_block(); - arms += [{pats: pats, guard: guard, body: blk}]; - } - let mut hi = self.span.hi; - self.bump(); - ret self.mk_expr(lo, hi, expr_alt(discriminant, arms, mode)); - } - - fn parse_expr() -> @expr { - ret self.parse_expr_res(UNRESTRICTED); - } - - fn parse_expr_or_hole() -> option<@expr> { - alt self.token { - token::UNDERSCORE { self.bump(); ret none; } - _ { ret some(self.parse_expr()); } - } - } - - fn parse_expr_res(r: restriction) -> @expr { - let old = self.restriction; - self.restriction = r; - let e = self.parse_assign_expr(); - self.restriction = old; - ret e; - } - - fn parse_initializer() -> option<initializer> { - alt self.token { - token::EQ { - self.bump(); - ret some({op: init_assign, expr: self.parse_expr()}); - } - token::LARROW { - self.bump(); - ret some({op: init_move, expr: self.parse_expr()}); - } - // Now that the the channel is the first argument to receive, - // combining it with an initializer doesn't really make sense. - // case (token::RECV) { - // self.bump(); - // ret some(rec(op = init_recv, - // expr = self.parse_expr())); - // } - _ { - ret none; - } - } - } - - fn parse_pats() -> [@pat] { - let mut pats = []; - loop { - pats += [self.parse_pat()]; - if self.token == token::BINOP(token::OR) { self.bump(); } - else { ret pats; } - }; - } - - fn parse_pat() -> @pat { - let lo = self.span.lo; - let mut hi = self.span.hi; - let mut pat; - alt self.token { - token::UNDERSCORE { self.bump(); pat = pat_wild; } - token::AT { - self.bump(); - let sub = self.parse_pat(); - pat = pat_box(sub); - hi = sub.span.hi; - } - token::TILDE { - self.bump(); - let sub = self.parse_pat(); - pat = pat_uniq(sub); - hi = sub.span.hi; - } - token::LBRACE { - self.bump(); - let mut fields = []; - let mut etc = false; - let mut first = true; - while self.token != token::RBRACE { - if first { first = false; } - else { self.expect(token::COMMA); } - - if self.token == token::UNDERSCORE { - self.bump(); - if self.token != token::RBRACE { - self.fatal("expecting }, found " + - token_to_str(self.reader, self.token)); - } - etc = true; - break; - } - - let lo1 = self.last_span.lo; - let fieldname = if self.look_ahead(1u) == token::COLON { - self.parse_ident() - } else { - self.parse_value_ident() - }; - let hi1 = self.last_span.lo; - let fieldpath = ast_util::ident_to_path(mk_sp(lo1, hi1), - fieldname); - let mut subpat; - if self.token == token::COLON { - self.bump(); - subpat = self.parse_pat(); - } else { - subpat = @{id: self.get_id(), - node: pat_ident(fieldpath, none), - span: mk_sp(lo, hi)}; - } - fields += [{ident: fieldname, pat: subpat}]; - } - hi = self.span.hi; - self.bump(); - pat = pat_rec(fields, etc); - } - token::LPAREN { - self.bump(); - if self.token == token::RPAREN { - hi = self.span.hi; - self.bump(); - let lit = @{node: lit_nil, span: mk_sp(lo, hi)}; - let expr = self.mk_expr(lo, hi, expr_lit(lit)); - pat = pat_lit(expr); - } else { - let mut fields = [self.parse_pat()]; - while self.token == token::COMMA { - self.bump(); - fields += [self.parse_pat()]; - } - if vec::len(fields) == 1u { self.expect(token::COMMA); } - hi = self.span.hi; - self.expect(token::RPAREN); - pat = pat_tup(fields); - } - } - tok { - if !is_ident(tok) || self.is_keyword("true") - || self.is_keyword("false") { - let val = self.parse_expr_res(RESTRICT_NO_BAR_OP); - if self.eat_keyword("to") { - let end = self.parse_expr_res(RESTRICT_NO_BAR_OP); - hi = end.span.hi; - pat = pat_range(val, end); - } else { - hi = val.span.hi; - pat = pat_lit(val); - } - } else if is_plain_ident(self.token) && - alt self.look_ahead(1u) { - token::LPAREN | token::LBRACKET | token::LT { false } - _ { true } - } { - let name = self.parse_value_path(); - let sub = if self.eat(token::AT) { some(self.parse_pat()) } - else { none }; - pat = pat_ident(name, sub); - } else { - let enum_path = self.parse_path_with_tps(true); - hi = enum_path.span.hi; - let mut args: [@pat] = []; - let mut star_pat = false; - alt self.token { - token::LPAREN { - alt self.look_ahead(1u) { - token::BINOP(token::STAR) { - // This is a "top constructor only" pat - self.bump(); self.bump(); - star_pat = true; - self.expect(token::RPAREN); - } - _ { - let a = self.parse_seq(token::LPAREN, token::RPAREN, - seq_sep(token::COMMA), - {|p| p.parse_pat()}); - args = a.node; - hi = a.span.hi; - } - } - } - _ { } - } - // at this point, we're not sure whether it's a enum or a bind - if star_pat { - pat = pat_enum(enum_path, none); - } - else if vec::is_empty(args) && - vec::len(enum_path.idents) == 1u { - pat = pat_ident(enum_path, none); - } - else { - pat = pat_enum(enum_path, some(args)); - } - } - } - } - ret @{id: self.get_id(), node: pat, span: mk_sp(lo, hi)}; - } - - fn parse_local(is_mutbl: bool, - allow_init: bool) -> @local { - let lo = self.span.lo; - let pat = self.parse_pat(); - let mut ty = @{id: self.get_id(), - node: ty_infer, - span: mk_sp(lo, lo)}; - if self.eat(token::COLON) { ty = self.parse_ty(false); } - let init = if allow_init { self.parse_initializer() } else { none }; - ret @spanned(lo, self.last_span.hi, - {is_mutbl: is_mutbl, ty: ty, pat: pat, - init: init, id: self.get_id()}); - } - - fn parse_let() -> @decl { - let is_mutbl = self.eat_keyword("mut"); - let lo = self.span.lo; - let mut locals = [self.parse_local(is_mutbl, true)]; - while self.eat(token::COMMA) { - locals += [self.parse_local(is_mutbl, true)]; - } - ret @spanned(lo, self.last_span.hi, decl_local(locals)); - } - - /* assumes "let" token has already been consumed */ - fn parse_instance_var(pr: visibility) -> @class_member { - let mut is_mutbl = class_immutable; - let lo = self.span.lo; - if self.eat_keyword("mut") { - is_mutbl = class_mutable; - } - if !is_plain_ident(self.token) { - self.fatal("expecting ident"); - } - let name = self.parse_ident(); - self.expect(token::COLON); - let ty = self.parse_ty(false); - ret @{node: instance_var(name, ty, is_mutbl, self.get_id(), pr), - span: mk_sp(lo, self.last_span.hi)}; - } - - fn parse_stmt(+first_item_attrs: [attribute]) -> @stmt { - fn check_expected_item(p: parser, current_attrs: [attribute]) { - // If we have attributes then we should have an item - if vec::is_not_empty(current_attrs) { - p.fatal("expected item"); - } - } - - let lo = self.span.lo; - if self.is_keyword("let") { - check_expected_item(self, first_item_attrs); - self.expect_keyword("let"); - let decl = self.parse_let(); - ret @spanned(lo, decl.span.hi, stmt_decl(decl, self.get_id())); - } else { - let mut item_attrs; - alt self.parse_outer_attrs_or_ext(first_item_attrs) { - none { item_attrs = []; } - some(left(attrs)) { item_attrs = attrs; } - some(right(ext)) { - ret @spanned(lo, ext.span.hi, stmt_expr(ext, self.get_id())); - } - } - - let item_attrs = first_item_attrs + item_attrs; - - alt self.parse_item(item_attrs, public) { - some(i) { - let mut hi = i.span.hi; - let decl = @spanned(lo, hi, decl_item(i)); - ret @spanned(lo, hi, stmt_decl(decl, self.get_id())); - } - none() { /* fallthrough */ } - } - - check_expected_item(self, item_attrs); - - // Remainder are line-expr stmts. - let e = self.parse_expr_res(RESTRICT_STMT_EXPR); - ret @spanned(lo, e.span.hi, stmt_expr(e, self.get_id())); - } - } - - fn expr_is_complete(e: pexpr) -> bool { - log(debug, ("expr_is_complete", self.restriction, - print::pprust::expr_to_str(*e), - classify::expr_requires_semi_to_be_stmt(*e))); - ret self.restriction == RESTRICT_STMT_EXPR && - !classify::expr_requires_semi_to_be_stmt(*e); - } - - fn parse_block() -> blk { - let (attrs, blk) = self.parse_inner_attrs_and_block(false); - assert vec::is_empty(attrs); - ret blk; - } - - fn parse_inner_attrs_and_block(parse_attrs: bool) -> ([attribute], blk) { - - fn maybe_parse_inner_attrs_and_next(p: parser, parse_attrs: bool) -> - {inner: [attribute], next: [attribute]} { - if parse_attrs { - p.parse_inner_attrs_and_next() - } else { - {inner: [], next: []} - } - } - - let lo = self.span.lo; - if self.eat_keyword("unchecked") { - self.expect(token::LBRACE); - let {inner, next} = maybe_parse_inner_attrs_and_next(self, - parse_attrs); - ret (inner, self.parse_block_tail_(lo, unchecked_blk, next)); - } else if self.eat_keyword("unsafe") { - self.expect(token::LBRACE); - let {inner, next} = maybe_parse_inner_attrs_and_next(self, - parse_attrs); - ret (inner, self.parse_block_tail_(lo, unsafe_blk, next)); - } else { - self.expect(token::LBRACE); - let {inner, next} = maybe_parse_inner_attrs_and_next(self, - parse_attrs); - ret (inner, self.parse_block_tail_(lo, default_blk, next)); - } - } - - fn parse_block_no_value() -> blk { - // We parse blocks that cannot have a value the same as any other - // block; the type checker will make sure that the tail expression (if - // any) has unit type. - ret self.parse_block(); - } - - // Precondition: already parsed the '{' or '#{' - // I guess that also means "already parsed the 'impure'" if - // necessary, and this should take a qualifier. - // some blocks start with "#{"... - fn parse_block_tail(lo: uint, s: blk_check_mode) -> blk { - self.parse_block_tail_(lo, s, []) - } - - fn parse_block_tail_(lo: uint, s: blk_check_mode, - +first_item_attrs: [attribute]) -> blk { - let mut stmts = []; - let mut expr = none; - let {attrs_remaining, view_items} = - self.parse_view(first_item_attrs, true); - let mut initial_attrs = attrs_remaining; - - if self.token == token::RBRACE && !vec::is_empty(initial_attrs) { - self.fatal("expected item"); - } - - while self.token != token::RBRACE { - alt self.token { - token::SEMI { - self.bump(); // empty - } - _ { - let stmt = self.parse_stmt(initial_attrs); - initial_attrs = []; - alt stmt.node { - stmt_expr(e, stmt_id) { // Expression without semicolon: - alt self.token { - token::SEMI { - self.bump(); - stmts += [@{node: stmt_semi(e, stmt_id) with *stmt}]; - } - token::RBRACE { - expr = some(e); - } - t { - if classify::stmt_ends_with_semi(*stmt) { - self.fatal("expected ';' or '}' after expression \ - but found '" - + token_to_str(self.reader, t) + "'"); - } - stmts += [stmt]; - } - } - } - - _ { // All other kinds of statements: - stmts += [stmt]; - - if classify::stmt_ends_with_semi(*stmt) { - self.expect(token::SEMI); - } - } - } - } - } - } - let mut hi = self.span.hi; - self.bump(); - let bloc = {view_items: view_items, stmts: stmts, expr: expr, - id: self.get_id(), rules: s}; - ret spanned(lo, hi, bloc); - } - - fn parse_ty_param() -> ty_param { - let mut bounds = []; - let ident = self.parse_ident(); - if self.eat(token::COLON) { - while self.token != token::COMMA && self.token != token::GT { - if self.eat_keyword("send") { bounds += [bound_send]; } - else if self.eat_keyword("copy") { bounds += [bound_copy]; } - else if self.eat_keyword("const") { bounds += [bound_const]; } - else { bounds += [bound_iface(self.parse_ty(false))]; } - } - } - ret {ident: ident, id: self.get_id(), bounds: @bounds}; - } - - fn parse_ty_params() -> [ty_param] { - if self.eat(token::LT) { - self.parse_seq_to_gt(some(token::COMMA), {|p| p.parse_ty_param()}) - } else { [] } - } - - // FIXME Remove after snapshot - fn parse_old_skool_capture_clause() -> [capture_item] { - fn expect_opt_trailing_semi(p: parser) { - if !p.eat(token::SEMI) { - if p.token != token::RBRACKET { - p.fatal("expecting ; or ]"); - } - } - } - - fn eat_ident_list(p: parser, is_move: bool) -> [capture_item] { - let mut res = []; - loop { - alt p.token { - token::IDENT(_, _) { - let id = p.get_id(); - let sp = mk_sp(p.span.lo, p.span.hi); - let ident = p.parse_ident(); - res += [@{id:id, is_move: is_move, name:ident, span:sp}]; - if !p.eat(token::COMMA) { - ret res; - } - } - - _ { ret res; } - } - }; - } - - let mut cap_items = []; - - if self.eat(token::LBRACKET) { - while !self.eat(token::RBRACKET) { - if self.eat_keyword("copy") { - cap_items += eat_ident_list(self, false); - expect_opt_trailing_semi(self); - } else if self.eat_keyword("move") { - cap_items += eat_ident_list(self, true); - expect_opt_trailing_semi(self); - } else { - let s: str = "expecting send, copy, or move clause"; - self.fatal(s); - } - } - } - - ret cap_items; - } - - fn parse_fn_decl(purity: purity, - parse_arg_fn: fn(parser) -> arg_or_capture_item) - -> (fn_decl, capture_clause) { - - let args_or_capture_items: [arg_or_capture_item] = - self.parse_seq(token::LPAREN, token::RPAREN, - seq_sep(token::COMMA), parse_arg_fn).node; - - let inputs = either::lefts(args_or_capture_items); - let capture_clause = @either::rights(args_or_capture_items); - - // Use the args list to translate each bound variable - // mentioned in a constraint to an arg index. - // Seems weird to do this in the parser, but I'm not sure how else to. - let mut constrs = []; - if self.token == token::COLON { - self.bump(); - constrs = self.parse_constrs({|p| p.parse_ty_constr(inputs) }); - } - let (ret_style, ret_ty) = self.parse_ret_ty(); - ret ({inputs: inputs, - output: ret_ty, - purity: purity, - cf: ret_style, - constraints: constrs}, capture_clause); - } - - fn parse_fn_block_decl() -> (fn_decl, capture_clause) { - let inputs_captures = { - if self.eat(token::OROR) { - [] - } else { - self.parse_seq(token::BINOP(token::OR), - token::BINOP(token::OR), seq_sep(token::COMMA), - {|p| p.parse_fn_block_arg()}).node - } - }; - let output = if self.eat(token::RARROW) { - self.parse_ty(false) - } else { - @{id: self.get_id(), node: ty_infer, span: self.span} - }; - ret ({inputs: either::lefts(inputs_captures), - output: output, - purity: impure_fn, - cf: return_val, - constraints: []}, - @either::rights(inputs_captures)); - } - - fn parse_fn_header() -> {ident: ident, tps: [ty_param]} { - let id = self.parse_value_ident(); - let ty_params = self.parse_ty_params(); - ret {ident: id, tps: ty_params}; - } - - fn mk_item(lo: uint, hi: uint, +ident: ident, - +node: item_, vis: visibility, - +attrs: [attribute]) -> @item { - ret @{ident: ident, - attrs: attrs, - id: self.get_id(), - node: node, - vis: vis, - span: mk_sp(lo, hi)}; - } - - fn parse_item_fn(purity: purity) -> item_info { - let t = self.parse_fn_header(); - let (decl, _) = self.parse_fn_decl(purity, {|p| p.parse_arg()}); - let (inner_attrs, body) = self.parse_inner_attrs_and_block(true); - (t.ident, item_fn(decl, t.tps, body), some(inner_attrs)) - } - - fn parse_method_name() -> ident { - alt self.token { - token::BINOP(op) { self.bump(); token::binop_to_str(op) } - token::NOT { self.bump(); "!" } - token::LBRACKET { self.bump(); self.expect(token::RBRACKET); "[]" } - _ { - let id = self.parse_value_ident(); - if id == "unary" && self.eat(token::BINOP(token::MINUS)) { - "unary-" - } - else { id } - } - } - } - - fn parse_method(pr: visibility) -> @method { - let attrs = self.parse_outer_attributes(); - let lo = self.span.lo, pur = self.parse_fn_purity(); - let ident = self.parse_method_name(); - let tps = self.parse_ty_params(); - let (decl, _) = self.parse_fn_decl(pur, {|p| p.parse_arg()}); - let (inner_attrs, body) = self.parse_inner_attrs_and_block(true); - let attrs = attrs + inner_attrs; - @{ident: ident, attrs: attrs, tps: tps, decl: decl, body: body, - id: self.get_id(), span: mk_sp(lo, body.span.hi), - self_id: self.get_id(), vis: pr} - } - - fn parse_item_iface() -> item_info { - let ident = self.parse_ident(); - let rp = self.parse_region_param(); - let tps = self.parse_ty_params(); - let meths = self.parse_ty_methods(); - (ident, item_iface(tps, rp, meths), none) - } - - // Parses three variants (with the region/type params always optional): - // impl /&<T: copy> of to_str for [T] { ... } - // impl name/&<T> of to_str for [T] { ... } - // impl name/&<T> for [T] { ... } - fn parse_item_impl() -> item_info { - fn wrap_path(p: parser, pt: @path) -> @ty { - @{id: p.get_id(), node: ty_path(pt, p.get_id()), span: pt.span} - } - let mut (ident, rp, tps) = { - if self.token == token::LT { - (none, rp_none, self.parse_ty_params()) - } else if self.token == token::BINOP(token::SLASH) { - (none, self.parse_region_param(), self.parse_ty_params()) - } - else if self.is_keyword("of") { - (none, rp_none, []) - } else { - let id = self.parse_ident(); - let rp = self.parse_region_param(); - (some(id), rp, self.parse_ty_params()) - } - }; - let ifce = if self.eat_keyword("of") { - let path = self.parse_path_with_tps(false); - if option::is_none(ident) { - ident = some(vec::last(path.idents)); - } - some(@{path: path, id: self.get_id()}) - } else { none }; - let ident = alt ident { - some(name) { name } - none { self.expect_keyword("of"); fail; } - }; - self.expect_keyword("for"); - let ty = self.parse_ty(false); - let mut meths = []; - self.expect(token::LBRACE); - while !self.eat(token::RBRACE) { - meths += [self.parse_method(public)]; - } - (ident, item_impl(tps, rp, ifce, ty, meths), none) - } - - fn parse_item_res() -> item_info { - let ident = self.parse_value_ident(); - let rp = self.parse_region_param(); - let ty_params = self.parse_ty_params(); - self.expect(token::LPAREN); - let arg_ident = self.parse_value_ident(); - self.expect(token::COLON); - let t = self.parse_ty(false); - self.expect(token::RPAREN); - let dtor = self.parse_block_no_value(); - let decl = { - inputs: [{mode: expl(by_ref), ty: t, - ident: arg_ident, id: self.get_id()}], - output: @{id: self.get_id(), node: ty_nil, - span: ast_util::dummy_sp()}, - purity: impure_fn, - cf: return_val, - constraints: [] - }; - (ident, item_res(decl, ty_params, dtor, - self.get_id(), self.get_id(), rp), none) - } - - // Instantiates ident <i> with references to <typarams> as arguments. - // Used to create a path that refers to a class which will be defined as - // the return type of the ctor function. - fn ident_to_path_tys(i: ident, - rp: region_param, - typarams: [ty_param]) -> @path { - let s = self.last_span; - - // Hack. But then, this whole function is in service of a hack. - let a_r = alt rp { - rp_none { none } - rp_self { some(self.region_from_name(some("self"))) } - }; - - @{span: s, global: false, idents: [i], - rp: a_r, - types: vec::map(typarams, {|tp| - @{id: self.get_id(), - node: ty_path(ident_to_path(s, tp.ident), self.get_id()), - span: s}}) - } - } - - fn parse_iface_ref() -> @iface_ref { - @{path: self.parse_path_with_tps(false), - id: self.get_id()} - } - - fn parse_iface_ref_list() -> [@iface_ref] { - self.parse_seq_to_before_end(token::LBRACE, seq_sep(token::COMMA), - {|p| p.parse_iface_ref()}) - } - - fn parse_item_class() -> item_info { - let class_name = self.parse_value_ident(); - let rp = self.parse_region_param(); - let ty_params = self.parse_ty_params(); - let class_path = self.ident_to_path_tys(class_name, rp, ty_params); - let ifaces : [@iface_ref] = if self.eat_keyword("implements") - { self.parse_iface_ref_list() } - else { [] }; - self.expect(token::LBRACE); - let mut ms: [@class_member] = []; - let ctor_id = self.get_id(); - let mut the_ctor : option<(fn_decl, blk, codemap::span)> = none; - let mut the_dtor : option<(blk, codemap::span)> = none; - while self.token != token::RBRACE { - alt self.parse_class_item(class_path) { - ctor_decl(a_fn_decl, blk, s) { - the_ctor = some((a_fn_decl, blk, s)); - } - dtor_decl(blk, s) { - the_dtor = some((blk, s)); - } - members(mms) { ms += mms; } - } - } - let actual_dtor = option::map(the_dtor) {|dtor| - let (d_body, d_s) = dtor; - {node: {id: self.get_id(), - self_id: self.get_id(), - body: d_body}, - span: d_s}}; - self.bump(); - alt the_ctor { - some((ct_d, ct_b, ct_s)) { - (class_name, - item_class(ty_params, ifaces, ms, { - node: {id: ctor_id, - self_id: self.get_id(), - dec: ct_d, - body: ct_b}, - span: ct_s}, actual_dtor, rp), - none) - } - /* - Is it strange for the parser to check this? - */ - none { - self.fatal("class with no ctor"); - } - } - } - - fn parse_single_class_item(vis: visibility) - -> @class_member { - if self.eat_keyword("let") { - let a_var = self.parse_instance_var(vis); - self.expect(token::SEMI); - ret a_var; - } - else { - let m = self.parse_method(vis); - ret @{node: class_method(m), span: m.span}; - } - } - - fn parse_ctor(result_ty: ast::ty_) -> class_contents { - // Can ctors/dtors have attrs? FIXME - let lo = self.last_span.lo; - let (decl_, _) = self.parse_fn_decl(impure_fn, {|p| p.parse_arg()}); - let decl = {output: @{id: self.get_id(), - node: result_ty, span: decl_.output.span} - with decl_}; - let body = self.parse_block(); - ctor_decl(decl, body, mk_sp(lo, self.last_span.hi)) - } - - fn parse_dtor() -> class_contents { - // Can ctors/dtors have attrs? FIXME - let lo = self.last_span.lo; - let body = self.parse_block(); - dtor_decl(body, mk_sp(lo, self.last_span.hi)) - } - - fn parse_class_item(class_name_with_tps: @path) - -> class_contents { - if self.eat_keyword("new") { - // result type is always the type of the class - ret self.parse_ctor(ty_path(class_name_with_tps, - self.get_id())); - } - else if self.eat_keyword("drop") { - ret self.parse_dtor(); - } - else if self.eat_keyword("priv") { - self.expect(token::LBRACE); - let mut results = []; - while self.token != token::RBRACE { - results += [self.parse_single_class_item(private)]; - } - self.bump(); - ret members(results); - } - else { - // Probably need to parse attrs - ret members([self.parse_single_class_item(public)]); - } -} - - fn parse_visibility(def: visibility) -> visibility { - if self.eat_keyword("pub") { public } - else if self.eat_keyword("priv") { private } - else { def } - } - - fn parse_mod_items(term: token::token, - +first_item_attrs: [attribute]) -> _mod { - // Shouldn't be any view items since we've already parsed an item attr - let {attrs_remaining, view_items} = - self.parse_view(first_item_attrs, false); - let mut items: [@item] = []; - let mut first = true; - while self.token != term { - let mut attrs = self.parse_outer_attributes(); - if first { attrs = attrs_remaining + attrs; first = false; } - #debug["parse_mod_items: parse_item(attrs=%?)", attrs]; - let vis = self.parse_visibility(private); - alt self.parse_item(attrs, vis) { - some(i) { items += [i]; } - _ { - self.fatal("expected item but found '" + - token_to_str(self.reader, self.token) + "'"); - } - } - #debug["parse_mod_items: attrs=%?", attrs]; - } - - if first && attrs_remaining.len() > 0u { - // We parsed attributes for the first item but didn't find it - self.fatal("expected item"); - } - - ret {view_items: view_items, items: items}; - } - - fn parse_item_const() -> item_info { - let id = self.parse_value_ident(); - self.expect(token::COLON); - let ty = self.parse_ty(false); - self.expect(token::EQ); - let e = self.parse_expr(); - self.expect(token::SEMI); - (id, item_const(ty, e), none) - } - - fn parse_item_mod() -> item_info { - let id = self.parse_ident(); - self.expect(token::LBRACE); - let inner_attrs = self.parse_inner_attrs_and_next(); - let m = self.parse_mod_items(token::RBRACE, inner_attrs.next); - self.expect(token::RBRACE); - (id, item_mod(m), some(inner_attrs.inner)) - } - - fn parse_item_native_fn(+attrs: [attribute], - purity: purity) -> @native_item { - let lo = self.last_span.lo; - let t = self.parse_fn_header(); - let (decl, _) = self.parse_fn_decl(purity, {|p| p.parse_arg()}); - let mut hi = self.span.hi; - self.expect(token::SEMI); - ret @{ident: t.ident, - attrs: attrs, - node: native_item_fn(decl, t.tps), - id: self.get_id(), - span: mk_sp(lo, hi)}; - } - - fn parse_fn_purity() -> purity { - if self.eat_keyword("fn") { impure_fn } - else if self.eat_keyword("pure") { - self.expect_keyword("fn"); - pure_fn - } else if self.eat_keyword("unsafe") { - self.expect_keyword("fn"); - unsafe_fn - } - else { self.unexpected(); } - } - - fn parse_native_item(+attrs: [attribute]) -> - @native_item { - self.parse_item_native_fn(attrs, self.parse_fn_purity()) - } - - fn parse_native_mod_items(+first_item_attrs: [attribute]) -> - native_mod { - // Shouldn't be any view items since we've already parsed an item attr - let {attrs_remaining, view_items} = - self.parse_view(first_item_attrs, false); - let mut items: [@native_item] = []; - let mut initial_attrs = attrs_remaining; - while self.token != token::RBRACE { - let attrs = initial_attrs + self.parse_outer_attributes(); - initial_attrs = []; - items += [self.parse_native_item(attrs)]; - } - ret {view_items: view_items, - items: items}; - } - - fn parse_item_native_mod() -> item_info { - self.expect_keyword("mod"); - let id = self.parse_ident(); - self.expect(token::LBRACE); - let more_attrs = self.parse_inner_attrs_and_next(); - let m = self.parse_native_mod_items(more_attrs.next); - self.expect(token::RBRACE); - (id, item_native_mod(m), some(more_attrs.inner)) - } - - fn parse_type_decl() -> {lo: uint, ident: ident} { - let lo = self.last_span.lo; - let id = self.parse_ident(); - ret {lo: lo, ident: id}; - } - - fn parse_item_type() -> item_info { - let t = self.parse_type_decl(); - let rp = self.parse_region_param(); - let tps = self.parse_ty_params(); - self.expect(token::EQ); - let ty = self.parse_ty(false); - self.expect(token::SEMI); - (t.ident, item_ty(ty, tps, rp), none) - } - - fn parse_region_param() -> region_param { - if self.eat(token::BINOP(token::SLASH)) { - self.expect(token::BINOP(token::AND)); - rp_self - } else { - rp_none - } - } - - fn parse_item_enum(default_vis: visibility) -> item_info { - let id = self.parse_ident(); - let rp = self.parse_region_param(); - let ty_params = self.parse_ty_params(); - let mut variants: [variant] = []; - // Newtype syntax - if self.token == token::EQ { - self.check_restricted_keywords_(id); - self.bump(); - let ty = self.parse_ty(false); - self.expect(token::SEMI); - let variant = - spanned(ty.span.lo, ty.span.hi, - {name: id, - attrs: [], - args: [{ty: ty, id: self.get_id()}], - id: self.get_id(), - disr_expr: none, - vis: public}); - ret (id, item_enum([variant], ty_params, rp), none); - } - self.expect(token::LBRACE); - - let mut all_nullary = true, have_disr = false; - - while self.token != token::RBRACE { - let variant_attrs = self.parse_outer_attributes(); - let vlo = self.span.lo; - let vis = self.parse_visibility(default_vis); - let ident = self.parse_value_ident(); - let mut args = [], disr_expr = none; - if self.token == token::LPAREN { - all_nullary = false; - let arg_tys = self.parse_seq(token::LPAREN, token::RPAREN, - seq_sep(token::COMMA), - {|p| p.parse_ty(false)}); - for arg_tys.node.each {|ty| - args += [{ty: ty, id: self.get_id()}]; - } - } else if self.eat(token::EQ) { - have_disr = true; - disr_expr = some(self.parse_expr()); - } - - let vr = {name: ident, attrs: variant_attrs, - args: args, id: self.get_id(), - disr_expr: disr_expr, vis: vis}; - variants += [spanned(vlo, self.last_span.hi, vr)]; - - if !self.eat(token::COMMA) { break; } - } - self.expect(token::RBRACE); - if (have_disr && !all_nullary) { - self.fatal("discriminator values can only be used with a c-like \ - enum"); - } - (id, item_enum(variants, ty_params, rp), none) - } - - fn parse_fn_ty_proto() -> proto { - alt self.token { - token::AT { - self.bump(); - proto_box - } - token::TILDE { - self.bump(); - proto_uniq - } - token::BINOP(token::AND) { - self.bump(); - proto_block - } - _ { - proto_any - } - } - } - - fn fn_expr_lookahead(tok: token::token) -> bool { - alt tok { - token::LPAREN | token::AT | token::TILDE | token::BINOP(_) { - true - } - _ { - false - } - } - } - - fn parse_item(+attrs: [attribute], vis: visibility) - -> option<@item> { - let lo = self.span.lo; - let (ident, item_, extra_attrs) = if self.eat_keyword("const") { - self.parse_item_const() - } else if self.is_keyword("fn") && - !self.fn_expr_lookahead(self.look_ahead(1u)) { - self.bump(); - self.parse_item_fn(impure_fn) - } else if self.eat_keyword("pure") { - self.expect_keyword("fn"); - self.parse_item_fn(pure_fn) - } else if self.is_keyword("unsafe") - && self.look_ahead(1u) != token::LBRACE { - self.bump(); - self.expect_keyword("fn"); - self.parse_item_fn(unsafe_fn) - } else if self.eat_keyword("crust") { - self.expect_keyword("fn"); - self.parse_item_fn(crust_fn) - } else if self.eat_keyword("mod") { - self.parse_item_mod() - } else if self.eat_keyword("native") { - self.parse_item_native_mod() - } else if self.eat_keyword("type") { - self.parse_item_type() - } else if self.eat_keyword("enum") { - self.parse_item_enum(vis) - } else if self.eat_keyword("iface") { - self.parse_item_iface() - } else if self.eat_keyword("impl") { - self.parse_item_impl() - } else if self.eat_keyword("resource") { - self.parse_item_res() - } else if self.eat_keyword("class") { - self.parse_item_class() - } else { ret none; }; - some(self.mk_item(lo, self.last_span.hi, ident, item_, vis, - alt extra_attrs { - some(as) { attrs + as } - none { attrs } - })) - } - - fn parse_use() -> view_item_ { - let ident = self.parse_ident(); - let metadata = self.parse_optional_meta(); - ret view_item_use(ident, metadata, self.get_id()); - } - - fn parse_view_path() -> @view_path { - let lo = self.span.lo; - let first_ident = self.parse_ident(); - let mut path = [first_ident]; - #debug("parsed view_path: %s", first_ident); - alt self.token { - token::EQ { - // x = foo::bar - self.bump(); - path = [self.parse_ident()]; - while self.token == token::MOD_SEP { - self.bump(); - let id = self.parse_ident(); - path += [id]; - } - let path = @{span: mk_sp(lo, self.span.hi), global: false, - idents: path, rp: none, types: []}; - ret @spanned(lo, self.span.hi, - view_path_simple(first_ident, path, self.get_id())); - } - - token::MOD_SEP { - // foo::bar or foo::{a,b,c} or foo::* - while self.token == token::MOD_SEP { - self.bump(); - - alt self.token { - - token::IDENT(i, _) { - self.bump(); - path += [self.get_str(i)]; - } - - // foo::bar::{a,b,c} - token::LBRACE { - let idents = - self.parse_seq(token::LBRACE, token::RBRACE, - seq_sep(token::COMMA), - {|p| p.parse_path_list_ident()}).node; - let path = @{span: mk_sp(lo, self.span.hi), - global: false, idents: path, - rp: none, types: []}; - ret @spanned(lo, self.span.hi, - view_path_list(path, idents, self.get_id())); - } - - // foo::bar::* - token::BINOP(token::STAR) { - self.bump(); - let path = @{span: mk_sp(lo, self.span.hi), - global: false, idents: path, - rp: none, types: []}; - ret @spanned(lo, self.span.hi, - view_path_glob(path, self.get_id())); - } - - _ { break; } - } - } - } - _ { } - } - let last = path[vec::len(path) - 1u]; - let path = @{span: mk_sp(lo, self.span.hi), global: false, - idents: path, rp: none, types: []}; - ret @spanned(lo, self.span.hi, - view_path_simple(last, path, self.get_id())); - } - - fn parse_view_paths() -> [@view_path] { - let mut vp = [self.parse_view_path()]; - while self.token == token::COMMA { - self.bump(); - vp += [self.parse_view_path()]; - } - ret vp; - } - - fn is_view_item() -> bool { - let tok = if !self.is_keyword("pub") && !self.is_keyword("priv") { - self.token - } else { self.look_ahead(1u) }; - self.token_is_keyword("use", tok) - || self.token_is_keyword("import", tok) - || self.token_is_keyword("export", tok) - } - - fn parse_view_item(+attrs: [attribute]) -> @view_item { - let lo = self.span.lo, vis = self.parse_visibility(private); - let node = if self.eat_keyword("use") { - self.parse_use() - } else if self.eat_keyword("import") { - view_item_import(self.parse_view_paths()) - } else if self.eat_keyword("export") { - view_item_export(self.parse_view_paths()) - } else { fail; }; - self.expect(token::SEMI); - @{node: node, attrs: attrs, - vis: vis, span: mk_sp(lo, self.last_span.hi)} - } - - fn parse_view(+first_item_attrs: [attribute], - only_imports: bool) -> {attrs_remaining: [attribute], - view_items: [@view_item]} { - let mut attrs = first_item_attrs + self.parse_outer_attributes(); - let mut items = []; - while if only_imports { self.is_keyword("import") } - else { self.is_view_item() } { - items += [self.parse_view_item(attrs)]; - attrs = self.parse_outer_attributes(); - } - {attrs_remaining: attrs, view_items: items} - } - - // Parses a source module as a crate - fn parse_crate_mod(_cfg: crate_cfg) -> @crate { - let lo = self.span.lo; - let crate_attrs = self.parse_inner_attrs_and_next(); - let first_item_outer_attrs = crate_attrs.next; - let m = self.parse_mod_items(token::EOF, first_item_outer_attrs); - ret @spanned(lo, self.span.lo, - {directives: [], - module: m, - attrs: crate_attrs.inner, - config: self.cfg}); - } - - fn parse_str() -> str { - alt self.token { - token::LIT_STR(s) { self.bump(); self.get_str(s) } - _ { - self.fatal("expected string literal") - } - } - } - - // Logic for parsing crate files (.rc) - // - // Each crate file is a sequence of directives. - // - // Each directive imperatively extends its environment with 0 or more - // items. - fn parse_crate_directive(first_outer_attr: [attribute]) -> - crate_directive { - - // Collect the next attributes - let outer_attrs = first_outer_attr + self.parse_outer_attributes(); - // In a crate file outer attributes are only going to apply to mods - let expect_mod = vec::len(outer_attrs) > 0u; - - let lo = self.span.lo; - if expect_mod || self.is_keyword("mod") { - self.expect_keyword("mod"); - let id = self.parse_ident(); - alt self.token { - // mod x = "foo.rs"; - token::SEMI { - let mut hi = self.span.hi; - self.bump(); - ret spanned(lo, hi, cdir_src_mod(id, outer_attrs)); - } - // mod x = "foo_dir" { ...directives... } - token::LBRACE { - self.bump(); - let inner_attrs = self.parse_inner_attrs_and_next(); - let mod_attrs = outer_attrs + inner_attrs.inner; - let next_outer_attr = inner_attrs.next; - let cdirs = self.parse_crate_directives(token::RBRACE, - next_outer_attr); - let mut hi = self.span.hi; - self.expect(token::RBRACE); - ret spanned(lo, hi, - cdir_dir_mod(id, cdirs, mod_attrs)); - } - _ { self.unexpected(); } - } - } else if self.is_view_item() { - let vi = self.parse_view_item(outer_attrs); - ret spanned(lo, vi.span.hi, cdir_view_item(vi)); - } else { ret self.fatal("expected crate directive"); } - } - - fn parse_crate_directives(term: token::token, - first_outer_attr: [attribute]) -> - [@crate_directive] { - - // This is pretty ugly. If we have an outer attribute then we can't - // accept seeing the terminator next, so if we do see it then fail the - // same way parse_crate_directive would - if vec::len(first_outer_attr) > 0u && self.token == term { - self.expect_keyword("mod"); - } - - let mut cdirs: [@crate_directive] = []; - let mut first_outer_attr = first_outer_attr; - while self.token != term { - let cdir = @self.parse_crate_directive(first_outer_attr); - cdirs += [cdir]; - first_outer_attr = []; - } - ret cdirs; - } -} -// -// Local Variables: -// mode: rust -// fill-column: 78; -// indent-tabs-mode: nil -// c-basic-offset: 4 -// buffer-file-coding-system: utf-8-unix -// End: -// |