user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

rustc: Make AST paths use interior vectors

Browse source
This commit is contained in:
Patrick Walton 2011-07-05 16:23:07 -07:00
parent 368f1f4ba8
commit 7714cb297b
12 changed files with 71 additions and 43 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/comp/syntax/ast.rs
View file

@ -1,4 +1,6 @@
// The Rust abstract syntax tree.
import std::ivec;
import std::option;
import std::str;
import std::vec;
@ -15,11 +17,11 @@ type fn_ident = option::t[ident];
// FIXME: with typestate constraint, could say
// idents and types are the same length, and are
// non-empty
type path_ = rec(vec[ident] idents, vec[@ty] types);
type path_ = rec(ident[] idents, (@ty)[] types);
type path = spanned[path_];
fn path_name(&path p) -> str { ret str::connect(p.node.idents, "::"); }
fn path_name(&path p) -> str { ret str::connect_ivec(p.node.idents, "::"); }
type crate_num = int;
type node_id = int;
@ -632,11 +634,11 @@ fn ternary_to_if(&@expr e) -> @ast::expr {
// Path stringification
fn path_to_str(&ast::path pth) -> str {
auto result = str::connect(pth.node.idents, "::");
if (vec::len[@ast::ty](pth.node.types) > 0u) {
auto result = str::connect_ivec(pth.node.idents, "::");
if (ivec::len[@ast::ty](pth.node.types) > 0u) {
fn f(&@ast::ty t) -> str { ret print::pprust::ty_to_str(*t); }
result += "[";
result += str::connect(vec::map(f, pth.node.types), ",");
result += str::connect_ivec(ivec::map(f, pth.node.types), ",");
result += "]";
}
ret result;

5
src/comp/syntax/ext/base.rs
View file

@ -1,3 +1,4 @@
import std::ivec;
import std::vec;
import std::option;
import std::map::hashmap;
@ -71,8 +72,8 @@ fn expr_to_str(&ext_ctxt cx, @ast::expr expr, str error) -> str {
fn expr_to_ident(&ext_ctxt cx, @ast::expr expr, str error) -> ast::ident {
alt(expr.node) {
case (ast::expr_path(?p)) {
if (vec::len(p.node.types) > 0u
|| vec::len(p.node.idents) != 1u) {
if (ivec::len(p.node.types) > 0u
|| ivec::len(p.node.idents) != 1u) {
cx.span_fatal(expr.span, error);
} else {
ret p.node.idents.(0);

11
src/comp/syntax/ext/fmt.rs
View file

@ -60,10 +60,9 @@ fn pieces_to_expr(&ext_ctxt cx, span sp, vec[piece] pieces,
auto binexpr = ast::expr_binary(ast::add, lhs, rhs);
ret @rec(id=cx.next_id(), node=binexpr, span=sp);
}
fn make_path_expr(&ext_ctxt cx, span sp, vec[ast::ident] idents)
fn make_path_expr(&ext_ctxt cx, span sp, &ast::ident[] idents)
-> @ast::expr {
let vec[@ast::ty] types = [];
auto path = rec(idents=idents, types=types);
auto path = rec(idents=idents, types=~[]);
auto sp_path = rec(node=path, span=sp);
auto pathexpr = ast::expr_path(sp_path);
ret @rec(id=cx.next_id(), node=pathexpr, span=sp);
@ -73,7 +72,7 @@ fn pieces_to_expr(&ext_ctxt cx, span sp, vec[piece] pieces,
auto vecexpr = ast::expr_vec(exprs, ast::imm, ast::sk_rc);
ret @rec(id=cx.next_id(), node=vecexpr, span=sp);
}
fn make_call(&ext_ctxt cx, span sp, vec[ast::ident] fn_path,
fn make_call(&ext_ctxt cx, span sp, &ast::ident[] fn_path,
vec[@ast::expr] args) -> @ast::expr {
auto pathexpr = make_path_expr(cx, sp, fn_path);
auto callexpr = ast::expr_call(pathexpr, args);
@ -92,11 +91,11 @@ fn pieces_to_expr(&ext_ctxt cx, span sp, vec[piece] pieces,
auto recexpr = ast::expr_rec(astfields, option::none[@ast::expr]);
ret @rec(id=cx.next_id(), node=recexpr, span=sp);
}
fn make_path_vec(str ident) -> vec[str] {
fn make_path_vec(str ident) -> str[] {
// FIXME: #fmt can't currently be used from within std
// because we're explicitly referencing the 'std' crate here
ret ["std", "extfmt", "rt", ident];
ret ~["std", "extfmt", "rt", ident];
}
fn make_rt_path_expr(&ext_ctxt cx, span sp, str ident) ->
@ast::expr {

6
src/comp/syntax/ext/simplext.rs
View file

@ -1,6 +1,7 @@
use std;
import codemap::span;
import std::ivec;
import std::vec;
import std::option;
import vec::map;
@ -50,7 +51,7 @@ fn subst_ident(&ext_ctxt cx, &vec[@ast::expr] args,
fn subst_path(&ext_ctxt cx, &vec[@ast::expr] args,
@vec[ident] param_names, &path_ p, ast_fold fld) -> path_ {
// Don't substitute into qualified names.
if (len(p.types) > 0u || len(p.idents) != 1u) { ret p; }
if (ivec::len(p.types) > 0u || ivec::len(p.idents) != 1u) { ret p; }
alt (position(p.idents.(0), *param_names)) {
case (some[uint](?idx)) {
alt (args.(idx).node) {
@ -75,7 +76,8 @@ fn subst_expr(&ext_ctxt cx, &vec[@ast::expr] args, @vec[ident] param_names,
ret alt(e) {
case (expr_path(?p)){
// Don't substitute into qualified names.
if (len(p.node.types) > 0u || len(p.node.idents) != 1u) { e }
if (ivec::len(p.node.types) > 0u ||
ivec::len(p.node.idents) != 1u) { e }
alt (position(p.node.idents.(0), *param_names)) {
case (some[uint](?idx)) {
args.(idx).node

5
src/comp/syntax/fold.rs
View file

@ -1,6 +1,7 @@
import syntax::codemap::span;
import ast::*;
import std::ivec;
import std::vec;
import std::option;
import vec::map;
@ -486,8 +487,8 @@ fn noop_fold_ident(&ident i, ast_fold fld) -> ident {
}
fn noop_fold_path(&path_ p, ast_fold fld) -> path_ {
ret rec(idents=map(fld.fold_ident, p.idents),
types=map(fld.fold_ty, p.types));
ret rec(idents=ivec::map(fld.fold_ident, p.idents),
types=ivec::map(fld.fold_ty, p.types));
}
fn noop_fold_local(&local_ l, ast_fold fld) -> local_ {

25
src/comp/syntax/parse/parser.rs
View file

@ -1,5 +1,6 @@
import std::io;
import std::ivec;
import std::vec;
import std::str;
import std::option;
@ -409,13 +410,18 @@ fn parse_ty_postfix(@ast::ty orig_t, &parser p) -> @ast::ty {
// This is explicit type parameter instantiation.
auto seq = parse_seq_to_end(token::RBRACKET, some(token::COMMA),
parse_ty, p);
// FIXME: Remove this vec->ivec conversion.
auto seq_ivec = ~[];
for (@ast::ty typ in seq) { seq_ivec += ~[typ]; }
alt (orig_t.node) {
case (ast::ty_path(?pth, ?ann)) {
auto hi = p.get_hi_pos();
ret @spanned(lo, hi,
ast::ty_path(spanned(lo, hi,
rec(idents=pth.node.idents,
types=seq)),
types=seq_ivec)),
ann));
}
case (_) {
@ -637,12 +643,12 @@ fn is_ident(token::token t) -> bool {
fn parse_path(&parser p) -> ast::path {
auto lo = p.get_lo_pos();
auto hi = lo;
let vec[ast::ident] ids = [];
let ast::ident[] ids = ~[];
while (true) {
alt (p.peek()) {
case (token::IDENT(?i, _)) {
hi = p.get_hi_pos();
ids += [p.get_str(i)];
ids += ~[p.get_str(i)];
p.bump();
if (p.peek() == token::MOD_SEP) { p.bump(); } else { break; }
}
@ -650,7 +656,7 @@ fn parse_path(&parser p) -> ast::path {
}
}
hi = p.get_hi_pos();
ret spanned(lo, hi, rec(idents=ids, types=[]));
ret spanned(lo, hi, rec(idents=ids, types=~[]));
}
fn parse_path_and_ty_param_substs(&parser p) -> ast::path {
@ -659,8 +665,13 @@ fn parse_path_and_ty_param_substs(&parser p) -> ast::path {
if (p.peek() == token::LBRACKET) {
auto seq = parse_seq(token::LBRACKET, token::RBRACKET,
some(token::COMMA), parse_ty, p);
// FIXME: Remove this vec->ivec conversion.
auto seq_ivec = ~[];
for (@ast::ty typ in seq.node) { seq_ivec += ~[typ]; }
auto hi = p.get_hi_pos();
path = spanned(lo, hi, rec(idents=path.node.idents, types=seq.node));
path = spanned(lo, hi, rec(idents=path.node.idents, types=seq_ivec));
}
ret path;
}
@ -954,7 +965,7 @@ fn parse_syntax_ext(&parser p) -> @ast::expr {
fn parse_syntax_ext_naked(&parser p, uint lo) -> @ast::expr {
auto pth = parse_path(p);
if (vec::len(pth.node.idents) == 0u) {
if (ivec::len(pth.node.idents) == 0u) {
p.fatal("expected a syntax expander name");
}
auto es = parse_seq(token::LPAREN, token::RPAREN,
@ -974,7 +985,7 @@ fn parse_syntax_ext_naked(&parser p, uint lo) -> @ast::expr {
fn expand_syntax_ext(&parser p, span sp, &ast::path path,
vec[@ast::expr] args, option::t[str] body) ->
ast::expr_ {
assert (vec::len(path.node.idents) > 0u);
assert (ivec::len(path.node.idents) > 0u);
auto extname = path.node.idents.(0);
alt (p.get_syntax_expanders().find(extname)) {
case (none) { p.fatal("unknown syntax expander: '" + extname + "'"); }

22
src/comp/syntax/print/pprust.rs
View file

@ -1,9 +1,10 @@
import std::uint;
import std::ivec;
import std::int;
import std::vec;
import std::str;
import std::io;
import std::str;
import std::uint;
import std::vec;
import std::option;
import parse::lexer;
import syntax::codemap::codemap;
@ -206,6 +207,17 @@ fn commasep[IN](&ps s, breaks b, vec[IN] elts, fn(&ps, &IN) op) {
end(s);
}
fn commasep_ivec[IN](&ps s, breaks b, &IN[] elts, fn(&ps, &IN) op) {
box(s, 0u, b);
auto first = true;
for (IN elt in elts) {
if (first) { first = false; } else { word_space(s, ","); }
op(s, elt);
}
end(s);
}
fn commasep_cmnt[IN](&ps s, breaks b, vec[IN] elts, fn(&ps, &IN) op,
fn(&IN) -> codemap::span get_span) {
box(s, 0u, b);
@ -1013,9 +1025,9 @@ fn print_path(&ps s, &ast::path path) {
if (first) { first = false; } else { word(s.s, "::"); }
word(s.s, id);
}
if (vec::len(path.node.types) > 0u) {
if (ivec::len(path.node.types) > 0u) {
word(s.s, "[");
commasep(s, inconsistent, path.node.types, print_boxed_type);
commasep_ivec(s, inconsistent, path.node.types, print_boxed_type);
word(s.s, "]");
}
}