OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Simplify representation of ast::path

Browse Source
This commit is contained in:
Marijn Haverbeke 2012-04-23 13:04:46 +02:00
parent 587d8a5d4f
commit a872a99bfe
21 changed files with 168 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/librustsyntax/ast.rs
View File

@ -37,10 +37,7 @@ type ident = str;
type fn_ident = option<ident>;
#[auto_serialize]
type path_ = {global: bool, idents: [ident], types: [@ty]};
#[auto_serialize]
type path = spanned<path_>;
type path = {span: span, global: bool, idents: [ident], types: [@ty]};
#[auto_serialize]
type crate_num = int;

8
src/librustsyntax/ast_util.rs
View File

@ -21,7 +21,7 @@ fn mk_sp(lo: uint, hi: uint) -> span {
// make this a const, once the compiler supports it
fn dummy_sp() -> span { ret mk_sp(0u, 0u); }
fn path_name(p: @path) -> str { path_name_i(p.node.idents) }
fn path_name(p: @path) -> str { path_name_i(p.idents) }
fn path_name_i(idents: [ident]) -> str { str::connect(idents, "::") }
@ -183,8 +183,8 @@ fn is_exported(i: ident, m: _mod) -> bool {
}
ast::view_path_list(path, ids, _) {
if vec::len(path.node.idents) == 1u {
if i == path.node.idents[0] { ret true; }
if vec::len(path.idents) == 1u {
if i == path.idents[0] { ret true; }
for ids.each {|id|
if id.node.name == i { ret true; }
}
@ -249,7 +249,7 @@ fn default_block(stmts1: [@stmt], expr1: option<@expr>, id1: node_id) ->
}
fn ident_to_path(s: span, i: ident) -> @path {
@respan(s, {global: false, idents: [i], types: []})
@{span: s, global: false, idents: [i], types: []}
}
pure fn is_unguarded(&&a: arm) -> bool {

31
src/librustsyntax/ext/auto_serialize.rs
View File

@ -124,19 +124,17 @@ fn expand(cx: ext_ctxt,
impl helpers for ext_ctxt {
fn helper_path(base_path: @ast::path,
helper_name: str) -> @ast::path {
let head = vec::init(base_path.node.idents);
let tail = vec::last(base_path.node.idents);
let head = vec::init(base_path.idents);
let tail = vec::last(base_path.idents);
self.path(base_path.span, head + [helper_name + "_" + tail])
}
fn path(span: span, strs: [str]) -> @ast::path {
@{node: {global: false, idents: strs, types: []},
span: span}
@{span: span, global: false, idents: strs, types: []}
}
fn path_tps(span: span, strs: [str], tps: [@ast::ty]) -> @ast::path {
@{node: {global: false, idents: strs, types: tps},
span: span}
@{span: span, global: false, idents: strs, types: tps}
}
fn ty_path(span: span, strs: [str], tps: [@ast::ty]) -> @ast::ty {
@ -195,10 +193,7 @@ impl helpers for ext_ctxt {
}
fn binder_pat(span: span, nm: str) -> @ast::pat {
let path = @{node: {global: false,
idents: [nm],
types: []},
span: span};
let path = @{span: span, global: false, idents: [nm], types: []};
@{id: self.next_id(),
node: ast::pat_ident(path, none),
span: span}
@ -292,7 +287,7 @@ fn ser_path(cx: ext_ctxt, tps: ser_tps_map, path: @ast::path,
ast::expr_path(
cx.helper_path(path, "serialize")));
let ty_args = vec::map(path.node.types) {|ty|
let ty_args = vec::map(path.types) {|ty|
let sv_stmts = ser_ty(cx, tps, ty, cx.clone(s), #ast{ __v });
let sv = cx.expr(path.span,
ast::expr_block(cx.blk(path.span, sv_stmts)));
@ -428,9 +423,9 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
}
ast::ty_path(path, _) {
if vec::len(path.node.idents) == 1u &&
vec::is_empty(path.node.types) {
let ident = path.node.idents[0];
if vec::len(path.idents) == 1u &&
vec::is_empty(path.types) {
let ident = path.idents[0];
alt tps.find(ident) {
some(f) { f(v) }
@ -566,7 +561,7 @@ fn deser_path(cx: ext_ctxt, tps: deser_tps_map, path: @ast::path,
ast::expr_path(
cx.helper_path(path, "deserialize")));
let ty_args = vec::map(path.node.types) {|ty|
let ty_args = vec::map(path.types) {|ty|
let dv_expr = deser_ty(cx, tps, ty, cx.clone(d));
cx.lambda(cx.expr_blk(dv_expr))
};
@ -650,9 +645,9 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map,
}
ast::ty_path(path, _) {
if vec::len(path.node.idents) == 1u &&
vec::is_empty(path.node.types) {
let ident = path.node.idents[0];
if vec::len(path.idents) == 1u &&
vec::is_empty(path.types) {
let ident = path.idents[0];
alt tps.find(ident) {
some(f) { f() }

4
src/librustsyntax/ext/base.rs
View File

@ -137,9 +137,9 @@ fn expr_to_str(cx: ext_ctxt, expr: @ast::expr, error: str) -> str {
fn expr_to_ident(cx: ext_ctxt, expr: @ast::expr, error: str) -> ast::ident {
alt expr.node {
ast::expr_path(p) {
if vec::len(p.node.types) > 0u || vec::len(p.node.idents) != 1u {
if vec::len(p.types) > 0u || vec::len(p.idents) != 1u {
cx.span_fatal(expr.span, error);
} else { ret p.node.idents[0]; }
} else { ret p.idents[0]; }
}
_ { cx.span_fatal(expr.span, error); }
}

5
src/librustsyntax/ext/build.rs
View File

@ -30,9 +30,8 @@ fn mk_unary(cx: ext_ctxt, sp: span, op: ast::unop, e: @ast::expr)
}
fn mk_path(cx: ext_ctxt, sp: span, idents: [ast::ident]) ->
@ast::expr {
let path = {global: false, idents: idents, types: []};
let sp_path = @{node: path, span: sp};
let pathexpr = ast::expr_path(sp_path);
let path = @{span: sp, global: false, idents: idents, types: []};
let pathexpr = ast::expr_path(path);
ret @{id: cx.next_id(), node: pathexpr, span: sp};
}
fn mk_access_(cx: ext_ctxt, sp: span, p: @ast::expr, m: ast::ident)

5
src/librustsyntax/ext/concat_idents.rs
View File

@ -16,8 +16,7 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg,
}
ret @{id: cx.next_id(),
node: ast::expr_path(@{node: {global: false, idents: [res],
types: []},
span: sp}),
node: ast::expr_path(@{span: sp, global: false, idents: [res],
types: []}),
span: sp};
}

4
src/librustsyntax/ext/expand.rs
View File

@ -19,8 +19,8 @@ fn expand_expr(exts: hashmap<str, syntax_extension>, cx: ext_ctxt,
expr_mac(mac) {
alt mac.node {
mac_invoc(pth, args, body) {
assert (vec::len(pth.node.idents) > 0u);
let extname = pth.node.idents[0];
assert (vec::len(pth.idents) > 0u);
let extname = pth.idents[0];
alt exts.find(extname) {
none {
cx.span_fatal(pth.span,

2
src/librustsyntax/ext/qquote.rs
View File

@ -142,7 +142,7 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
ecx.span_fatal(_sp, "#ast requires exactly one arg");
}
alt (args[0].node) {
ast::expr_path(@{node: {idents: id, _},_}) if vec::len(id) == 1u
ast::expr_path(@{idents: id, _}) if vec::len(id) == 1u
{what = id[0]}
_ {ecx.span_fatal(args[0].span, "expected an identifier");}
}

40
src/librustsyntax/ext/simplext.rs
View File

@ -5,14 +5,14 @@ import base::*;
import fold::*;
import ast_util::respan;
import ast::{ident, path, ty, blk_, expr, path_, expr_path,
import ast::{ident, path, ty, blk_, expr, expr_path,
expr_vec, expr_mac, mac_invoc, node_id};
export add_new_extension;
fn path_to_ident(pth: @path) -> option<ident> {
if vec::len(pth.node.idents) == 1u && vec::len(pth.node.types) == 0u {
ret some(pth.node.idents[0u]);
if vec::len(pth.idents) == 1u && vec::len(pth.types) == 0u {
ret some(pth.idents[0u]);
}
ret none;
}
@ -190,7 +190,7 @@ fn transcribe(cx: ext_ctxt, b: bindings, body: @expr) -> @expr {
let afp = default_ast_fold();
let f_pre =
{fold_ident: bind transcribe_ident(cx, b, idx_path, _, _),
fold_path: bind transcribe_path(cx, b, idx_path, _, _, _),
fold_path: bind transcribe_path(cx, b, idx_path, _, _),
fold_expr:
bind transcribe_expr(cx, b, idx_path, _, _, _, afp.fold_expr),
fold_ty: bind transcribe_type(cx, b, idx_path, _, _, _, afp.fold_ty),
@ -329,17 +329,17 @@ fn transcribe_ident(cx: ext_ctxt, b: bindings, idx_path: @mut [uint],
fn transcribe_path(cx: ext_ctxt, b: bindings, idx_path: @mut [uint],
p: path_, s:span, _fld: ast_fold) -> (path_, span) {
p: path, _fld: ast_fold) -> path {
// Don't substitute into qualified names.
if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { ret (p, s); }
ret alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
some(match_ident(id)) {
({global: false, idents: [id.node], types: []}, id.span)
}
some(match_path(a_pth)) { (a_pth.node, a_pth.span) }
some(m) { match_error(cx, m, "a path") }
none { (p, s) }
}
if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { ret p; }
alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
some(match_ident(id)) {
{span: id.span, global: false, idents: [id.node], types: []}
}
some(match_path(a_pth)) { *a_pth }
some(m) { match_error(cx, m, "a path") }
none { p }
}
}
@ -351,15 +351,15 @@ fn transcribe_expr(cx: ext_ctxt, b: bindings, idx_path: @mut [uint],
ret alt e {
expr_path(p) {
// Don't substitute into qualified names.
if vec::len(p.node.types) > 0u || vec::len(p.node.idents) != 1u {
if vec::len(p.types) > 0u || vec::len(p.idents) != 1u {
(e, s);
}
alt follow_for_trans(cx, b.find(p.node.idents[0]), idx_path) {
alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
some(match_ident(id)) {
(expr_path(@respan(id.span,
{global: false,
idents: [id.node],
types: []})), id.span)
(expr_path(@{span: id.span,
global: false,
idents: [id.node],
types: []}), id.span)
}
some(match_path(a_pth)) { (expr_path(a_pth), s) }
some(match_expr(a_exp)) { (a_exp.node, a_exp.span) }

11
src/librustsyntax/fold.rs
View File

@ -46,7 +46,7 @@ type ast_fold_precursor =
fold_native_mod: fn@(native_mod, ast_fold) -> native_mod,
fold_variant: fn@(variant_, span, ast_fold) -> (variant_, span),
fold_ident: fn@(&&ident, ast_fold) -> ident,
fold_path: fn@(path_, span, ast_fold) -> (path_, span),
fold_path: fn@(path, ast_fold) -> path,
fold_local: fn@(local_, span, ast_fold) -> (local_, span),
map_exprs: fn@(fn@(&&@expr) -> @expr, [@expr]) -> [@expr],
new_id: fn@(node_id) -> node_id,
@ -559,8 +559,8 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
fn noop_fold_ident(&&i: ident, _fld: ast_fold) -> ident { ret i; }
fn noop_fold_path(&&p: path_, fld: ast_fold) -> path_ {
ret {global: p.global,
fn noop_fold_path(&&p: path, fld: ast_fold) -> path {
ret {span: fld.new_span(p.span), global: p.global,
idents: vec::map(p.idents, fld.fold_ident),
types: vec::map(p.types, fld.fold_ty)};
}
@ -613,7 +613,7 @@ fn default_ast_fold() -> @ast_fold_precursor {
fold_native_mod: noop_fold_native_mod,
fold_variant: wrap(noop_fold_variant),
fold_ident: noop_fold_ident,
fold_path: wrap(noop_fold_path),
fold_path: noop_fold_path,
fold_local: wrap(noop_fold_local),
map_exprs: noop_map_exprs,
new_id: noop_id,
@ -754,8 +754,7 @@ fn make_fold(afp: ast_fold_precursor) -> ast_fold {
ret afp.fold_ident(x, f);
}
fn f_path(afp: ast_fold_precursor, f: ast_fold, &&x: @path) -> @path {
let (n, s) = afp.fold_path(x.node, x.span, f);
ret @{node: n, span: afp.new_span(s)};
@afp.fold_path(*x, f)
}
fn f_local(afp: ast_fold_precursor, f: ast_fold, &&x: @local) -> @local {
let (n, s) = afp.fold_local(x.node, x.span, f);

138
src/librustsyntax/parse/parser.rs
View File

@ -67,7 +67,7 @@ impl parser for parser {
if vec::len(self.buffer) == 0u {
let next = lexer::next_token(self.reader);
self.token = next.tok;
self.span = ast_util::mk_sp(next.chpos, self.reader.chpos);
self.span = mk_sp(next.chpos, self.reader.chpos);
} else {
let next = vec::pop(self.buffer);
self.token = next.tok;
@ -76,12 +76,12 @@ impl parser for parser {
}
fn swap(next: token::token, lo: uint, hi: uint) {
self.token = next;
self.span = ast_util::mk_sp(lo, hi);
self.span = mk_sp(lo, hi);
}
fn look_ahead(distance: uint) -> token::token {
while vec::len(self.buffer) < distance {
let next = lexer::next_token(self.reader);
let sp = ast_util::mk_sp(next.chpos, self.reader.chpos);
let sp = mk_sp(next.chpos, self.reader.chpos);
self.buffer = [{tok: next.tok, span: sp}] + self.buffer;
}
ret self.buffer[distance - 1u].tok;
@ -140,7 +140,7 @@ fn parse_ty_methods(p: parser) -> [ast::ty_method] {
let d = parse_ty_fn(p), fhi = p.last_span.hi;
expect(p, token::SEMI);
{ident: ident, attrs: attrs, decl: {purity: pur with d}, tps: tps,
span: ast_util::mk_sp(flo, fhi)}
span: mk_sp(flo, fhi)}
}, p).node
}
@ -237,7 +237,7 @@ fn parse_ty_postfix(orig_t: ast::ty_, p: parser, colons_before_params: bool,
fn mk_ty(p: parser, t: ast::ty_, lo: uint, hi: uint) -> @ast::ty {
@{id: p.get_id(),
node: t,
span: ast_util::mk_sp(lo, hi)}
span: mk_sp(lo, hi)}
}
if p.token == token::BINOP(token::SLASH) {
@ -266,10 +266,10 @@ fn parse_ty_postfix(orig_t: ast::ty_, p: parser, colons_before_params: bool,
alt orig_t {
ast::ty_path(pth, ann) {
ret mk_ty(p, ast::ty_path(@spanned(lo, p.last_span.hi,
{global: pth.node.global,
idents: pth.node.idents,
types: seq}), ann),
ret mk_ty(p, ast::ty_path(@{span: mk_sp(lo, p.last_span.hi),
global: pth.global,
idents: pth.idents,
types: seq}, ann),
lo, p.last_span.hi);
}
_ { p.fatal("type parameter instantiation only allowed for paths"); }
@ -282,7 +282,7 @@ fn parse_ret_ty(p: parser) -> (ast::ret_style, @ast::ty) {
if eat(p, token::NOT) {
(ast::noreturn, @{id: p.get_id(),
node: ast::ty_bot,
span: ast_util::mk_sp(lo, p.last_span.hi)})
span: mk_sp(lo, p.last_span.hi)})
} else {
(ast::return_val, parse_ty(p, false))
}
@ -290,7 +290,7 @@ fn parse_ret_ty(p: parser) -> (ast::ret_style, @ast::ty) {
let pos = p.span.lo;
(ast::return_val, @{id: p.get_id(),
node: ast::ty_nil,
span: ast_util::mk_sp(pos, pos)})
span: mk_sp(pos, pos)})
}
}
@ -331,7 +331,7 @@ fn parse_ty(p: parser, colons_before_params: bool) -> @ast::ty {
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)};
span: mk_sp(lo, p.span.hi)};
}
none {}
}
@ -373,7 +373,7 @@ fn parse_ty(p: parser, colons_before_params: bool) -> @ast::ty {
p.bump();
ast::ty_constr(@{id: p.get_id(),
node: t,
span: ast_util::mk_sp(lo, hi)},
span: mk_sp(lo, hi)},
parse_type_constraints(p))
} else { t }
} else if p.token == token::LBRACKET {
@ -435,7 +435,7 @@ fn parse_fn_block_arg(p: parser) -> ast::arg {
} else {
@{id: p.get_id(),
node: ast::ty_infer,
span: ast_util::mk_sp(p.span.lo, p.span.hi)}
span: mk_sp(p.span.lo, p.span.hi)}
};
ret {mode: m, ty: t, ident: i, id: p.get_id()};
}
@ -455,7 +455,7 @@ fn maybe_parse_dollar_mac(p: parser) -> option<ast::mac_> {
let e = parse_expr(p);
expect(p, token::RPAREN);
let hi = p.last_span.hi;
some(ast::mac_aq(ast_util::mk_sp(lo,hi), e))
some(ast::mac_aq(mk_sp(lo,hi), e))
}
_ {
p.fatal("expected `(` or integer literal");
@ -526,7 +526,7 @@ fn parse_lit(p: parser) -> ast::lit {
p.bump();
lit_from_token(p, tok)
};
ret {node: lit, span: ast_util::mk_sp(lo, p.last_span.hi)};
ret {node: lit, span: mk_sp(lo, p.last_span.hi)};
}
fn parse_path(p: parser) -> @ast::path {
@ -536,13 +536,12 @@ fn parse_path(p: parser) -> @ast::path {
while p.look_ahead(1u) != token::LT && eat(p, token::MOD_SEP) {
ids += [parse_ident(p)];
}
ret @spanned(lo, p.last_span.hi,
{global: global, idents: ids, types: []});
@{span: mk_sp(lo, p.last_span.hi), global: global, idents: ids, types: []}
}
fn parse_value_path(p: parser) -> @ast::path {
let pt = parse_path(p);
let last_word = pt.node.idents[vec::len(pt.node.idents)-1u];
let last_word = vec::last(pt.idents);
if p.bad_expr_words.contains_key(last_word) {
p.fatal("found " + last_word + " in expression position");
}
@ -552,15 +551,12 @@ fn parse_value_path(p: parser) -> @ast::path {
fn parse_path_and_ty_param_substs(p: parser, colons: bool) -> @ast::path {
let lo = p.span.lo;
let path = parse_path(p);
let b = if colons {
eat(p, token::MOD_SEP)
} else {
p.token == token::LT
};
let b = if colons { eat(p, token::MOD_SEP) }
else { p.token == token::LT };
if b {
let seq = parse_seq_lt_gt(some(token::COMMA),
{|p| parse_ty(p, false)}, p);
@spanned(lo, seq.span.hi, {types: seq.node with path.node})
@{span: mk_sp(lo, seq.span.hi), types: seq.node with *path}
} else { path }
}
@ -586,13 +582,13 @@ fn parse_field(p: parser, sep: token::token) -> ast::field {
}
fn mk_expr(p: parser, lo: uint, hi: uint, node: ast::expr_) -> @ast::expr {
ret @{id: p.get_id(), node: node, span: ast_util::mk_sp(lo, hi)};
ret @{id: p.get_id(), node: node, span: mk_sp(lo, hi)};
}
fn mk_mac_expr(p: parser, lo: uint, hi: uint, m: ast::mac_) -> @ast::expr {
ret @{id: p.get_id(),
node: ast::expr_mac({node: m, span: ast_util::mk_sp(lo, hi)}),
span: ast_util::mk_sp(lo, hi)};
node: ast::expr_mac({node: m, span: mk_sp(lo, hi)}),
span: mk_sp(lo, hi)};
}
fn mk_lit_u32(p: parser, i: u32) -> @ast::expr {
@ -1156,7 +1152,7 @@ fn parse_capture_clause(p: parser) -> @ast::capture_clause {
alt p.token {
token::IDENT(_, _) {
let id = p.get_id();
let sp = ast_util::mk_sp(p.span.lo, p.span.hi);
let sp = mk_sp(p.span.lo, p.span.hi);
let ident = parse_ident(p);
res += [@{id:id, name:ident, span:sp}];
if !eat(p, token::COMMA) {
@ -1364,7 +1360,7 @@ fn parse_pat(p: parser) -> @ast::pat {
let lo1 = p.last_span.lo;
let fieldname = parse_ident(p);
let hi1 = p.last_span.lo;
let fieldpath = ast_util::ident_to_path(ast_util::mk_sp(lo1, hi1),
let fieldpath = ast_util::ident_to_path(mk_sp(lo1, hi1),
fieldname);
let mut subpat;
if p.token == token::COLON {
@ -1376,7 +1372,7 @@ fn parse_pat(p: parser) -> @ast::pat {
}
subpat = @{id: p.get_id(),
node: ast::pat_ident(fieldpath, none),
span: ast_util::mk_sp(lo, hi)};
span: mk_sp(lo, hi)};
}
fields += [{ident: fieldname, pat: subpat}];
}
@ -1389,7 +1385,7 @@ fn parse_pat(p: parser) -> @ast::pat {
if p.token == token::RPAREN {
hi = p.span.hi;
p.bump();
let lit = @{node: ast::lit_nil, span: ast_util::mk_sp(lo, hi)};
let lit = @{node: ast::lit_nil, span: mk_sp(lo, hi)};
let expr = mk_expr(p, lo, hi, ast::expr_lit(lit));
pat = ast::pat_lit(expr);
} else {
@ -1454,7 +1450,7 @@ fn parse_pat(p: parser) -> @ast::pat {
pat = ast::pat_enum(enum_path, none);
}
else if vec::is_empty(args) &&
vec::len(enum_path.node.idents) == 1u {
vec::len(enum_path.idents) == 1u {
pat = ast::pat_ident(enum_path, none);
}
else {
@ -1463,7 +1459,7 @@ fn parse_pat(p: parser) -> @ast::pat {
}
}
}
ret @{id: p.get_id(), node: pat, span: ast_util::mk_sp(lo, hi)};
ret @{id: p.get_id(), node: pat, span: mk_sp(lo, hi)};
}
fn parse_local(p: parser, is_mutbl: bool,
@ -1472,7 +1468,7 @@ fn parse_local(p: parser, is_mutbl: bool,
let pat = parse_pat(p);
let mut ty = @{id: p.get_id(),
node: ast::ty_infer,
span: ast_util::mk_sp(lo, lo)};
span: 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,
@ -1504,7 +1500,7 @@ fn parse_instance_var(p:parser, pr: ast::privacy) -> @ast::class_member {
expect(p, token::COLON);
let ty = parse_ty(p, false);
ret @{node: ast::instance_var(name, ty, is_mutbl, p.get_id(), pr),
span: ast_util::mk_sp(lo, p.last_span.hi)};
span: mk_sp(lo, p.last_span.hi)};
}
fn parse_stmt(p: parser, first_item_attrs: [ast::attribute]) -> @ast::stmt {
@ -1739,7 +1735,7 @@ fn mk_item(p: parser, lo: uint, hi: uint, ident: ast::ident, node: ast::item_,
attrs: attrs,
id: p.get_id(),
node: node,
span: ast_util::mk_sp(lo, hi)};
span: mk_sp(lo, hi)};
}
fn parse_item_fn(p: parser, purity: ast::purity,
@ -1775,7 +1771,7 @@ fn parse_method(p: parser, pr: ast::privacy) -> @ast::method {
let (inner_attrs, body) = parse_inner_attrs_and_block(p, true);
let attrs = attrs + inner_attrs;
@{ident: ident, attrs: attrs, tps: tps, decl: decl, body: body,
id: p.get_id(), span: ast_util::mk_sp(lo, body.span.hi),
id: p.get_id(), span: mk_sp(lo, body.span.hi),
self_id: p.get_id(), privacy: pr}
}
@ -1802,7 +1798,7 @@ fn parse_item_impl(p: parser, attrs: [ast::attribute]) -> @ast::item {
let ifce = if eat_word(p, "of") {
let path = parse_path_and_ty_param_substs(p, false);
if option::is_none(ident) {
ident = some(path.node.idents[vec::len(path.node.idents) - 1u]);
ident = some(vec::last(path.idents));
}
some(wrap_path(p, path))
} else { none };
@ -1836,7 +1832,7 @@ fn parse_item_res(p: parser, attrs: [ast::attribute]) -> @ast::item {
ident: arg_ident, id: p.get_id()}],
output: @{id: p.get_id(),
node: ast::ty_nil,
span: ast_util::mk_sp(lo, lo)},
span: mk_sp(lo, lo)},
purity: ast::impure_fn,
cf: ast::return_val,
constraints: []};
@ -1850,13 +1846,13 @@ fn parse_item_res(p: parser, attrs: [ast::attribute]) -> @ast::item {
fn ident_to_path_tys(p: parser, i: ast::ident,
typarams: [ast::ty_param]) -> @ast::path {
let s = p.last_span;
let p_: ast::path_ = {global: false, idents: [i],
types: vec::map(typarams,
{|tp| @{id: p.get_id(),
node: ast::ty_path(ident_to_path(s, tp.ident),
p.get_id()),
span: s}})};
@spanned(s.lo, s.hi, p_)
@{span: s, global: false, idents: [i],
types: vec::map(typarams, {|tp|
@{id: p.get_id(),
node: ast::ty_path(ident_to_path(s, tp.ident),
p.get_id()),
span: s}})
}
}
fn parse_iface_ref_list(p:parser) -> [ast::iface_ref] {
@ -1934,7 +1930,7 @@ fn parse_class_item(p:parser, class_name_with_tps:@ast::path)
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));
ret ctor_decl(decl, body, mk_sp(lo, p.last_span.hi));
}
else if eat_word(p, "priv") {
expect(p, token::LBRACE);
@ -2014,7 +2010,7 @@ fn parse_item_native_fn(p: parser, attrs: [ast::attribute],
attrs: attrs,
node: ast::native_item_fn(decl, t.tps),
id: p.get_id(),
span: ast_util::mk_sp(lo, hi)};
span: mk_sp(lo, hi)};
}
fn parse_fn_purity(p: parser) -> ast::purity {
@ -2236,13 +2232,10 @@ fn parse_view_path(p: parser) -> @ast::view_path {
let id = parse_ident(p);
path += [id];
}
let mut hi = p.span.hi;
ret @spanned(lo, hi,
ast::view_path_simple(first_ident,
@spanned(lo, hi,
{global: false, idents: path,
types: []}),
p.get_id()));
let path = @{span: mk_sp(lo, p.span.hi), global: false,
idents: path, types: []};
ret @spanned(lo, p.span.hi,
ast::view_path_simple(first_ident, path, p.get_id()));
}
token::MOD_SEP {
@ -2263,25 +2256,19 @@ fn parse_view_path(p: parser) -> @ast::view_path {
parse_seq(token::LBRACE, token::RBRACE,
seq_sep(token::COMMA),
parse_path_list_ident, p).node;
let mut hi = p.span.hi;
ret @spanned(lo, hi,
ast::view_path_list(@spanned(lo, hi,
{global: false,
idents: path,
types: []}), idents,
p.get_id()));
let path = @{span: mk_sp(lo, p.span.hi),
global: false, idents: path, types: []};
ret @spanned(lo, p.span.hi,
ast::view_path_list(path, idents, p.get_id()));
}
// foo::bar::*
token::BINOP(token::STAR) {
p.bump();
let mut hi = p.span.hi;
ret @spanned(lo, hi,
ast::view_path_glob(@spanned(lo, hi,
{global: false,
idents: path,
types: []}),
p.get_id()));
let path = @{span: mk_sp(lo, p.span.hi),
global: false, idents: path, types: []};
ret @spanned(lo, p.span.hi,
ast::view_path_glob(path, p.get_id()));
}
_ { break; }
@ -2290,14 +2277,11 @@ fn parse_view_path(p: parser) -> @ast::view_path {
}
_ { }
}
let mut hi = p.span.hi;
let last = path[vec::len(path) - 1u];
ret @spanned(lo, hi,
ast::view_path_simple(last, @spanned(lo, hi,
{global: false,
idents: path,
types: []}),
p.get_id()));
let path = @{span: mk_sp(lo, p.span.hi), global: false,
idents: path, types: []};
ret @spanned(lo, p.span.hi,
ast::view_path_simple(last, path, p.get_id()));
}
fn parse_view_paths(p: parser) -> [@ast::view_path] {

10
src/librustsyntax/print/pprust.rs
View File

@ -1222,16 +1222,16 @@ fn print_for_decl(s: ps, loc: @ast::local, coll: @ast::expr) {
fn print_path(s: ps, &&path: @ast::path, colons_before_params: bool) {
maybe_print_comment(s, path.span.lo);
if path.node.global { word(s.s, "::"); }
if path.global { word(s.s, "::"); }
let mut first = true;
for path.node.idents.each {|id|
for path.idents.each {|id|
if first { first = false; } else { word(s.s, "::"); }
word(s.s, id);
}
if vec::len(path.node.types) > 0u {
if vec::len(path.types) > 0u {
if colons_before_params { word(s.s, "::"); }
word(s.s, "<");
commasep(s, inconsistent, path.node.types, print_type);
commasep(s, inconsistent, path.types, print_type);
word(s.s, ">");
}
}
@ -1455,7 +1455,7 @@ fn print_meta_item(s: ps, &&item: @ast::meta_item) {
fn print_view_path(s: ps, &&vp: @ast::view_path) {
alt vp.node {
ast::view_path_simple(ident, path, _) {
if path.node.idents[vec::len(path.node.idents)-1u] != ident {
if path.idents[vec::len(path.idents)-1u] != ident {
word_space(s, ident);
word_space(s, "=");
}

2
src/librustsyntax/visit.rs
View File

@ -213,7 +213,7 @@ fn visit_constr<E>(_operator: @path, _sp: span, _id: node_id, _e: E,
}
fn visit_path<E>(p: @path, e: E, v: vt<E>) {
for p.node.types.each {|tp| v.visit_ty(tp, e, v); }
for p.types.each {|tp| v.visit_ty(tp, e, v); }
}
fn visit_pat<E>(p: @pat, e: E, v: vt<E>) {

24
src/rustc/front/test.rs
View File

@ -206,6 +206,10 @@ fn nospan<T: copy>(t: T) -> ast::spanned<T> {
ret {node: t, span: dummy_sp()};
}
fn path_node(ids: [ast::ident]) -> @ast::path {
@{span: dummy_sp(), global: false, idents: ids, types: []}
}
fn mk_tests(cx: test_ctxt) -> @ast::item {
let ret_ty = mk_test_desc_vec_ty(cx);
@ -248,10 +252,7 @@ fn mk_path(cx: test_ctxt, path: [ast::ident]) -> [ast::ident] {
// The ast::ty of [std::test::test_desc]
fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::ty {
let test_desc_ty_path =
@nospan({global: false,
idents: mk_path(cx, ["test", "test_desc"]),
types: []});
let test_desc_ty_path = path_node(mk_path(cx, ["test", "test_desc"]));
let test_desc_ty: ast::ty =
{id: cx.sess.next_node_id(),
@ -294,7 +295,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
let name_field: ast::field =
nospan({mutbl: ast::m_imm, ident: "name", expr: @name_expr});
let fn_path = @nospan({global: false, idents: path, types: []});
let fn_path = path_node(path);
let fn_expr: ast::expr =
{id: cx.sess.next_node_id(),
@ -380,7 +381,7 @@ fn mk_test_wrapper(cx: test_ctxt,
}
fn mk_main(cx: test_ctxt) -> @ast::item {
let str_pt = @nospan({global: false, idents: ["str"], types: []});
let str_pt = path_node(["str"]);
let str_ty = @{id: cx.sess.next_node_id(),
node: ast::ty_path(str_pt, cx.sess.next_node_id()),
span: dummy_sp()};
@ -426,8 +427,7 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
fn mk_test_main_call(cx: test_ctxt) -> @ast::expr {
// Get the args passed to main so we can pass the to test_main
let args_path =
@nospan({global: false, idents: ["args"], types: []});
let args_path = path_node(["args"]);
let args_path_expr_: ast::expr_ = ast::expr_path(args_path);
@ -435,8 +435,7 @@ fn mk_test_main_call(cx: test_ctxt) -> @ast::expr {
{id: cx.sess.next_node_id(), node: args_path_expr_, span: dummy_sp()};
// Call __test::test to generate the vector of test_descs
let test_path =
@nospan({global: false, idents: ["tests"], types: []});
let test_path = path_node(["tests"]);
let test_path_expr_: ast::expr_ = ast::expr_path(test_path);
@ -449,10 +448,7 @@ fn mk_test_main_call(cx: test_ctxt) -> @ast::expr {
{id: cx.sess.next_node_id(), node: test_call_expr_, span: dummy_sp()};
// Call std::test::test_main
let test_main_path =
@nospan({global: false,
idents: mk_path(cx, ["test", "test_main"]),
types: []});
let test_main_path = path_node(mk_path(cx, ["test", "test_main"]));
let test_main_path_expr_: ast::expr_ = ast::expr_path(test_main_path);

4
src/rustc/metadata/tydecode.rs
View File

@ -103,8 +103,8 @@ fn parse_path(st: @pstate) -> @ast::path {
':' { next(st); next(st); }
c {
if c == '(' {
ret @respan(ast_util::dummy_sp(),
{global: false, idents: idents, types: []});
ret @{span: ast_util::dummy_sp(),
global: false, idents: idents, types: []};
} else { idents += [parse_ident_(st, is_last)]; }
}
}

2
src/rustc/middle/infer.rs
View File

@ -493,7 +493,7 @@ impl unify_methods for infer_ctxt {
ast::carg_ident(p) {
alt actual.node {
ast::carg_ident(q) {
if p.node != q.node { ret err_res; }
if p.idents != q.idents { ret err_res; }
}
_ { ret err_res; }
}

5
src/rustc/middle/pat_util.rs
View File

@ -69,7 +69,4 @@ fn pat_binding_ids(dm: resolve::def_map, pat: @pat) -> [node_id] {
ret found;
}
fn path_to_ident(p: @path) -> ident {
assert (vec::is_not_empty(p.node.idents)); // should be a constraint on path
vec::last(p.node.idents)
}
fn path_to_ident(p: @path) -> ident { vec::last(p.idents) }

32
src/rustc/middle/resolve.rs
View File

@ -231,16 +231,16 @@ fn map_crate(e: @env, c: @ast::crate) {
iter_effective_import_paths(*i) { |vp|
alt vp.node {
ast::view_path_simple(name, path, id) {
e.imports.insert(id, todo(name, @path.node.idents, vp.span,
e.imports.insert(id, todo(name, @path.idents, vp.span,
sc));
}
ast::view_path_glob(path, id) {
e.imports.insert(id, is_glob(@path.node.idents, sc, vp.span));
e.imports.insert(id, is_glob(@path.idents, sc, vp.span));
}
ast::view_path_list(mod_path, idents, _) {
for idents.each {|ident|
let t = todo(ident.node.name,
@(mod_path.node.idents + [ident.node.name]),
@(mod_path.idents + [ident.node.name]),
ident.span, sc);
e.imports.insert(ident.node.id, t);
}
@ -293,7 +293,7 @@ fn map_crate(e: @env, c: @ast::crate) {
iter_effective_import_paths(*vi) { |vp|
alt vp.node {
ast::view_path_glob(path, _) {
alt follow_import(*e, sc, path.node.idents, vp.span) {
alt follow_import(*e, sc, path.idents, vp.span) {
some(imp) {
let glob = {def: imp, path: vp};
alt list::head(sc) {
@ -433,8 +433,7 @@ fn resolve_names(e: @env, c: @ast::crate) {
/* visit the iface paths... */
for ifaces.each {|p|
maybe_insert(e, p.id,
lookup_path_strict(*e, sc, p.path.span, p.path.node,
ns_type))};
lookup_path_strict(*e, sc, p.path.span, p.path, ns_type))};
}
_ {}
}
@ -445,8 +444,7 @@ fn resolve_names(e: @env, c: @ast::crate) {
alt exp.node {
ast::expr_path(p) {
maybe_insert(e, exp.id,
lookup_path_strict(*e, sc, exp.span, p.node,
ns_val));
lookup_path_strict(*e, sc, exp.span, p, ns_val));
}
ast::expr_fn(_, _, _, cap_clause) {
let rci = bind resolve_capture_item(e, sc, _);
@ -461,7 +459,7 @@ fn resolve_names(e: @env, c: @ast::crate) {
alt t.node {
ast::ty_path(p, id) {
maybe_insert(e, id,
lookup_path_strict(*e, sc, t.span, p.node, ns_type));
lookup_path_strict(*e, sc, t.span, p, ns_type));
}
_ { }
}
@ -483,13 +481,13 @@ fn resolve_names(e: @env, c: @ast::crate) {
}
fn walk_constr(e: @env, p: @ast::path, sp: span, id: node_id, sc: scopes,
_v: vt<scopes>) {
maybe_insert(e, id, lookup_path_strict(*e, sc, sp, p.node, ns_val));
maybe_insert(e, id, lookup_path_strict(*e, sc, sp, p, ns_val));
}
fn walk_pat(e: @env, pat: @ast::pat, sc: scopes, v: vt<scopes>) {
visit::visit_pat(pat, sc, v);
alt pat.node {
ast::pat_enum(p, _) {
alt lookup_path_strict(*e, sc, p.span, p.node, ns_val) {
alt lookup_path_strict(*e, sc, p.span, p, ns_val) {
some(fnd@ast::def_variant(_,_)) {
e.def_map.insert(pat.id, fnd);
}
@ -709,7 +707,7 @@ fn follow_import(e: env, sc: scopes, path: [ident], sp: span) ->
}
fn resolve_constr(e: @env, c: @ast::constr, sc: scopes, _v: vt<scopes>) {
alt lookup_path_strict(*e, sc, c.span, c.node.path.node, ns_val) {
alt lookup_path_strict(*e, sc, c.span, c.node.path, ns_val) {
some(d@ast::def_fn(_,ast::pure_fn)) {
e.def_map.insert(c.node.id, d);
}
@ -892,7 +890,7 @@ fn mk_unresolved_msg(id: ident, kind: str) -> str {
}
// Lookup helpers
fn lookup_path_strict(e: env, sc: scopes, sp: span, pth: ast::path_,
fn lookup_path_strict(e: env, sc: scopes, sp: span, pth: @ast::path,
ns: namespace) -> option<def> {
let n_idents = vec::len(pth.idents);
let headns = if n_idents == 1u { ns } else { ns_module };
@ -2069,8 +2067,8 @@ fn check_exports(e: @env) {
check_export(e, ident, _mod, id, vi);
}
ast::view_path_list(path, ids, node_id) {
let id = if vec::len(path.node.idents) == 1u {
path.node.idents[0]
let id = if vec::len(path.idents) == 1u {
path.idents[0]
} else {
e.sess.span_fatal(vp.span, "bad export name-list")
};
@ -2137,12 +2135,12 @@ fn find_impls_in_view_item(e: env, vi: @ast::view_item,
alt vp.node {
ast::view_path_simple(name, pt, id) {
let mut found = [];
if vec::len(pt.node.idents) == 1u {
if vec::len(pt.idents) == 1u {
option::iter(sc) {|sc|
list::iter(sc) {|level|
if vec::len(found) == 0u {
for vec::each(*level) {|imp|
if imp.ident == pt.node.idents[0] {
if imp.ident == pt.idents[0] {
found += [@{ident: name with *imp}];
}
}

2
src/rustc/middle/tstate/auxiliary.rs
View File

@ -594,7 +594,7 @@ fn expr_to_constr_arg(tcx: ty::ctxt, e: @expr) -> @constr_arg_use {
some(def_local(nid, _)) | some(def_arg(nid, _)) |
some(def_binding(nid)) | some(def_upvar(nid, _, _)) {
ret @respan(p.span,
carg_ident({ident: p.node.idents[0], node: nid}));
carg_ident({ident: p.idents[0], node: nid}));
}
some(what) {
tcx.sess.span_bug(e.span,

19
src/rustc/middle/tstate/bitvectors.rs
View File

@ -183,20 +183,13 @@ fn kill_poststate(fcx: fn_ctxt, id: node_id, c: tsconstr) -> bool {
fn clear_in_poststate_expr(fcx: fn_ctxt, e: @expr, t: poststate) {
alt e.node {
expr_path(p) {
alt vec::last_opt(p.node.idents) {
some(i) {
alt local_node_id_to_def(fcx, e.id) {
some(def_local(nid, _)) {
clear_in_poststate_(bit_num(fcx, ninit(nid, i)), t);
}
some(_) {/* ignore args (for now...) */ }
_ {
fcx.ccx.tcx.sess.bug("clear_in_poststate_expr: \
unbound var");
}
}
alt local_node_id_to_def(fcx, e.id) {
some(def_local(nid, _)) {
clear_in_poststate_(bit_num(fcx, ninit(nid, vec::last(p.idents))),
t);
}
_ { fcx.ccx.tcx.sess.bug("clear_in_poststate_expr"); }
some(_) {/* ignore args (for now...) */ }
_ { fcx.ccx.tcx.sess.bug("clear_in_poststate_expr: unbound var"); }
}
}
_ {/* do nothing */ }

28
src/rustc/middle/typeck.rs
View File

@ -224,7 +224,7 @@ fn instantiate_path(fcx: @fn_ctxt,
sp: span,
id: ast::node_id) {
let ty_param_count = vec::len(*tpt.bounds);
let ty_substs_len = vec::len(pth.node.types);
let ty_substs_len = vec::len(pth.types);
// For now, there is no way to explicitly specify the region bound.
// This will have to change eventually.
@ -248,7 +248,7 @@ fn instantiate_path(fcx: @fn_ctxt,
(sp, "not enough type parameters provided for this item");
fcx.next_ty_vars(ty_param_count)
} else {
pth.node.types.map { |aty| fcx.to_ty(aty) }
pth.types.map { |aty| fcx.to_ty(aty) }
};
let substs = {self_r: self_r, tps: tps};
@ -593,7 +593,7 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy>(
some(d) { d }};
alt a_def {
ast::def_ty(did) | ast::def_class(did) {
instantiate(self, rscope, ast_ty.span, did, id, path.node.types)
instantiate(self, rscope, ast_ty.span, did, id, path.types)
}
ast::def_prim_ty(nty) {
alt nty {
@ -605,7 +605,7 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy>(
}
}
ast::def_ty_param(id, n) {
if vec::len(path.node.types) > 0u {
if vec::len(path.types) > 0u {
tcx.sess.span_err(ast_ty.span, "provided type parameters \
to a type parameter");
}
@ -614,12 +614,12 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy>(
ast::def_self(self_id) {
alt check tcx.items.get(self_id) {
ast_map::node_item(@{node: ast::item_iface(tps, _), _}, _) {
if vec::len(tps) != vec::len(path.node.types) {
if vec::len(tps) != vec::len(path.types) {
tcx.sess.span_err(ast_ty.span, "incorrect number of \
type parameters to \
self type");
}
ty::mk_self(tcx, vec::map(path.node.types, {|ast_ty|
ty::mk_self(tcx, vec::map(path.types, {|ast_ty|
ast_ty_to_ty(self, rscope, ast_ty)
}))
}
@ -3970,22 +3970,20 @@ fn check_constraints(fcx: @fn_ctxt, cs: [@ast::constr], args: [ast::arg]) {
}
ast::carg_ident(i) {
if i < num_args {
let p: ast::path_ =
{global: false,
idents: [args[i].ident],
types: []};
let p = @{span: a.span, global: false,
idents: [args[i].ident], types: []};
let arg_occ_node_id =
fcx.ccx.tcx.sess.next_node_id();
fcx.ccx.tcx.def_map.insert
(arg_occ_node_id,
ast::def_arg(args[i].id, args[i].mode));
{id: arg_occ_node_id,
node: ast::expr_path(@respan(a.span, p)),
node: ast::expr_path(p),
span: a.span}
} else {
fcx.ccx.tcx.sess.span_bug(a.span,
"check_constraints:\
carg_ident index out of bounds");
fcx.ccx.tcx.sess.span_bug(
a.span, "check_constraints:\
carg_ident index out of bounds");
}
}
}];
@ -4181,7 +4179,7 @@ fn check_fn(ccx: @crate_ctxt,
if !pat_util::pat_is_variant(fcx.ccx.tcx.def_map, p) {
assign(p.id, none);
#debug["Pattern binding %s is assigned to %s",
path.node.idents[0],
path.idents[0],
fcx.locals.get(p.id).to_str()];
}
_ {}