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

Merge branch 'master' into recursive-elseif

Browse source 
Conflicts:

	src/comp/middle/typeck.rs
This commit is contained in:
Brian Anderson 2011-03-13 19:40:25 -04:00
commit bbb6836da0
44 changed files with 1856 additions and 961 deletions
Download patch file Download diff file Expand all files Collapse all files

53
src/comp/front/ast.rs
View file

@ -21,7 +21,7 @@ type ty_param = rec(ident ident, def_id id);
// Annotations added during successive passes.
tag ann {
ann_none;
ann_type(@middle.ty.t);
ann_type(@middle.ty.t, option.t[vec[@middle.ty.t]] /* ty param substs */);
}
tag def {
@ -29,9 +29,11 @@ tag def {
def_obj(def_id);
def_obj_field(def_id);
def_mod(def_id);
def_native_mod(def_id);
def_const(def_id);
def_arg(def_id);
def_local(def_id);
def_upvar(def_id);
def_variant(def_id /* tag */, def_id /* variant */);
def_ty(def_id);
def_ty_arg(def_id);
@ -42,7 +44,8 @@ tag def {
}
type crate = spanned[crate_];
type crate_ = rec(_mod module);
type crate_ = rec(vec[@crate_directive] directives,
_mod module);
tag crate_directive_ {
cdir_expr(@expr);
@ -64,9 +67,15 @@ type meta_item = spanned[meta_item_];
type meta_item_ = rec(ident name, str value);
type block = spanned[block_];
type block_index = hashmap[ident, block_index_entry];
tag block_index_entry {
bie_item(@item);
bie_local(@local);
bie_tag_variant(@item /* tag item */, uint /* variant index */);
}
type block_ = rec(vec[@stmt] stmts,
option.t[@expr] expr,
hashmap[ident,uint] index);
hashmap[ident,block_index_entry] index);
type variant_def = tup(def_id /* tag */, def_id /* variant */);
@ -427,6 +436,44 @@ fn index_native_view_item(native_mod_index index, @view_item it) {
}
}
fn index_stmt(block_index index, @stmt s) {
alt (s.node) {
case (ast.stmt_decl(?d)) {
alt (d.node) {
case (ast.decl_local(?loc)) {
index.insert(loc.ident, ast.bie_local(loc));
}
case (ast.decl_item(?it)) {
alt (it.node) {
case (ast.item_fn(?i, _, _, _, _)) {
index.insert(i, ast.bie_item(it));
}
case (ast.item_mod(?i, _, _)) {
index.insert(i, ast.bie_item(it));
}
case (ast.item_ty(?i, _, _, _, _)) {
index.insert(i, ast.bie_item(it));
}
case (ast.item_tag(?i, ?variants, _, _)) {
index.insert(i, ast.bie_item(it));
let uint vid = 0u;
for (ast.variant v in variants) {
auto t = ast.bie_tag_variant(it, vid);
index.insert(v.name, t);
vid += 1u;
}
}
case (ast.item_obj(?i, _, _, _, _)) {
index.insert(i, ast.bie_item(it));
}
}
}
}
}
case (_) { /* fall through */ }
}
}
fn is_call_expr(@expr e) -> bool {
alt (e.node) {
case (expr_call(_, _, _)) {

9
src/comp/front/eval.rs
View file

@ -42,7 +42,7 @@ fn val_is_bool(val v) -> bool {
fn val_is_int(val v) -> bool {
alt (v) {
case (val_bool(_)) { ret true; }
case (val_int(_)) { ret true; }
case (_) { }
}
ret false;
@ -386,9 +386,12 @@ impure fn eval_crate_directive(parser p,
auto full_path = prefix + std.os.path_sep() + file_path;
auto p0 = new_parser(p.get_session(), e, 0, full_path);
auto start_id = p.next_def_id();
auto p0 = new_parser(p.get_session(), e, start_id, full_path);
auto m0 = parse_mod_items(p0, token.EOF);
auto im = ast.item_mod(id, m0, p.next_def_id());
auto next_id = p0.next_def_id();
p.set_def(next_id._1);
auto im = ast.item_mod(id, m0, next_id);
auto i = @spanned(cdir.span, cdir.span, im);
ast.index_item(index, i);
append[@ast.item](items, i);

56
src/comp/front/parser.rs
View file

@ -35,12 +35,13 @@ state type parser =
fn get_session() -> session.session;
fn get_span() -> common.span;
fn next_def_id() -> ast.def_id;
fn set_def(ast.def_num);
fn get_prec_table() -> vec[op_spec];
};
impure fn new_parser(session.session sess,
eval.env env,
ast.crate_num crate,
ast.def_id initial_def,
str path) -> parser {
state obj stdio_parser(session.session sess,
eval.env env,
@ -94,6 +95,10 @@ impure fn new_parser(session.session sess,
ret tup(crate, def);
}
fn set_def(ast.def_num d) {
def = d;
}
fn get_file_type() -> file_type {
ret ftype;
}
@ -114,8 +119,8 @@ impure fn new_parser(session.session sess,
auto rdr = lexer.new_reader(srdr, path);
auto npos = rdr.get_curr_pos();
ret stdio_parser(sess, env, ftype, lexer.next_token(rdr),
npos, npos, 0, UNRESTRICTED, crate, rdr,
prec_table());
npos, npos, initial_def._1, UNRESTRICTED, initial_def._0,
rdr, prec_table());
}
impure fn unexpected(parser p, token.token t) {
@ -1465,39 +1470,9 @@ impure fn parse_source_stmt(parser p) -> @ast.stmt {
}
fn index_block(vec[@ast.stmt] stmts, option.t[@ast.expr] expr) -> ast.block_ {
auto index = new_str_hash[uint]();
auto u = 0u;
auto index = new_str_hash[ast.block_index_entry]();
for (@ast.stmt s in stmts) {
alt (s.node) {
case (ast.stmt_decl(?d)) {
alt (d.node) {
case (ast.decl_local(?loc)) {
index.insert(loc.ident, u);
}
case (ast.decl_item(?it)) {
alt (it.node) {
case (ast.item_fn(?i, _, _, _, _)) {
index.insert(i, u);
}
case (ast.item_mod(?i, _, _)) {
index.insert(i, u);
}
case (ast.item_ty(?i, _, _, _, _)) {
index.insert(i, u);
}
case (ast.item_tag(?i, _, _, _)) {
index.insert(i, u);
}
case (ast.item_obj(?i, _, _, _, _)) {
index.insert(i, u);
}
}
}
}
}
case (_) { /* fall through */ }
}
u += 1u;
ast.index_stmt(index, s);
}
ret rec(stmts=stmts, expr=expr, index=index);
}
@ -2261,7 +2236,9 @@ impure fn parse_crate_from_source_file(parser p) -> @ast.crate {
auto lo = p.get_span();
auto hi = lo;
auto m = parse_mod_items(p, token.EOF);
ret @spanned(lo, hi, rec(module=m));
let vec[@ast.crate_directive] cdirs = vec();
ret @spanned(lo, hi, rec(directives=cdirs,
module=m));
}
// Logic for parsing crate files (.rc)
@ -2276,8 +2253,6 @@ impure fn parse_crate_directive(parser p) -> ast.crate_directive
auto hi = lo;
alt (p.peek()) {
case (token.AUTH) {
// FIXME: currently dropping auth clauses on the floor,
// as there is no effect-checking pass.
p.bump();
auto n = parse_path(p, GREEDY);
expect(p, token.EQ);
@ -2288,8 +2263,6 @@ impure fn parse_crate_directive(parser p) -> ast.crate_directive
}
case (token.META) {
// FIXME: currently dropping meta clauses on the floor,
// as there is no crate metadata system
p.bump();
auto mis = parse_meta(p);
hi = p.get_span();
@ -2398,7 +2371,8 @@ impure fn parse_crate_from_crate_file(parser p) -> @ast.crate {
cdirs, prefix);
hi = p.get_span();
expect(p, token.EOF);
ret @spanned(lo, hi, rec(module=m));
ret @spanned(lo, hi, rec(directives=cdirs,
module=m));
}

87
src/comp/front/pretty.rs
View file

@ -1,87 +0,0 @@
import std._int;
import std._str;
import std._uint;
import std._vec;
export print_expr;
// FIXME this is superseded by ../pretty/pprust.rs. can it be dropped?
fn unknown() -> str {
ret "<unknown ast node>";
}
fn print_expr(@ast.expr expr) -> str {
alt (expr.node) {
case (ast.expr_lit(?lit, _)) {
ret print_lit(lit);
}
case (ast.expr_binary(?op, ?lhs, ?rhs, _)) {
ret print_expr_binary(op, lhs, rhs);
}
case (ast.expr_call(?path, ?args, _)) {
ret print_expr_call(path, args);
}
case (ast.expr_path(?path, _, _)) {
ret print_path(path);
}
case (_) {
ret unknown();
}
}
}
fn print_lit(@ast.lit lit) -> str {
alt (lit.node) {
case (ast.lit_str(?s)) {
ret "\"" + s + "\"";
}
case (ast.lit_int(?i)) {
ret _int.to_str(i, 10u);
}
case (ast.lit_uint(?u)) {
ret _uint.to_str(u, 10u);
}
case (_) {
ret unknown();
}
}
}
fn print_expr_binary(ast.binop op, @ast.expr lhs, @ast.expr rhs) -> str {
alt (op) {
case (ast.add) {
auto l = print_expr(lhs);
auto r = print_expr(rhs);
ret l + " + " + r;
}
}
}
fn print_expr_call(@ast.expr path_expr, vec[@ast.expr] args) -> str {
auto s = print_expr(path_expr);
s += "(";
fn print_expr_ref(&@ast.expr e) -> str { ret print_expr(e); }
auto mapfn = print_expr_ref;
auto argstrs = _vec.map[@ast.expr, str](mapfn, args);
s += _str.connect(argstrs, ", ");
s += ")";
ret s;
}
fn print_path(ast.path path) -> str {
ret _str.connect(path.node.idents, ".");
}
//
// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// compile-command: "make -k -C ../.. 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
// End:
//