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>; type fn_ident = option<ident>;
#[auto_serialize] #[auto_serialize]
type path_ = {global: bool, idents: [ident], types: [@ty]}; type path = {span: span, global: bool, idents: [ident], types: [@ty]};
#[auto_serialize]
type path = spanned<path_>;
#[auto_serialize] #[auto_serialize]
type crate_num = int; 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 // make this a const, once the compiler supports it
fn dummy_sp() -> span { ret mk_sp(0u, 0u); } 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, "::") } 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, _) { ast::view_path_list(path, ids, _) {
if vec::len(path.node.idents) == 1u { if vec::len(path.idents) == 1u {
if i == path.node.idents[0] { ret true; } if i == path.idents[0] { ret true; }
for ids.each {|id| for ids.each {|id|
if id.node.name == i { ret true; } 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 { 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 { 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 { impl helpers for ext_ctxt {
fn helper_path(base_path: @ast::path, fn helper_path(base_path: @ast::path,
helper_name: str) -> @ast::path { helper_name: str) -> @ast::path {
let head = vec::init(base_path.node.idents); let head = vec::init(base_path.idents);
let tail = vec::last(base_path.node.idents); let tail = vec::last(base_path.idents);
self.path(base_path.span, head + [helper_name + "_" + tail]) self.path(base_path.span, head + [helper_name + "_" + tail])
} }
fn path(span: span, strs: [str]) -> @ast::path { fn path(span: span, strs: [str]) -> @ast::path {
@{node: {global: false, idents: strs, types: []}, @{span: span, global: false, idents: strs, types: []}
span: span}
} }
fn path_tps(span: span, strs: [str], tps: [@ast::ty]) -> @ast::path { fn path_tps(span: span, strs: [str], tps: [@ast::ty]) -> @ast::path {
@{node: {global: false, idents: strs, types: tps}, @{span: span, global: false, idents: strs, types: tps}
span: span}
} }
fn ty_path(span: span, strs: [str], tps: [@ast::ty]) -> @ast::ty { 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 { fn binder_pat(span: span, nm: str) -> @ast::pat {
let path = @{node: {global: false, let path = @{span: span, global: false, idents: [nm], types: []};
idents: [nm],
types: []},
span: span};
@{id: self.next_id(), @{id: self.next_id(),
node: ast::pat_ident(path, none), node: ast::pat_ident(path, none),
span: span} span: span}
@ -292,7 +287,7 @@ fn ser_path(cx: ext_ctxt, tps: ser_tps_map, path: @ast::path,
ast::expr_path( ast::expr_path(
cx.helper_path(path, "serialize"))); 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_stmts = ser_ty(cx, tps, ty, cx.clone(s), #ast{ __v });
let sv = cx.expr(path.span, let sv = cx.expr(path.span,
ast::expr_block(cx.blk(path.span, sv_stmts))); 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, _) { ast::ty_path(path, _) {
if vec::len(path.node.idents) == 1u && if vec::len(path.idents) == 1u &&
vec::is_empty(path.node.types) { vec::is_empty(path.types) {
let ident = path.node.idents[0]; let ident = path.idents[0];
alt tps.find(ident) { alt tps.find(ident) {
some(f) { f(v) } some(f) { f(v) }
@ -566,7 +561,7 @@ fn deser_path(cx: ext_ctxt, tps: deser_tps_map, path: @ast::path,
ast::expr_path( ast::expr_path(
cx.helper_path(path, "deserialize"))); 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)); let dv_expr = deser_ty(cx, tps, ty, cx.clone(d));
cx.lambda(cx.expr_blk(dv_expr)) 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, _) { ast::ty_path(path, _) {
if vec::len(path.node.idents) == 1u && if vec::len(path.idents) == 1u &&
vec::is_empty(path.node.types) { vec::is_empty(path.types) {
let ident = path.node.idents[0]; let ident = path.idents[0];
alt tps.find(ident) { alt tps.find(ident) {
some(f) { f() } 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 { fn expr_to_ident(cx: ext_ctxt, expr: @ast::expr, error: str) -> ast::ident {
alt expr.node { alt expr.node {
ast::expr_path(p) { 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); cx.span_fatal(expr.span, error);
} else { ret p.node.idents[0]; } } else { ret p.idents[0]; }
} }
_ { cx.span_fatal(expr.span, error); } _ { 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]) -> fn mk_path(cx: ext_ctxt, sp: span, idents: [ast::ident]) ->
@ast::expr { @ast::expr {
let path = {global: false, idents: idents, types: []}; let path = @{span: sp, global: false, idents: idents, types: []};
let sp_path = @{node: path, span: sp}; let pathexpr = ast::expr_path(path);
let pathexpr = ast::expr_path(sp_path);
ret @{id: cx.next_id(), node: pathexpr, span: sp}; ret @{id: cx.next_id(), node: pathexpr, span: sp};
} }
fn mk_access_(cx: ext_ctxt, sp: span, p: @ast::expr, m: ast::ident) 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(), ret @{id: cx.next_id(),
node: ast::expr_path(@{node: {global: false, idents: [res], node: ast::expr_path(@{span: sp, global: false, idents: [res],
types: []}, types: []}),
span: sp}),
span: sp}; 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) { expr_mac(mac) {
alt mac.node { alt mac.node {
mac_invoc(pth, args, body) { mac_invoc(pth, args, body) {
assert (vec::len(pth.node.idents) > 0u); assert (vec::len(pth.idents) > 0u);
let extname = pth.node.idents[0]; let extname = pth.idents[0];
alt exts.find(extname) { alt exts.find(extname) {
none { none {
cx.span_fatal(pth.span, 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"); ecx.span_fatal(_sp, "#ast requires exactly one arg");
} }
alt (args[0].node) { 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]} {what = id[0]}
_ {ecx.span_fatal(args[0].span, "expected an identifier");} _ {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 fold::*;
import ast_util::respan; 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}; expr_vec, expr_mac, mac_invoc, node_id};
export add_new_extension; export add_new_extension;
fn path_to_ident(pth: @path) -> option<ident> { fn path_to_ident(pth: @path) -> option<ident> {
if vec::len(pth.node.idents) == 1u && vec::len(pth.node.types) == 0u { if vec::len(pth.idents) == 1u && vec::len(pth.types) == 0u {
ret some(pth.node.idents[0u]); ret some(pth.idents[0u]);
} }
ret none; ret none;
} }
@ -190,7 +190,7 @@ fn transcribe(cx: ext_ctxt, b: bindings, body: @expr) -> @expr {
let afp = default_ast_fold(); let afp = default_ast_fold();
let f_pre = let f_pre =
{fold_ident: bind transcribe_ident(cx, b, idx_path, _, _), {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: fold_expr:
bind transcribe_expr(cx, b, idx_path, _, _, _, afp.fold_expr), bind transcribe_expr(cx, b, idx_path, _, _, _, afp.fold_expr),
fold_ty: bind transcribe_type(cx, b, idx_path, _, _, _, afp.fold_ty), 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], 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. // Don't substitute into qualified names.
if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { ret (p, s); } if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { ret p; }
ret alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) { alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
some(match_ident(id)) { some(match_ident(id)) {
({global: false, idents: [id.node], types: []}, id.span) {span: id.span, global: false, idents: [id.node], types: []}
} }
some(match_path(a_pth)) { (a_pth.node, a_pth.span) } some(match_path(a_pth)) { *a_pth }
some(m) { match_error(cx, m, "a path") } some(m) { match_error(cx, m, "a path") }
none { (p, s) } none { p }
} }
} }
@ -351,15 +351,15 @@ fn transcribe_expr(cx: ext_ctxt, b: bindings, idx_path: @mut [uint],
ret alt e { ret alt e {
expr_path(p) { expr_path(p) {
// Don't substitute into qualified names. // 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); (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)) { some(match_ident(id)) {
(expr_path(@respan(id.span, (expr_path(@{span: id.span,
{global: false, global: false,
idents: [id.node], idents: [id.node],
types: []})), id.span) types: []}), id.span)
} }
some(match_path(a_pth)) { (expr_path(a_pth), s) } some(match_path(a_pth)) { (expr_path(a_pth), s) }
some(match_expr(a_exp)) { (a_exp.node, a_exp.span) } 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_native_mod: fn@(native_mod, ast_fold) -> native_mod,
fold_variant: fn@(variant_, span, ast_fold) -> (variant_, span), fold_variant: fn@(variant_, span, ast_fold) -> (variant_, span),
fold_ident: fn@(&&ident, ast_fold) -> ident, 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), fold_local: fn@(local_, span, ast_fold) -> (local_, span),
map_exprs: fn@(fn@(&&@expr) -> @expr, [@expr]) -> [@expr], map_exprs: fn@(fn@(&&@expr) -> @expr, [@expr]) -> [@expr],
new_id: fn@(node_id) -> node_id, 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_ident(&&i: ident, _fld: ast_fold) -> ident { ret i; }
fn noop_fold_path(&&p: path_, fld: ast_fold) -> path_ { fn noop_fold_path(&&p: path, fld: ast_fold) -> path {
ret {global: p.global, ret {span: fld.new_span(p.span), global: p.global,
idents: vec::map(p.idents, fld.fold_ident), idents: vec::map(p.idents, fld.fold_ident),
types: vec::map(p.types, fld.fold_ty)}; 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_native_mod: noop_fold_native_mod,
fold_variant: wrap(noop_fold_variant), fold_variant: wrap(noop_fold_variant),
fold_ident: noop_fold_ident, fold_ident: noop_fold_ident,
fold_path: wrap(noop_fold_path), fold_path: noop_fold_path,
fold_local: wrap(noop_fold_local), fold_local: wrap(noop_fold_local),
map_exprs: noop_map_exprs, map_exprs: noop_map_exprs,
new_id: noop_id, new_id: noop_id,
@ -754,8 +754,7 @@ fn make_fold(afp: ast_fold_precursor) -> ast_fold {
ret afp.fold_ident(x, f); ret afp.fold_ident(x, f);
} }
fn f_path(afp: ast_fold_precursor, f: ast_fold, &&x: @path) -> @path { fn f_path(afp: ast_fold_precursor, f: ast_fold, &&x: @path) -> @path {
let (n, s) = afp.fold_path(x.node, x.span, f); @afp.fold_path(*x, f)
ret @{node: n, span: afp.new_span(s)};
} }
fn f_local(afp: ast_fold_precursor, f: ast_fold, &&x: @local) -> @local { fn f_local(afp: ast_fold_precursor, f: ast_fold, &&x: @local) -> @local {
let (n, s) = afp.fold_local(x.node, x.span, f); 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 { if vec::len(self.buffer) == 0u {
let next = lexer::next_token(self.reader); let next = lexer::next_token(self.reader);
self.token = next.tok; 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 { } else {
let next = vec::pop(self.buffer); let next = vec::pop(self.buffer);
self.token = next.tok; self.token = next.tok;
@ -76,12 +76,12 @@ impl parser for parser {
} }
fn swap(next: token::token, lo: uint, hi: uint) { fn swap(next: token::token, lo: uint, hi: uint) {
self.token = next; self.token = next;
self.span = ast_util::mk_sp(lo, hi); self.span = mk_sp(lo, hi);
} }
fn look_ahead(distance: uint) -> token::token { fn look_ahead(distance: uint) -> token::token {
while vec::len(self.buffer) < distance { while vec::len(self.buffer) < distance {
let next = lexer::next_token(self.reader); 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; self.buffer = [{tok: next.tok, span: sp}] + self.buffer;
} }
ret self.buffer[distance - 1u].tok; 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; let d = parse_ty_fn(p), fhi = p.last_span.hi;
expect(p, token::SEMI); expect(p, token::SEMI);
{ident: ident, attrs: attrs, decl: {purity: pur with d}, tps: tps, {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 }, 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 { fn mk_ty(p: parser, t: ast::ty_, lo: uint, hi: uint) -> @ast::ty {
@{id: p.get_id(), @{id: p.get_id(),
node: t, node: t,
span: ast_util::mk_sp(lo, hi)} span: mk_sp(lo, hi)}
} }
if p.token == token::BINOP(token::SLASH) { 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 { alt orig_t {
ast::ty_path(pth, ann) { ast::ty_path(pth, ann) {
ret mk_ty(p, ast::ty_path(@spanned(lo, p.last_span.hi, ret mk_ty(p, ast::ty_path(@{span: mk_sp(lo, p.last_span.hi),
{global: pth.node.global, global: pth.global,
idents: pth.node.idents, idents: pth.idents,
types: seq}), ann), types: seq}, ann),
lo, p.last_span.hi); lo, p.last_span.hi);
} }
_ { p.fatal("type parameter instantiation only allowed for paths"); } _ { 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) { if eat(p, token::NOT) {
(ast::noreturn, @{id: p.get_id(), (ast::noreturn, @{id: p.get_id(),
node: ast::ty_bot, node: ast::ty_bot,
span: ast_util::mk_sp(lo, p.last_span.hi)}) span: mk_sp(lo, p.last_span.hi)})
} else { } else {
(ast::return_val, parse_ty(p, false)) (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; let pos = p.span.lo;
(ast::return_val, @{id: p.get_id(), (ast::return_val, @{id: p.get_id(),
node: ast::ty_nil, 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) { some(e) {
ret @{id: p.get_id(), ret @{id: p.get_id(),
node: ast::ty_mac(spanned(lo, p.span.hi, e)), 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 {} none {}
} }
@ -373,7 +373,7 @@ fn parse_ty(p: parser, colons_before_params: bool) -> @ast::ty {
p.bump(); p.bump();
ast::ty_constr(@{id: p.get_id(), ast::ty_constr(@{id: p.get_id(),
node: t, node: t,
span: ast_util::mk_sp(lo, hi)}, span: mk_sp(lo, hi)},
parse_type_constraints(p)) parse_type_constraints(p))
} else { t } } else { t }
} else if p.token == token::LBRACKET { } else if p.token == token::LBRACKET {
@ -435,7 +435,7 @@ fn parse_fn_block_arg(p: parser) -> ast::arg {
} else { } else {
@{id: p.get_id(), @{id: p.get_id(),
node: ast::ty_infer, 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()}; 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); let e = parse_expr(p);
expect(p, token::RPAREN); expect(p, token::RPAREN);
let hi = p.last_span.hi; 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"); p.fatal("expected `(` or integer literal");
@ -526,7 +526,7 @@ fn parse_lit(p: parser) -> ast::lit {
p.bump(); p.bump();
lit_from_token(p, tok) 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 { 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) { while p.look_ahead(1u) != token::LT && eat(p, token::MOD_SEP) {
ids += [parse_ident(p)]; ids += [parse_ident(p)];
} }
ret @spanned(lo, p.last_span.hi, @{span: mk_sp(lo, p.last_span.hi), global: global, idents: ids, types: []}
{global: global, idents: ids, types: []});
} }
fn parse_value_path(p: parser) -> @ast::path { fn parse_value_path(p: parser) -> @ast::path {
let pt = parse_path(p); 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) { if p.bad_expr_words.contains_key(last_word) {
p.fatal("found " + last_word + " in expression position"); 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 { fn parse_path_and_ty_param_substs(p: parser, colons: bool) -> @ast::path {
let lo = p.span.lo; let lo = p.span.lo;
let path = parse_path(p); let path = parse_path(p);
let b = if colons { let b = if colons { eat(p, token::MOD_SEP) }
eat(p, token::MOD_SEP) else { p.token == token::LT };
} else {
p.token == token::LT
};
if b { if b {
let seq = parse_seq_lt_gt(some(token::COMMA), let seq = parse_seq_lt_gt(some(token::COMMA),
{|p| parse_ty(p, false)}, p); {|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 } } 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 { 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 { fn mk_mac_expr(p: parser, lo: uint, hi: uint, m: ast::mac_) -> @ast::expr {
ret @{id: p.get_id(), ret @{id: p.get_id(),
node: ast::expr_mac({node: m, span: ast_util::mk_sp(lo, hi)}), node: ast::expr_mac({node: m, span: mk_sp(lo, hi)}),
span: ast_util::mk_sp(lo, hi)}; span: mk_sp(lo, hi)};
} }
fn mk_lit_u32(p: parser, i: u32) -> @ast::expr { 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 { alt p.token {
token::IDENT(_, _) { token::IDENT(_, _) {
let id = p.get_id(); 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); let ident = parse_ident(p);
res += [@{id:id, name:ident, span:sp}]; res += [@{id:id, name:ident, span:sp}];
if !eat(p, token::COMMA) { if !eat(p, token::COMMA) {
@ -1364,7 +1360,7 @@ fn parse_pat(p: parser) -> @ast::pat {
let lo1 = p.last_span.lo; let lo1 = p.last_span.lo;
let fieldname = parse_ident(p); let fieldname = parse_ident(p);
let hi1 = p.last_span.lo; 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); fieldname);
let mut subpat; let mut subpat;
if p.token == token::COLON { if p.token == token::COLON {
@ -1376,7 +1372,7 @@ fn parse_pat(p: parser) -> @ast::pat {
} }
subpat = @{id: p.get_id(), subpat = @{id: p.get_id(),
node: ast::pat_ident(fieldpath, none), node: ast::pat_ident(fieldpath, none),
span: ast_util::mk_sp(lo, hi)}; span: mk_sp(lo, hi)};
} }
fields += [{ident: fieldname, pat: subpat}]; fields += [{ident: fieldname, pat: subpat}];
} }
@ -1389,7 +1385,7 @@ fn parse_pat(p: parser) -> @ast::pat {
if p.token == token::RPAREN { if p.token == token::RPAREN {
hi = p.span.hi; hi = p.span.hi;
p.bump(); 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)); let expr = mk_expr(p, lo, hi, ast::expr_lit(lit));
pat = ast::pat_lit(expr); pat = ast::pat_lit(expr);
} else { } else {
@ -1454,7 +1450,7 @@ fn parse_pat(p: parser) -> @ast::pat {
pat = ast::pat_enum(enum_path, none); pat = ast::pat_enum(enum_path, none);
} }
else if vec::is_empty(args) && 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); pat = ast::pat_ident(enum_path, none);
} }
else { 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, 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 pat = parse_pat(p);
let mut ty = @{id: p.get_id(), let mut ty = @{id: p.get_id(),
node: ast::ty_infer, 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); } if eat(p, token::COLON) { ty = parse_ty(p, false); }
let init = if allow_init { parse_initializer(p) } else { none }; let init = if allow_init { parse_initializer(p) } else { none };
ret @spanned(lo, p.last_span.hi, 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); expect(p, token::COLON);
let ty = parse_ty(p, false); let ty = parse_ty(p, false);
ret @{node: ast::instance_var(name, ty, is_mutbl, p.get_id(), pr), 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 { 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, attrs: attrs,
id: p.get_id(), id: p.get_id(),
node: node, node: node,
span: ast_util::mk_sp(lo, hi)}; span: mk_sp(lo, hi)};
} }
fn parse_item_fn(p: parser, purity: ast::purity, 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 (inner_attrs, body) = parse_inner_attrs_and_block(p, true);
let attrs = attrs + inner_attrs; let attrs = attrs + inner_attrs;
@{ident: ident, attrs: attrs, tps: tps, decl: decl, body: body, @{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} 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 ifce = if eat_word(p, "of") {
let path = parse_path_and_ty_param_substs(p, false); let path = parse_path_and_ty_param_substs(p, false);
if option::is_none(ident) { 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)) some(wrap_path(p, path))
} else { none }; } else { none };
@ -1836,7 +1832,7 @@ fn parse_item_res(p: parser, attrs: [ast::attribute]) -> @ast::item {
ident: arg_ident, id: p.get_id()}], ident: arg_ident, id: p.get_id()}],
output: @{id: p.get_id(), output: @{id: p.get_id(),
node: ast::ty_nil, node: ast::ty_nil,
span: ast_util::mk_sp(lo, lo)}, span: mk_sp(lo, lo)},
purity: ast::impure_fn, purity: ast::impure_fn,
cf: ast::return_val, cf: ast::return_val,
constraints: []}; 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, fn ident_to_path_tys(p: parser, i: ast::ident,
typarams: [ast::ty_param]) -> @ast::path { typarams: [ast::ty_param]) -> @ast::path {
let s = p.last_span; let s = p.last_span;
let p_: ast::path_ = {global: false, idents: [i], @{span: s, global: false, idents: [i],
types: vec::map(typarams, types: vec::map(typarams, {|tp|
{|tp| @{id: p.get_id(), @{id: p.get_id(),
node: ast::ty_path(ident_to_path(s, tp.ident), node: ast::ty_path(ident_to_path(s, tp.ident),
p.get_id()), p.get_id()),
span: s}})}; span: s}})
@spanned(s.lo, s.hi, p_) }
} }
fn parse_iface_ref_list(p:parser) -> [ast::iface_ref] { 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} span: decl_.output.span}
with decl_}; with decl_};
let body = parse_block(p); 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") { else if eat_word(p, "priv") {
expect(p, token::LBRACE); expect(p, token::LBRACE);
@ -2014,7 +2010,7 @@ fn parse_item_native_fn(p: parser, attrs: [ast::attribute],
attrs: attrs, attrs: attrs,
node: ast::native_item_fn(decl, t.tps), node: ast::native_item_fn(decl, t.tps),
id: p.get_id(), id: p.get_id(),
span: ast_util::mk_sp(lo, hi)}; span: mk_sp(lo, hi)};
} }
fn parse_fn_purity(p: parser) -> ast::purity { 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); let id = parse_ident(p);
path += [id]; path += [id];
} }
let mut hi = p.span.hi; let path = @{span: mk_sp(lo, p.span.hi), global: false,
ret @spanned(lo, hi, idents: path, types: []};
ast::view_path_simple(first_ident, ret @spanned(lo, p.span.hi,
@spanned(lo, hi, ast::view_path_simple(first_ident, path, p.get_id()));
{global: false, idents: path,
types: []}),
p.get_id()));
} }
token::MOD_SEP { token::MOD_SEP {
@ -2263,25 +2256,19 @@ fn parse_view_path(p: parser) -> @ast::view_path {
parse_seq(token::LBRACE, token::RBRACE, parse_seq(token::LBRACE, token::RBRACE,
seq_sep(token::COMMA), seq_sep(token::COMMA),
parse_path_list_ident, p).node; parse_path_list_ident, p).node;
let mut hi = p.span.hi; let path = @{span: mk_sp(lo, p.span.hi),
ret @spanned(lo, hi, global: false, idents: path, types: []};
ast::view_path_list(@spanned(lo, hi, ret @spanned(lo, p.span.hi,
{global: false, ast::view_path_list(path, idents, p.get_id()));
idents: path,
types: []}), idents,
p.get_id()));
} }
// foo::bar::* // foo::bar::*
token::BINOP(token::STAR) { token::BINOP(token::STAR) {
p.bump(); p.bump();
let mut hi = p.span.hi; let path = @{span: mk_sp(lo, p.span.hi),
ret @spanned(lo, hi, global: false, idents: path, types: []};
ast::view_path_glob(@spanned(lo, hi, ret @spanned(lo, p.span.hi,
{global: false, ast::view_path_glob(path, p.get_id()));
idents: path,
types: []}),
p.get_id()));
} }
_ { break; } _ { 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]; let last = path[vec::len(path) - 1u];
ret @spanned(lo, hi, let path = @{span: mk_sp(lo, p.span.hi), global: false,
ast::view_path_simple(last, @spanned(lo, hi, idents: path, types: []};
{global: false, ret @spanned(lo, p.span.hi,
idents: path, ast::view_path_simple(last, path, p.get_id()));
types: []}),
p.get_id()));
} }
fn parse_view_paths(p: parser) -> [@ast::view_path] { 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) { fn print_path(s: ps, &&path: @ast::path, colons_before_params: bool) {
maybe_print_comment(s, path.span.lo); maybe_print_comment(s, path.span.lo);
if path.node.global { word(s.s, "::"); } if path.global { word(s.s, "::"); }
let mut first = true; let mut first = true;
for path.node.idents.each {|id| for path.idents.each {|id|
if first { first = false; } else { word(s.s, "::"); } if first { first = false; } else { word(s.s, "::"); }
word(s.s, id); word(s.s, id);
} }
if vec::len(path.node.types) > 0u { if vec::len(path.types) > 0u {
if colons_before_params { word(s.s, "::"); } if colons_before_params { word(s.s, "::"); }
word(s.s, "<"); word(s.s, "<");
commasep(s, inconsistent, path.node.types, print_type); commasep(s, inconsistent, path.types, print_type);
word(s.s, ">"); 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) { fn print_view_path(s: ps, &&vp: @ast::view_path) {
alt vp.node { alt vp.node {
ast::view_path_simple(ident, path, _) { 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, ident);
word_space(s, "="); 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>) { 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>) { 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()}; 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 { fn mk_tests(cx: test_ctxt) -> @ast::item {
let ret_ty = mk_test_desc_vec_ty(cx); 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] // The ast::ty of [std::test::test_desc]
fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::ty { fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::ty {
let test_desc_ty_path = let test_desc_ty_path = path_node(mk_path(cx, ["test", "test_desc"]));
@nospan({global: false,
idents: mk_path(cx, ["test", "test_desc"]),
types: []});
let test_desc_ty: ast::ty = let test_desc_ty: ast::ty =
{id: cx.sess.next_node_id(), {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 = let name_field: ast::field =
nospan({mutbl: ast::m_imm, ident: "name", expr: @name_expr}); 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 = let fn_expr: ast::expr =
{id: cx.sess.next_node_id(), {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 { 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(), let str_ty = @{id: cx.sess.next_node_id(),
node: ast::ty_path(str_pt, cx.sess.next_node_id()), node: ast::ty_path(str_pt, cx.sess.next_node_id()),
span: dummy_sp()}; 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 { fn mk_test_main_call(cx: test_ctxt) -> @ast::expr {
// Get the args passed to main so we can pass the to test_main // Get the args passed to main so we can pass the to test_main
let args_path = let args_path = path_node(["args"]);
@nospan({global: false, idents: ["args"], types: []});
let args_path_expr_: ast::expr_ = ast::expr_path(args_path); 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()}; {id: cx.sess.next_node_id(), node: args_path_expr_, span: dummy_sp()};
// Call __test::test to generate the vector of test_descs // Call __test::test to generate the vector of test_descs
let test_path = let test_path = path_node(["tests"]);
@nospan({global: false, idents: ["tests"], types: []});
let test_path_expr_: ast::expr_ = ast::expr_path(test_path); 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()}; {id: cx.sess.next_node_id(), node: test_call_expr_, span: dummy_sp()};
// Call std::test::test_main // Call std::test::test_main
let test_main_path = let test_main_path = path_node(mk_path(cx, ["test", "test_main"]));
@nospan({global: false,
idents: mk_path(cx, ["test", "test_main"]),
types: []});
let test_main_path_expr_: ast::expr_ = ast::expr_path(test_main_path); 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); } ':' { next(st); next(st); }
c { c {
if c == '(' { if c == '(' {
ret @respan(ast_util::dummy_sp(), ret @{span: ast_util::dummy_sp(),
{global: false, idents: idents, types: []}); global: false, idents: idents, types: []};
} else { idents += [parse_ident_(st, is_last)]; } } 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) { ast::carg_ident(p) {
alt actual.node { alt actual.node {
ast::carg_ident(q) { ast::carg_ident(q) {
if p.node != q.node { ret err_res; } if p.idents != q.idents { ret err_res; }
} }
_ { 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; ret found;
} }
fn path_to_ident(p: @path) -> ident { fn path_to_ident(p: @path) -> ident { vec::last(p.idents) }
assert (vec::is_not_empty(p.node.idents)); // should be a constraint on path
vec::last(p.node.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| iter_effective_import_paths(*i) { |vp|
alt vp.node { alt vp.node {
ast::view_path_simple(name, path, id) { 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)); sc));
} }
ast::view_path_glob(path, id) { 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, _) { ast::view_path_list(mod_path, idents, _) {
for idents.each {|ident| for idents.each {|ident|
let t = todo(ident.node.name, let t = todo(ident.node.name,
@(mod_path.node.idents + [ident.node.name]), @(mod_path.idents + [ident.node.name]),
ident.span, sc); ident.span, sc);
e.imports.insert(ident.node.id, t); 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| iter_effective_import_paths(*vi) { |vp|
alt vp.node { alt vp.node {
ast::view_path_glob(path, _) { 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) { some(imp) {
let glob = {def: imp, path: vp}; let glob = {def: imp, path: vp};
alt list::head(sc) { alt list::head(sc) {
@ -433,8 +433,7 @@ fn resolve_names(e: @env, c: @ast::crate) {
/* visit the iface paths... */ /* visit the iface paths... */
for ifaces.each {|p| for ifaces.each {|p|
maybe_insert(e, p.id, maybe_insert(e, p.id,
lookup_path_strict(*e, sc, p.path.span, p.path.node, lookup_path_strict(*e, sc, p.path.span, p.path, ns_type))};
ns_type))};
} }
_ {} _ {}
} }
@ -445,8 +444,7 @@ fn resolve_names(e: @env, c: @ast::crate) {
alt exp.node { alt exp.node {
ast::expr_path(p) { ast::expr_path(p) {
maybe_insert(e, exp.id, maybe_insert(e, exp.id,
lookup_path_strict(*e, sc, exp.span, p.node, lookup_path_strict(*e, sc, exp.span, p, ns_val));
ns_val));
} }
ast::expr_fn(_, _, _, cap_clause) { ast::expr_fn(_, _, _, cap_clause) {
let rci = bind resolve_capture_item(e, sc, _); let rci = bind resolve_capture_item(e, sc, _);
@ -461,7 +459,7 @@ fn resolve_names(e: @env, c: @ast::crate) {
alt t.node { alt t.node {
ast::ty_path(p, id) { ast::ty_path(p, id) {
maybe_insert(e, 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, fn walk_constr(e: @env, p: @ast::path, sp: span, id: node_id, sc: scopes,
_v: vt<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>) { fn walk_pat(e: @env, pat: @ast::pat, sc: scopes, v: vt<scopes>) {
visit::visit_pat(pat, sc, v); visit::visit_pat(pat, sc, v);
alt pat.node { alt pat.node {
ast::pat_enum(p, _) { 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(_,_)) { some(fnd@ast::def_variant(_,_)) {
e.def_map.insert(pat.id, fnd); 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>) { 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)) { some(d@ast::def_fn(_,ast::pure_fn)) {
e.def_map.insert(c.node.id, d); e.def_map.insert(c.node.id, d);
} }
@ -892,7 +890,7 @@ fn mk_unresolved_msg(id: ident, kind: str) -> str {
} }
// Lookup helpers // 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> { ns: namespace) -> option<def> {
let n_idents = vec::len(pth.idents); let n_idents = vec::len(pth.idents);
let headns = if n_idents == 1u { ns } else { ns_module }; 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); check_export(e, ident, _mod, id, vi);
} }
ast::view_path_list(path, ids, node_id) { ast::view_path_list(path, ids, node_id) {
let id = if vec::len(path.node.idents) == 1u { let id = if vec::len(path.idents) == 1u {
path.node.idents[0] path.idents[0]
} else { } else {
e.sess.span_fatal(vp.span, "bad export name-list") 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 { alt vp.node {
ast::view_path_simple(name, pt, id) { ast::view_path_simple(name, pt, id) {
let mut found = []; let mut found = [];
if vec::len(pt.node.idents) == 1u { if vec::len(pt.idents) == 1u {
option::iter(sc) {|sc| option::iter(sc) {|sc|
list::iter(sc) {|level| list::iter(sc) {|level|
if vec::len(found) == 0u { if vec::len(found) == 0u {
for vec::each(*level) {|imp| for vec::each(*level) {|imp|
if imp.ident == pt.node.idents[0] { if imp.ident == pt.idents[0] {
found += [@{ident: name with *imp}]; 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_local(nid, _)) | some(def_arg(nid, _)) |
some(def_binding(nid)) | some(def_upvar(nid, _, _)) { some(def_binding(nid)) | some(def_upvar(nid, _, _)) {
ret @respan(p.span, ret @respan(p.span,
carg_ident({ident: p.node.idents[0], node: nid})); carg_ident({ident: p.idents[0], node: nid}));
} }
some(what) { some(what) {
tcx.sess.span_bug(e.span, 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) { fn clear_in_poststate_expr(fcx: fn_ctxt, e: @expr, t: poststate) {
alt e.node { alt e.node {
expr_path(p) { expr_path(p) {
alt vec::last_opt(p.node.idents) { alt local_node_id_to_def(fcx, e.id) {
some(i) { some(def_local(nid, _)) {
alt local_node_id_to_def(fcx, e.id) { clear_in_poststate_(bit_num(fcx, ninit(nid, vec::last(p.idents))),
some(def_local(nid, _)) { t);
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");
}
}
} }
_ { 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 */ } _ {/* do nothing */ }

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

@ -224,7 +224,7 @@ fn instantiate_path(fcx: @fn_ctxt,
sp: span, sp: span,
id: ast::node_id) { id: ast::node_id) {
let ty_param_count = vec::len(*tpt.bounds); 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. // For now, there is no way to explicitly specify the region bound.
// This will have to change eventually. // 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"); (sp, "not enough type parameters provided for this item");
fcx.next_ty_vars(ty_param_count) fcx.next_ty_vars(ty_param_count)
} else { } 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}; 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 }}; some(d) { d }};
alt a_def { alt a_def {
ast::def_ty(did) | ast::def_class(did) { 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) { ast::def_prim_ty(nty) {
alt 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) { 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 \ tcx.sess.span_err(ast_ty.span, "provided type parameters \
to a type parameter"); 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) { ast::def_self(self_id) {
alt check tcx.items.get(self_id) { alt check tcx.items.get(self_id) {
ast_map::node_item(@{node: ast::item_iface(tps, _), _}, _) { 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 \ tcx.sess.span_err(ast_ty.span, "incorrect number of \
type parameters to \ type parameters to \
self type"); 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) 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) { ast::carg_ident(i) {
if i < num_args { if i < num_args {
let p: ast::path_ = let p = @{span: a.span, global: false,
{global: false, idents: [args[i].ident], types: []};
idents: [args[i].ident],
types: []};
let arg_occ_node_id = let arg_occ_node_id =
fcx.ccx.tcx.sess.next_node_id(); fcx.ccx.tcx.sess.next_node_id();
fcx.ccx.tcx.def_map.insert fcx.ccx.tcx.def_map.insert
(arg_occ_node_id, (arg_occ_node_id,
ast::def_arg(args[i].id, args[i].mode)); ast::def_arg(args[i].id, args[i].mode));
{id: arg_occ_node_id, {id: arg_occ_node_id,
node: ast::expr_path(@respan(a.span, p)), node: ast::expr_path(p),
span: a.span} span: a.span}
} else { } else {
fcx.ccx.tcx.sess.span_bug(a.span, fcx.ccx.tcx.sess.span_bug(
"check_constraints:\ a.span, "check_constraints:\
carg_ident index out of bounds"); 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) { if !pat_util::pat_is_variant(fcx.ccx.tcx.def_map, p) {
assign(p.id, none); assign(p.id, none);
#debug["Pattern binding %s is assigned to %s", #debug["Pattern binding %s is assigned to %s",
path.node.idents[0], path.idents[0],
fcx.locals.get(p.id).to_str()]; fcx.locals.get(p.id).to_str()];
} }
_ {} _ {}