bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

rustc: Add node IDs to AST types so we can associate them with region environments

Browse source
This commit is contained in:
Patrick Walton 2012-03-12 16:26:31 -07:00
parent d60813146d
commit dd610a151b
7 changed files with 84 additions and 37 deletions
Download patch file Download diff file Expand all files Collapse all files

62
src/rustc/syntax/parse/parser.rs
View file

@ -385,7 +385,11 @@ fn parse_ty_postfix(orig_t: ast::ty_, p: parser, colons_before_params: bool,
expect(p, token::LT);
} else if !colons_before_params && p.token == token::LT {
p.bump();
} else { ret @spanned(lo, p.last_span.hi, orig_t); }
} else {
ret @{id: p.get_id(),
node: orig_t,
span: ast_util::mk_sp(lo, p.last_span.hi)};
}
// If we're here, we have explicit type parameter instantiation.
let seq = parse_seq_to_gt(some(token::COMMA), {|p| parse_ty(p, false)},
@ -393,11 +397,12 @@ fn parse_ty_postfix(orig_t: ast::ty_, p: parser, colons_before_params: bool,
alt orig_t {
ast::ty_path(pth, ann) {
ret @spanned(lo, p.last_span.hi,
ast::ty_path(@spanned(lo, p.last_span.hi,
{global: pth.node.global,
idents: pth.node.idents,
types: seq}), ann));
ret @{id: p.get_id(),
node: ast::ty_path(@spanned(lo, p.last_span.hi,
{global: pth.node.global,
idents: pth.node.idents,
types: seq}), ann),
span: ast_util::mk_sp(lo, p.last_span.hi)};
}
_ { p.fatal("type parameter instantiation only allowed for paths"); }
}
@ -407,11 +412,17 @@ fn parse_ret_ty(p: parser) -> (ast::ret_style, @ast::ty) {
ret if eat(p, token::RARROW) {
let lo = p.span.lo;
if eat(p, token::NOT) {
(ast::noreturn, @spanned(lo, p.last_span.hi, ast::ty_bot))
} else { (ast::return_val, parse_ty(p, false)) }
(ast::noreturn, @{id: p.get_id(),
node: ast::ty_bot,
span: ast_util::mk_sp(lo, p.last_span.hi)})
} else {
(ast::return_val, parse_ty(p, false))
}
} else {
let pos = p.span.lo;
(ast::return_val, @spanned(pos, pos, ast::ty_nil))
(ast::return_val, @{id: p.get_id(),
node: ast::ty_nil,
span: ast_util::mk_sp(pos, pos)})
}
}
@ -435,8 +446,11 @@ fn parse_ty(p: parser, colons_before_params: bool) -> @ast::ty {
let lo = p.span.lo;
alt have_dollar(p) {
some(e) {ret @spanned(lo, p.span.hi,
ast::ty_mac(spanned(lo, p.span.hi, e)))}
some(e) {
ret @{id: p.get_id(),
node: ast::ty_mac(spanned(lo, p.span.hi, e)),
span: ast_util::mk_sp(lo, p.span.hi)};
}
none {}
}
@ -475,7 +489,10 @@ fn parse_ty(p: parser, colons_before_params: bool) -> @ast::ty {
let t = ast::ty_rec(elems.node);
if p.token == token::COLON {
p.bump();
ast::ty_constr(@spanned(lo, hi, t), parse_type_constraints(p))
ast::ty_constr(@{id: p.get_id(),
node: t,
span: ast_util::mk_sp(lo, hi)},
parse_type_constraints(p))
} else { t }
} else if p.token == token::LBRACKET {
expect(p, token::LBRACKET);
@ -534,7 +551,9 @@ fn parse_fn_block_arg(p: parser) -> ast::arg {
let t = if eat(p, token::COLON) {
parse_ty(p, false)
} else {
@spanned(p.span.lo, p.span.hi, ast::ty_infer)
@{id: p.get_id(),
node: ast::ty_infer,
span: ast_util::mk_sp(p.span.lo, p.span.hi)}
};
ret {mode: m, ty: t, ident: i, id: p.get_id()};
}
@ -1606,7 +1625,9 @@ fn parse_local(p: parser, is_mutbl: bool,
allow_init: bool) -> @ast::local {
let lo = p.span.lo;
let pat = parse_pat(p);
let ty = @spanned(lo, lo, ast::ty_infer);
let ty = @{id: p.get_id(),
node: ast::ty_infer,
span: ast_util::mk_sp(lo, lo)};
if eat(p, token::COLON) { ty = parse_ty(p, false); }
let init = if allow_init { parse_initializer(p) } else { none };
ret @spanned(lo, p.last_span.hi,
@ -1882,7 +1903,7 @@ fn parse_fn_block_decl(p: parser) -> ast::fn_decl {
let output = if eat(p, token::RARROW) {
parse_ty(p, false)
} else {
@spanned(p.span.lo, p.span.hi, ast::ty_infer)
@{id: p.get_id(), node: ast::ty_infer, span: p.span}
};
ret {inputs: inputs,
output: output,
@ -1957,7 +1978,7 @@ fn parse_item_iface(p: parser, attrs: [ast::attribute]) -> @ast::item {
fn parse_item_impl(p: parser, attrs: [ast::attribute]) -> @ast::item {
let lo = p.last_span.lo;
fn wrap_path(p: parser, pt: @ast::path) -> @ast::ty {
@{node: ast::ty_path(pt, p.get_id()), span: pt.span}
@{id: p.get_id(), node: ast::ty_path(pt, p.get_id()), span: pt.span}
}
let (ident, tps) = if !is_word(p, "of") {
if p.token == token::LT { (none, parse_ty_params(p)) }
@ -1996,7 +2017,9 @@ fn parse_item_res(p: parser, attrs: [ast::attribute]) -> @ast::item {
{inputs:
[{mode: ast::expl(ast::by_ref), ty: t,
ident: arg_ident, id: p.get_id()}],
output: @spanned(lo, lo, ast::ty_nil),
output: @{id: p.get_id(),
node: ast::ty_nil,
span: ast_util::mk_sp(lo, lo)},
purity: ast::impure_fn,
cf: ast::return_val,
constraints: []};
@ -2066,8 +2089,9 @@ enum class_contents { ctor_decl(ast::fn_decl, ast::blk, codemap::span),
// Can ctors have attrs?
// result type is always the type of the class
let decl_ = parse_fn_decl(p, ast::impure_fn);
let decl = {output: @{node: ast::ty_path(class_name, p.get_id()),
span: decl_.output.span}
let decl = {output: @{id: p.get_id(),
node: ast::ty_path(class_name, p.get_id()),
span: decl_.output.span}
with decl_};
let body = parse_block(p);
ret ctor_decl(decl, body, ast_util::mk_sp(lo, p.last_span.hi));