From 3816e57fd2a8ab19e4ac6d4b3ddd5b49d5973ff2 Mon Sep 17 00:00:00 2001 From: Marijn Haverbeke Date: Thu, 12 May 2011 17:24:54 +0200 Subject: Downcase std modules again, move to :: for module dereferencing This should be a snapshot transition. --- src/comp/front/ast.rs | 63 +- src/comp/front/codemap.rs | 8 +- src/comp/front/creader.rs | 462 ++++++------- src/comp/front/eval.rs | 170 ++--- src/comp/front/extenv.rs | 47 +- src/comp/front/extfmt.rs | 210 +++--- src/comp/front/lexer.rs | 396 +++++------ src/comp/front/parser.rs | 1615 +++++++++++++++++++++++---------------------- src/comp/front/token.rs | 26 +- 9 files changed, 1500 insertions(+), 1497 deletions(-) (limited to 'src/comp/front') diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs index 84dae306..c107e7c8 100644 --- a/src/comp/front/ast.rs +++ b/src/comp/front/ast.rs @@ -1,13 +1,13 @@ -import std.Map.hashmap; -import std.Option; -import std.Str; -import std.Vec; -import util.common.span; -import util.common.spanned; -import util.common.ty_mach; -import util.common.filename; -import util.typestate_ann.ts_ann; +import std::map::hashmap; +import std::option; +import std::_str; +import std::_vec; +import util::common::span; +import util::common::spanned; +import util::common::ty_mach; +import util::common::filename; +import util::typestate_ann::ts_ann; type ident = str; @@ -25,9 +25,9 @@ type ty_param = ident; tag ann { ann_none(uint); ann_type(uint, - middle.ty.t, - Option.t[vec[middle.ty.t]], /* ty param substs */ - Option.t[@ts_ann]); /* pre- and postcondition for typestate */ + middle::ty::t, + option::t[vec[middle::ty::t]], /* ty param substs */ + option::t[@ts_ann]); /* pre- and postcondition for typestate */ } fn ann_tag(&ann a) -> uint { @@ -96,8 +96,8 @@ tag crate_directive_ { // and redirected to the use of const stmt_decls inside // crate directive blocks. cdir_let(ident, @expr, vec[@crate_directive]); - cdir_src_mod(ident, Option.t[filename]); - cdir_dir_mod(ident, Option.t[filename], vec[@crate_directive]); + cdir_src_mod(ident, option::t[filename]); + cdir_dir_mod(ident, option::t[filename], vec[@crate_directive]); cdir_view_item(@view_item); cdir_meta(vec[@meta_item]); cdir_syntax(path); @@ -111,7 +111,7 @@ type meta_item_ = rec(ident name, str value); type block = spanned[block_]; type block_ = rec(vec[@stmt] stmts, - Option.t[@expr] expr, + option::t[@expr] expr, ann a); /* ann is only meaningful for the ts_ann field */ type pat = spanned[pat_]; @@ -234,10 +234,10 @@ tag init_op { type initializer = rec(init_op op, @expr expr); -type local = rec(Option.t[@ty] ty, +type local = rec(option::t[@ty] ty, bool infer, ident ident, - Option.t[initializer] init, + option::t[initializer] init, def_id id, ann ann); @@ -261,16 +261,16 @@ type expr = spanned[expr_]; tag expr_ { expr_vec(vec[@expr], mutability, ann); expr_tup(vec[elt], ann); - expr_rec(vec[field], Option.t[@expr], ann); + expr_rec(vec[field], option::t[@expr], ann); expr_call(@expr, vec[@expr], ann); expr_self_method(ident, ann); - expr_bind(@expr, vec[Option.t[@expr]], ann); - expr_spawn(spawn_dom, Option.t[str], @expr, vec[@expr], ann); + expr_bind(@expr, vec[option::t[@expr]], ann); + expr_spawn(spawn_dom, option::t[str], @expr, vec[@expr], ann); expr_binary(binop, @expr, @expr, ann); expr_unary(unop, @expr, ann); expr_lit(@lit, ann); expr_cast(@expr, @ty, ann); - expr_if(@expr, block, Option.t[@expr], ann); + expr_if(@expr, block, option::t[@expr], ann); expr_while(@expr, block, ann); expr_for(@decl, @expr, block, ann); expr_for_each(@decl, @expr, block, ann); @@ -284,12 +284,12 @@ tag expr_ { expr_field(@expr, ident, ann); expr_index(@expr, @expr, ann); expr_path(path, ann); - expr_ext(path, vec[@expr], Option.t[str], @expr, ann); + expr_ext(path, vec[@expr], option::t[str], @expr, ann); expr_fail(ann); expr_break(ann); expr_cont(ann); - expr_ret(Option.t[@expr], ann); - expr_put(Option.t[@expr], ann); + expr_ret(option::t[@expr], ann); + expr_put(option::t[@expr], ann); expr_be(@expr, ann); expr_log(int, @expr, ann); /* just an assert, no significance to typestate */ @@ -328,7 +328,7 @@ tag ty_ { ty_int; ty_uint; ty_float; - ty_machine(util.common.ty_mach); + ty_machine(util::common::ty_mach); ty_char; ty_str; ty_box(mt); @@ -365,14 +365,13 @@ type _fn = rec(fn_decl decl, proto proto, block body); - type method_ = rec(ident ident, _fn meth, def_id id, ann ann); type method = spanned[method_]; type obj_field = rec(@ty ty, ident ident, def_id id, ann ann); type _obj = rec(vec[obj_field] fields, vec[@method] methods, - Option.t[@method] dtor); + option::t[@method] dtor); type _mod = rec(vec[@view_item] view_items, vec[@item] items); @@ -395,7 +394,7 @@ type variant = spanned[variant_]; type view_item = spanned[view_item_]; tag view_item_ { - view_item_use(ident, vec[@meta_item], def_id, Option.t[int]); + view_item_use(ident, vec[@meta_item], def_id, option::t[int]); view_item_import(ident, vec[ident], def_id); view_item_export(ident); } @@ -428,16 +427,16 @@ fn item_ident(@item it) -> ident { type native_item = spanned[native_item_]; tag native_item_ { native_item_ty(ident, def_id); - native_item_fn(ident, Option.t[str], + native_item_fn(ident, option::t[str], fn_decl, vec[ty_param], def_id, ann); } fn is_exported(ident i, _mod m) -> bool { auto count = 0; - for (@ast.view_item vi in m.view_items) { + for (@ast::view_item vi in m.view_items) { alt (vi.node) { - case (ast.view_item_export(?id)) { - if (Str.eq(i, id)) { + case (ast::view_item_export(?id)) { + if (_str::eq(i, id)) { ret true; } count += 1; diff --git a/src/comp/front/codemap.rs b/src/comp/front/codemap.rs index 578f574b..c474fa07 100644 --- a/src/comp/front/codemap.rs +++ b/src/comp/front/codemap.rs @@ -1,4 +1,4 @@ -import std.Vec; +import std::_vec; /* A codemap is a thing that maps uints to file/line/column positions * in a crate. This to make it possible to represent the positions @@ -24,18 +24,18 @@ fn new_filemap(str filename, uint start_pos) -> filemap { } fn next_line(filemap file, uint pos) { - Vec.push[uint](file.lines, pos); + _vec::push[uint](file.lines, pos); } fn lookup_pos(codemap map, uint pos) -> loc { - auto a = 0u; auto b = Vec.len[filemap](map.files); + auto a = 0u; auto b = _vec::len[filemap](map.files); while (b - a > 1u) { auto m = (a + b) / 2u; if (map.files.(m).start_pos > pos) { b = m; } else { a = m; } } auto f = map.files.(a); - a = 0u; b = Vec.len[uint](f.lines); + a = 0u; b = _vec::len[uint](f.lines); while (b - a > 1u) { auto m = (a + b) / 2u; if (f.lines.(m) > pos) { b = m; } diff --git a/src/comp/front/creader.rs b/src/comp/front/creader.rs index 5ae56417..03b5cb1e 100644 --- a/src/comp/front/creader.rs +++ b/src/comp/front/creader.rs @@ -1,56 +1,56 @@ // -*- rust -*- -import driver.session; -import front.ast; -import lib.llvm.False; -import lib.llvm.llvm; -import lib.llvm.mk_object_file; -import lib.llvm.mk_section_iter; -import middle.fold; -import middle.metadata; -import middle.trans; -import middle.ty; -import back.x86; -import util.common; -import util.common.span; - -import std.Str; -import std.UInt; -import std.Vec; -import std.EBML; -import std.FS; -import std.IO; -import std.Option; -import std.Option.none; -import std.Option.some; -import std.OS; -import std.Map.hashmap; +import driver::session; +import front::ast; +import lib::llvm::False; +import lib::llvm::llvm; +import lib::llvm::mk_object_file; +import lib::llvm::mk_section_iter; +import middle::fold; +import middle::metadata; +import middle::trans; +import middle::ty; +import back::x86; +import util::common; +import util::common::span; + +import std::_str; +import std::_uint; +import std::_vec; +import std::ebml; +import std::fs; +import std::io; +import std::option; +import std::option::none; +import std::option::some; +import std::os; +import std::map::hashmap; // TODO: map to a real type here. type env = @rec( - session.session sess, + session::session sess, @hashmap[str, int] crate_cache, vec[str] library_search_paths, mutable int next_crate_num ); tag resolve_result { - rr_ok(ast.def_id); - rr_not_found(ast.ident); + rr_ok(ast::def_id); + rr_not_found(ast::ident); } // Type decoding -// Compact string representation for ty.t values. API ty_str & parse_from_str. +// Compact string representation for ty::t values. API ty_str & parse_from_str // (The second has to be authed pure.) Extra parameters are for converting // to/from def_ids in the data buffer. Whatever format you choose should not // contain pipe characters. -// Callback to translate defs to strs or back. -type str_def = fn(str) -> ast.def_id; +// Callback to translate defs to strs or back: +type str_def = fn(str) -> ast::def_id; type pstate = rec(vec[u8] data, int crate, - mutable uint pos, uint len, ty.ctxt tcx); + mutable uint pos, uint len, ty::ctxt tcx); fn peek(@pstate st) -> u8 { ret st.data.(st.pos); @@ -62,105 +62,105 @@ fn next(@pstate st) -> u8 { } fn parse_ty_data(vec[u8] data, int crate_num, uint pos, uint len, - str_def sd, ty.ctxt tcx) -> ty.t { + str_def sd, ty::ctxt tcx) -> ty::t { auto st = @rec(data=data, crate=crate_num, mutable pos=pos, len=len, tcx=tcx); auto result = parse_ty(st, sd); ret result; } -fn parse_ty(@pstate st, str_def sd) -> ty.t { +fn parse_ty(@pstate st, str_def sd) -> ty::t { alt (next(st) as char) { - case ('n') { ret ty.mk_nil(st.tcx); } - case ('b') { ret ty.mk_bool(st.tcx); } - case ('i') { ret ty.mk_int(st.tcx); } - case ('u') { ret ty.mk_uint(st.tcx); } - case ('l') { ret ty.mk_float(st.tcx); } + case ('n') { ret ty::mk_nil(st.tcx); } + case ('b') { ret ty::mk_bool(st.tcx); } + case ('i') { ret ty::mk_int(st.tcx); } + case ('u') { ret ty::mk_uint(st.tcx); } + case ('l') { ret ty::mk_float(st.tcx); } case ('M') { alt (next(st) as char) { - case ('b') { ret ty.mk_mach(st.tcx, common.ty_u8); } - case ('w') { ret ty.mk_mach(st.tcx, common.ty_u16); } - case ('l') { ret ty.mk_mach(st.tcx, common.ty_u32); } - case ('d') { ret ty.mk_mach(st.tcx, common.ty_u64); } - case ('B') { ret ty.mk_mach(st.tcx, common.ty_i8); } - case ('W') { ret ty.mk_mach(st.tcx, common.ty_i16); } - case ('L') { ret ty.mk_mach(st.tcx, common.ty_i32); } - case ('D') { ret ty.mk_mach(st.tcx, common.ty_i64); } - case ('f') { ret ty.mk_mach(st.tcx, common.ty_f32); } - case ('F') { ret ty.mk_mach(st.tcx, common.ty_f64); } + case ('b') { ret ty::mk_mach(st.tcx, common::ty_u8); } + case ('w') { ret ty::mk_mach(st.tcx, common::ty_u16); } + case ('l') { ret ty::mk_mach(st.tcx, common::ty_u32); } + case ('d') { ret ty::mk_mach(st.tcx, common::ty_u64); } + case ('B') { ret ty::mk_mach(st.tcx, common::ty_i8); } + case ('W') { ret ty::mk_mach(st.tcx, common::ty_i16); } + case ('L') { ret ty::mk_mach(st.tcx, common::ty_i32); } + case ('D') { ret ty::mk_mach(st.tcx, common::ty_i64); } + case ('f') { ret ty::mk_mach(st.tcx, common::ty_f32); } + case ('F') { ret ty::mk_mach(st.tcx, common::ty_f64); } } } - case ('c') { ret ty.mk_char(st.tcx); } - case ('s') { ret ty.mk_str(st.tcx); } + case ('c') { ret ty::mk_char(st.tcx); } + case ('s') { ret ty::mk_str(st.tcx); } case ('t') { assert (next(st) as char == '['); auto def = parse_def(st, sd); - let vec[ty.t] params = vec(); + let vec[ty::t] params = vec(); while (peek(st) as char != ']') { params += vec(parse_ty(st, sd)); } st.pos = st.pos + 1u; - ret ty.mk_tag(st.tcx, def, params); + ret ty::mk_tag(st.tcx, def, params); } - case ('p') { ret ty.mk_param(st.tcx, parse_int(st) as uint); } - case ('@') { ret ty.mk_box(st.tcx, parse_mt(st, sd)); } - case ('V') { ret ty.mk_vec(st.tcx, parse_mt(st, sd)); } - case ('P') { ret ty.mk_port(st.tcx, parse_ty(st, sd)); } - case ('C') { ret ty.mk_chan(st.tcx, parse_ty(st, sd)); } + case ('p') { ret ty::mk_param(st.tcx, parse_int(st) as uint); } + case ('@') { ret ty::mk_box(st.tcx, parse_mt(st, sd)); } + case ('V') { ret ty::mk_vec(st.tcx, parse_mt(st, sd)); } + case ('P') { ret ty::mk_port(st.tcx, parse_ty(st, sd)); } + case ('C') { ret ty::mk_chan(st.tcx, parse_ty(st, sd)); } case ('T') { assert (next(st) as char == '['); - let vec[ty.mt] params = vec(); + let vec[ty::mt] params = vec(); while (peek(st) as char != ']') { params += vec(parse_mt(st, sd)); } st.pos = st.pos + 1u; - ret ty.mk_tup(st.tcx, params); + ret ty::mk_tup(st.tcx, params); } case ('R') { assert (next(st) as char == '['); - let vec[ty.field] fields = vec(); + let vec[ty::field] fields = vec(); while (peek(st) as char != ']') { auto name = ""; while (peek(st) as char != '=') { - name += Str.unsafe_from_byte(next(st)); + name += _str::unsafe_from_byte(next(st)); } st.pos = st.pos + 1u; fields += vec(rec(ident=name, mt=parse_mt(st, sd))); } st.pos = st.pos + 1u; - ret ty.mk_rec(st.tcx, fields); + ret ty::mk_rec(st.tcx, fields); } case ('F') { auto func = parse_ty_fn(st, sd); - ret ty.mk_fn(st.tcx, ast.proto_fn, func._0, func._1); + ret ty::mk_fn(st.tcx, ast::proto_fn, func._0, func._1); } case ('W') { auto func = parse_ty_fn(st, sd); - ret ty.mk_fn(st.tcx, ast.proto_iter, func._0, func._1); + ret ty::mk_fn(st.tcx, ast::proto_iter, func._0, func._1); } case ('N') { auto abi; alt (next(st) as char) { - case ('r') { abi = ast.native_abi_rust; } - case ('i') { abi = ast.native_abi_rust_intrinsic; } - case ('c') { abi = ast.native_abi_cdecl; } - case ('l') { abi = ast.native_abi_llvm; } + case ('r') { abi = ast::native_abi_rust; } + case ('i') { abi = ast::native_abi_rust_intrinsic; } + case ('c') { abi = ast::native_abi_cdecl; } + case ('l') { abi = ast::native_abi_llvm; } } auto func = parse_ty_fn(st, sd); - ret ty.mk_native_fn(st.tcx,abi,func._0,func._1); + ret ty::mk_native_fn(st.tcx,abi,func._0,func._1); } case ('O') { assert (next(st) as char == '['); - let vec[ty.method] methods = vec(); + let vec[ty::method] methods = vec(); while (peek(st) as char != ']') { auto proto; alt (next(st) as char) { - case ('W') {proto = ast.proto_iter;} - case ('F') {proto = ast.proto_fn;} + case ('W') {proto = ast::proto_iter;} + case ('F') {proto = ast::proto_fn;} } auto name = ""; while (peek(st) as char != '[') { - name += Str.unsafe_from_byte(next(st)); + name += _str::unsafe_from_byte(next(st)); } auto func = parse_ty_fn(st, sd); methods += vec(rec(proto=proto, @@ -169,19 +169,19 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t { output=func._1)); } st.pos += 1u; - ret ty.mk_obj(st.tcx, methods); + ret ty::mk_obj(st.tcx, methods); } - case ('X') { ret ty.mk_var(st.tcx, parse_int(st)); } - case ('E') { ret ty.mk_native(st.tcx); } - case ('Y') { ret ty.mk_type(st.tcx); } + case ('X') { ret ty::mk_var(st.tcx, parse_int(st)); } + case ('E') { ret ty::mk_native(st.tcx); } + case ('Y') { ret ty::mk_type(st.tcx); } case ('#') { auto pos = parse_hex(st); assert (next(st) as char == ':'); auto len = parse_hex(st); assert (next(st) as char == '#'); alt (st.tcx.rcache.find(tup(st.crate,pos,len))) { - case (some[ty.t](?tt)) { ret tt; } - case (none[ty.t]) { + case (some[ty::t](?tt)) { ret tt; } + case (none[ty::t]) { auto ps = @rec(pos=pos, len=len with *st); auto tt = parse_ty(ps, sd); st.tcx.rcache.insert(tup(st.crate,pos,len), tt); @@ -197,20 +197,20 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t { } } -fn parse_mt(@pstate st, str_def sd) -> ty.mt { +fn parse_mt(@pstate st, str_def sd) -> ty::mt { auto mut; alt (peek(st) as char) { - case ('m') {next(st); mut = ast.mut;} - case ('?') {next(st); mut = ast.maybe_mut;} - case (_) {mut=ast.imm;} + case ('m') {next(st); mut = ast::mut;} + case ('?') {next(st); mut = ast::maybe_mut;} + case (_) {mut=ast::imm;} } ret rec(ty=parse_ty(st, sd), mut=mut); } -fn parse_def(@pstate st, str_def sd) -> ast.def_id { +fn parse_def(@pstate st, str_def sd) -> ast::def_id { auto def = ""; while (peek(st) as char != '|') { - def += Str.unsafe_from_byte(next(st)); + def += _str::unsafe_from_byte(next(st)); } st.pos = st.pos + 1u; ret sd(def); @@ -245,13 +245,13 @@ fn parse_hex(@pstate st) -> uint { ret n; } -fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty.arg], ty.t) { +fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty::arg], ty::t) { assert (next(st) as char == '['); - let vec[ty.arg] inputs = vec(); + let vec[ty::arg] inputs = vec(); while (peek(st) as char != ']') { - auto mode = ty.mo_val; + auto mode = ty::mo_val; if (peek(st) as char == '&') { - mode = ty.mo_alias; + mode = ty::mo_alias; st.pos = st.pos + 1u; } inputs += vec(rec(mode=mode, ty=parse_ty(st, sd))); @@ -263,9 +263,9 @@ fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty.arg], ty.t) { // Rust metadata parsing -fn parse_def_id(vec[u8] buf) -> ast.def_id { +fn parse_def_id(vec[u8] buf) -> ast::def_id { auto colon_idx = 0u; - auto len = Vec.len[u8](buf); + auto len = _vec::len[u8](buf); while (colon_idx < len && buf.(colon_idx) != (':' as u8)) { colon_idx += 1u; } @@ -274,30 +274,31 @@ fn parse_def_id(vec[u8] buf) -> ast.def_id { fail; } - auto crate_part = Vec.slice[u8](buf, 0u, colon_idx); - auto def_part = Vec.slice[u8](buf, colon_idx + 1u, len); - auto crate_num = UInt.parse_buf(crate_part, 10u) as int; - auto def_num = UInt.parse_buf(def_part, 10u) as int; + auto crate_part = _vec::slice[u8](buf, 0u, colon_idx); + auto def_part = _vec::slice[u8](buf, colon_idx + 1u, len); + auto crate_num = _uint::parse_buf(crate_part, 10u) as int; + auto def_num = _uint::parse_buf(def_part, 10u) as int; ret tup(crate_num, def_num); } -fn lookup_hash(&EBML.doc d, fn(vec[u8]) -> bool eq_fn, uint hash) - -> Option.t[EBML.doc] { - auto index = EBML.get_doc(d, metadata.tag_index); - auto table = EBML.get_doc(index, metadata.tag_index_table); +fn lookup_hash(&ebml::doc d, fn(vec[u8]) -> bool eq_fn, uint hash) + -> option::t[ebml::doc] { + auto index = ebml::get_doc(d, metadata::tag_index); + auto table = ebml::get_doc(index, metadata::tag_index_table); auto hash_pos = table.start + (hash % 256u) * 4u; - auto pos = EBML.be_uint_from_bytes(d.data, hash_pos, 4u); - auto bucket = EBML.doc_at(d.data, pos); + auto pos = ebml::be_uint_from_bytes(d.data, hash_pos, 4u); + auto bucket = ebml::doc_at(d.data, pos); // Awkward logic because we can't ret from foreach yet - auto result = Option.none[EBML.doc]; - auto belt = metadata.tag_index_buckets_bucket_elt; - for each (EBML.doc elt in EBML.tagged_docs(bucket, belt)) { + auto result = option::none[ebml::doc]; + auto belt = metadata::tag_index_buckets_bucket_elt; + for each (ebml::doc elt in ebml::tagged_docs(bucket, belt)) { alt (result) { - case (Option.none[EBML.doc]) { - auto pos = EBML.be_uint_from_bytes(elt.data, elt.start, 4u); - if (eq_fn(Vec.slice[u8](elt.data, elt.start+4u, elt.end))) { - result = Option.some[EBML.doc](EBML.doc_at(d.data, pos)); + case (option::none[ebml::doc]) { + auto pos = ebml::be_uint_from_bytes(elt.data, elt.start, 4u); + if (eq_fn(_vec::slice[u8](elt.data, elt.start+4u, elt.end))) { + result = option::some[ebml::doc] + (ebml::doc_at(d.data, pos)); } } case (_) {} @@ -308,127 +309,127 @@ fn lookup_hash(&EBML.doc d, fn(vec[u8]) -> bool eq_fn, uint hash) // Given a path and serialized crate metadata, returns the ID of the // definition the path refers to. -fn resolve_path(vec[ast.ident] path, vec[u8] data) -> resolve_result { +fn resolve_path(vec[ast::ident] path, vec[u8] data) -> resolve_result { fn eq_item(vec[u8] data, str s) -> bool { - ret Str.eq(Str.unsafe_from_bytes(data), s); + ret _str::eq(_str::unsafe_from_bytes(data), s); } - auto s = Str.connect(path, "::"); - auto md = EBML.new_doc(data); - auto paths = EBML.get_doc(md, metadata.tag_paths); + auto s = _str::connect(path, "::"); + auto md = ebml::new_doc(data); + auto paths = ebml::get_doc(md, metadata::tag_paths); auto eqer = bind eq_item(_, s); - alt (lookup_hash(paths, eqer, metadata.hash_path(s))) { - case (Option.some[EBML.doc](?d)) { - auto did_doc = EBML.get_doc(d, metadata.tag_def_id); - ret rr_ok(parse_def_id(EBML.doc_data(did_doc))); + alt (lookup_hash(paths, eqer, metadata::hash_path(s))) { + case (option::some[ebml::doc](?d)) { + auto did_doc = ebml::get_doc(d, metadata::tag_def_id); + ret rr_ok(parse_def_id(ebml::doc_data(did_doc))); } - case (Option.none[EBML.doc]) { + case (option::none[ebml::doc]) { ret rr_not_found(s); } } } -fn maybe_find_item(int item_id, &EBML.doc items) -> Option.t[EBML.doc] { +fn maybe_find_item(int item_id, &ebml::doc items) -> option::t[ebml::doc] { fn eq_item(vec[u8] bytes, int item_id) -> bool { - ret EBML.be_uint_from_bytes(bytes, 0u, 4u) as int == item_id; + ret ebml::be_uint_from_bytes(bytes, 0u, 4u) as int == item_id; } auto eqer = bind eq_item(_, item_id); - ret lookup_hash(items, eqer, metadata.hash_def_num(item_id)); + ret lookup_hash(items, eqer, metadata::hash_def_num(item_id)); } -fn find_item(int item_id, &EBML.doc items) -> EBML.doc { +fn find_item(int item_id, &ebml::doc items) -> ebml::doc { alt (maybe_find_item(item_id, items)) { - case (Option.some[EBML.doc](?d)) {ret d;} + case (option::some[ebml::doc](?d)) {ret d;} } } -// Looks up an item in the given metadata and returns an EBML doc pointing +// Looks up an item in the given metadata and returns an ebml doc pointing // to the item data. -fn lookup_item(int item_id, vec[u8] data) -> EBML.doc { - auto items = EBML.get_doc(EBML.new_doc(data), metadata.tag_items); +fn lookup_item(int item_id, vec[u8] data) -> ebml::doc { + auto items = ebml::get_doc(ebml::new_doc(data), metadata::tag_items); ret find_item(item_id, items); } -fn item_kind(&EBML.doc item) -> u8 { - auto kind = EBML.get_doc(item, metadata.tag_items_data_item_kind); - ret EBML.doc_as_uint(kind) as u8; +fn item_kind(&ebml::doc item) -> u8 { + auto kind = ebml::get_doc(item, metadata::tag_items_data_item_kind); + ret ebml::doc_as_uint(kind) as u8; } -fn item_symbol(&EBML.doc item) -> str { - auto sym = EBML.get_doc(item, metadata.tag_items_data_item_symbol); - ret Str.unsafe_from_bytes(EBML.doc_data(sym)); +fn item_symbol(&ebml::doc item) -> str { + auto sym = ebml::get_doc(item, metadata::tag_items_data_item_symbol); + ret _str::unsafe_from_bytes(ebml::doc_data(sym)); } -fn variant_tag_id(&EBML.doc d) -> ast.def_id { - auto tagdoc = EBML.get_doc(d, metadata.tag_items_data_item_tag_id); - ret parse_def_id(EBML.doc_data(tagdoc)); +fn variant_tag_id(&ebml::doc d) -> ast::def_id { + auto tagdoc = ebml::get_doc(d, metadata::tag_items_data_item_tag_id); + ret parse_def_id(ebml::doc_data(tagdoc)); } -fn item_type(&EBML.doc item, int this_cnum, ty.ctxt tcx) -> ty.t { - fn parse_external_def_id(int this_cnum, str s) -> ast.def_id { +fn item_type(&ebml::doc item, int this_cnum, ty::ctxt tcx) -> ty::t { + fn parse_external_def_id(int this_cnum, str s) -> ast::def_id { // FIXME: This is completely wrong when linking against a crate // that, in turn, links against another crate. We need a mapping // from crate ID to crate "meta" attributes as part of the crate - // metadata. - auto buf = Str.bytes(s); + // metadata: + auto buf = _str::bytes(s); auto external_def_id = parse_def_id(buf); ret tup(this_cnum, external_def_id._1); } - auto tp = EBML.get_doc(item, metadata.tag_items_data_item_type); - auto s = Str.unsafe_from_bytes(EBML.doc_data(tp)); + auto tp = ebml::get_doc(item, metadata::tag_items_data_item_type); + auto s = _str::unsafe_from_bytes(ebml::doc_data(tp)); ret parse_ty_data(item.data, this_cnum, tp.start, tp.end - tp.start, bind parse_external_def_id(this_cnum, _), tcx); } -fn item_ty_param_count(&EBML.doc item, int this_cnum) -> uint { +fn item_ty_param_count(&ebml::doc item, int this_cnum) -> uint { let uint ty_param_count = 0u; - auto tp = metadata.tag_items_data_item_ty_param_count; - for each (EBML.doc p in EBML.tagged_docs(item, tp)) { - ty_param_count = EBML.vint_at(EBML.doc_data(p), 0u)._0; + auto tp = metadata::tag_items_data_item_ty_param_count; + for each (ebml::doc p in ebml::tagged_docs(item, tp)) { + ty_param_count = ebml::vint_at(ebml::doc_data(p), 0u)._0; } ret ty_param_count; } -fn tag_variant_ids(&EBML.doc item, int this_cnum) -> vec[ast.def_id] { - let vec[ast.def_id] ids = vec(); - auto v = metadata.tag_items_data_item_variant; - for each (EBML.doc p in EBML.tagged_docs(item, v)) { - auto ext = parse_def_id(EBML.doc_data(p)); - Vec.push[ast.def_id](ids, tup(this_cnum, ext._1)); +fn tag_variant_ids(&ebml::doc item, int this_cnum) -> vec[ast::def_id] { + let vec[ast::def_id] ids = vec(); + auto v = metadata::tag_items_data_item_variant; + for each (ebml::doc p in ebml::tagged_docs(item, v)) { + auto ext = parse_def_id(ebml::doc_data(p)); + _vec::push[ast::def_id](ids, tup(this_cnum, ext._1)); } ret ids; } -fn get_metadata_section(str filename) -> Option.t[vec[u8]] { - auto mb = llvm.LLVMRustCreateMemoryBufferWithContentsOfFile - (Str.buf(filename)); - if (mb as int == 0) {ret Option.none[vec[u8]];} +fn get_metadata_section(str filename) -> option::t[vec[u8]] { + auto mb = llvm::LLVMRustCreateMemoryBufferWithContentsOfFile + (_str::buf(filename)); + if (mb as int == 0) {ret option::none[vec[u8]];} auto of = mk_object_file(mb); auto si = mk_section_iter(of.llof); - while (llvm.LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False) { - auto name_buf = llvm.LLVMGetSectionName(si.llsi); - auto name = Str.str_from_cstr(name_buf); - if (Str.eq(name, x86.get_meta_sect_name())) { - auto cbuf = llvm.LLVMGetSectionContents(si.llsi); - auto csz = llvm.LLVMGetSectionSize(si.llsi); - auto cvbuf = cbuf as Vec.vbuf; - ret Option.some[vec[u8]](Vec.vec_from_vbuf[u8](cvbuf, csz)); + while (llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False) { + auto name_buf = llvm::LLVMGetSectionName(si.llsi); + auto name = _str::str_from_cstr(name_buf); + if (_str::eq(name, x86::get_meta_sect_name())) { + auto cbuf = llvm::LLVMGetSectionContents(si.llsi); + auto csz = llvm::LLVMGetSectionSize(si.llsi); + auto cvbuf = cbuf as _vec::vbuf; + ret option::some[vec[u8]](_vec::vec_from_vbuf[u8](cvbuf, csz)); } - llvm.LLVMMoveToNextSection(si.llsi); + llvm::LLVMMoveToNextSection(si.llsi); } - ret Option.none[vec[u8]]; + ret option::none[vec[u8]]; } -fn load_crate(session.session sess, +fn load_crate(session::session sess, int cnum, - ast.ident ident, + ast::ident ident, vec[str] library_search_paths) { - auto filename = parser.default_native_name(sess, ident); + auto filename = parser::default_native_name(sess, ident); for (str library_search_path in library_search_paths) { - auto path = FS.connect(library_search_path, filename); + auto path = fs::connect(library_search_path, filename); alt (get_metadata_section(path)) { - case (Option.some[vec[u8]](?cvec)) { + case (option::some[vec[u8]](?cvec)) { sess.set_external_crate(cnum, rec(name=ident, data=cvec)); ret; } @@ -441,10 +442,10 @@ fn load_crate(session.session sess, fail; } -fn fold_view_item_use(&env e, &span sp, &ast.ident ident, - &vec[@ast.meta_item] meta_items, - &ast.def_id id, &Option.t[int] cnum_opt) - -> @ast.view_item { +fn fold_view_item_use(&env e, &span sp, &ast::ident ident, + &vec[@ast::meta_item] meta_items, + &ast::def_id id, &option::t[int] cnum_opt) + -> @ast::view_item { auto cnum; if (!e.crate_cache.contains_key(ident)) { cnum = e.next_crate_num; @@ -455,23 +456,24 @@ fn fold_view_item_use(&env e, &span sp, &ast.ident ident, cnum = e.crate_cache.get(ident); } - auto viu = ast.view_item_use(ident, meta_items, id, some[int](cnum)); - ret @fold.respan[ast.view_item_](sp, viu); + auto viu = ast::view_item_use(ident, meta_items, id, some[int](cnum)); + ret @fold::respan[ast::view_item_](sp, viu); } // Reads external crates referenced by "use" directives. -fn read_crates(session.session sess, - @ast.crate crate) -> @ast.crate { +fn read_crates(session::session sess, + @ast::crate crate) -> @ast::crate { auto e = @rec( sess=sess, - crate_cache=@common.new_str_hash[int](), + crate_cache=@common::new_str_hash[int](), library_search_paths=sess.get_opts().library_search_paths, mutable next_crate_num=1 ); auto f = fold_view_item_use; - auto fld = @rec(fold_view_item_use=f with *fold.new_identity_fold[env]()); - ret fold.fold_crate[env](e, fld, crate); + auto fld = @rec(fold_view_item_use=f + with *fold::new_identity_fold[env]()); + ret fold::fold_crate[env](e, fld, crate); } @@ -497,15 +499,15 @@ fn kind_has_type_params(u8 kind_ch) -> bool { // Crate metadata queries -fn lookup_def(session.session sess, int cnum, vec[ast.ident] path) - -> Option.t[ast.def] { +fn lookup_def(session::session sess, int cnum, vec[ast::ident] path) + -> option::t[ast::def] { auto data = sess.get_external_crate(cnum).data; auto did; alt (resolve_path(path, data)) { case (rr_ok(?di)) { did = di; } case (rr_not_found(?name)) { - ret none[ast.def]; + ret none[ast::def]; } } @@ -516,31 +518,31 @@ fn lookup_def(session.session sess, int cnum, vec[ast.ident] path) // FIXME: It'd be great if we had u8 char literals. auto def; - if (kind_ch == ('c' as u8)) { def = ast.def_const(did); } - else if (kind_ch == ('f' as u8)) { def = ast.def_fn(did); } - else if (kind_ch == ('F' as u8)) { def = ast.def_native_fn(did); } - else if (kind_ch == ('y' as u8)) { def = ast.def_ty(did); } - else if (kind_ch == ('o' as u8)) { def = ast.def_obj(did); } - else if (kind_ch == ('T' as u8)) { def = ast.def_native_ty(did); } + if (kind_ch == ('c' as u8)) { def = ast::def_const(did); } + else if (kind_ch == ('f' as u8)) { def = ast::def_fn(did); } + else if (kind_ch == ('F' as u8)) { def = ast::def_native_fn(did); } + else if (kind_ch == ('y' as u8)) { def = ast::def_ty(did); } + else if (kind_ch == ('o' as u8)) { def = ast::def_obj(did); } + else if (kind_ch == ('T' as u8)) { def = ast::def_native_ty(did); } else if (kind_ch == ('t' as u8)) { // We treat references to tags as references to types. - def = ast.def_ty(did); - } else if (kind_ch == ('m' as u8)) { def = ast.def_mod(did); } - else if (kind_ch == ('n' as u8)) { def = ast.def_native_mod(did); } + def = ast::def_ty(did); + } else if (kind_ch == ('m' as u8)) { def = ast::def_mod(did); } + else if (kind_ch == ('n' as u8)) { def = ast::def_native_mod(did); } else if (kind_ch == ('v' as u8)) { auto tid = variant_tag_id(item); tid = tup(cnum, tid._1); - def = ast.def_variant(tid, did); + def = ast::def_variant(tid, did); } else { log_err #fmt("lookup_def(): unknown kind char: %d", kind_ch as int); fail; } - ret some[ast.def](def); + ret some[ast::def](def); } -fn get_type(session.session sess, ty.ctxt tcx, ast.def_id def) - -> ty.ty_param_count_and_ty { +fn get_type(session::session sess, ty::ctxt tcx, ast::def_id def) + -> ty::ty_param_count_and_ty { auto external_crate_id = def._0; auto data = sess.get_external_crate(external_crate_id).data; auto item = lookup_item(def._1, data); @@ -558,29 +560,29 @@ fn get_type(session.session sess, ty.ctxt tcx, ast.def_id def) ret tup(tp_count, t); } -fn get_symbol(session.session sess, ast.def_id def) -> str { +fn get_symbol(session::session sess, ast::def_id def) -> str { auto external_crate_id = def._0; auto data = sess.get_external_crate(external_crate_id).data; auto item = lookup_item(def._1, data); ret item_symbol(item); } -fn get_tag_variants(session.session sess, ty.ctxt tcx, ast.def_id def) - -> vec[trans.variant_info] { +fn get_tag_variants(session::session sess, ty::ctxt tcx, ast::def_id def) + -> vec[trans::variant_info] { auto external_crate_id = def._0; auto data = sess.get_external_crate(external_crate_id).data; - auto items = EBML.get_doc(EBML.new_doc(data), metadata.tag_items); + auto items = ebml::get_doc(ebml::new_doc(data), metadata::tag_items); auto item = find_item(def._1, items); - let vec[trans.variant_info] infos = vec(); + let vec[trans::variant_info] infos = vec(); auto variant_ids = tag_variant_ids(item, external_crate_id); - for (ast.def_id did in variant_ids) { + for (ast::def_id did in variant_ids) { auto item = find_item(did._1, items); auto ctor_ty = item_type(item, external_crate_id, tcx); - let vec[ty.t] arg_tys = vec(); - alt (ty.struct(tcx, ctor_ty)) { - case (ty.ty_fn(_, ?args, _)) { - for (ty.arg a in args) { + let vec[ty::t] arg_tys = vec(); + alt (ty::struct(tcx, ctor_ty)) { + case (ty::ty_fn(_, ?args, _)) { + for (ty::arg a in args) { arg_tys += vec(a.ty); } } @@ -594,46 +596,46 @@ fn get_tag_variants(session.session sess, ty.ctxt tcx, ast.def_id def) ret infos; } -fn list_file_metadata(str path, IO.writer out) { +fn list_file_metadata(str path, io::writer out) { alt (get_metadata_section(path)) { - case (Option.some[vec[u8]](?bytes)) { + case (option::some[vec[u8]](?bytes)) { list_crate_metadata(bytes, out); } - case (Option.none[vec[u8]]) { + case (option::none[vec[u8]]) { out.write_str("Could not find metadata in " + path + ".\n"); } } } -fn read_path(&EBML.doc d) -> tup(str, uint) { - auto desc = EBML.doc_data(d); - auto pos = EBML.be_uint_from_bytes(desc, 0u, 4u); - auto pathbytes = Vec.slice[u8](desc, 4u, Vec.len[u8](desc)); - auto path = Str.unsafe_from_bytes(pathbytes); +fn read_path(&ebml::doc d) -> tup(str, uint) { + auto desc = ebml::doc_data(d); + auto pos = ebml::be_uint_from_bytes(desc, 0u, 4u); + auto pathbytes = _vec::slice[u8](desc, 4u, _vec::len[u8](desc)); + auto path = _str::unsafe_from_bytes(pathbytes); ret tup(path, pos); } -fn list_crate_metadata(vec[u8] bytes, IO.writer out) { - auto md = EBML.new_doc(bytes); - auto paths = EBML.get_doc(md, metadata.tag_paths); - auto items = EBML.get_doc(md, metadata.tag_items); - auto index = EBML.get_doc(paths, metadata.tag_index); - auto bs = EBML.get_doc(index, metadata.tag_index_buckets); - for each (EBML.doc bucket in - EBML.tagged_docs(bs, metadata.tag_index_buckets_bucket)) { - auto et = metadata.tag_index_buckets_bucket_elt; - for each (EBML.doc elt in EBML.tagged_docs(bucket, et)) { +fn list_crate_metadata(vec[u8] bytes, io::writer out) { + auto md = ebml::new_doc(bytes); + auto paths = ebml::get_doc(md, metadata::tag_paths); + auto items = ebml::get_doc(md, metadata::tag_items); + auto index = ebml::get_doc(paths, metadata::tag_index); + auto bs = ebml::get_doc(index, metadata::tag_index_buckets); + for each (ebml::doc bucket in + ebml::tagged_docs(bs, metadata::tag_index_buckets_bucket)) { + auto et = metadata::tag_index_buckets_bucket_elt; + for each (ebml::doc elt in ebml::tagged_docs(bucket, et)) { auto data = read_path(elt); - auto def = EBML.doc_at(bytes, data._1); - auto did_doc = EBML.get_doc(def, metadata.tag_def_id); - auto did = parse_def_id(EBML.doc_data(did_doc)); + auto def = ebml::doc_at(bytes, data._1); + auto did_doc = ebml::get_doc(def, metadata::tag_def_id); + auto did = parse_def_id(ebml::doc_data(did_doc)); out.write_str(#fmt("%s (%s)\n", data._0, describe_def(items, did))); } } } -fn describe_def(&EBML.doc items, ast.def_id id) -> str { +fn describe_def(&ebml::doc items, ast::def_id id) -> str { if (id._0 != 0) {ret "external";} auto item = find_item(id._1, items); ret item_kind_to_str(item_kind(item)); diff --git a/src/comp/front/eval.rs b/src/comp/front/eval.rs index c03e313d..0416611c 100644 --- a/src/comp/front/eval.rs +++ b/src/comp/front/eval.rs @@ -1,20 +1,20 @@ -import std.Vec; -import std.Str; -import std.Option; -import std.Option.some; -import std.Option.none; -import std.Map.hashmap; - -import driver.session; -import ast.ident; -import front.parser.parser; -import front.parser.spanned; -import front.parser.new_parser; -import front.parser.parse_mod_items; -import util.common; -import util.common.filename; -import util.common.span; -import util.common.new_str_hash; +import std::_vec; +import std::_str; +import std::option; +import std::option::some; +import std::option::none; +import std::map::hashmap; + +import driver::session; +import ast::ident; +import front::parser::parser; +import front::parser::spanned; +import front::parser::new_parser; +import front::parser::parse_mod_items; +import util::common; +import util::common::filename; +import util::common::span; +import util::common::new_str_hash; // Simple dynamic-typed value type for eval_expr. @@ -33,7 +33,7 @@ type env = vec[tup(ident, val)]; type ctx = @rec(parser p, eval_mode mode, mutable vec[str] deps, - session.session sess, + session::session sess, mutable uint chpos, mutable uint next_ann); @@ -90,9 +90,9 @@ fn val_as_str(val v) -> str { fail; } -fn lookup(session.session sess, env e, span sp, ident i) -> val { +fn lookup(session::session sess, env e, span sp, ident i) -> val { for (tup(ident, val) pair in e) { - if (Str.eq(i, pair._0)) { + if (_str::eq(i, pair._0)) { ret pair._1; } } @@ -100,11 +100,11 @@ fn lookup(session.session sess, env e, span sp, ident i) -> val { fail; } -fn eval_lit(ctx cx, span sp, @ast.lit lit) -> val { +fn eval_lit(ctx cx, span sp, @ast::lit lit) -> val { alt (lit.node) { - case (ast.lit_bool(?b)) { ret val_bool(b); } - case (ast.lit_int(?i)) { ret val_int(i); } - case (ast.lit_str(?s)) { ret val_str(s); } + case (ast::lit_bool(?b)) { ret val_bool(b); } + case (ast::lit_int(?i)) { ret val_int(i); } + case (ast::lit_str(?s)) { ret val_str(s); } case (_) { cx.sess.span_err(sp, "evaluating unsupported literal"); } @@ -112,24 +112,24 @@ fn eval_lit(ctx cx, span sp, @ast.lit lit) -> val { fail; } -fn eval_expr(ctx cx, env e, @ast.expr x) -> val { +fn eval_expr(ctx cx, env e, @ast::expr x) -> val { alt (x.node) { - case (ast.expr_path(?pth, _)) { - if (Vec.len[ident](pth.node.idents) == 1u && - Vec.len[@ast.ty](pth.node.types) == 0u) { + case (ast::expr_path(?pth, _)) { + if (_vec::len[ident](pth.node.idents) == 1u && + _vec::len[@ast::ty](pth.node.types) == 0u) { ret lookup(cx.sess, e, x.span, pth.node.idents.(0)); } cx.sess.span_err(x.span, "evaluating structured path-name"); } - case (ast.expr_lit(?lit, _)) { + case (ast::expr_lit(?lit, _)) { ret eval_lit(cx, x.span, lit); } - case (ast.expr_unary(?op, ?a, _)) { + case (ast::expr_unary(?op, ?a, _)) { auto av = eval_expr(cx, e, a); alt (op) { - case (ast.not) { + case (ast::not) { if (val_is_bool(av)) { ret val_bool(!val_as_bool(av)); } @@ -141,11 +141,11 @@ fn eval_expr(ctx cx, env e, @ast.expr x) -> val { } } - case (ast.expr_binary(?op, ?a, ?b, _)) { + case (ast::expr_binary(?op, ?a, ?b, _)) { auto av = eval_expr(cx, e, a); auto bv = eval_expr(cx, e, b); alt (op) { - case (ast.add) { + case (ast::add) { if (val_is_int(av) && val_is_int(bv)) { ret val_int(val_as_int(av) + val_as_int(bv)); } @@ -155,53 +155,53 @@ fn eval_expr(ctx cx, env e, @ast.expr x) -> val { cx.sess.span_err(x.span, "bad types in '+' expression"); } - case (ast.sub) { + case (ast::sub) { if (val_is_int(av) && val_is_int(bv)) { ret val_int(val_as_int(av) - val_as_int(bv)); } cx.sess.span_err(x.span, "bad types in '-' expression"); } - case (ast.mul) { + case (ast::mul) { if (val_is_int(av) && val_is_int(bv)) { ret val_int(val_as_int(av) * val_as_int(bv)); } cx.sess.span_err(x.span, "bad types in '*' expression"); } - case (ast.div) { + case (ast::div) { if (val_is_int(av) && val_is_int(bv)) { ret val_int(val_as_int(av) / val_as_int(bv)); } cx.sess.span_err(x.span, "bad types in '/' expression"); } - case (ast.rem) { + case (ast::rem) { if (val_is_int(av) && val_is_int(bv)) { ret val_int(val_as_int(av) % val_as_int(bv)); } cx.sess.span_err(x.span, "bad types in '%' expression"); } - case (ast.and) { + case (ast::and) { if (val_is_bool(av) && val_is_bool(bv)) { ret val_bool(val_as_bool(av) && val_as_bool(bv)); } cx.sess.span_err(x.span, "bad types in '&&' expression"); } - case (ast.or) { + case (ast::or) { if (val_is_bool(av) && val_is_bool(bv)) { ret val_bool(val_as_bool(av) || val_as_bool(bv)); } cx.sess.span_err(x.span, "bad types in '||' expression"); } - case (ast.eq) { + case (ast::eq) { ret val_bool(val_eq(cx.sess, x.span, av, bv)); } - case (ast.ne) { + case (ast::ne) { ret val_bool(! val_eq(cx.sess, x.span, av, bv)); } @@ -217,7 +217,7 @@ fn eval_expr(ctx cx, env e, @ast.expr x) -> val { fail; } -fn val_eq(session.session sess, span sp, val av, val bv) -> bool { +fn val_eq(session::session sess, span sp, val av, val bv) -> bool { if (val_is_bool(av) && val_is_bool(bv)) { ret val_as_bool(av) == val_as_bool(bv); } @@ -225,7 +225,7 @@ fn val_eq(session.session sess, span sp, val av, val bv) -> bool { ret val_as_int(av) == val_as_int(bv); } if (val_is_str(av) && val_is_str(bv)) { - ret Str.eq(val_as_str(av), + ret _str::eq(val_as_str(av), val_as_str(bv)); } sess.span_err(sp, "bad types in comparison"); @@ -234,12 +234,12 @@ fn val_eq(session.session sess, span sp, val av, val bv) -> bool { fn eval_crate_directives(ctx cx, env e, - vec[@ast.crate_directive] cdirs, + vec[@ast::crate_directive] cdirs, str prefix, - &mutable vec[@ast.view_item] view_items, - &mutable vec[@ast.item] items) { + &mutable vec[@ast::view_item] view_items, + &mutable vec[@ast::item] items) { - for (@ast.crate_directive sub_cdir in cdirs) { + for (@ast::crate_directive sub_cdir in cdirs) { eval_crate_directive(cx, e, sub_cdir, prefix, view_items, items); } @@ -247,10 +247,10 @@ fn eval_crate_directives(ctx cx, fn eval_crate_directives_to_mod(ctx cx, env e, - vec[@ast.crate_directive] cdirs, - str prefix) -> ast._mod { - let vec[@ast.view_item] view_items = vec(); - let vec[@ast.item] items = vec(); + vec[@ast::crate_directive] cdirs, + str prefix) -> ast::_mod { + let vec[@ast::view_item] view_items = vec(); + let vec[@ast::item] items = vec(); eval_crate_directives(cx, e, cdirs, prefix, view_items, items); @@ -261,14 +261,14 @@ fn eval_crate_directives_to_mod(ctx cx, env e, fn eval_crate_directive_block(ctx cx, env e, - &ast.block blk, + &ast::block blk, str prefix, - &mutable vec[@ast.view_item] view_items, - &mutable vec[@ast.item] items) { + &mutable vec[@ast::view_item] view_items, + &mutable vec[@ast::item] items) { - for (@ast.stmt s in blk.node.stmts) { + for (@ast::stmt s in blk.node.stmts) { alt (s.node) { - case (ast.stmt_crate_directive(?cdir)) { + case (ast::stmt_crate_directive(?cdir)) { eval_crate_directive(cx, e, cdir, prefix, view_items, items); } @@ -282,13 +282,13 @@ fn eval_crate_directive_block(ctx cx, fn eval_crate_directive_expr(ctx cx, env e, - @ast.expr x, + @ast::expr x, str prefix, - &mutable vec[@ast.view_item] view_items, - &mutable vec[@ast.item] items) { + &mutable vec[@ast::view_item] view_items, + &mutable vec[@ast::item] items) { alt (x.node) { - case (ast.expr_if(?cond, ?thn, ?elopt, _)) { + case (ast::expr_if(?cond, ?thn, ?elopt, _)) { auto cv = eval_expr(cx, e, cond); if (!val_is_bool(cv)) { cx.sess.span_err(x.span, "bad cond type in 'if'"); @@ -300,7 +300,7 @@ fn eval_crate_directive_expr(ctx cx, } alt (elopt) { - case (some[@ast.expr](?els)) { + case (some[@ast::expr](?els)) { ret eval_crate_directive_expr(cx, e, els, prefix, view_items, items); } @@ -310,18 +310,18 @@ fn eval_crate_directive_expr(ctx cx, } } - case (ast.expr_alt(?v, ?arms, _)) { + case (ast::expr_alt(?v, ?arms, _)) { auto vv = eval_expr(cx, e, v); - for (ast.arm arm in arms) { + for (ast::arm arm in arms) { alt (arm.pat.node) { - case (ast.pat_lit(?lit, _)) { + case (ast::pat_lit(?lit, _)) { auto pv = eval_lit(cx, arm.pat.span, lit); if (val_eq(cx.sess, arm.pat.span, vv, pv)) { ret eval_crate_directive_block (cx, e, arm.block, prefix, view_items, items); } } - case (ast.pat_wild(_)) { + case (ast::pat_wild(_)) { ret eval_crate_directive_block (cx, e, arm.block, prefix, view_items, items); @@ -335,7 +335,7 @@ fn eval_crate_directive_expr(ctx cx, cx.sess.span_err(x.span, "no cases matched in 'alt'"); } - case (ast.expr_block(?block, _)) { + case (ast::expr_block(?block, _)) { ret eval_crate_directive_block(cx, e, block, prefix, view_items, items); } @@ -348,25 +348,25 @@ fn eval_crate_directive_expr(ctx cx, fn eval_crate_directive(ctx cx, env e, - @ast.crate_directive cdir, + @ast::crate_directive cdir, str prefix, - &mutable vec[@ast.view_item] view_items, - &mutable vec[@ast.item] items) { + &mutable vec[@ast::view_item] view_items, + &mutable vec[@ast::item] items) { alt (cdir.node) { - case (ast.cdir_let(?id, ?x, ?cdirs)) { + case (ast::cdir_let(?id, ?x, ?cdirs)) { auto v = eval_expr(cx, e, x); auto e0 = vec(tup(id, v)) + e; eval_crate_directives(cx, e0, cdirs, prefix, view_items, items); } - case (ast.cdir_expr(?x)) { + case (ast::cdir_expr(?x)) { eval_crate_directive_expr(cx, e, x, prefix, view_items, items); } - case (ast.cdir_src_mod(?id, ?file_opt)) { + case (ast::cdir_src_mod(?id, ?file_opt)) { auto file_path = id + ".rs"; alt (file_opt) { @@ -376,7 +376,7 @@ fn eval_crate_directive(ctx cx, case (none[filename]) {} } - auto full_path = prefix + std.FS.path_sep() + file_path; + auto full_path = prefix + std::fs::path_sep() + file_path; if (cx.mode == mode_depend) { cx.deps += vec(full_path); @@ -386,18 +386,18 @@ fn eval_crate_directive(ctx cx, auto start_id = cx.p.next_def_id(); auto p0 = new_parser(cx.sess, e, start_id, full_path, cx.chpos, cx.next_ann); - auto m0 = parse_mod_items(p0, token.EOF); + auto m0 = parse_mod_items(p0, token::EOF); auto next_id = p0.next_def_id(); // Thread defids and chpos through the parsers cx.p.set_def(next_id._1); cx.chpos = p0.get_chpos(); cx.next_ann = p0.next_ann_num(); - auto im = ast.item_mod(id, m0, next_id); + auto im = ast::item_mod(id, m0, next_id); auto i = @spanned(cdir.span.lo, cdir.span.hi, im); - Vec.push[@ast.item](items, i); + _vec::push[@ast::item](items, i); } - case (ast.cdir_dir_mod(?id, ?dir_opt, ?cdirs)) { + case (ast::cdir_dir_mod(?id, ?dir_opt, ?cdirs)) { auto path = id; alt (dir_opt) { @@ -407,23 +407,23 @@ fn eval_crate_directive(ctx cx, case (none[filename]) {} } - auto full_path = prefix + std.FS.path_sep() + path; + auto full_path = prefix + std::fs::path_sep() + path; auto m0 = eval_crate_directives_to_mod(cx, e, cdirs, full_path); - auto im = ast.item_mod(id, m0, cx.p.next_def_id()); + auto im = ast::item_mod(id, m0, cx.p.next_def_id()); auto i = @spanned(cdir.span.lo, cdir.span.hi, im); - Vec.push[@ast.item](items, i); + _vec::push[@ast::item](items, i); } - case (ast.cdir_view_item(?vi)) { - Vec.push[@ast.view_item](view_items, vi); + case (ast::cdir_view_item(?vi)) { + _vec::push[@ast::view_item](view_items, vi); } - case (ast.cdir_meta(?mi)) { + case (ast::cdir_meta(?mi)) { cx.sess.add_metadata(mi); } - case (ast.cdir_syntax(?pth)) {} - case (ast.cdir_auth(?pth, ?eff)) {} + case (ast::cdir_syntax(?pth)) {} + case (ast::cdir_auth(?pth, ?eff)) {} } } diff --git a/src/comp/front/extenv.rs b/src/comp/front/extenv.rs index a7fd545d..f9ac6a52 100644 --- a/src/comp/front/extenv.rs +++ b/src/comp/front/extenv.rs @@ -4,47 +4,47 @@ * interface. */ -import util.common; +import util::common; -import std.Str; -import std.Vec; -import std.Option; -import std.GenericOS; +import std::_str; +import std::_vec; +import std::option; +import std::generic_os; export expand_syntax_ext; // FIXME: Need to thread parser through here to handle errors correctly -fn expand_syntax_ext(parser.parser p, - common.span sp, - vec[@ast.expr] args, - Option.t[str] body) -> @ast.expr { +fn expand_syntax_ext(parser::parser p, + common::span sp, + vec[@ast::expr] args, + option::t[str] body) -> @ast::expr { - if (Vec.len[@ast.expr](args) != 1u) { + if (_vec::len[@ast::expr](args) != 1u) { p.err("malformed #env call"); } // FIXME: if this was more thorough it would manufacture an - // Option.t[str] rather than just an maybe-empty string. + // option::t[str] rather than just an maybe-empty string. auto var = expr_to_str(p, args.(0)); - alt (GenericOS.getenv(var)) { - case (Option.none[str]) { + alt (generic_os::getenv(var)) { + case (option::none[str]) { ret make_new_str(p, sp, ""); } - case (Option.some[str](?s)) { + case (option::some[str](?s)) { ret make_new_str(p, sp, s); } } } -// FIXME: duplicate code copied from extfmt. +// FIXME: duplicate code copied from extfmt: -fn expr_to_str(parser.parser p, - @ast.expr expr) -> str { +fn expr_to_str(parser::parser p, + @ast::expr expr) -> str { alt (expr.node) { - case (ast.expr_lit(?l, _)) { + case (ast::expr_lit(?l, _)) { alt (l.node) { - case (ast.lit_str(?s)) { + case (ast::lit_str(?s)) { ret s; } } @@ -54,14 +54,15 @@ fn expr_to_str(parser.parser p, fail; } -fn make_new_lit(parser.parser p, common.span sp, ast.lit_ lit) -> @ast.expr { +fn make_new_lit(parser::parser p, common::span sp, ast::lit_ lit) + -> @ast::expr { auto sp_lit = @rec(node=lit, span=sp); - auto expr = ast.expr_lit(sp_lit, p.get_ann()); + auto expr = ast::expr_lit(sp_lit, p.get_ann()); ret @rec(node=expr, span=sp); } -fn make_new_str(parser.parser p, common.span sp, str s) -> @ast.expr { - auto lit = ast.lit_str(s); +fn make_new_str(parser::parser p, common::span sp, str s) -> @ast::expr { + auto lit = ast::lit_str(s); ret make_new_lit(p, sp, lit); } diff --git a/src/comp/front/extfmt.rs b/src/comp/front/extfmt.rs index 36050e19..085e5d98 100644 --- a/src/comp/front/extfmt.rs +++ b/src/comp/front/extfmt.rs @@ -1,56 +1,56 @@ /* * The compiler code necessary to support the #fmt extension. Eventually this - * should all get sucked into either the standard library ExtFmt module or the + * should all get sucked into either the standard library extfmt module or the * compiler syntax extension plugin interface. */ -import front.parser.parser; -import util.common; - -import std.Str; -import std.Vec; -import std.Option; -import std.Option.none; -import std.Option.some; - -import std.ExtFmt.CT.signedness; -import std.ExtFmt.CT.signed; -import std.ExtFmt.CT.unsigned; -import std.ExtFmt.CT.caseness; -import std.ExtFmt.CT.case_upper; -import std.ExtFmt.CT.case_lower; -import std.ExtFmt.CT.ty; -import std.ExtFmt.CT.ty_bool; -import std.ExtFmt.CT.ty_str; -import std.ExtFmt.CT.ty_char; -import std.ExtFmt.CT.ty_int; -import std.ExtFmt.CT.ty_bits; -import std.ExtFmt.CT.ty_hex; -import std.ExtFmt.CT.ty_octal; -import std.ExtFmt.CT.flag; -import std.ExtFmt.CT.flag_left_justify; -import std.ExtFmt.CT.flag_left_zero_pad; -import std.ExtFmt.CT.flag_space_for_sign; -import std.ExtFmt.CT.flag_sign_always; -import std.ExtFmt.CT.flag_alternate; -import std.ExtFmt.CT.count; -import std.ExtFmt.CT.count_is; -import std.ExtFmt.CT.count_is_param; -import std.ExtFmt.CT.count_is_next_param; -import std.ExtFmt.CT.count_implied; -import std.ExtFmt.CT.conv; -import std.ExtFmt.CT.piece; -import std.ExtFmt.CT.piece_string; -import std.ExtFmt.CT.piece_conv; -import std.ExtFmt.CT.parse_fmt_string; +import front::parser::parser; +import util::common; + +import std::_str; +import std::_vec; +import std::option; +import std::option::none; +import std::option::some; + +import std::extfmt::CT::signedness; +import std::extfmt::CT::signed; +import std::extfmt::CT::unsigned; +import std::extfmt::CT::caseness; +import std::extfmt::CT::case_upper; +import std::extfmt::CT::case_lower; +import std::extfmt::CT::ty; +import std::extfmt::CT::ty_bool; +import std::extfmt::CT::ty_str; +import std::extfmt::CT::ty_char; +import std::extfmt::CT::ty_int; +import std::extfmt::CT::ty_bits; +import std::extfmt::CT::ty_hex; +import std::extfmt::CT::ty_octal; +import std::extfmt::CT::flag; +import std::extfmt::CT::flag_left_justify; +import std::extfmt::CT::flag_left_zero_pad; +import std::extfmt::CT::flag_space_for_sign; +import std::extfmt::CT::flag_sign_always; +import std::extfmt::CT::flag_alternate; +import std::extfmt::CT::count; +import std::extfmt::CT::count_is; +import std::extfmt::CT::count_is_param; +import std::extfmt::CT::count_is_next_param; +import std::extfmt::CT::count_implied; +import std::extfmt::CT::conv; +import std::extfmt::CT::piece; +import std::extfmt::CT::piece_string; +import std::extfmt::CT::piece_conv; +import std::extfmt::CT::parse_fmt_string; export expand_syntax_ext; fn expand_syntax_ext(parser p, - vec[@ast.expr] args, - Option.t[str] body) -> @ast.expr { + vec[@ast::expr] args, + option::t[str] body) -> @ast::expr { - if (Vec.len[@ast.expr](args) == 0u) { + if (_vec::len[@ast::expr](args) == 0u) { // FIXME: Handle error correctly. log_err "malformed #fmt call"; fail; @@ -62,16 +62,16 @@ fn expand_syntax_ext(parser p, // log fmt; auto pieces = parse_fmt_string(fmt); - auto args_len = Vec.len[@ast.expr](args); - auto fmt_args = Vec.slice[@ast.expr](args, 1u, args_len - 1u); + auto args_len = _vec::len[@ast::expr](args); + auto fmt_args = _vec::slice[@ast::expr](args, 1u, args_len - 1u); ret pieces_to_expr(p, pieces, args); } -fn expr_to_str(@ast.expr expr) -> str { +fn expr_to_str(@ast::expr expr) -> str { alt (expr.node) { - case (ast.expr_lit(?l, _)) { + case (ast::expr_lit(?l, _)) { alt (l.node) { - case (ast.lit_str(?s)) { + case (ast::lit_str(?s)) { ret s; } } @@ -86,75 +86,75 @@ fn expr_to_str(@ast.expr expr) -> str { // be factored out in common with other code that builds expressions. // FIXME: Probably should be using the parser's span functions // FIXME: Cleanup the naming of these functions -fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) - -> @ast.expr { +fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args) + -> @ast::expr { - fn make_new_lit(parser p, common.span sp, ast.lit_ lit) -> @ast.expr { + fn make_new_lit(parser p, common::span sp, ast::lit_ lit) -> @ast::expr { auto sp_lit = @rec(node=lit, span=sp); - auto expr = ast.expr_lit(sp_lit, p.get_ann()); + auto expr = ast::expr_lit(sp_lit, p.get_ann()); ret @rec(node=expr, span=sp); } - fn make_new_str(parser p, common.span sp, str s) -> @ast.expr { - auto lit = ast.lit_str(s); + fn make_new_str(parser p, common::span sp, str s) -> @ast::expr { + auto lit = ast::lit_str(s); ret make_new_lit(p, sp, lit); } - fn make_new_int(parser p, common.span sp, int i) -> @ast.expr { - auto lit = ast.lit_int(i); + fn make_new_int(parser p, common::span sp, int i) -> @ast::expr { + auto lit = ast::lit_int(i); ret make_new_lit(p, sp, lit); } - fn make_new_uint(parser p, common.span sp, uint u) -> @ast.expr { - auto lit = ast.lit_uint(u); + fn make_new_uint(parser p, common::span sp, uint u) -> @ast::expr { + auto lit = ast::lit_uint(u); ret make_new_lit(p, sp, lit); } - fn make_add_expr(parser p, common.span sp, - @ast.expr lhs, @ast.expr rhs) -> @ast.expr { - auto binexpr = ast.expr_binary(ast.add, lhs, rhs, p.get_ann()); + fn make_add_expr(parser p, common::span sp, + @ast::expr lhs, @ast::expr rhs) -> @ast::expr { + auto binexpr = ast::expr_binary(ast::add, lhs, rhs, p.get_ann()); ret @rec(node=binexpr, span=sp); } - fn make_path_expr(parser p, common.span sp, vec[ast.ident] idents) - -> @ast.expr { - let vec[@ast.ty] types = vec(); + fn make_path_expr(parser p, common::span sp, vec[ast::ident] idents) + -> @ast::expr { + let vec[@ast::ty] types = vec(); auto path = rec(idents=idents, types=types); auto sp_path = rec(node=path, span=sp); - auto pathexpr = ast.expr_path(sp_path, p.get_ann()); + auto pathexpr = ast::expr_path(sp_path, p.get_ann()); auto sp_pathexpr = @rec(node=pathexpr, span=sp); ret sp_pathexpr; } - fn make_vec_expr(parser p, common.span sp, vec[@ast.expr] exprs) - -> @ast.expr { - auto vecexpr = ast.expr_vec(exprs, ast.imm, p.get_ann()); + fn make_vec_expr(parser p, common::span sp, vec[@ast::expr] exprs) + -> @ast::expr { + auto vecexpr = ast::expr_vec(exprs, ast::imm, p.get_ann()); auto sp_vecexpr = @rec(node=vecexpr, span=sp); ret sp_vecexpr; } - fn make_call(parser p, common.span sp, vec[ast.ident] fn_path, - vec[@ast.expr] args) -> @ast.expr { + fn make_call(parser p, common::span sp, vec[ast::ident] fn_path, + vec[@ast::expr] args) -> @ast::expr { auto pathexpr = make_path_expr(p, sp, fn_path); - auto callexpr = ast.expr_call(pathexpr, args, p.get_ann()); + auto callexpr = ast::expr_call(pathexpr, args, p.get_ann()); auto sp_callexpr = @rec(node=callexpr, span=sp); ret sp_callexpr; } - fn make_rec_expr(parser p, common.span sp, - vec[tup(ast.ident, @ast.expr)] fields) -> @ast.expr { - let vec[ast.field] astfields = vec(); - for (tup(ast.ident, @ast.expr) field in fields) { + fn make_rec_expr(parser p, common::span sp, + vec[tup(ast::ident, @ast::expr)] fields) -> @ast::expr { + let vec[ast::field] astfields = vec(); + for (tup(ast::ident, @ast::expr) field in fields) { auto ident = field._0; auto val = field._1; - auto astfield = rec(mut = ast.imm, + auto astfield = rec(mut = ast::imm, ident = ident, expr = val); astfields += vec(astfield); } - auto recexpr = ast.expr_rec(astfields, - Option.none[@ast.expr], + auto recexpr = ast::expr_rec(astfields, + option::none[@ast::expr], p.get_ann()); auto sp_recexpr = @rec(node=recexpr, span=sp); ret sp_recexpr; @@ -166,18 +166,18 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) ret vec("std", "extfmt", "RT", ident); } - fn make_rt_path_expr(parser p, common.span sp, str ident) -> @ast.expr { + fn make_rt_path_expr(parser p, common::span sp, str ident) -> @ast::expr { auto path = make_path_vec(ident); ret make_path_expr(p, sp, path); } - // Produces an AST expression that represents a RT.conv record, - // which tells the RT.conv* functions how to perform the conversion - fn make_rt_conv_expr(parser p, common.span sp, &conv cnv) -> @ast.expr { + // Produces an AST expression that represents a RT::conv record, + // which tells the RT::conv* functions how to perform the conversion + fn make_rt_conv_expr(parser p, common::span sp, &conv cnv) -> @ast::expr { - fn make_flags(parser p, common.span sp, vec[flag] flags) - -> @ast.expr { - let vec[@ast.expr] flagexprs = vec(); + fn make_flags(parser p, common::span sp, vec[flag] flags) + -> @ast::expr { + let vec[@ast::expr] flagexprs = vec(); for (flag f in flags) { auto fstr; alt (f) { @@ -203,14 +203,14 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) // FIXME: 0-length vectors can't have their type inferred // through the rec that these flags are a member of, so // this is a hack placeholder flag - if (Vec.len[@ast.expr](flagexprs) == 0u) { + if (_vec::len[@ast::expr](flagexprs) == 0u) { flagexprs += vec(make_rt_path_expr(p, sp, "flag_none")); } ret make_vec_expr(p, sp, flagexprs); } - fn make_count(parser p, common.span sp, &count cnt) -> @ast.expr { + fn make_count(parser p, common::span sp, &count cnt) -> @ast::expr { alt (cnt) { case (count_implied) { ret make_rt_path_expr(p, sp, "count_implied"); @@ -228,7 +228,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) } } - fn make_ty(parser p, common.span sp, &ty t) -> @ast.expr { + fn make_ty(parser p, common::span sp, &ty t) -> @ast::expr { auto rt_type; alt (t) { case (ty_hex(?c)) { @@ -256,11 +256,11 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) } fn make_conv_rec(parser p, - common.span sp, - @ast.expr flags_expr, - @ast.expr width_expr, - @ast.expr precision_expr, - @ast.expr ty_expr) -> @ast.expr { + common::span sp, + @ast::expr flags_expr, + @ast::expr width_expr, + @ast::expr precision_expr, + @ast::expr ty_expr) -> @ast::expr { ret make_rec_expr(p, sp, vec(tup("flags", flags_expr), tup("width", width_expr), tup("precision", precision_expr), @@ -279,8 +279,8 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) rt_conv_ty); } - fn make_conv_call(parser p, common.span sp, str conv_type, - &conv cnv, @ast.expr arg) -> @ast.expr { + fn make_conv_call(parser p, common::span sp, str conv_type, + &conv cnv, @ast::expr arg) -> @ast::expr { auto fname = "conv_" + conv_type; auto path = make_path_vec(fname); auto cnv_expr = make_rt_conv_expr(p, sp, cnv); @@ -288,9 +288,9 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) ret make_call(p, arg.span, path, args); } - fn make_new_conv(parser p, conv cnv, @ast.expr arg) -> @ast.expr { + fn make_new_conv(parser p, conv cnv, @ast::expr arg) -> @ast::expr { - // FIXME: Extract all this validation into ExtFmt.CT + // FIXME: Extract all this validation into extfmt::CT fn is_signed_type(conv cnv) -> bool { alt (cnv.ty) { case (ty_int(?s)) { @@ -312,7 +312,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) auto unsupported = "conversion not supported in #fmt string"; alt (cnv.param) { - case (Option.none[int]) { + case (option::none[int]) { } case (_) { log_err unsupported; @@ -407,7 +407,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) fn log_conv(conv c) { alt (c.param) { case (some[int](?p)) { - log "param: " + std.Int.to_str(p, 10u); + log "param: " + std::_int::to_str(p, 10u); } case (_) { log "param: none"; @@ -434,10 +434,10 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) } alt (c.width) { case (count_is(?i)) { - log "width: count is " + std.Int.to_str(i, 10u); + log "width: count is " + std::_int::to_str(i, 10u); } case (count_is_param(?i)) { - log "width: count is param " + std.Int.to_str(i, 10u); + log "width: count is param " + std::_int::to_str(i, 10u); } case (count_is_next_param) { log "width: count is next param"; @@ -448,10 +448,10 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) } alt (c.precision) { case (count_is(?i)) { - log "prec: count is " + std.Int.to_str(i, 10u); + log "prec: count is " + std::_int::to_str(i, 10u); } case (count_is_param(?i)) { - log "prec: count is param " + std.Int.to_str(i, 10u); + log "prec: count is param " + std::_int::to_str(i, 10u); } case (count_is_next_param) { log "prec: count is next param"; @@ -507,7 +507,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) tmp_expr = make_add_expr(p, sp, tmp_expr, s_expr); } case (piece_conv(?conv)) { - if (n >= Vec.len[@ast.expr](args)) { + if (n >= _vec::len[@ast::expr](args)) { log_err "too many conversions in #fmt string"; fail; } @@ -526,7 +526,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) // TODO: Remove this debug logging // log "dumping expanded ast:"; - // log pretty.print_expr(tmp_expr); + // log pretty::print_expr(tmp_expr); ret tmp_expr; } diff --git a/src/comp/front/lexer.rs b/src/comp/front/lexer.rs index adcdaa16..f01d782a 100644 --- a/src/comp/front/lexer.rs +++ b/src/comp/front/lexer.rs @@ -1,15 +1,15 @@ -import std.IO; -import std.Str; -import std.Vec; -import std.Int; -import std.Map; -import std.Map.hashmap; -import std.Option; -import std.Option.some; -import std.Option.none; -import driver.session.session; -import util.common; -import util.common.new_str_hash; +import std::io; +import std::_str; +import std::_vec; +import std::_int; +import std::map; +import std::map::hashmap; +import std::option; +import std::option::some; +import std::option::none; +import driver::session::session; +import util::common; +import util::common::new_str_hash; state type reader = state obj { fn is_eof() -> bool; @@ -19,17 +19,17 @@ state type reader = state obj { fn bump(); fn mark(); fn get_mark_chpos() -> uint; - fn add_str(str) -> token.str_num; - fn get_str(token.str_num) -> str; + fn add_str(str) -> token::str_num; + fn get_str(token::str_num) -> str; fn get_chpos() -> uint; - fn get_keywords() -> hashmap[str,token.token]; + fn get_keywords() -> hashmap[str,token::token]; fn get_reserved() -> hashmap[str,()]; - fn get_filemap() -> codemap.filemap; + fn get_filemap() -> codemap::filemap; fn err(str m); }; -fn new_reader(session sess, IO.reader rdr, - codemap.filemap filemap) -> reader { +fn new_reader(session sess, io::reader rdr, + codemap::filemap filemap) -> reader { state obj reader(session sess, str file, @@ -39,9 +39,9 @@ fn new_reader(session sess, IO.reader rdr, mutable uint mark_chpos, mutable uint chpos, mutable vec[str] strs, - hashmap[str,token.token] keywords, + hashmap[str,token::token] keywords, hashmap[str,()] reserved, - codemap.filemap fm) { + codemap::filemap fm) { fn is_eof() -> bool { ret ch == -1 as char; @@ -56,13 +56,13 @@ fn new_reader(session sess, IO.reader rdr, } fn next() -> char { - if (pos < len) {ret Str.char_at(file, pos);} + if (pos < len) {ret _str::char_at(file, pos);} else {ret -1 as char;} } fn init() { if (pos < len) { - auto next = Str.char_range_at(file, pos); + auto next = _str::char_range_at(file, pos); pos = next._1; ch = next._0; } @@ -72,9 +72,9 @@ fn new_reader(session sess, IO.reader rdr, if (pos < len) { chpos += 1u; if (ch == '\n') { - codemap.next_line(fm, chpos); + codemap::next_line(fm, chpos); } - auto next = Str.char_range_at(file, pos); + auto next = _str::char_range_at(file, pos); pos = next._1; ch = next._0; } else { @@ -82,16 +82,16 @@ fn new_reader(session sess, IO.reader rdr, } } - fn get_keywords() -> hashmap[str,token.token] { + fn get_keywords() -> hashmap[str,token::token] { ret keywords; } - fn add_str(str s) -> token.str_num { + fn add_str(str s) -> token::str_num { strs += vec(s); - ret Vec.len[str](strs) - 1u; + ret _vec::len[str](strs) - 1u; } - fn get_str(token.str_num i) -> str { + fn get_str(token::str_num i) -> str { ret strs.(i); } @@ -99,7 +99,7 @@ fn new_reader(session sess, IO.reader rdr, ret reserved; } - fn get_filemap() -> codemap.filemap { + fn get_filemap() -> codemap::filemap { ret fm; } @@ -107,9 +107,9 @@ fn new_reader(session sess, IO.reader rdr, sess.span_err(rec(lo=chpos, hi=chpos), m); } } - auto file = Str.unsafe_from_bytes(rdr.read_whole_stream()); + auto file = _str::unsafe_from_bytes(rdr.read_whole_stream()); let vec[str] strs = vec(); - auto rd = reader(sess, file, Str.byte_len(file), 0u, -1 as char, + auto rd = reader(sess, file, _str::byte_len(file), 0u, -1 as char, filemap.start_pos, filemap.start_pos, strs, keyword_table(), reserved_word_table(), @@ -118,115 +118,115 @@ fn new_reader(session sess, IO.reader rdr, ret rd; } -fn keyword_table() -> std.Map.hashmap[str, token.token] { - auto keywords = new_str_hash[token.token](); +fn keyword_table() -> std::map::hashmap[str, token::token] { + auto keywords = new_str_hash[token::token](); - keywords.insert("mod", token.MOD); - keywords.insert("use", token.USE); - keywords.insert("meta", token.META); - keywords.insert("auth", token.AUTH); + keywords.insert("mod", token::MOD); + keywords.insert("use", token::USE); + keywords.insert("meta", token::META); + keywords.insert("auth", token::AUTH); - keywords.insert("syntax", token.SYNTAX); + keywords.insert("syntax", token::SYNTAX); - keywords.insert("if", token.IF); - keywords.insert("else", token.ELSE); - keywords.insert("while", token.WHILE); - keywords.insert("do", token.DO); - keywords.insert("alt", token.ALT); - keywords.insert("case", token.CASE); + keywords.insert("if", token::IF); + keywords.insert("else", token::ELSE); + keywords.insert("while", token::WHILE); + keywords.insert("do", token::DO); + keywords.insert("alt", token::ALT); + keywords.insert("case", token::CASE); - keywords.insert("for", token.FOR); - keywords.insert("each", token.EACH); - keywords.insert("break", token.BREAK); - keywords.insert("cont", token.CONT); - keywords.insert("put", token.PUT); - keywords.insert("ret", token.RET); - keywords.insert("be", token.BE); + keywords.insert("for", token::FOR); + keywords.insert("each", token::EACH); + keywords.insert("break", token::BREAK); + keywords.insert("cont", token::CONT); + keywords.insert("put", token::PUT); + keywords.insert("ret", token::RET); + keywords.insert("be", token::BE); - keywords.insert("fail", token.FAIL); - keywords.insert("drop", token.DROP); + keywords.insert("fail", token::FAIL); + keywords.insert("drop", token::DROP); - keywords.insert("type", token.TYPE); - keywords.insert("check", token.CHECK); - keywords.insert("assert", token.ASSERT); - keywords.insert("claim", token.CLAIM); - keywords.insert("prove", token.PROVE); + keywords.insert("type", token::TYPE); + keywords.insert("check", token::CHECK); + keywords.insert("assert", token::ASSERT); + keywords.insert("claim", token::CLAIM); + keywords.insert("prove", token::PROVE); - keywords.insert("state", token.STATE); - keywords.insert("gc", token.GC); + keywords.insert("state", token::STATE); + keywords.insert("gc", token::GC); - keywords.insert("unsafe", token.UNSAFE); + keywords.insert("unsafe", token::UNSAFE); - keywords.insert("native", token.NATIVE); - keywords.insert("mutable", token.MUTABLE); - keywords.insert("auto", token.AUTO); + keywords.insert("native", token::NATIVE); + keywords.insert("mutable", token::MUTABLE); + keywords.insert("auto", token::AUTO); - keywords.insert("fn", token.FN); - keywords.insert("pred", token.PRED); - keywords.insert("iter", token.ITER); + keywords.insert("fn", token::FN); + keywords.insert("pred", token::PRED); + keywords.insert("iter", token::ITER); - keywords.insert("import", token.IMPORT); - keywords.insert("export", token.EXPORT); + keywords.insert("import", token::IMPORT); + keywords.insert("export", token::EXPORT); - keywords.insert("let", token.LET); - keywords.insert("const", token.CONST); + keywords.insert("let", token::LET); + keywords.insert("const", token::CONST); - keywords.insert("log", token.LOG); - keywords.insert("log_err", token.LOG_ERR); - keywords.insert("spawn", token.SPAWN); - keywords.insert("thread", token.THREAD); - keywords.insert("yield", token.YIELD); - keywords.insert("join", token.JOIN); + keywords.insert("log", token::LOG); + keywords.insert("log_err", token::LOG_ERR); + keywords.insert("spawn", token::SPAWN); + keywords.insert("thread", token::THREAD); + keywords.insert("yield", token::YIELD); + keywords.insert("join", token::JOIN); - keywords.insert("bool", token.BOOL); + keywords.insert("bool", token::BOOL); - keywords.insert("int", token.INT); - keywords.insert("uint", token.UINT); - keywords.insert("float", token.FLOAT); + keywords.insert("int", token::INT); + keywords.insert("uint", token::UINT); + keywords.insert("float", token::FLOAT); - keywords.insert("char", token.CHAR); - keywords.insert("str", token.STR); + keywords.insert("char", token::CHAR); + keywords.insert("str", token::STR); - keywords.insert("rec", token.REC); - keywords.insert("tup", token.TUP); - keywords.insert("tag", token.TAG); - keywords.insert("vec", token.VEC); - keywords.insert("any", token.ANY); + keywords.insert("rec", token::REC); + keywords.insert("tup", token::TUP); + keywords.insert("tag", token::TAG); + keywords.insert("vec", token::VEC); + keywords.insert("any", token::ANY); - keywords.insert("obj", token.OBJ); - keywords.insert("self", token.SELF); + keywords.insert("obj", token::OBJ); + keywords.insert("self", token::SELF); - keywords.insert("port", token.PORT); - keywords.insert("chan", token.CHAN); + keywords.insert("port", token::PORT); + keywords.insert("chan", token::CHAN); - keywords.insert("task", token.TASK); + keywords.insert("task", token::TASK); - keywords.insert("true", token.LIT_BOOL(true)); - keywords.insert("false", token.LIT_BOOL(false)); + keywords.insert("true", token::LIT_BOOL(true)); + keywords.insert("false", token::LIT_BOOL(false)); - keywords.insert("in", token.IN); + keywords.insert("in", token::IN); - keywords.insert("as", token.AS); - keywords.insert("with", token.WITH); + keywords.insert("as", token::AS); + keywords.insert("with", token::WITH); - keywords.insert("bind", token.BIND); + keywords.insert("bind", token::BIND); - keywords.insert("u8", token.MACH(common.ty_u8)); - keywords.insert("u16", token.MACH(common.ty_u16)); - keywords.insert("u32", token.MACH(common.ty_u32)); - keywords.insert("u64", token.MACH(common.ty_u64)); - keywords.insert("i8", token.MACH(common.ty_i8)); - keywords.insert("i16", token.MACH(common.ty_i16)); - keywords.insert("i32", token.MACH(common.ty_i32)); - keywords.insert("i64", token.MACH(common.ty_i64)); - keywords.insert("f32", token.MACH(common.ty_f32)); - keywords.insert("f64", token.MACH(common.ty_f64)); + keywords.insert("u8", token::MACH(common::ty_u8)); + keywords.insert("u16", token::MACH(common::ty_u16)); + keywords.insert("u32", token::MACH(common::ty_u32)); + keywords.insert("u64", token::MACH(common::ty_u64)); + keywords.insert("i8", token::MACH(common::ty_i8)); + keywords.insert("i16", token::MACH(common::ty_i16)); + keywords.insert("i32", token::MACH(common::ty_i32)); + keywords.insert("i64", token::MACH(common::ty_i64)); + keywords.insert("f32", token::MACH(common::ty_f32)); + keywords.insert("f64", token::MACH(common::ty_f64)); ret keywords; } -fn reserved_word_table() -> std.Map.hashmap[str, ()] { +fn reserved_word_table() -> std::map::hashmap[str, ()] { auto reserved = new_str_hash[()](); reserved.insert("f16", ()); // IEEE 754-2008 'binary16' interchange fmt reserved.insert("f80", ()); // IEEE 754-1985 'extended' @@ -362,20 +362,20 @@ fn digits_to_string(str s) -> int { ret accum_int; } -fn scan_exponent(reader rdr) -> Option.t[str] { +fn scan_exponent(reader rdr) -> option::t[str] { auto c = rdr.curr(); auto res = ""; if (c == 'e' || c == 'E') { - res += Str.from_bytes(vec(c as u8)); + res += _str::from_bytes(vec(c as u8)); rdr.bump(); c = rdr.curr(); if (c == '-' || c == '+') { - res += Str.from_bytes(vec(c as u8)); + res += _str::from_bytes(vec(c as u8)); rdr.bump(); } auto exponent = scan_dec_digits(rdr); - if (Str.byte_len(exponent) > 0u) { + if (_str::byte_len(exponent) > 0u) { ret(some(res + exponent)); } else { @@ -395,7 +395,7 @@ fn scan_dec_digits(reader rdr) -> str { while (is_dec_digit (c) || c == '_') { if (c != '_') { - res += Str.from_bytes(vec(c as u8)); + res += _str::from_bytes(vec(c as u8)); } rdr.bump(); c = rdr.curr(); @@ -404,7 +404,7 @@ fn scan_dec_digits(reader rdr) -> str { ret res; } -fn scan_number(char c, reader rdr) -> token.token { +fn scan_number(char c, reader rdr) -> token::token { auto accum_int = 0; let str dec_str = ""; let bool is_dec_integer = false; @@ -453,9 +453,9 @@ fn scan_number(char c, reader rdr) -> token.token { if (c == '8') { rdr.bump(); if (signed) { - ret token.LIT_MACH_INT(common.ty_i8, accum_int); + ret token::LIT_MACH_INT(common::ty_i8, accum_int); } else { - ret token.LIT_MACH_INT(common.ty_u8, accum_int); + ret token::LIT_MACH_INT(common::ty_u8, accum_int); } } @@ -464,18 +464,18 @@ fn scan_number(char c, reader rdr) -> token.token { rdr.bump(); rdr.bump(); if (signed) { - ret token.LIT_MACH_INT(common.ty_i16, accum_int); + ret token::LIT_MACH_INT(common::ty_i16, accum_int); } else { - ret token.LIT_MACH_INT(common.ty_u16, accum_int); + ret token::LIT_MACH_INT(common::ty_u16, accum_int); } } if (c == '3' && n == '2') { rdr.bump(); rdr.bump(); if (signed) { - ret token.LIT_MACH_INT(common.ty_i32, accum_int); + ret token::LIT_MACH_INT(common::ty_i32, accum_int); } else { - ret token.LIT_MACH_INT(common.ty_u32, accum_int); + ret token::LIT_MACH_INT(common::ty_u32, accum_int); } } @@ -483,17 +483,17 @@ fn scan_number(char c, reader rdr) -> token.token { rdr.bump(); rdr.bump(); if (signed) { - ret token.LIT_MACH_INT(common.ty_i64, accum_int); + ret token::LIT_MACH_INT(common::ty_i64, accum_int); } else { - ret token.LIT_MACH_INT(common.ty_u64, accum_int); + ret token::LIT_MACH_INT(common::ty_u64, accum_int); } } if (signed) { - ret token.LIT_INT(accum_int); + ret token::LIT_INT(accum_int); } else { // FIXME: should cast in the target bit-width. - ret token.LIT_UINT(accum_int as uint); + ret token::LIT_UINT(accum_int as uint); } } c = rdr.curr(); @@ -520,29 +520,29 @@ fn scan_number(char c, reader rdr) -> token.token { n = rdr.next(); if (c == '3' && n == '2') { rdr.bump(); rdr.bump(); - ret token.LIT_MACH_FLOAT(util.common.ty_f32, + ret token::LIT_MACH_FLOAT(util::common::ty_f32, rdr.add_str(float_str)); } else if (c == '6' && n == '4') { rdr.bump(); rdr.bump(); - ret token.LIT_MACH_FLOAT(util.common.ty_f64, + ret token::LIT_MACH_FLOAT(util::common::ty_f64, rdr.add_str(float_str)); /* FIXME: if this is out of range for either a 32-bit or 64-bit float, it won't be noticed till the back-end */ } } else { - ret token.LIT_FLOAT(rdr.add_str(float_str)); + ret token::LIT_FLOAT(rdr.add_str(float_str)); } } auto maybe_exponent = scan_exponent(rdr); alt(maybe_exponent) { case(some[str](?s)) { - ret token.LIT_FLOAT(rdr.add_str(dec_str + s)); + ret token::LIT_FLOAT(rdr.add_str(dec_str + s)); } case(none[str]) { - ret token.LIT_INT(accum_int); + ret token::LIT_INT(accum_int); } } } @@ -583,25 +583,25 @@ fn scan_numeric_escape(reader rdr) -> char { } -fn next_token(reader rdr) -> token.token { +fn next_token(reader rdr) -> token::token { auto accum_str = ""; consume_any_whitespace(rdr); - if (rdr.is_eof()) { ret token.EOF; } + if (rdr.is_eof()) { ret token::EOF; } rdr.mark(); auto c = rdr.curr(); if (is_alpha(c) || c == '_') { while (is_alnum(c) || c == '_') { - Str.push_char(accum_str, c); + _str::push_char(accum_str, c); rdr.bump(); c = rdr.curr(); } - if (Str.eq(accum_str, "_")) { - ret token.UNDERSCORE; + if (_str::eq(accum_str, "_")) { + ret token::UNDERSCORE; } auto kwds = rdr.get_keywords(); @@ -615,46 +615,46 @@ fn next_token(reader rdr) -> token.token { fail; } - ret token.IDENT(rdr.add_str(accum_str)); + ret token::IDENT(rdr.add_str(accum_str)); } if (is_dec_digit(c)) { ret scan_number(c, rdr); } - fn binop(reader rdr, token.binop op) -> token.token { + fn binop(reader rdr, token::binop op) -> token::token { rdr.bump(); if (rdr.curr() == '=') { rdr.bump(); - ret token.BINOPEQ(op); + ret token::BINOPEQ(op); } else { - ret token.BINOP(op); + ret token::BINOP(op); } } alt (c) { // One-byte tokens. - case ('?') { rdr.bump(); ret token.QUES; } - case (';') { rdr.bump(); ret token.SEMI; } - case (',') { rdr.bump(); ret token.COMMA; } - case ('.') { rdr.bump(); ret token.DOT; } - case ('(') { rdr.bump(); ret token.LPAREN; } - case (')') { rdr.bump(); ret token.RPAREN; } - case ('{') { rdr.bump(); ret token.LBRACE; } - case ('}') { rdr.bump(); ret token.RBRACE; } - case ('[') { rdr.bump(); ret token.LBRACKET; } - case (']') { rdr.bump(); ret token.RBRACKET; } - case ('@') { rdr.bump(); ret token.AT; } - case ('#') { rdr.bump(); ret token.POUND; } - case ('~') { rdr.bump(); ret token.TILDE; } + case ('?') { rdr.bump(); ret token::QUES; } + case (';') { rdr.bump(); ret token::SEMI; } + case (',') { rdr.bump(); ret token::COMMA; } + case ('.') { rdr.bump(); ret token::DOT; } + case ('(') { rdr.bump(); ret token::LPAREN; } + case (')') { rdr.bump(); ret token::RPAREN; } + case ('{') { rdr.bump(); ret token::LBRACE; } + case ('}') { rdr.bump(); ret token::RBRACE; } + case ('[') { rdr.bump(); ret token::LBRACKET; } + case (']') { rdr.bump(); ret token::RBRACKET; } + case ('@') { rdr.bump(); ret token::AT; } + case ('#') { rdr.bump(); ret token::POUND; } + case ('~') { rdr.bump(); ret token::TILDE; } case (':') { rdr.bump(); if (rdr.curr() == ':') { rdr.bump(); - ret token.MOD_SEP; + ret token::MOD_SEP; } else { - ret token.COLON; + ret token::COLON; }; } @@ -663,9 +663,9 @@ fn next_token(reader rdr) -> token.token { rdr.bump(); if (rdr.curr() == '=') { rdr.bump(); - ret token.EQEQ; + ret token::EQEQ; } else { - ret token.EQ; + ret token::EQ; } } @@ -673,9 +673,9 @@ fn next_token(reader rdr) -> token.token { rdr.bump(); if (rdr.curr() == '=') { rdr.bump(); - ret token.NE; + ret token::NE; } else { - ret token.NOT; + ret token::NOT; } } @@ -684,21 +684,21 @@ fn next_token(reader rdr) -> token.token { alt (rdr.curr()) { case ('=') { rdr.bump(); - ret token.LE; + ret token::LE; } case ('<') { - ret binop(rdr, token.LSL); + ret binop(rdr, token::LSL); } case ('-') { rdr.bump(); - ret token.LARROW; + ret token::LARROW; } case ('|') { rdr.bump(); - ret token.SEND; + ret token::SEND; } case (_) { - ret token.LT; + ret token::LT; } } } @@ -708,20 +708,20 @@ fn next_token(reader rdr) -> token.token { alt (rdr.curr()) { case ('=') { rdr.bump(); - ret token.GE; + ret token::GE; } case ('>') { if (rdr.next() == '>') { rdr.bump(); - ret binop(rdr, token.ASR); + ret binop(rdr, token::ASR); } else { - ret binop(rdr, token.LSR); + ret binop(rdr, token::LSR); } } case (_) { - ret token.GT; + ret token::GT; } } } @@ -756,7 +756,7 @@ fn next_token(reader rdr) -> token.token { } rdr.bump(); // advance curr to closing ' rdr.bump(); // advance curr past token - ret token.LIT_CHAR(c2); + ret token::LIT_CHAR(c2); } case ('"') { @@ -767,37 +767,37 @@ fn next_token(reader rdr) -> token.token { alt (rdr.next()) { case ('n') { rdr.bump(); - Str.push_byte(accum_str, '\n' as u8); + _str::push_byte(accum_str, '\n' as u8); } case ('r') { rdr.bump(); - Str.push_byte(accum_str, '\r' as u8); + _str::push_byte(accum_str, '\r' as u8); } case ('t') { rdr.bump(); - Str.push_byte(accum_str, '\t' as u8); + _str::push_byte(accum_str, '\t' as u8); } case ('\\') { rdr.bump(); - Str.push_byte(accum_str, '\\' as u8); + _str::push_byte(accum_str, '\\' as u8); } case ('"') { rdr.bump(); - Str.push_byte(accum_str, '"' as u8); + _str::push_byte(accum_str, '"' as u8); } case ('x') { - Str.push_char(accum_str, + _str::push_char(accum_str, scan_numeric_escape(rdr)); } case ('u') { - Str.push_char(accum_str, + _str::push_char(accum_str, scan_numeric_escape(rdr)); } case ('U') { - Str.push_char(accum_str, + _str::push_char(accum_str, scan_numeric_escape(rdr)); } @@ -809,22 +809,22 @@ fn next_token(reader rdr) -> token.token { } } case (_) { - Str.push_char(accum_str, rdr.curr()); + _str::push_char(accum_str, rdr.curr()); } } rdr.bump(); } rdr.bump(); - ret token.LIT_STR(rdr.add_str(accum_str)); + ret token::LIT_STR(rdr.add_str(accum_str)); } case ('-') { if (rdr.next() == '>') { rdr.bump(); rdr.bump(); - ret token.RARROW; + ret token::RARROW; } else { - ret binop(rdr, token.MINUS); + ret binop(rdr, token::MINUS); } } @@ -832,9 +832,9 @@ fn next_token(reader rdr) -> token.token { if (rdr.next() == '&') { rdr.bump(); rdr.bump(); - ret token.ANDAND; + ret token::ANDAND; } else { - ret binop(rdr, token.AND); + ret binop(rdr, token::AND); } } @@ -842,30 +842,30 @@ fn next_token(reader rdr) -> token.token { if (rdr.next() == '|') { rdr.bump(); rdr.bump(); - ret token.OROR; + ret token::OROR; } else { - ret binop(rdr, token.OR); + ret binop(rdr, token::OR); } } case ('+') { - ret binop(rdr, token.PLUS); + ret binop(rdr, token::PLUS); } case ('*') { - ret binop(rdr, token.STAR); + ret binop(rdr, token::STAR); } case ('/') { - ret binop(rdr, token.SLASH); + ret binop(rdr, token::SLASH); } case ('^') { - ret binop(rdr, token.CARET); + ret binop(rdr, token::CARET); } case ('%') { - ret binop(rdr, token.PERCENT); + ret binop(rdr, token::PERCENT); } case (?c) { @@ -899,7 +899,7 @@ fn read_line_comment(reader rdr) -> cmnt { while (rdr.curr() == ' ') {rdr.bump();} auto val = ""; while (rdr.curr() != '\n' && !rdr.is_eof()) { - Str.push_char(val, rdr.curr()); + _str::push_char(val, rdr.curr()); rdr.bump(); } ret rec(val=cmnt_line(val), @@ -916,7 +916,7 @@ fn read_block_comment(reader rdr) -> cmnt { auto level = 1; while (true) { if (rdr.curr() == '\n') { - Vec.push[str](lines, val); + _vec::push[str](lines, val); val = ""; consume_whitespace(rdr); } else { @@ -924,13 +924,13 @@ fn read_block_comment(reader rdr) -> cmnt { level -= 1; if (level == 0) { rdr.bump(); rdr.bump(); - Vec.push[str](lines, val); + _vec::push[str](lines, val); break; } } else if (rdr.curr() == '/' && rdr.next() == '*') { level += 1; } - Str.push_char(val, rdr.curr()); + _str::push_char(val, rdr.curr()); rdr.bump(); } if (rdr.is_eof()) { @@ -944,16 +944,16 @@ fn read_block_comment(reader rdr) -> cmnt { } fn gather_comments(session sess, str path) -> vec[cmnt] { - auto srdr = IO.file_reader(path); - auto rdr = new_reader(sess, srdr, codemap.new_filemap(path, 0u)); + auto srdr = io::file_reader(path); + auto rdr = new_reader(sess, srdr, codemap::new_filemap(path, 0u)); let vec[cmnt] comments = vec(); while (!rdr.is_eof()) { while (true) { consume_whitespace(rdr); if (rdr.curr() == '/' && rdr.next() == '/') { - Vec.push[cmnt](comments, read_line_comment(rdr)); + _vec::push[cmnt](comments, read_line_comment(rdr)); } else if (rdr.curr() == '/' && rdr.next() == '*') { - Vec.push[cmnt](comments, read_block_comment(rdr)); + _vec::push[cmnt](comments, read_block_comment(rdr)); } else { break; } } next_token(rdr); diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index a14bcf3a..5292c49c 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1,16 +1,16 @@ -import std.IO; -import std.Vec; -import std.Str; -import std.Option; -import std.Option.some; -import std.Option.none; -import std.Map.hashmap; - -import driver.session; -import util.common; -import util.common.filename; -import util.common.span; -import util.common.new_str_hash; +import std::io; +import std::_vec; +import std::_str; +import std::option; +import std::option::some; +import std::option::none; +import std::map::hashmap; + +import driver::session; +import util::common; +import util::common::filename; +import util::common::span; +import util::common::new_str_hash; tag restriction { UNRESTRICTED; @@ -24,53 +24,53 @@ tag file_type { state type parser = state obj { - fn peek() -> token.token; + fn peek() -> token::token; fn bump(); fn err(str s); fn restrict(restriction r); fn get_restriction() -> restriction; fn get_file_type() -> file_type; - fn get_env() -> eval.env; - fn get_session() -> session.session; - fn get_span() -> common.span; + fn get_env() -> eval::env; + fn get_session() -> session::session; + fn get_span() -> common::span; fn get_lo_pos() -> uint; fn get_hi_pos() -> uint; - fn next_def_id() -> ast.def_id; - fn set_def(ast.def_num); + fn next_def_id() -> ast::def_id; + fn set_def(ast::def_num); fn get_prec_table() -> vec[op_spec]; - fn get_str(token.str_num) -> str; - fn get_reader() -> lexer.reader; - fn get_filemap() -> codemap.filemap; + fn get_str(token::str_num) -> str; + fn get_reader() -> lexer::reader; + fn get_filemap() -> codemap::filemap; fn get_chpos() -> uint; - fn get_ann() -> ast.ann; + fn get_ann() -> ast::ann; fn next_ann_num() -> uint; }; -fn new_parser(session.session sess, - eval.env env, - ast.def_id initial_def, +fn new_parser(session::session sess, + eval::env env, + ast::def_id initial_def, str path, uint pos, uint next_ann) -> parser { - state obj stdio_parser(session.session sess, - eval.env env, + state obj stdio_parser(session::session sess, + eval::env env, file_type ftype, - mutable token.token tok, + mutable token::token tok, mutable uint lo, mutable uint hi, - mutable ast.def_num def, + mutable ast::def_num def, mutable restriction res, - ast.crate_num crate, - lexer.reader rdr, + ast::crate_num crate, + lexer::reader rdr, vec[op_spec] precs, mutable uint next_ann_var) { - fn peek() -> token.token { + fn peek() -> token::token { ret tok; } fn bump() { // log rdr.get_filename() - // + ":" + common.istr(lo.line as int); - tok = lexer.next_token(rdr); + // + ":" + common::istr(lo.line as int); + tok = lexer::next_token(rdr); lo = rdr.get_mark_chpos(); hi = rdr.get_chpos(); } @@ -87,20 +87,20 @@ fn new_parser(session.session sess, ret res; } - fn get_session() -> session.session { + fn get_session() -> session::session { ret sess; } - fn get_span() -> common.span { ret rec(lo=lo, hi=hi); } + fn get_span() -> common::span { ret rec(lo=lo, hi=hi); } fn get_lo_pos() -> uint { ret lo; } fn get_hi_pos() -> uint { ret hi; } - fn next_def_id() -> ast.def_id { + fn next_def_id() -> ast::def_id { def += 1; ret tup(crate, def); } - fn set_def(ast.def_num d) { + fn set_def(ast::def_num d) { def = d; } @@ -108,7 +108,7 @@ fn new_parser(session.session sess, ret ftype; } - fn get_env() -> eval.env { + fn get_env() -> eval::env { ret env; } @@ -116,22 +116,22 @@ fn new_parser(session.session sess, ret precs; } - fn get_str(token.str_num i) -> str { + fn get_str(token::str_num i) -> str { ret rdr.get_str(i); } - fn get_reader() -> lexer.reader { + fn get_reader() -> lexer::reader { ret rdr; } - fn get_filemap() -> codemap.filemap { + fn get_filemap() -> codemap::filemap { ret rdr.get_filemap(); } fn get_chpos() -> uint {ret rdr.get_chpos();} - fn get_ann() -> ast.ann { - auto rv = ast.ann_none(next_ann_var); + fn get_ann() -> ast::ann { + auto rv = ast::ann_none(next_ann_var); next_ann_var += 1u; ret rv; } @@ -140,46 +140,46 @@ fn new_parser(session.session sess, } } auto ftype = SOURCE_FILE; - if (Str.ends_with(path, ".rc")) { + if (_str::ends_with(path, ".rc")) { ftype = CRATE_FILE; } - auto srdr = IO.file_reader(path); - auto filemap = codemap.new_filemap(path, pos); - Vec.push[codemap.filemap](sess.get_codemap().files, filemap); - auto rdr = lexer.new_reader(sess, srdr, filemap); - // Make sure npos points at first actual token. - lexer.consume_any_whitespace(rdr); + auto srdr = io::file_reader(path); + auto filemap = codemap::new_filemap(path, pos); + _vec::push[codemap::filemap](sess.get_codemap().files, filemap); + auto rdr = lexer::new_reader(sess, srdr, filemap); + // Make sure npos points at first actual token: + lexer::consume_any_whitespace(rdr); auto npos = rdr.get_chpos(); - ret stdio_parser(sess, env, ftype, lexer.next_token(rdr), + ret stdio_parser(sess, env, ftype, lexer::next_token(rdr), npos, npos, initial_def._1, UNRESTRICTED, initial_def._0, rdr, prec_table(), next_ann); } -fn unexpected(parser p, token.token t) { +fn unexpected(parser p, token::token t) { let str s = "unexpected token: "; - s += token.to_str(p.get_reader(), t); + s += token::to_str(p.get_reader(), t); p.err(s); } -fn expect(parser p, token.token t) { +fn expect(parser p, token::token t) { if (p.peek() == t) { p.bump(); } else { let str s = "expecting "; - s += token.to_str(p.get_reader(), t); + s += token::to_str(p.get_reader(), t); s += ", found "; - s += token.to_str(p.get_reader(), p.peek()); + s += token::to_str(p.get_reader(), p.peek()); p.err(s); } } -fn spanned[T](uint lo, uint hi, &T node) -> ast.spanned[T] { +fn spanned[T](uint lo, uint hi, &T node) -> ast::spanned[T] { ret rec(node=node, span=rec(lo=lo, hi=hi)); } -fn parse_ident(parser p) -> ast.ident { +fn parse_ident(parser p) -> ast::ident { alt (p.peek()) { - case (token.IDENT(?i)) { p.bump(); ret p.get_str(i); } + case (token::IDENT(?i)) { p.bump(); ret p.get_str(i); } case (_) { p.err("expecting ident"); fail; @@ -193,17 +193,17 @@ fn parse_ident(parser p) -> ast.ident { * lexical sytnax-extension or something similar. For now we just imitate * rustboot. */ -fn parse_str_lit_or_env_ident(parser p) -> ast.ident { +fn parse_str_lit_or_env_ident(parser p) -> ast::ident { alt (p.peek()) { - case (token.LIT_STR(?s)) { p.bump(); ret p.get_str(s); } - case (token.IDENT(?i)) { - auto v = eval.lookup(p.get_session(), p.get_env(), + case (token::LIT_STR(?s)) { p.bump(); ret p.get_str(s); } + case (token::IDENT(?i)) { + auto v = eval::lookup(p.get_session(), p.get_env(), p.get_span(), p.get_str(i)); - if (!eval.val_is_str(v)) { + if (!eval::val_is_str(v)) { p.err("expecting string-valued variable"); } p.bump(); - ret eval.val_as_str(v); + ret eval::val_as_str(v); } case (_) { p.err("expecting string literal"); @@ -213,26 +213,26 @@ fn parse_str_lit_or_env_ident(parser p) -> ast.ident { } -fn parse_ty_fn(ast.proto proto, parser p, uint lo) - -> ast.ty_ { - fn parse_fn_input_ty(parser p) -> rec(ast.mode mode, @ast.ty ty) { +fn parse_ty_fn(ast::proto proto, parser p, uint lo) + -> ast::ty_ { + fn parse_fn_input_ty(parser p) -> rec(ast::mode mode, @ast::ty ty) { auto mode; - if (p.peek() == token.BINOP(token.AND)) { + if (p.peek() == token::BINOP(token::AND)) { p.bump(); - mode = ast.alias; + mode = ast::alias; - if (p.peek() == token.MUTABLE) { + if (p.peek() == token::MUTABLE) { p.bump(); // TODO: handle mutable alias args } } else { - mode = ast.val; + mode = ast::val; } auto t = parse_ty(p); alt (p.peek()) { - case (token.IDENT(_)) { p.bump(); /* ignore the param name */ } + case (token::IDENT(_)) { p.bump(); /* ignore the param name */ } case (_) { /* no param name present */ } } @@ -242,45 +242,45 @@ fn parse_ty_fn(ast.proto proto, parser p, uint lo) auto lo = p.get_lo_pos(); auto f = parse_fn_input_ty; // FIXME: trans_const_lval bug - auto inputs = parse_seq[rec(ast.mode mode, @ast.ty ty)](token.LPAREN, - token.RPAREN, some(token.COMMA), f, p); + auto inputs = parse_seq[rec(ast::mode mode, @ast::ty ty)](token::LPAREN, + token::RPAREN, some(token::COMMA), f, p); // FIXME: dropping constrs on the floor at the moment. // pick them up when they're used by typestate pass. parse_constrs(p); - let @ast.ty output; - if (p.peek() == token.RARROW) { + let @ast::ty output; + if (p.peek() == token::RARROW) { p.bump(); output = parse_ty(p); } else { - output = @spanned(lo, inputs.span.hi, ast.ty_nil); + output = @spanned(lo, inputs.span.hi, ast::ty_nil); } - ret ast.ty_fn(proto, inputs.node, output); + ret ast::ty_fn(proto, inputs.node, output); } -fn parse_proto(parser p) -> ast.proto { +fn parse_proto(parser p) -> ast::proto { alt (p.peek()) { - case (token.ITER) { p.bump(); ret ast.proto_iter; } - case (token.FN) { p.bump(); ret ast.proto_fn; } - case (token.PRED) { p.bump(); ret ast.proto_fn; } + case (token::ITER) { p.bump(); ret ast::proto_iter; } + case (token::FN) { p.bump(); ret ast::proto_fn; } + case (token::PRED) { p.bump(); ret ast::proto_fn; } case (?t) { unexpected(p, t); } } fail; } -fn parse_ty_obj(parser p, &mutable uint hi) -> ast.ty_ { - expect(p, token.OBJ); - fn parse_method_sig(parser p) -> ast.ty_method { +fn parse_ty_obj(parser p, &mutable uint hi) -> ast::ty_ { + expect(p, token::OBJ); + fn parse_method_sig(parser p) -> ast::ty_method { auto flo = p.get_lo_pos(); - let ast.proto proto = parse_proto(p); + let ast::proto proto = parse_proto(p); auto ident = parse_ident(p); auto f = parse_ty_fn(proto, p, flo); - expect(p, token.SEMI); + expect(p, token::SEMI); alt (f) { - case (ast.ty_fn(?proto, ?inputs, ?output)) { + case (ast::ty_fn(?proto, ?inputs, ?output)) { ret rec(proto=proto, ident=ident, inputs=inputs, output=output); } @@ -289,58 +289,58 @@ fn parse_ty_obj(parser p, &mutable uint hi) -> ast.ty_ { } auto f = parse_method_sig; auto meths = - parse_seq[ast.ty_method](token.LBRACE, - token.RBRACE, - none[token.token], + parse_seq[ast::ty_method](token::LBRACE, + token::RBRACE, + none[token::token], f, p); hi = meths.span.hi; - ret ast.ty_obj(meths.node); + ret ast::ty_obj(meths.node); } -fn parse_mt(parser p) -> ast.mt { +fn parse_mt(parser p) -> ast::mt { auto mut = parse_mutability(p); auto t = parse_ty(p); ret rec(ty=t, mut=mut); } -fn parse_ty_field(parser p) -> ast.ty_field { +fn parse_ty_field(parser p) -> ast::ty_field { auto mt = parse_mt(p); auto id = parse_ident(p); ret rec(ident=id, mt=mt); } -fn parse_constr_arg(parser p) -> @ast.constr_arg { +fn parse_constr_arg(parser p) -> @ast::constr_arg { auto sp = p.get_span(); - auto carg = ast.carg_base; - if (p.peek() == token.BINOP(token.STAR)) { + auto carg = ast::carg_base; + if (p.peek() == token::BINOP(token::STAR)) { p.bump(); } else { - carg = ast.carg_ident(parse_ident(p)); + carg = ast::carg_ident(parse_ident(p)); } ret @rec(node=carg, span=sp); } -fn parse_ty_constr(parser p) -> @ast.constr { +fn parse_ty_constr(parser p) -> @ast::constr { auto lo = p.get_lo_pos(); auto path = parse_path(p); auto pf = parse_constr_arg; - auto args = parse_seq[@ast.constr_arg](token.LPAREN, - token.RPAREN, - some(token.COMMA), pf, p); + auto args = parse_seq[@ast::constr_arg](token::LPAREN, + token::RPAREN, + some(token::COMMA), pf, p); ret @spanned(lo, args.span.hi, rec(path=path, args=args.node)); } -fn parse_constrs(parser p) -> common.spanned[vec[@ast.constr]] { +fn parse_constrs(parser p) -> common::spanned[vec[@ast::constr]] { auto lo = p.get_lo_pos(); auto hi = p.get_hi_pos(); - let vec[@ast.constr] constrs = vec(); - if (p.peek() == token.COLON) { + let vec[@ast::constr] constrs = vec(); + if (p.peek() == token::COLON) { p.bump(); while (true) { auto constr = parse_ty_constr(p); hi = constr.span.hi; - Vec.push[@ast.constr](constrs, constr); - if (p.peek() == token.COMMA) { + _vec::push[@ast::constr](constrs, constr); + if (p.peek() == token::COMMA) { p.bump(); } else { break; @@ -350,134 +350,134 @@ fn parse_constrs(parser p) -> common.spanned[vec[@ast.constr]] { ret spanned(lo, hi, constrs); } -fn parse_ty_constrs(@ast.ty t, parser p) -> @ast.ty { - if (p.peek() == token.COLON) { +fn parse_ty_constrs(@ast::ty t, parser p) -> @ast::ty { + if (p.peek() == token::COLON) { auto constrs = parse_constrs(p); ret @spanned(t.span.lo, constrs.span.hi, - ast.ty_constr(t, constrs.node)); + ast::ty_constr(t, constrs.node)); } ret t; } -fn parse_ty(parser p) -> @ast.ty { +fn parse_ty(parser p) -> @ast::ty { auto lo = p.get_lo_pos(); auto hi = lo; - let ast.ty_ t; + let ast::ty_ t; // FIXME: do something with this - let ast.layer lyr = parse_layer(p); + let ast::layer lyr = parse_layer(p); alt (p.peek()) { - case (token.BOOL) { p.bump(); t = ast.ty_bool; } - case (token.INT) { p.bump(); t = ast.ty_int; } - case (token.UINT) { p.bump(); t = ast.ty_uint; } - case (token.FLOAT) { p.bump(); t = ast.ty_float; } - case (token.STR) { p.bump(); t = ast.ty_str; } - case (token.CHAR) { p.bump(); t = ast.ty_char; } - case (token.MACH(?tm)) { p.bump(); t = ast.ty_machine(tm); } - - case (token.LPAREN) { + case (token::BOOL) { p.bump(); t = ast::ty_bool; } + case (token::INT) { p.bump(); t = ast::ty_int; } + case (token::UINT) { p.bump(); t = ast::ty_uint; } + case (token::FLOAT) { p.bump(); t = ast::ty_float; } + case (token::STR) { p.bump(); t = ast::ty_str; } + case (token::CHAR) { p.bump(); t = ast::ty_char; } + case (token::MACH(?tm)) { p.bump(); t = ast::ty_machine(tm); } + + case (token::LPAREN) { p.bump(); alt (p.peek()) { - case (token.RPAREN) { + case (token::RPAREN) { hi = p.get_hi_pos(); p.bump(); - t = ast.ty_nil; + t = ast::ty_nil; } case (_) { t = parse_ty(p).node; hi = p.get_hi_pos(); - expect(p, token.RPAREN); + expect(p, token::RPAREN); } } } - case (token.AT) { + case (token::AT) { p.bump(); auto mt = parse_mt(p); hi = mt.ty.span.hi; - t = ast.ty_box(mt); + t = ast::ty_box(mt); } - case (token.VEC) { + case (token::VEC) { p.bump(); - expect(p, token.LBRACKET); - t = ast.ty_vec(parse_mt(p)); + expect(p, token::LBRACKET); + t = ast::ty_vec(parse_mt(p)); hi = p.get_hi_pos(); - expect(p, token.RBRACKET); + expect(p, token::RBRACKET); } - case (token.TUP) { + case (token::TUP) { p.bump(); auto f = parse_mt; // FIXME: trans_const_lval bug - auto elems = parse_seq[ast.mt] (token.LPAREN, - token.RPAREN, - some(token.COMMA), f, p); + auto elems = parse_seq[ast::mt] (token::LPAREN, + token::RPAREN, + some(token::COMMA), f, p); hi = elems.span.hi; - t = ast.ty_tup(elems.node); + t = ast::ty_tup(elems.node); } - case (token.REC) { + case (token::REC) { p.bump(); auto f = parse_ty_field; // FIXME: trans_const_lval bug auto elems = - parse_seq[ast.ty_field](token.LPAREN, - token.RPAREN, - some(token.COMMA), + parse_seq[ast::ty_field](token::LPAREN, + token::RPAREN, + some(token::COMMA), f, p); hi = elems.span.hi; - t = ast.ty_rec(elems.node); + t = ast::ty_rec(elems.node); } - case (token.FN) { + case (token::FN) { auto flo = p.get_lo_pos(); p.bump(); - t = parse_ty_fn(ast.proto_fn, p, flo); + t = parse_ty_fn(ast::proto_fn, p, flo); alt (t) { - case (ast.ty_fn(_, _, ?out)) { + case (ast::ty_fn(_, _, ?out)) { hi = out.span.hi; } } } - case (token.ITER) { + case (token::ITER) { auto flo = p.get_lo_pos(); p.bump(); - t = parse_ty_fn(ast.proto_iter, p, flo); + t = parse_ty_fn(ast::proto_iter, p, flo); alt (t) { - case (ast.ty_fn(_, _, ?out)) { + case (ast::ty_fn(_, _, ?out)) { hi = out.span.hi; } } } - case (token.OBJ) { + case (token::OBJ) { t = parse_ty_obj(p, hi); } - case (token.PORT) { + case (token::PORT) { p.bump(); - expect(p, token.LBRACKET); - t = ast.ty_port(parse_ty(p)); + expect(p, token::LBRACKET); + t = ast::ty_port(parse_ty(p)); hi = p.get_hi_pos(); - expect(p, token.RBRACKET); + expect(p, token::RBRACKET); } - case (token.CHAN) { + case (token::CHAN) { p.bump(); - expect(p, token.LBRACKET); - t = ast.ty_chan(parse_ty(p)); + expect(p, token::LBRACKET); + t = ast::ty_chan(parse_ty(p)); hi = p.get_hi_pos(); - expect(p, token.RBRACKET); + expect(p, token::RBRACKET); } - case (token.IDENT(_)) { + case (token::IDENT(_)) { auto path = parse_path(p); - t = ast.ty_path(path, p.get_ann()); + t = ast::ty_path(path, p.get_ann()); hi = path.span.hi; } - case (token.MUTABLE) { + case (token::MUTABLE) { p.bump(); p.get_session().span_warn(p.get_span(), "ignoring deprecated 'mutable' type constructor"); @@ -488,7 +488,7 @@ fn parse_ty(parser p) -> @ast.ty { case (_) { p.err("expecting type"); - t = ast.ty_nil; + t = ast::ty_nil; fail; } } @@ -496,24 +496,24 @@ fn parse_ty(parser p) -> @ast.ty { ret parse_ty_constrs(@spanned(lo, hi, t), p); } -fn parse_arg(parser p) -> ast.arg { - let ast.mode m = ast.val; - if (p.peek() == token.BINOP(token.AND)) { - m = ast.alias; +fn parse_arg(parser p) -> ast::arg { + let ast::mode m = ast::val; + if (p.peek() == token::BINOP(token::AND)) { + m = ast::alias; p.bump(); - if (p.peek() == token.MUTABLE) { + if (p.peek() == token::MUTABLE) { // TODO: handle mutable alias args p.bump(); } } - let @ast.ty t = parse_ty(p); - let ast.ident i = parse_ident(p); + let @ast::ty t = parse_ty(p); + let ast::ident i = parse_ident(p); ret rec(mode=m, ty=t, ident=i, id=p.next_def_id()); } -fn parse_seq_to_end[T](token.token ket, - Option.t[token.token] sep, +fn parse_seq_to_end[T](token::token ket, + option::t[token::token] sep, (fn(parser) -> T) f, uint hi, parser p) -> vec[T] { @@ -521,7 +521,7 @@ fn parse_seq_to_end[T](token.token ket, let vec[T] v = vec(); while (p.peek() != ket) { alt(sep) { - case (some[token.token](?t)) { + case (some[token::token](?t)) { if (first) { first = false; } else { @@ -540,11 +540,11 @@ fn parse_seq_to_end[T](token.token ket, ret v; } -fn parse_seq[T](token.token bra, - token.token ket, - Option.t[token.token] sep, +fn parse_seq[T](token::token bra, + token::token ket, + option::t[token::token] sep, (fn(parser) -> T) f, - parser p) -> util.common.spanned[vec[T]] { + parser p) -> util::common::spanned[vec[T]] { auto lo = p.get_lo_pos(); auto hi = p.get_hi_pos(); expect(p, bra); @@ -552,41 +552,41 @@ fn parse_seq[T](token.token bra, ret spanned(lo, hi, result); } -fn parse_lit(parser p) -> ast.lit { +fn parse_lit(parser p) -> ast::lit { auto sp = p.get_span(); - let ast.lit_ lit = ast.lit_nil; + let ast::lit_ lit = ast::lit_nil; alt (p.peek()) { - case (token.LIT_INT(?i)) { + case (token::LIT_INT(?i)) { p.bump(); - lit = ast.lit_int(i); + lit = ast::lit_int(i); } - case (token.LIT_UINT(?u)) { + case (token::LIT_UINT(?u)) { p.bump(); - lit = ast.lit_uint(u); + lit = ast::lit_uint(u); } - case (token.LIT_FLOAT(?s)) { + case (token::LIT_FLOAT(?s)) { p.bump(); - lit = ast.lit_float(p.get_str(s)); + lit = ast::lit_float(p.get_str(s)); } - case (token.LIT_MACH_INT(?tm, ?i)) { + case (token::LIT_MACH_INT(?tm, ?i)) { p.bump(); - lit = ast.lit_mach_int(tm, i); + lit = ast::lit_mach_int(tm, i); } - case (token.LIT_MACH_FLOAT(?tm, ?s)) { + case (token::LIT_MACH_FLOAT(?tm, ?s)) { p.bump(); - lit = ast.lit_mach_float(tm, p.get_str(s)); + lit = ast::lit_mach_float(tm, p.get_str(s)); } - case (token.LIT_CHAR(?c)) { + case (token::LIT_CHAR(?c)) { p.bump(); - lit = ast.lit_char(c); + lit = ast::lit_char(c); } - case (token.LIT_BOOL(?b)) { + case (token::LIT_BOOL(?b)) { p.bump(); - lit = ast.lit_bool(b); + lit = ast::lit_bool(b); } - case (token.LIT_STR(?s)) { + case (token::LIT_STR(?s)) { p.bump(); - lit = ast.lit_str(p.get_str(s)); + lit = ast::lit_str(p.get_str(s)); } case (?t) { unexpected(p, t); @@ -595,42 +595,42 @@ fn parse_lit(parser p) -> ast.lit { ret rec(node=lit, span=sp); } -fn is_ident(token.token t) -> bool { +fn is_ident(token::token t) -> bool { alt (t) { - case (token.IDENT(_)) { ret true; } + case (token::IDENT(_)) { ret true; } case (_) {} } ret false; } fn parse_ty_args(parser p, uint hi) -> - util.common.spanned[vec[@ast.ty]] { + util::common::spanned[vec[@ast::ty]] { - if (p.peek() == token.LBRACKET) { + if (p.peek() == token::LBRACKET) { auto pf = parse_ty; - ret parse_seq[@ast.ty](token.LBRACKET, - token.RBRACKET, - some(token.COMMA), + ret parse_seq[@ast::ty](token::LBRACKET, + token::RBRACKET, + some(token::COMMA), pf, p); } - let vec[@ast.ty] v = vec(); + let vec[@ast::ty] v = vec(); auto pos = p.get_lo_pos(); ret spanned(hi, hi, v); } -fn parse_path(parser p) -> ast.path { +fn parse_path(parser p) -> ast::path { auto lo = p.get_lo_pos(); auto hi = lo; - let vec[ast.ident] ids = vec(); + let vec[ast::ident] ids = vec(); while (true) { alt (p.peek()) { - case (token.IDENT(?i)) { + case (token::IDENT(?i)) { hi = p.get_hi_pos(); ids += vec(p.get_str(i)); p.bump(); - if (p.peek() == token.MOD_SEP) { + if (p.peek() == token::MOD_SEP) { p.bump(); } else { break; } } @@ -642,114 +642,114 @@ fn parse_path(parser p) -> ast.path { ret spanned(lo, tys.span.hi, rec(idents=ids, types=tys.node)); } -fn parse_mutability(parser p) -> ast.mutability { - if (p.peek() == token.MUTABLE) { +fn parse_mutability(parser p) -> ast::mutability { + if (p.peek() == token::MUTABLE) { p.bump(); - if (p.peek() == token.QUES) { + if (p.peek() == token::QUES) { p.bump(); - ret ast.maybe_mut; + ret ast::maybe_mut; } - ret ast.mut; + ret ast::mut; } - ret ast.imm; + ret ast::imm; } -fn parse_field(parser p) -> ast.field { +fn parse_field(parser p) -> ast::field { auto m = parse_mutability(p); auto i = parse_ident(p); - expect(p, token.EQ); + expect(p, token::EQ); auto e = parse_expr(p); ret rec(mut=m, ident=i, expr=e); } -fn parse_bottom_expr(parser p) -> @ast.expr { +fn parse_bottom_expr(parser p) -> @ast::expr { auto lo = p.get_lo_pos(); auto hi = p.get_hi_pos(); // FIXME: can only remove this sort of thing when both typestate and // alt-exhaustive-match checking are co-operating. - auto lit = @spanned(lo, hi, ast.lit_nil); - let ast.expr_ ex = ast.expr_lit(lit, p.get_ann()); + auto lit = @spanned(lo, hi, ast::lit_nil); + let ast::expr_ ex = ast::expr_lit(lit, p.get_ann()); alt (p.peek()) { - case (token.IDENT(_)) { + case (token::IDENT(_)) { auto pth = parse_path(p); hi = pth.span.hi; - ex = ast.expr_path(pth, p.get_ann()); + ex = ast::expr_path(pth, p.get_ann()); } - case (token.LPAREN) { + case (token::LPAREN) { p.bump(); alt (p.peek()) { - case (token.RPAREN) { + case (token::RPAREN) { hi = p.get_hi_pos(); p.bump(); - auto lit = @spanned(lo, hi, ast.lit_nil); + auto lit = @spanned(lo, hi, ast::lit_nil); ret @spanned(lo, hi, - ast.expr_lit(lit, p.get_ann())); + ast::expr_lit(lit, p.get_ann())); } case (_) { /* fall through */ } } auto e = parse_expr(p); hi = p.get_hi_pos(); - expect(p, token.RPAREN); + expect(p, token::RPAREN); ret @spanned(lo, hi, e.node); } - case (token.TUP) { + case (token::TUP) { p.bump(); - fn parse_elt(parser p) -> ast.elt { + fn parse_elt(parser p) -> ast::elt { auto m = parse_mutability(p); auto e = parse_expr(p); ret rec(mut=m, expr=e); } auto pf = parse_elt; auto es = - parse_seq[ast.elt](token.LPAREN, - token.RPAREN, - some(token.COMMA), + parse_seq[ast::elt](token::LPAREN, + token::RPAREN, + some(token::COMMA), pf, p); hi = es.span.hi; - ex = ast.expr_tup(es.node, p.get_ann()); + ex = ast::expr_tup(es.node, p.get_ann()); } - case (token.VEC) { + case (token::VEC) { p.bump(); auto pf = parse_expr; - expect(p, token.LPAREN); + expect(p, token::LPAREN); auto mut = parse_mutability(p); - auto es = parse_seq_to_end[@ast.expr](token.RPAREN, - some(token.COMMA), + auto es = parse_seq_to_end[@ast::expr](token::RPAREN, + some(token::COMMA), pf, hi, p); - ex = ast.expr_vec(es, mut, p.get_ann()); + ex = ast::expr_vec(es, mut, p.get_ann()); } - case (token.REC) { + case (token::REC) { p.bump(); - expect(p, token.LPAREN); + expect(p, token::LPAREN); auto fields = vec(parse_field(p)); auto more = true; - auto base = none[@ast.expr]; + auto base = none[@ast::expr]; while (more) { alt (p.peek()) { - case (token.RPAREN) { + case (token::RPAREN) { hi = p.get_hi_pos(); p.bump(); more = false; } - case (token.WITH) { + case (token::WITH) { p.bump(); - base = some[@ast.expr](parse_expr(p)); + base = some[@ast::expr](parse_expr(p)); hi = p.get_hi_pos(); - expect(p, token.RPAREN); + expect(p, token::RPAREN); more = false; } - case (token.COMMA) { + case (token::COMMA) { p.bump(); fields += vec(parse_field(p)); } @@ -760,170 +760,170 @@ fn parse_bottom_expr(parser p) -> @ast.expr { } - ex = ast.expr_rec(fields, base, p.get_ann()); + ex = ast::expr_rec(fields, base, p.get_ann()); } - case (token.BIND) { + case (token::BIND) { p.bump(); auto e = parse_expr_res(p, RESTRICT_NO_CALL_EXPRS); - fn parse_expr_opt(parser p) -> Option.t[@ast.expr] { + fn parse_expr_opt(parser p) -> option::t[@ast::expr] { alt (p.peek()) { - case (token.UNDERSCORE) { + case (token::UNDERSCORE) { p.bump(); - ret none[@ast.expr]; + ret none[@ast::expr]; } case (_) { - ret some[@ast.expr](parse_expr(p)); + ret some[@ast::expr](parse_expr(p)); } } } auto pf = parse_expr_opt; - auto es = parse_seq[Option.t[@ast.expr]](token.LPAREN, - token.RPAREN, - some(token.COMMA), + auto es = parse_seq[option::t[@ast::expr]](token::LPAREN, + token::RPAREN, + some(token::COMMA), pf, p); hi = es.span.hi; - ex = ast.expr_bind(e, es.node, p.get_ann()); + ex = ast::expr_bind(e, es.node, p.get_ann()); } - case (token.POUND) { + case (token::POUND) { p.bump(); auto pth = parse_path(p); auto pf = parse_expr; - auto es = parse_seq[@ast.expr](token.LPAREN, - token.RPAREN, - some(token.COMMA), + auto es = parse_seq[@ast::expr](token::LPAREN, + token::RPAREN, + some(token::COMMA), pf, p); hi = es.span.hi; ex = expand_syntax_ext(p, es.span, pth, es.node, none[str]); } - case (token.FAIL) { + case (token::FAIL) { p.bump(); - ex = ast.expr_fail(p.get_ann()); + ex = ast::expr_fail(p.get_ann()); } - case (token.LOG) { + case (token::LOG) { p.bump(); auto e = parse_expr(p); auto hi = e.span.hi; - ex = ast.expr_log(1, e, p.get_ann()); + ex = ast::expr_log(1, e, p.get_ann()); } - case (token.LOG_ERR) { + case (token::LOG_ERR) { p.bump(); auto e = parse_expr(p); auto hi = e.span.hi; - ex = ast.expr_log(0, e, p.get_ann()); + ex = ast::expr_log(0, e, p.get_ann()); } - case (token.ASSERT) { + case (token::ASSERT) { p.bump(); auto e = parse_expr(p); auto hi = e.span.hi; - ex = ast.expr_assert(e, p.get_ann()); + ex = ast::expr_assert(e, p.get_ann()); } - case (token.CHECK) { + case (token::CHECK) { p.bump(); /* Should be a predicate (pure boolean function) applied to arguments that are all either slot variables or literals. but the typechecker enforces that. */ auto e = parse_expr(p); auto hi = e.span.hi; - ex = ast.expr_check(e, p.get_ann()); + ex = ast::expr_check(e, p.get_ann()); } - case (token.RET) { + case (token::RET) { p.bump(); alt (p.peek()) { - case (token.SEMI) { - ex = ast.expr_ret(none[@ast.expr], p.get_ann()); + case (token::SEMI) { + ex = ast::expr_ret(none[@ast::expr], p.get_ann()); } case (_) { auto e = parse_expr(p); hi = e.span.hi; - ex = ast.expr_ret(some[@ast.expr](e), p.get_ann()); + ex = ast::expr_ret(some[@ast::expr](e), p.get_ann()); } } } - case (token.BREAK) { + case (token::BREAK) { p.bump(); - ex = ast.expr_break(p.get_ann()); + ex = ast::expr_break(p.get_ann()); } - case (token.CONT) { + case (token::CONT) { p.bump(); - ex = ast.expr_cont(p.get_ann()); + ex = ast::expr_cont(p.get_ann()); } - case (token.PUT) { + case (token::PUT) { p.bump(); alt (p.peek()) { - case (token.SEMI) { - ex = ast.expr_put(none[@ast.expr], p.get_ann()); + case (token::SEMI) { + ex = ast::expr_put(none[@ast::expr], p.get_ann()); } case (_) { auto e = parse_expr(p); hi = e.span.hi; - ex = ast.expr_put(some[@ast.expr](e), p.get_ann()); + ex = ast::expr_put(some[@ast::expr](e), p.get_ann()); } } } - case (token.BE) { + case (token::BE) { p.bump(); auto e = parse_expr(p); // FIXME: Is this the right place for this check? - if /*check*/ (ast.is_call_expr(e)) { + if /*check*/ (ast::is_call_expr(e)) { hi = e.span.hi; - ex = ast.expr_be(e, p.get_ann()); + ex = ast::expr_be(e, p.get_ann()); } else { p.err("Non-call expression in tail call"); } } - case (token.PORT) { + case (token::PORT) { p.bump(); - expect(p, token.LPAREN); - expect(p, token.RPAREN); + expect(p, token::LPAREN); + expect(p, token::RPAREN); hi = p.get_hi_pos(); - ex = ast.expr_port(p.get_ann()); + ex = ast::expr_port(p.get_ann()); } - case (token.CHAN) { + case (token::CHAN) { p.bump(); - expect(p, token.LPAREN); + expect(p, token::LPAREN); auto e = parse_expr(p); hi = e.span.hi; - expect(p, token.RPAREN); - ex = ast.expr_chan(e, p.get_ann()); + expect(p, token::RPAREN); + ex = ast::expr_chan(e, p.get_ann()); } - case (token.SELF) { + case (token::SELF) { log "parsing a self-call..."; p.bump(); - expect(p, token.DOT); + expect(p, token::DOT); // The rest is a call expression. - let @ast.expr f = parse_self_method(p); + let @ast::expr f = parse_self_method(p); auto pf = parse_expr; - auto es = parse_seq[@ast.expr](token.LPAREN, - token.RPAREN, - some(token.COMMA), + auto es = parse_seq[@ast::expr](token::LPAREN, + token::RPAREN, + some(token::COMMA), pf, p); hi = es.span.hi; - ex = ast.expr_call(f, es.node, p.get_ann()); + ex = ast::expr_call(f, es.node, p.get_ann()); } case (_) { auto lit = parse_lit(p); hi = lit.span.hi; - ex = ast.expr_lit(@lit, p.get_ann()); + ex = ast::expr_lit(@lit, p.get_ann()); } } @@ -939,22 +939,22 @@ fn parse_bottom_expr(parser p) -> @ast.expr { * rust crates. At the moment we have neither. */ -fn expand_syntax_ext(parser p, ast.span sp, - &ast.path path, vec[@ast.expr] args, - Option.t[str] body) -> ast.expr_ { +fn expand_syntax_ext(parser p, ast::span sp, + &ast::path path, vec[@ast::expr] args, + option::t[str] body) -> ast::expr_ { - assert (Vec.len[ast.ident](path.node.idents) > 0u); + assert (_vec::len[ast::ident](path.node.idents) > 0u); auto extname = path.node.idents.(0); - if (Str.eq(extname, "fmt")) { - auto expanded = extfmt.expand_syntax_ext(p, args, body); - auto newexpr = ast.expr_ext(path, args, body, + if (_str::eq(extname, "fmt")) { + auto expanded = extfmt::expand_syntax_ext(p, args, body); + auto newexpr = ast::expr_ext(path, args, body, expanded, p.get_ann()); ret newexpr; - } else if (Str.eq(extname, "env")) { - auto expanded = extenv.expand_syntax_ext(p, sp, args, body); - auto newexpr = ast.expr_ext(path, args, body, + } else if (_str::eq(extname, "env")) { + auto expanded = extenv::expand_syntax_ext(p, sp, args, body); + auto newexpr = ast::expr_ext(path, args, body, expanded, p.get_ann()); @@ -965,54 +965,54 @@ fn expand_syntax_ext(parser p, ast.span sp, } } -fn parse_self_method(parser p) -> @ast.expr { +fn parse_self_method(parser p) -> @ast::expr { auto sp = p.get_span(); - let ast.ident f_name = parse_ident(p); + let ast::ident f_name = parse_ident(p); auto hi = p.get_span(); - ret @rec(node=ast.expr_self_method(f_name, p.get_ann()), span=sp); + ret @rec(node=ast::expr_self_method(f_name, p.get_ann()), span=sp); } -fn parse_dot_or_call_expr(parser p) -> @ast.expr { +fn parse_dot_or_call_expr(parser p) -> @ast::expr { auto lo = p.get_lo_pos(); auto e = parse_bottom_expr(p); auto hi = e.span.hi; while (true) { alt (p.peek()) { - case (token.LPAREN) { + case (token::LPAREN) { if (p.get_restriction() == RESTRICT_NO_CALL_EXPRS) { ret e; } else { // Call expr. auto pf = parse_expr; - auto es = parse_seq[@ast.expr](token.LPAREN, - token.RPAREN, - some(token.COMMA), + auto es = parse_seq[@ast::expr](token::LPAREN, + token::RPAREN, + some(token::COMMA), pf, p); hi = es.span.hi; - auto e_ = ast.expr_call(e, es.node, p.get_ann()); + auto e_ = ast::expr_call(e, es.node, p.get_ann()); e = @spanned(lo, hi, e_); } } - case (token.DOT) { + case (token::DOT) { p.bump(); alt (p.peek()) { - case (token.IDENT(?i)) { + case (token::IDENT(?i)) { hi = p.get_hi_pos(); p.bump(); - auto e_ = ast.expr_field(e, p.get_str(i), + auto e_ = ast::expr_field(e, p.get_str(i), p.get_ann()); e = @spanned(lo, hi, e_); } - case (token.LPAREN) { + case (token::LPAREN) { p.bump(); auto ix = parse_expr(p); hi = ix.span.hi; - expect(p, token.RPAREN); - auto e_ = ast.expr_index(e, ix, p.get_ann()); + expect(p, token::RPAREN); + auto e_ = ast::expr_index(e, ix, p.get_ann()); e = @spanned(lo, hi, e_); } @@ -1029,9 +1029,9 @@ fn parse_dot_or_call_expr(parser p) -> @ast.expr { ret e; } -fn parse_prefix_expr(parser p) -> @ast.expr { +fn parse_prefix_expr(parser p) -> @ast::expr { - if (p.peek() == token.MUTABLE) { + if (p.peek() == token::MUTABLE) { p.bump(); p.get_session().span_warn(p.get_span(), "ignoring deprecated 'mutable' prefix operator"); @@ -1042,39 +1042,39 @@ fn parse_prefix_expr(parser p) -> @ast.expr { // FIXME: can only remove this sort of thing when both typestate and // alt-exhaustive-match checking are co-operating. - auto lit = @spanned(lo, lo, ast.lit_nil); - let ast.expr_ ex = ast.expr_lit(lit, p.get_ann()); + auto lit = @spanned(lo, lo, ast::lit_nil); + let ast::expr_ ex = ast::expr_lit(lit, p.get_ann()); alt (p.peek()) { - case (token.NOT) { + case (token::NOT) { p.bump(); auto e = parse_prefix_expr(p); hi = e.span.hi; - ex = ast.expr_unary(ast.not, e, p.get_ann()); + ex = ast::expr_unary(ast::not, e, p.get_ann()); } - case (token.TILDE) { + case (token::TILDE) { p.bump(); auto e = parse_prefix_expr(p); hi = e.span.hi; - ex = ast.expr_unary(ast.bitnot, e, p.get_ann()); + ex = ast::expr_unary(ast::bitnot, e, p.get_ann()); } - case (token.BINOP(?b)) { + case (token::BINOP(?b)) { alt (b) { - case (token.MINUS) { + case (token::MINUS) { p.bump(); auto e = parse_prefix_expr(p); hi = e.span.hi; - ex = ast.expr_unary(ast.neg, e, p.get_ann()); + ex = ast::expr_unary(ast::neg, e, p.get_ann()); } - case (token.STAR) { + case (token::STAR) { p.bump(); auto e = parse_prefix_expr(p); hi = e.span.hi; - ex = ast.expr_unary(ast.deref, e, p.get_ann()); + ex = ast::expr_unary(ast::deref, e, p.get_ann()); } case (_) { @@ -1083,12 +1083,12 @@ fn parse_prefix_expr(parser p) -> @ast.expr { } } - case (token.AT) { + case (token::AT) { p.bump(); auto m = parse_mutability(p); auto e = parse_prefix_expr(p); hi = e.span.hi; - ex = ast.expr_unary(ast.box(m), e, p.get_ann()); + ex = ast::expr_unary(ast::box(m), e, p.get_ann()); } case (_) { @@ -1098,42 +1098,42 @@ fn parse_prefix_expr(parser p) -> @ast.expr { ret @spanned(lo, hi, ex); } -type op_spec = rec(token.token tok, ast.binop op, int prec); +type op_spec = rec(token::token tok, ast::binop op, int prec); // FIXME make this a const, don't store it in parser state fn prec_table() -> vec[op_spec] { - ret vec(rec(tok=token.BINOP(token.STAR), op=ast.mul, prec=11), - rec(tok=token.BINOP(token.SLASH), op=ast.div, prec=11), - rec(tok=token.BINOP(token.PERCENT), op=ast.rem, prec=11), - rec(tok=token.BINOP(token.PLUS), op=ast.add, prec=10), - rec(tok=token.BINOP(token.MINUS), op=ast.sub, prec=10), - rec(tok=token.BINOP(token.LSL), op=ast.lsl, prec=9), - rec(tok=token.BINOP(token.LSR), op=ast.lsr, prec=9), - rec(tok=token.BINOP(token.ASR), op=ast.asr, prec=9), - rec(tok=token.BINOP(token.AND), op=ast.bitand, prec=8), - rec(tok=token.BINOP(token.CARET), op=ast.bitxor, prec=6), - rec(tok=token.BINOP(token.OR), op=ast.bitor, prec=6), - // ast.mul is a bogus placeholder here, AS is special + ret vec(rec(tok=token::BINOP(token::STAR), op=ast::mul, prec=11), + rec(tok=token::BINOP(token::SLASH), op=ast::div, prec=11), + rec(tok=token::BINOP(token::PERCENT), op=ast::rem, prec=11), + rec(tok=token::BINOP(token::PLUS), op=ast::add, prec=10), + rec(tok=token::BINOP(token::MINUS), op=ast::sub, prec=10), + rec(tok=token::BINOP(token::LSL), op=ast::lsl, prec=9), + rec(tok=token::BINOP(token::LSR), op=ast::lsr, prec=9), + rec(tok=token::BINOP(token::ASR), op=ast::asr, prec=9), + rec(tok=token::BINOP(token::AND), op=ast::bitand, prec=8), + rec(tok=token::BINOP(token::CARET), op=ast::bitxor, prec=6), + rec(tok=token::BINOP(token::OR), op=ast::bitor, prec=6), + // ast::mul is a bogus placeholder here, AS is special // cased in parse_more_binops - rec(tok=token.AS, op=ast.mul, prec=5), - rec(tok=token.LT, op=ast.lt, prec=4), - rec(tok=token.LE, op=ast.le, prec=4), - rec(tok=token.GE, op=ast.ge, prec=4), - rec(tok=token.GT, op=ast.gt, prec=4), - rec(tok=token.EQEQ, op=ast.eq, prec=3), - rec(tok=token.NE, op=ast.ne, prec=3), - rec(tok=token.ANDAND, op=ast.and, prec=2), - rec(tok=token.OROR, op=ast.or, prec=1)); -} - -fn parse_binops(parser p) -> @ast.expr { + rec(tok=token::AS, op=ast::mul, prec=5), + rec(tok=token::LT, op=ast::lt, prec=4), + rec(tok=token::LE, op=ast::le, prec=4), + rec(tok=token::GE, op=ast::ge, prec=4), + rec(tok=token::GT, op=ast::gt, prec=4), + rec(tok=token::EQEQ, op=ast::eq, prec=3), + rec(tok=token::NE, op=ast::ne, prec=3), + rec(tok=token::ANDAND, op=ast::and, prec=2), + rec(tok=token::OROR, op=ast::or, prec=1)); +} + +fn parse_binops(parser p) -> @ast::expr { ret parse_more_binops(p, parse_prefix_expr(p), 0); } -fn parse_more_binops(parser p, @ast.expr lhs, int min_prec) - -> @ast.expr { +fn parse_more_binops(parser p, @ast::expr lhs, int min_prec) + -> @ast::expr { // Magic nonsense to work around rustboot bug - fn op_eq(token.token a, token.token b) -> bool { + fn op_eq(token::token a, token::token b) -> bool { if (a == b) {ret true;} else {ret false;} } @@ -1142,16 +1142,16 @@ fn parse_more_binops(parser p, @ast.expr lhs, int min_prec) if (cur.prec > min_prec && op_eq(cur.tok, peeked)) { p.bump(); alt (cur.tok) { - case (token.AS) { + case (token::AS) { auto rhs = parse_ty(p); - auto _as = ast.expr_cast(lhs, rhs, p.get_ann()); + auto _as = ast::expr_cast(lhs, rhs, p.get_ann()); auto span = @spanned(lhs.span.lo, rhs.span.hi, _as); ret parse_more_binops(p, span, min_prec); } case (_) { auto rhs = parse_more_binops(p, parse_prefix_expr(p), cur.prec); - auto bin = ast.expr_binary(cur.op, lhs, rhs, + auto bin = ast::expr_binary(cur.op, lhs, rhs, p.get_ann()); auto span = @spanned(lhs.span.lo, rhs.span.hi, bin); ret parse_more_binops(p, span, min_prec); @@ -1162,65 +1162,65 @@ fn parse_more_binops(parser p, @ast.expr lhs, int min_prec) ret lhs; } -fn parse_assign_expr(parser p) -> @ast.expr { +fn parse_assign_expr(parser p) -> @ast::expr { auto lo = p.get_lo_pos(); auto lhs = parse_binops(p); alt (p.peek()) { - case (token.EQ) { + case (token::EQ) { p.bump(); auto rhs = parse_expr(p); ret @spanned(lo, rhs.span.hi, - ast.expr_assign(lhs, rhs, p.get_ann())); + ast::expr_assign(lhs, rhs, p.get_ann())); } - case (token.BINOPEQ(?op)) { + case (token::BINOPEQ(?op)) { p.bump(); auto rhs = parse_expr(p); - auto aop = ast.add; + auto aop = ast::add; alt (op) { - case (token.PLUS) { aop = ast.add; } - case (token.MINUS) { aop = ast.sub; } - case (token.STAR) { aop = ast.mul; } - case (token.SLASH) { aop = ast.div; } - case (token.PERCENT) { aop = ast.rem; } - case (token.CARET) { aop = ast.bitxor; } - case (token.AND) { aop = ast.bitand; } - case (token.OR) { aop = ast.bitor; } - case (token.LSL) { aop = ast.lsl; } - case (token.LSR) { aop = ast.lsr; } - case (token.ASR) { aop = ast.asr; } + case (token::PLUS) { aop = ast::add; } + case (token::MINUS) { aop = ast::sub; } + case (token::STAR) { aop = ast::mul; } + case (token::SLASH) { aop = ast::div; } + case (token::PERCENT) { aop = ast::rem; } + case (token::CARET) { aop = ast::bitxor; } + case (token::AND) { aop = ast::bitand; } + case (token::OR) { aop = ast::bitor; } + case (token::LSL) { aop = ast::lsl; } + case (token::LSR) { aop = ast::lsr; } + case (token::ASR) { aop = ast::asr; } } ret @spanned(lo, rhs.span.hi, - ast.expr_assign_op(aop, lhs, rhs, p.get_ann())); + ast::expr_assign_op(aop, lhs, rhs, p.get_ann())); } - case (token.SEND) { + case (token::SEND) { p.bump(); auto rhs = parse_expr(p); ret @spanned(lo, rhs.span.hi, - ast.expr_send(lhs, rhs, p.get_ann())); + ast::expr_send(lhs, rhs, p.get_ann())); } - case (token.LARROW) { + case (token::LARROW) { p.bump(); auto rhs = parse_expr(p); ret @spanned(lo, rhs.span.hi, - ast.expr_recv(lhs, rhs, p.get_ann())); + ast::expr_recv(lhs, rhs, p.get_ann())); } case (_) { /* fall through */ } } ret lhs; } -fn parse_if_expr(parser p) -> @ast.expr { +fn parse_if_expr(parser p) -> @ast::expr { auto lo = p.get_lo_pos(); - expect(p, token.IF); - expect(p, token.LPAREN); + expect(p, token::IF); + expect(p, token::LPAREN); auto cond = parse_expr(p); - expect(p, token.RPAREN); + expect(p, token::RPAREN); auto thn = parse_block(p); - let Option.t[@ast.expr] els = none[@ast.expr]; + let option::t[@ast::expr] els = none[@ast::expr]; auto hi = thn.span.hi; alt (p.peek()) { - case (token.ELSE) { + case (token::ELSE) { auto elexpr = parse_else_expr(p); els = some(elexpr); hi = elexpr.span.hi; @@ -1228,106 +1228,106 @@ fn parse_if_expr(parser p) -> @ast.expr { case (_) { /* fall through */ } } - ret @spanned(lo, hi, ast.expr_if(cond, thn, els, p.get_ann())); + ret @spanned(lo, hi, ast::expr_if(cond, thn, els, p.get_ann())); } -fn parse_else_expr(parser p) -> @ast.expr { - expect(p, token.ELSE); +fn parse_else_expr(parser p) -> @ast::expr { + expect(p, token::ELSE); alt (p.peek()) { - case (token.IF) { + case (token::IF) { ret parse_if_expr(p); } case (_) { auto blk = parse_block(p); ret @spanned(blk.span.lo, blk.span.hi, - ast.expr_block(blk, p.get_ann())); + ast::expr_block(blk, p.get_ann())); } } } -fn parse_head_local(parser p) -> @ast.decl { +fn parse_head_local(parser p) -> @ast::decl { auto lo = p.get_lo_pos(); - let @ast.local local; - if (p.peek() == token.AUTO) { + let @ast::local local; + if (p.peek() == token::AUTO) { local = parse_auto_local(p); } else { local = parse_typed_local(p); } - ret @spanned(lo, p.get_hi_pos(), ast.decl_local(local)); + ret @spanned(lo, p.get_hi_pos(), ast::decl_local(local)); } -fn parse_for_expr(parser p) -> @ast.expr { +fn parse_for_expr(parser p) -> @ast::expr { auto lo = p.get_lo_pos(); auto is_each = false; - expect(p, token.FOR); - if (p.peek() == token.EACH) { + expect(p, token::FOR); + if (p.peek() == token::EACH) { is_each = true; p.bump(); } - expect (p, token.LPAREN); + expect (p, token::LPAREN); auto decl = parse_head_local(p); - expect(p, token.IN); + expect(p, token::IN); auto seq = parse_expr(p); - expect(p, token.RPAREN); + expect(p, token::RPAREN); auto body = parse_block(p); auto hi = body.span.hi; if (is_each) { - ret @spanned(lo, hi, ast.expr_for_each(decl, seq, body, + ret @spanned(lo, hi, ast::expr_for_each(decl, seq, body, p.get_ann())); } else { - ret @spanned(lo, hi, ast.expr_for(decl, seq, body, + ret @spanned(lo, hi, ast::expr_for(decl, seq, body, p.get_ann())); } } -fn parse_while_expr(parser p) -> @ast.expr { +fn parse_while_expr(parser p) -> @ast::expr { auto lo = p.get_lo_pos(); - expect(p, token.WHILE); - expect (p, token.LPAREN); + expect(p, token::WHILE); + expect (p, token::LPAREN); auto cond = parse_expr(p); - expect(p, token.RPAREN); + expect(p, token::RPAREN); auto body = parse_block(p); auto hi = body.span.hi; - ret @spanned(lo, hi, ast.expr_while(cond, body, p.get_ann())); + ret @spanned(lo, hi, ast::expr_while(cond, body, p.get_ann())); } -fn parse_do_while_expr(parser p) -> @ast.expr { +fn parse_do_while_expr(parser p) -> @ast::expr { auto lo = p.get_lo_pos(); - expect(p, token.DO); + expect(p, token::DO); auto body = parse_block(p); - expect(p, token.WHILE); - expect (p, token.LPAREN); + expect(p, token::WHILE); + expect (p, token::LPAREN); auto cond = parse_expr(p); - expect(p, token.RPAREN); + expect(p, token::RPAREN); auto hi = cond.span.hi; - ret @spanned(lo, hi, ast.expr_do_while(body, cond, p.get_ann())); + ret @spanned(lo, hi, ast::expr_do_while(body, cond, p.get_ann())); } -fn parse_alt_expr(parser p) -> @ast.expr { +fn parse_alt_expr(parser p) -> @ast::expr { auto lo = p.get_lo_pos(); - expect(p, token.ALT); - expect(p, token.LPAREN); + expect(p, token::ALT); + expect(p, token::LPAREN); auto discriminant = parse_expr(p); - expect(p, token.RPAREN); - expect(p, token.LBRACE); + expect(p, token::RPAREN); + expect(p, token::LBRACE); - let vec[ast.arm] arms = vec(); - while (p.peek() != token.RBRACE) { + let vec[ast::arm] arms = vec(); + while (p.peek() != token::RBRACE) { alt (p.peek()) { - case (token.CASE) { + case (token::CASE) { p.bump(); - expect(p, token.LPAREN); + expect(p, token::LPAREN); auto pat = parse_pat(p); - expect(p, token.RPAREN); + expect(p, token::RPAREN); auto block = parse_block(p); arms += vec(rec(pat=pat, block=block)); } @@ -1340,53 +1340,53 @@ fn parse_alt_expr(parser p) -> @ast.expr { // meaning, and only exists due to the cexp/pexp split // in rustboot, which we're not maintaining. - case (token.ELSE) { + case (token::ELSE) { p.bump(); auto hi = p.get_hi_pos(); - auto pat = @spanned(lo, hi, ast.pat_wild(p.get_ann())); + auto pat = @spanned(lo, hi, ast::pat_wild(p.get_ann())); auto block = parse_block(p); arms += vec(rec(pat=pat, block=block)); } - case (token.RBRACE) { /* empty */ } + case (token::RBRACE) { /* empty */ } case (?tok) { p.err("expected 'case' or '}' when parsing 'alt' statement " + - "but found " + token.to_str(p.get_reader(), tok)); + "but found " + token::to_str(p.get_reader(), tok)); } } } auto hi = p.get_hi_pos(); p.bump(); - auto expr = ast.expr_alt(discriminant, arms, p.get_ann()); + auto expr = ast::expr_alt(discriminant, arms, p.get_ann()); ret @spanned(lo, hi, expr); } -fn parse_spawn_expr(parser p) -> @ast.expr { +fn parse_spawn_expr(parser p) -> @ast::expr { auto lo = p.get_lo_pos(); - expect(p, token.SPAWN); + expect(p, token::SPAWN); // FIXME: Parse domain and name // FIXME: why no full expr? auto fn_expr = parse_bottom_expr(p); auto pf = parse_expr; - auto es = parse_seq[@ast.expr](token.LPAREN, - token.RPAREN, - some(token.COMMA), + auto es = parse_seq[@ast::expr](token::LPAREN, + token::RPAREN, + some(token::COMMA), pf, p); auto hi = es.span.hi; - auto spawn_expr = ast.expr_spawn(ast.dom_implicit, - Option.none[str], + auto spawn_expr = ast::expr_spawn(ast::dom_implicit, + option::none[str], fn_expr, es.node, p.get_ann()); ret @spanned(lo, hi, spawn_expr); } -fn parse_expr(parser p) -> @ast.expr { +fn parse_expr(parser p) -> @ast::expr { ret parse_expr_res(p, UNRESTRICTED); } -fn parse_expr_res(parser p, restriction r) -> @ast.expr { +fn parse_expr_res(parser p, restriction r) -> @ast::expr { auto old = p.get_restriction(); p.restrict(r); auto e = parse_expr_inner(p); @@ -1394,29 +1394,29 @@ fn parse_expr_res(parser p, restriction r) -> @ast.expr { ret e; } -fn parse_expr_inner(parser p) -> @ast.expr { +fn parse_expr_inner(parser p) -> @ast::expr { alt (p.peek()) { - case (token.LBRACE) { + case (token::LBRACE) { auto blk = parse_block(p); ret @spanned(blk.span.lo, blk.span.hi, - ast.expr_block(blk, p.get_ann())); + ast::expr_block(blk, p.get_ann())); } - case (token.IF) { + case (token::IF) { ret parse_if_expr(p); } - case (token.FOR) { + case (token::FOR) { ret parse_for_expr(p); } - case (token.WHILE) { + case (token::WHILE) { ret parse_while_expr(p); } - case (token.DO) { + case (token::DO) { ret parse_do_while_expr(p); } - case (token.ALT) { + case (token::ALT) { ret parse_alt_expr(p); } - case (token.SPAWN) { + case (token::SPAWN) { ret parse_spawn_expr(p); } case (_) { @@ -1426,80 +1426,81 @@ fn parse_expr_inner(parser p) -> @ast.expr { } } -fn parse_initializer(parser p) -> Option.t[ast.initializer] { +fn parse_initializer(parser p) -> option::t[ast::initializer] { alt (p.peek()) { - case (token.EQ) { + case (token::EQ) { p.bump(); - ret some(rec(op = ast.init_assign, + ret some(rec(op = ast::init_assign, expr = parse_expr(p))); } - case (token.LARROW) { + case (token::LARROW) { p.bump(); - ret some(rec(op = ast.init_recv, + ret some(rec(op = ast::init_recv, expr = parse_expr(p))); } case (_) { - ret none[ast.initializer]; + ret none[ast::initializer]; } } } -fn parse_pat(parser p) -> @ast.pat { +fn parse_pat(parser p) -> @ast::pat { auto lo = p.get_lo_pos(); auto hi = p.get_hi_pos(); auto pat; alt (p.peek()) { - case (token.UNDERSCORE) { + case (token::UNDERSCORE) { p.bump(); - pat = ast.pat_wild(p.get_ann()); + pat = ast::pat_wild(p.get_ann()); } - case (token.QUES) { + case (token::QUES) { p.bump(); alt (p.peek()) { - case (token.IDENT(?id)) { + case (token::IDENT(?id)) { hi = p.get_hi_pos(); p.bump(); - pat = ast.pat_bind(p.get_str(id), p.next_def_id(), + pat = ast::pat_bind(p.get_str(id), p.next_def_id(), p.get_ann()); } case (?tok) { p.err("expected identifier after '?' in pattern but " + - "found " + token.to_str(p.get_reader(), tok)); + "found " + token::to_str(p.get_reader(), tok)); fail; } } } - case (token.IDENT(_)) { + case (token::IDENT(_)) { auto tag_path = parse_path(p); hi = tag_path.span.hi; - let vec[@ast.pat] args; + let vec[@ast::pat] args; alt (p.peek()) { - case (token.LPAREN) { + case (token::LPAREN) { auto f = parse_pat; - auto a = parse_seq[@ast.pat](token.LPAREN, token.RPAREN, - some(token.COMMA), f, p); + auto a = parse_seq[@ast::pat](token::LPAREN, + token::RPAREN, + some(token::COMMA), f, p); args = a.node; hi = a.span.hi; } case (_) { args = vec(); } } - pat = ast.pat_tag(tag_path, args, p.get_ann()); + pat = ast::pat_tag(tag_path, args, p.get_ann()); } case (_) { auto lit = parse_lit(p); hi = lit.span.hi; - pat = ast.pat_lit(@lit, p.get_ann()); + pat = ast::pat_lit(@lit, p.get_ann()); } } ret @spanned(lo, hi, pat); } -fn parse_local_full(&Option.t[@ast.ty] tyopt, - parser p) -> @ast.local { +fn parse_local_full(&option::t[@ast::ty] tyopt, + parser p) -> @ast::local { auto ident = parse_ident(p); auto init = parse_initializer(p); ret @rec(ty = tyopt, @@ -1510,30 +1511,30 @@ fn parse_local_full(&Option.t[@ast.ty] tyopt, ann = p.get_ann()); } -fn parse_typed_local(parser p) -> @ast.local { +fn parse_typed_local(parser p) -> @ast::local { auto ty = parse_ty(p); ret parse_local_full(some(ty), p); } -fn parse_auto_local(parser p) -> @ast.local { - ret parse_local_full(none[@ast.ty], p); +fn parse_auto_local(parser p) -> @ast::local { + ret parse_local_full(none[@ast::ty], p); } -fn parse_let(parser p) -> @ast.decl { +fn parse_let(parser p) -> @ast::decl { auto lo = p.get_lo_pos(); - expect(p, token.LET); + expect(p, token::LET); auto local = parse_typed_local(p); - ret @spanned(lo, p.get_hi_pos(), ast.decl_local(local)); + ret @spanned(lo, p.get_hi_pos(), ast::decl_local(local)); } -fn parse_auto(parser p) -> @ast.decl { +fn parse_auto(parser p) -> @ast::decl { auto lo = p.get_lo_pos(); - expect(p, token.AUTO); + expect(p, token::AUTO); auto local = parse_auto_local(p); - ret @spanned(lo, p.get_hi_pos(), ast.decl_local(local)); + ret @spanned(lo, p.get_hi_pos(), ast::decl_local(local)); } -fn parse_stmt(parser p) -> @ast.stmt { +fn parse_stmt(parser p) -> @ast::stmt { if (p.get_file_type() == SOURCE_FILE) { ret parse_source_stmt(p); } else { @@ -1541,27 +1542,27 @@ fn parse_stmt(parser p) -> @ast.stmt { } } -fn parse_crate_stmt(parser p) -> @ast.stmt { +fn parse_crate_stmt(parser p) -> @ast::stmt { auto cdir = parse_crate_directive(p); ret @spanned(cdir.span.lo, cdir.span.hi, - ast.stmt_crate_directive(@cdir)); + ast::stmt_crate_directive(@cdir)); } -fn parse_source_stmt(parser p) -> @ast.stmt { +fn parse_source_stmt(parser p) -> @ast::stmt { auto lo = p.get_lo_pos(); alt (p.peek()) { - case (token.LET) { + case (token::LET) { auto decl = parse_let(p); auto hi = p.get_span(); ret @spanned - (lo, decl.span.hi, ast.stmt_decl(decl, p.get_ann())); + (lo, decl.span.hi, ast::stmt_decl(decl, p.get_ann())); } - case (token.AUTO) { + case (token::AUTO) { auto decl = parse_auto(p); auto hi = p.get_span(); - ret @spanned(lo, decl.span.hi, ast.stmt_decl(decl, p.get_ann())); + ret @spanned(lo, decl.span.hi, ast::stmt_decl(decl, p.get_ann())); } case (_) { @@ -1569,14 +1570,14 @@ fn parse_source_stmt(parser p) -> @ast.stmt { // Might be a local item decl. auto i = parse_item(p); auto hi = i.span.hi; - auto decl = @spanned(lo, hi, ast.decl_item(i)); - ret @spanned(lo, hi, ast.stmt_decl(decl, p.get_ann())); + auto decl = @spanned(lo, hi, ast::decl_item(i)); + ret @spanned(lo, hi, ast::stmt_decl(decl, p.get_ann())); } else { // Remainder are line-expr stmts. auto e = parse_expr(p); auto hi = p.get_span(); - ret @spanned(lo, e.span.hi, ast.stmt_expr(e, p.get_ann())); + ret @spanned(lo, e.span.hi, ast::stmt_expr(e, p.get_ann())); } } } @@ -1584,103 +1585,103 @@ fn parse_source_stmt(parser p) -> @ast.stmt { fail; } -fn stmt_to_expr(@ast.stmt stmt) -> Option.t[@ast.expr] { +fn stmt_to_expr(@ast::stmt stmt) -> option::t[@ast::expr] { alt (stmt.node) { - case (ast.stmt_expr(?e,_)) { ret some[@ast.expr](e); } + case (ast::stmt_expr(?e,_)) { ret some[@ast::expr](e); } case (_) { /* fall through */ } } - ret none[@ast.expr]; + ret none[@ast::expr]; } -fn stmt_ends_with_semi(@ast.stmt stmt) -> bool { +fn stmt_ends_with_semi(@ast::stmt stmt) -> bool { alt (stmt.node) { - case (ast.stmt_decl(?d,_)) { + case (ast::stmt_decl(?d,_)) { alt (d.node) { - case (ast.decl_local(_)) { ret true; } - case (ast.decl_item(_)) { ret false; } + case (ast::decl_local(_)) { ret true; } + case (ast::decl_item(_)) { ret false; } } } - case (ast.stmt_expr(?e,_)) { + case (ast::stmt_expr(?e,_)) { alt (e.node) { - case (ast.expr_vec(_,_,_)) { ret true; } - case (ast.expr_tup(_,_)) { ret true; } - case (ast.expr_rec(_,_,_)) { ret true; } - case (ast.expr_call(_,_,_)) { ret true; } - case (ast.expr_self_method(_,_)){ ret false; } - case (ast.expr_binary(_,_,_,_)) { ret true; } - case (ast.expr_unary(_,_,_)) { ret true; } - case (ast.expr_lit(_,_)) { ret true; } - case (ast.expr_cast(_,_,_)) { ret true; } - case (ast.expr_if(_,_,_,_)) { ret false; } - case (ast.expr_for(_,_,_,_)) { ret false; } - case (ast.expr_for_each(_,_,_,_)) + case (ast::expr_vec(_,_,_)) { ret true; } + case (ast::expr_tup(_,_)) { ret true; } + case (ast::expr_rec(_,_,_)) { ret true; } + case (ast::expr_call(_,_,_)) { ret true; } + case (ast::expr_self_method(_,_)){ ret false; } + case (ast::expr_binary(_,_,_,_)) { ret true; } + case (ast::expr_unary(_,_,_)) { ret true; } + case (ast::expr_lit(_,_)) { ret true; } + case (ast::expr_cast(_,_,_)) { ret true; } + case (ast::expr_if(_,_,_,_)) { ret false; } + case (ast::expr_for(_,_,_,_)) { ret false; } + case (ast::expr_for_each(_,_,_,_)) { ret false; } - case (ast.expr_while(_,_,_)) { ret false; } - case (ast.expr_do_while(_,_,_)) { ret false; } - case (ast.expr_alt(_,_,_)) { ret false; } - case (ast.expr_block(_,_)) { ret false; } - case (ast.expr_assign(_,_,_)) { ret true; } - case (ast.expr_assign_op(_,_,_,_)) + case (ast::expr_while(_,_,_)) { ret false; } + case (ast::expr_do_while(_,_,_)) { ret false; } + case (ast::expr_alt(_,_,_)) { ret false; } + case (ast::expr_block(_,_)) { ret false; } + case (ast::expr_assign(_,_,_)) { ret true; } + case (ast::expr_assign_op(_,_,_,_)) { ret true; } - case (ast.expr_send(_,_,_)) { ret true; } - case (ast.expr_recv(_,_,_)) { ret true; } - case (ast.expr_field(_,_,_)) { ret true; } - case (ast.expr_index(_,_,_)) { ret true; } - case (ast.expr_path(_,_)) { ret true; } - case (ast.expr_fail(_)) { ret true; } - case (ast.expr_break(_)) { ret true; } - case (ast.expr_cont(_)) { ret true; } - case (ast.expr_ret(_,_)) { ret true; } - case (ast.expr_put(_,_)) { ret true; } - case (ast.expr_be(_,_)) { ret true; } - case (ast.expr_log(_,_,_)) { ret true; } - case (ast.expr_check(_,_)) { ret true; } - case (ast.expr_assert(_,_)) { ret true; } + case (ast::expr_send(_,_,_)) { ret true; } + case (ast::expr_recv(_,_,_)) { ret true; } + case (ast::expr_field(_,_,_)) { ret true; } + case (ast::expr_index(_,_,_)) { ret true; } + case (ast::expr_path(_,_)) { ret true; } + case (ast::expr_fail(_)) { ret true; } + case (ast::expr_break(_)) { ret true; } + case (ast::expr_cont(_)) { ret true; } + case (ast::expr_ret(_,_)) { ret true; } + case (ast::expr_put(_,_)) { ret true; } + case (ast::expr_be(_,_)) { ret true; } + case (ast::expr_log(_,_,_)) { ret true; } + case (ast::expr_check(_,_)) { ret true; } + case (ast::expr_assert(_,_)) { ret true; } } } // We should not be calling this on a cdir. - case (ast.stmt_crate_directive(?cdir)) { fail; } + case (ast::stmt_crate_directive(?cdir)) { fail; } } } -fn parse_block(parser p) -> ast.block { +fn parse_block(parser p) -> ast::block { auto lo = p.get_lo_pos(); - let vec[@ast.stmt] stmts = vec(); - let Option.t[@ast.expr] expr = none[@ast.expr]; + let vec[@ast::stmt] stmts = vec(); + let option::t[@ast::expr] expr = none[@ast::expr]; - expect(p, token.LBRACE); - while (p.peek() != token.RBRACE) { + expect(p, token::LBRACE); + while (p.peek() != token::RBRACE) { alt (p.peek()) { - case (token.RBRACE) { + case (token::RBRACE) { // empty; fall through to next iteration } - case (token.SEMI) { + case (token::SEMI) { p.bump(); // empty } case (_) { auto stmt = parse_stmt(p); alt (stmt_to_expr(stmt)) { - case (some[@ast.expr](?e)) { + case (some[@ast::expr](?e)) { alt (p.peek()) { - case (token.SEMI) { + case (token::SEMI) { p.bump(); stmts += vec(stmt); } - case (token.RBRACE) { expr = some(e); } + case (token::RBRACE) { expr = some(e); } case (?t) { if (stmt_ends_with_semi(stmt)) { p.err("expected ';' or '}' after " + "expression but found " + - token.to_str(p.get_reader(), t)); + token::to_str(p.get_reader(), t)); fail; } stmts += vec(stmt); } } } - case (none[@ast.expr]) { + case (none[@ast::expr]) { // Not an expression statement. stmts += vec(stmt); // FIXME: crazy differentiation between conditions @@ -1688,7 +1689,7 @@ fn parse_block(parser p) -> ast.block { // means we cannot use && here. I know, right? if (p.get_file_type() == SOURCE_FILE) { if (stmt_ends_with_semi(stmt)) { - expect(p, token.SEMI); + expect(p, token::SEMI); } } } @@ -1701,51 +1702,51 @@ fn parse_block(parser p) -> ast.block { p.bump(); auto bloc = rec(stmts=stmts, expr=expr, a=p.get_ann()); - ret spanned[ast.block_](lo, hi, bloc); + ret spanned[ast::block_](lo, hi, bloc); } -fn parse_ty_param(parser p) -> ast.ty_param { +fn parse_ty_param(parser p) -> ast::ty_param { ret parse_ident(p); } -fn parse_ty_params(parser p) -> vec[ast.ty_param] { - let vec[ast.ty_param] ty_params = vec(); - if (p.peek() == token.LBRACKET) { +fn parse_ty_params(parser p) -> vec[ast::ty_param] { + let vec[ast::ty_param] ty_params = vec(); + if (p.peek() == token::LBRACKET) { auto f = parse_ty_param; // FIXME: pass as lval directly - ty_params = parse_seq[ast.ty_param](token.LBRACKET, token.RBRACKET, - some(token.COMMA), f, p).node; + ty_params = parse_seq[ast::ty_param](token::LBRACKET, token::RBRACKET, + some(token::COMMA), f, p).node; } ret ty_params; } -fn parse_fn_decl(parser p, ast.purity purity) -> ast.fn_decl { +fn parse_fn_decl(parser p, ast::purity purity) -> ast::fn_decl { auto pf = parse_arg; - let util.common.spanned[vec[ast.arg]] inputs = + let util::common::spanned[vec[ast::arg]] inputs = // FIXME: passing parse_arg as an lval doesn't work at the // moment. - parse_seq[ast.arg] - (token.LPAREN, - token.RPAREN, - some(token.COMMA), + parse_seq[ast::arg] + (token::LPAREN, + token::RPAREN, + some(token::COMMA), pf, p); - let @ast.ty output; + let @ast::ty output; // FIXME: dropping constrs on the floor at the moment. // pick them up when they're used by typestate pass. parse_constrs(p); - if (p.peek() == token.RARROW) { + if (p.peek() == token::RARROW) { p.bump(); output = parse_ty(p); } else { - output = @spanned(inputs.span.lo, inputs.span.hi, ast.ty_nil); + output = @spanned(inputs.span.lo, inputs.span.hi, ast::ty_nil); } // FIXME ret rec(inputs=inputs.node, output=output, purity=purity); } -fn parse_fn(parser p, ast.proto proto, ast.purity purity) -> ast._fn { +fn parse_fn(parser p, ast::proto proto, ast::purity purity) -> ast::_fn { auto decl = parse_fn_decl(p, purity); auto body = parse_block(p); ret rec(decl = decl, @@ -1754,167 +1755,167 @@ fn parse_fn(parser p, ast.proto proto, ast.purity purity) -> ast._fn { } fn parse_fn_header(parser p) - -> tup(ast.ident, vec[ast.ty_param]) { + -> tup(ast::ident, vec[ast::ty_param]) { auto id = parse_ident(p); auto ty_params = parse_ty_params(p); ret tup(id, ty_params); } -fn parse_item_fn_or_iter(parser p, ast.purity purity) -> @ast.item { +fn parse_item_fn_or_iter(parser p, ast::purity purity) -> @ast::item { auto lo = p.get_lo_pos(); auto proto = parse_proto(p); auto t = parse_fn_header(p); auto f = parse_fn(p, proto, purity); - auto item = ast.item_fn(t._0, f, t._1, + auto item = ast::item_fn(t._0, f, t._1, p.next_def_id(), p.get_ann()); ret @spanned(lo, f.body.span.hi, item); } -fn parse_obj_field(parser p) -> ast.obj_field { +fn parse_obj_field(parser p) -> ast::obj_field { auto mut = parse_mutability(p); // TODO: store this, use it in typeck auto ty = parse_ty(p); auto ident = parse_ident(p); ret rec(ty=ty, ident=ident, id=p.next_def_id(), ann=p.get_ann()); } -fn parse_method(parser p) -> @ast.method { +fn parse_method(parser p) -> @ast::method { auto lo = p.get_lo_pos(); auto proto = parse_proto(p); auto ident = parse_ident(p); - auto f = parse_fn(p, proto, ast.impure_fn); + auto f = parse_fn(p, proto, ast::impure_fn); auto meth = rec(ident=ident, meth=f, id=p.next_def_id(), ann=p.get_ann()); ret @spanned(lo, f.body.span.hi, meth); } -fn parse_dtor(parser p) -> @ast.method { +fn parse_dtor(parser p) -> @ast::method { auto lo = p.get_lo_pos(); - expect(p, token.DROP); - let ast.block b = parse_block(p); - let vec[ast.arg] inputs = vec(); - let @ast.ty output = @spanned(lo, lo, ast.ty_nil); - let ast.fn_decl d = rec(inputs=inputs, + expect(p, token::DROP); + let ast::block b = parse_block(p); + let vec[ast::arg] inputs = vec(); + let @ast::ty output = @spanned(lo, lo, ast::ty_nil); + let ast::fn_decl d = rec(inputs=inputs, output=output, - purity=ast.impure_fn); - let ast._fn f = rec(decl = d, - proto = ast.proto_fn, + purity=ast::impure_fn); + let ast::_fn f = rec(decl = d, + proto = ast::proto_fn, body = b); - let ast.method_ m = rec(ident="drop", + let ast::method_ m = rec(ident="drop", meth=f, id=p.next_def_id(), ann=p.get_ann()); ret @spanned(lo, f.body.span.hi, m); } -fn parse_item_obj(parser p, ast.layer lyr) -> @ast.item { +fn parse_item_obj(parser p, ast::layer lyr) -> @ast::item { auto lo = p.get_lo_pos(); - expect(p, token.OBJ); + expect(p, token::OBJ); auto ident = parse_ident(p); auto ty_params = parse_ty_params(p); auto pf = parse_obj_field; - let util.common.spanned[vec[ast.obj_field]] fields = - parse_seq[ast.obj_field] - (token.LPAREN, - token.RPAREN, - some(token.COMMA), + let util::common::spanned[vec[ast::obj_field]] fields = + parse_seq[ast::obj_field] + (token::LPAREN, + token::RPAREN, + some(token::COMMA), pf, p); - let vec[@ast.method] meths = vec(); - let Option.t[@ast.method] dtor = none[@ast.method]; + let vec[@ast::method] meths = vec(); + let option::t[@ast::method] dtor = none[@ast::method]; - expect(p, token.LBRACE); - while (p.peek() != token.RBRACE) { + expect(p, token::LBRACE); + while (p.peek() != token::RBRACE) { alt (p.peek()) { - case (token.DROP) { - dtor = some[@ast.method](parse_dtor(p)); + case (token::DROP) { + dtor = some[@ast::method](parse_dtor(p)); } case (_) { - Vec.push[@ast.method](meths, + _vec::push[@ast::method](meths, parse_method(p)); } } } auto hi = p.get_hi_pos(); - expect(p, token.RBRACE); + expect(p, token::RBRACE); - let ast._obj ob = rec(fields=fields.node, + let ast::_obj ob = rec(fields=fields.node, methods=meths, dtor=dtor); auto odid = rec(ty=p.next_def_id(), ctor=p.next_def_id()); - auto item = ast.item_obj(ident, ob, ty_params, odid, p.get_ann()); + auto item = ast::item_obj(ident, ob, ty_params, odid, p.get_ann()); ret @spanned(lo, hi, item); } -fn parse_mod_items(parser p, token.token term) -> ast._mod { +fn parse_mod_items(parser p, token::token term) -> ast::_mod { auto view_items = parse_view(p); - let vec[@ast.item] items = vec(); + let vec[@ast::item] items = vec(); while (p.peek() != term) { items += vec(parse_item(p)); } ret rec(view_items=view_items, items=items); } -fn parse_item_const(parser p) -> @ast.item { +fn parse_item_const(parser p) -> @ast::item { auto lo = p.get_lo_pos(); - expect(p, token.CONST); + expect(p, token::CONST); auto ty = parse_ty(p); auto id = parse_ident(p); - expect(p, token.EQ); + expect(p, token::EQ); auto e = parse_expr(p); auto hi = p.get_hi_pos(); - expect(p, token.SEMI); - auto item = ast.item_const(id, ty, e, p.next_def_id(), p.get_ann()); + expect(p, token::SEMI); + auto item = ast::item_const(id, ty, e, p.next_def_id(), p.get_ann()); ret @spanned(lo, hi, item); } -fn parse_item_mod(parser p) -> @ast.item { +fn parse_item_mod(parser p) -> @ast::item { auto lo = p.get_lo_pos(); - expect(p, token.MOD); + expect(p, token::MOD); auto id = parse_ident(p); - expect(p, token.LBRACE); - auto m = parse_mod_items(p, token.RBRACE); + expect(p, token::LBRACE); + auto m = parse_mod_items(p, token::RBRACE); auto hi = p.get_hi_pos(); - expect(p, token.RBRACE); - auto item = ast.item_mod(id, m, p.next_def_id()); + expect(p, token::RBRACE); + auto item = ast::item_mod(id, m, p.next_def_id()); ret @spanned(lo, hi, item); } -fn parse_item_native_type(parser p) -> @ast.native_item { +fn parse_item_native_type(parser p) -> @ast::native_item { auto t = parse_type_decl(p); auto hi = p.get_hi_pos(); - expect(p, token.SEMI); - auto item = ast.native_item_ty(t._1, p.next_def_id()); + expect(p, token::SEMI); + auto item = ast::native_item_ty(t._1, p.next_def_id()); ret @spanned(t._0, hi, item); } -fn parse_item_native_fn(parser p) -> @ast.native_item { +fn parse_item_native_fn(parser p) -> @ast::native_item { auto lo = p.get_lo_pos(); - expect(p, token.FN); + expect(p, token::FN); auto t = parse_fn_header(p); - auto decl = parse_fn_decl(p, ast.impure_fn); + auto decl = parse_fn_decl(p, ast::impure_fn); auto link_name = none[str]; - if (p.peek() == token.EQ) { + if (p.peek() == token::EQ) { p.bump(); link_name = some[str](parse_str_lit_or_env_ident(p)); } auto hi = p.get_hi_pos(); - expect(p, token.SEMI); - auto item = ast.native_item_fn(t._0, link_name, decl, + expect(p, token::SEMI); + auto item = ast::native_item_fn(t._0, link_name, decl, t._1, p.next_def_id(), p.get_ann()); ret @spanned(lo, hi, item); } -fn parse_native_item(parser p) -> @ast.native_item { - let ast.layer lyr = parse_layer(p); +fn parse_native_item(parser p) -> @ast::native_item { + let ast::layer lyr = parse_layer(p); alt (p.peek()) { - case (token.TYPE) { + case (token::TYPE) { ret parse_item_native_type(p); } - case (token.FN) { + case (token::FN) { ret parse_item_native_fn(p); } case (?t) { @@ -1926,12 +1927,12 @@ fn parse_native_item(parser p) -> @ast.native_item { fn parse_native_mod_items(parser p, str native_name, - ast.native_abi abi) -> ast.native_mod { - let vec[@ast.native_item] items = vec(); + ast::native_abi abi) -> ast::native_mod { + let vec[@ast::native_item] items = vec(); auto view_items = parse_native_view(p); - while (p.peek() != token.RBRACE) { + while (p.peek() != token::RBRACE) { items += vec(parse_native_item(p)); } ret rec(native_name=native_name, abi=abi, @@ -1939,98 +1940,98 @@ fn parse_native_mod_items(parser p, items=items); } -fn default_native_name(session.session sess, str id) -> str { +fn default_native_name(session::session sess, str id) -> str { alt (sess.get_targ_cfg().os) { - case (session.os_win32) { + case (session::os_win32) { ret id + ".dll"; } - case (session.os_macos) { + case (session::os_macos) { ret "lib" + id + ".dylib"; } - case (session.os_linux) { + case (session::os_linux) { ret "lib" + id + ".so"; } } } -fn parse_item_native_mod(parser p) -> @ast.item { +fn parse_item_native_mod(parser p) -> @ast::item { auto lo = p.get_lo_pos(); - expect(p, token.NATIVE); - auto abi = ast.native_abi_cdecl; - if (p.peek() != token.MOD) { + expect(p, token::NATIVE); + auto abi = ast::native_abi_cdecl; + if (p.peek() != token::MOD) { auto t = parse_str_lit_or_env_ident(p); - if (Str.eq(t, "cdecl")) { - } else if (Str.eq(t, "rust")) { - abi = ast.native_abi_rust; - } else if (Str.eq(t, "llvm")) { - abi = ast.native_abi_llvm; - } else if (Str.eq(t, "rust-intrinsic")) { - abi = ast.native_abi_rust_intrinsic; + if (_str::eq(t, "cdecl")) { + } else if (_str::eq(t, "rust")) { + abi = ast::native_abi_rust; + } else if (_str::eq(t, "llvm")) { + abi = ast::native_abi_llvm; + } else if (_str::eq(t, "rust-intrinsic")) { + abi = ast::native_abi_rust_intrinsic; } else { p.err("unsupported abi: " + t); fail; } } - expect(p, token.MOD); + expect(p, token::MOD); auto id = parse_ident(p); auto native_name; - if (p.peek() == token.EQ) { - expect(p, token.EQ); + if (p.peek() == token::EQ) { + expect(p, token::EQ); native_name = parse_str_lit_or_env_ident(p); } else { native_name = default_native_name(p.get_session(), id); } - expect(p, token.LBRACE); + expect(p, token::LBRACE); auto m = parse_native_mod_items(p, native_name, abi); auto hi = p.get_hi_pos(); - expect(p, token.RBRACE); - auto item = ast.item_native_mod(id, m, p.next_def_id()); + expect(p, token::RBRACE); + auto item = ast::item_native_mod(id, m, p.next_def_id()); ret @spanned(lo, hi, item); } -fn parse_type_decl(parser p) -> tup(uint, ast.ident) { +fn parse_type_decl(parser p) -> tup(uint, ast::ident) { auto lo = p.get_lo_pos(); - expect(p, token.TYPE); + expect(p, token::TYPE); auto id = parse_ident(p); ret tup(lo, id); } -fn parse_item_type(parser p) -> @ast.item { +fn parse_item_type(parser p) -> @ast::item { auto t = parse_type_decl(p); auto tps = parse_ty_params(p); - expect(p, token.EQ); + expect(p, token::EQ); auto ty = parse_ty(p); auto hi = p.get_hi_pos(); - expect(p, token.SEMI); - auto item = ast.item_ty(t._1, ty, tps, p.next_def_id(), p.get_ann()); + expect(p, token::SEMI); + auto item = ast::item_ty(t._1, ty, tps, p.next_def_id(), p.get_ann()); ret @spanned(t._0, hi, item); } -fn parse_item_tag(parser p) -> @ast.item { +fn parse_item_tag(parser p) -> @ast::item { auto lo = p.get_lo_pos(); - expect(p, token.TAG); + expect(p, token::TAG); auto id = parse_ident(p); auto ty_params = parse_ty_params(p); - let vec[ast.variant] variants = vec(); - expect(p, token.LBRACE); - while (p.peek() != token.RBRACE) { + let vec[ast::variant] variants = vec(); + expect(p, token::LBRACE); + while (p.peek() != token::RBRACE) { auto tok = p.peek(); alt (tok) { - case (token.IDENT(?name)) { + case (token::IDENT(?name)) { auto vlo = p.get_lo_pos(); p.bump(); - let vec[ast.variant_arg] args = vec(); + let vec[ast::variant_arg] args = vec(); alt (p.peek()) { - case (token.LPAREN) { + case (token::LPAREN) { auto f = parse_ty; - auto arg_tys = parse_seq[@ast.ty](token.LPAREN, - token.RPAREN, - some(token.COMMA), + auto arg_tys = parse_seq[@ast::ty](token::LPAREN, + token::RPAREN, + some(token::COMMA), f, p); - for (@ast.ty ty in arg_tys.node) { + for (@ast::ty ty in arg_tys.node) { args += vec(rec(ty=ty, id=p.next_def_id())); } } @@ -2038,52 +2039,52 @@ fn parse_item_tag(parser p) -> @ast.item { } auto vhi = p.get_hi_pos(); - expect(p, token.SEMI); + expect(p, token::SEMI); auto id = p.next_def_id(); auto vr = rec(name=p.get_str(name), args=args, id=id, ann=p.get_ann()); - variants += vec(spanned[ast.variant_](vlo, vhi, vr)); + variants += vec(spanned[ast::variant_](vlo, vhi, vr)); } - case (token.RBRACE) { /* empty */ } + case (token::RBRACE) { /* empty */ } case (_) { p.err("expected name of variant or '}' but found " + - token.to_str(p.get_reader(), tok)); + token::to_str(p.get_reader(), tok)); } } } auto hi = p.get_hi_pos(); p.bump(); - auto item = ast.item_tag(id, variants, ty_params, p.next_def_id(), + auto item = ast::item_tag(id, variants, ty_params, p.next_def_id(), p.get_ann()); ret @spanned(lo, hi, item); } -fn parse_layer(parser p) -> ast.layer { +fn parse_layer(parser p) -> ast::layer { alt (p.peek()) { - case (token.STATE) { + case (token::STATE) { p.bump(); - ret ast.layer_state; + ret ast::layer_state; } - case (token.GC) { + case (token::GC) { p.bump(); - ret ast.layer_gc; + ret ast::layer_gc; } case (_) { - ret ast.layer_value; + ret ast::layer_value; } } fail; } -fn parse_auth(parser p) -> ast._auth { +fn parse_auth(parser p) -> ast::_auth { alt (p.peek()) { - case (token.UNSAFE) { + case (token::UNSAFE) { p.bump(); - ret ast.auth_unsafe; + ret ast::auth_unsafe; } case (?t) { unexpected(p, t); @@ -2094,75 +2095,75 @@ fn parse_auth(parser p) -> ast._auth { fn peeking_at_item(parser p) -> bool { alt (p.peek()) { - case (token.STATE) { ret true; } - case (token.GC) { ret true; } - case (token.CONST) { ret true; } - case (token.FN) { ret true; } - case (token.PRED) { ret true; } - case (token.ITER) { ret true; } - case (token.MOD) { ret true; } - case (token.TYPE) { ret true; } - case (token.TAG) { ret true; } - case (token.OBJ) { ret true; } + case (token::STATE) { ret true; } + case (token::GC) { ret true; } + case (token::CONST) { ret true; } + case (token::FN) { ret true; } + case (token::PRED) { ret true; } + case (token::ITER) { ret true; } + case (token::MOD) { ret true; } + case (token::TYPE) { ret true; } + case (token::TAG) { ret true; } + case (token::OBJ) { ret true; } case (_) { ret false; } } ret false; } -fn parse_item(parser p) -> @ast.item { - let ast.layer lyr = parse_layer(p); +fn parse_item(parser p) -> @ast::item { + let ast::layer lyr = parse_layer(p); alt (p.peek()) { - case (token.CONST) { - assert (lyr == ast.layer_value); + case (token::CONST) { + assert (lyr == ast::layer_value); ret parse_item_const(p); } - case (token.FN) { - assert (lyr == ast.layer_value); - ret parse_item_fn_or_iter(p, ast.impure_fn); + case (token::FN) { + assert (lyr == ast::layer_value); + ret parse_item_fn_or_iter(p, ast::impure_fn); } - case (token.PRED) { - assert (lyr == ast.layer_value); - ret parse_item_fn_or_iter(p, ast.pure_fn); + case (token::PRED) { + assert (lyr == ast::layer_value); + ret parse_item_fn_or_iter(p, ast::pure_fn); } - case (token.ITER) { - assert (lyr == ast.layer_value); - ret parse_item_fn_or_iter(p, ast.impure_fn); + case (token::ITER) { + assert (lyr == ast::layer_value); + ret parse_item_fn_or_iter(p, ast::impure_fn); } - case (token.MOD) { - assert (lyr == ast.layer_value); + case (token::MOD) { + assert (lyr == ast::layer_value); ret parse_item_mod(p); } - case (token.NATIVE) { - assert (lyr == ast.layer_value); + case (token::NATIVE) { + assert (lyr == ast::layer_value); ret parse_item_native_mod(p); } - case (token.TYPE) { + case (token::TYPE) { ret parse_item_type(p); } - case (token.TAG) { + case (token::TAG) { ret parse_item_tag(p); } - case (token.OBJ) { + case (token::OBJ) { ret parse_item_obj(p, lyr); } case (?t) { p.err("expected item but found " + - token.to_str(p.get_reader(), t)); + token::to_str(p.get_reader(), t)); } } fail; } -fn parse_meta_item(parser p) -> @ast.meta_item { +fn parse_meta_item(parser p) -> @ast::meta_item { auto lo = p.get_lo_pos(); auto ident = parse_ident(p); - expect(p, token.EQ); + expect(p, token::EQ); alt (p.peek()) { - case (token.LIT_STR(?s)) { + case (token::LIT_STR(?s)) { auto hi = p.get_hi_pos(); p.bump(); ret @spanned(lo, hi, rec(name = ident, @@ -2175,43 +2176,43 @@ fn parse_meta_item(parser p) -> @ast.meta_item { fail; } -fn parse_meta(parser p) -> vec[@ast.meta_item] { +fn parse_meta(parser p) -> vec[@ast::meta_item] { auto pf = parse_meta_item; - ret parse_seq[@ast.meta_item](token.LPAREN, token.RPAREN, - some(token.COMMA), pf, p).node; + ret parse_seq[@ast::meta_item](token::LPAREN, token::RPAREN, + some(token::COMMA), pf, p).node; } -fn parse_optional_meta(parser p) -> vec[@ast.meta_item] { +fn parse_optional_meta(parser p) -> vec[@ast::meta_item] { alt (p.peek()) { - case (token.LPAREN) { + case (token::LPAREN) { ret parse_meta(p); } case (_) { - let vec[@ast.meta_item] v = vec(); + let vec[@ast::meta_item] v = vec(); ret v; } } } -fn parse_use(parser p) -> @ast.view_item { +fn parse_use(parser p) -> @ast::view_item { auto lo = p.get_lo_pos(); - expect(p, token.USE); + expect(p, token::USE); auto ident = parse_ident(p); auto metadata = parse_optional_meta(p); auto hi = p.get_hi_pos(); - expect(p, token.SEMI); - auto use_decl = ast.view_item_use(ident, metadata, p.next_def_id(), + expect(p, token::SEMI); + auto use_decl = ast::view_item_use(ident, metadata, p.next_def_id(), none[int]); ret @spanned(lo, hi, use_decl); } -fn parse_rest_import_name(parser p, ast.ident first, - Option.t[ast.ident] def_ident) - -> @ast.view_item { +fn parse_rest_import_name(parser p, ast::ident first, + option::t[ast::ident] def_ident) + -> @ast::view_item { auto lo = p.get_lo_pos(); - let vec[ast.ident] identifiers = vec(first); - while (p.peek() != token.SEMI) { - expect(p, token.MOD_SEP); + let vec[ast::ident] identifiers = vec(first); + while (p.peek() != token::SEMI) { + expect(p, token::MOD_SEP); auto i = parse_ident(p); identifiers += vec(i); } @@ -2219,23 +2220,23 @@ fn parse_rest_import_name(parser p, ast.ident first, p.bump(); auto defined_id; alt (def_ident) { - case(some[ast.ident](?i)) { + case(some[ast::ident](?i)) { defined_id = i; } case (_) { - auto len = Vec.len[ast.ident](identifiers); + auto len = _vec::len[ast::ident](identifiers); defined_id = identifiers.(len - 1u); } } - auto import_decl = ast.view_item_import(defined_id, identifiers, + auto import_decl = ast::view_item_import(defined_id, identifiers, p.next_def_id()); ret @spanned(lo, hi, import_decl); } -fn parse_full_import_name(parser p, ast.ident def_ident) - -> @ast.view_item { +fn parse_full_import_name(parser p, ast::ident def_ident) + -> @ast::view_item { alt (p.peek()) { - case (token.IDENT(?i)) { + case (token::IDENT(?i)) { p.bump(); ret parse_rest_import_name(p, p.get_str(i), some(def_ident)); } @@ -2246,19 +2247,19 @@ fn parse_full_import_name(parser p, ast.ident def_ident) fail; } -fn parse_import(parser p) -> @ast.view_item { - expect(p, token.IMPORT); +fn parse_import(parser p) -> @ast::view_item { + expect(p, token::IMPORT); alt (p.peek()) { - case (token.IDENT(?i)) { + case (token::IDENT(?i)) { p.bump(); alt (p.peek()) { - case (token.EQ) { + case (token::EQ) { p.bump(); ret parse_full_import_name(p, p.get_str(i)); } case (_) { ret parse_rest_import_name(p, p.get_str(i), - none[ast.ident]); + none[ast::ident]); } } } @@ -2269,49 +2270,49 @@ fn parse_import(parser p) -> @ast.view_item { fail; } -fn parse_export(parser p) -> @ast.view_item { +fn parse_export(parser p) -> @ast::view_item { auto lo = p.get_lo_pos(); - expect(p, token.EXPORT); + expect(p, token::EXPORT); auto id = parse_ident(p); auto hi = p.get_hi_pos(); - expect(p, token.SEMI); - ret @spanned(lo, hi, ast.view_item_export(id)); + expect(p, token::SEMI); + ret @spanned(lo, hi, ast::view_item_export(id)); } -fn parse_view_item(parser p) -> @ast.view_item { +fn parse_view_item(parser p) -> @ast::view_item { alt (p.peek()) { - case (token.USE) { + case (token::USE) { ret parse_use(p); } - case (token.IMPORT) { + case (token::IMPORT) { ret parse_import(p); } - case (token.EXPORT) { + case (token::EXPORT) { ret parse_export(p); } } } -fn is_view_item(token.token t) -> bool { +fn is_view_item(token::token t) -> bool { alt (t) { - case (token.USE) { ret true; } - case (token.IMPORT) { ret true; } - case (token.EXPORT) { ret true; } + case (token::USE) { ret true; } + case (token::IMPORT) { ret true; } + case (token::EXPORT) { ret true; } case (_) {} } ret false; } -fn parse_view(parser p) -> vec[@ast.view_item] { - let vec[@ast.view_item] items = vec(); +fn parse_view(parser p) -> vec[@ast::view_item] { + let vec[@ast::view_item] items = vec(); while (is_view_item(p.peek())) { items += vec(parse_view_item(p)); } ret items; } -fn parse_native_view(parser p) -> vec[@ast.view_item] { - let vec[@ast.view_item] items = vec(); +fn parse_native_view(parser p) -> vec[@ast::view_item] { + let vec[@ast::view_item] items = vec(); while (is_view_item(p.peek())) { items += vec(parse_view_item(p)); } @@ -2319,10 +2320,10 @@ fn parse_native_view(parser p) -> vec[@ast.view_item] { } -fn parse_crate_from_source_file(parser p) -> @ast.crate { +fn parse_crate_from_source_file(parser p) -> @ast::crate { auto lo = p.get_lo_pos(); - auto m = parse_mod_items(p, token.EOF); - let vec[@ast.crate_directive] cdirs = vec(); + auto m = parse_mod_items(p, token::EOF); + let vec[@ast::crate_directive] cdirs = vec(); ret @spanned(lo, p.get_lo_pos(), rec(directives=cdirs, module=m)); } @@ -2333,34 +2334,34 @@ fn parse_crate_from_source_file(parser p) -> @ast.crate { // // Each directive imperatively extends its environment with 0 or more items. -fn parse_crate_directive(parser p) -> ast.crate_directive +fn parse_crate_directive(parser p) -> ast::crate_directive { auto lo = p.get_lo_pos(); alt (p.peek()) { - case (token.AUTH) { + case (token::AUTH) { p.bump(); auto n = parse_path(p); - expect(p, token.EQ); + expect(p, token::EQ); auto a = parse_auth(p); auto hi = p.get_hi_pos(); - expect(p, token.SEMI); - ret spanned(lo, hi, ast.cdir_auth(n, a)); + expect(p, token::SEMI); + ret spanned(lo, hi, ast::cdir_auth(n, a)); } - case (token.META) { + case (token::META) { p.bump(); auto mis = parse_meta(p); auto hi = p.get_hi_pos(); - expect(p, token.SEMI); - ret spanned(lo, hi, ast.cdir_meta(mis)); + expect(p, token::SEMI); + ret spanned(lo, hi, ast::cdir_meta(mis)); } - case (token.MOD) { + case (token::MOD) { p.bump(); auto id = parse_ident(p); auto file_opt = none[filename]; alt (p.peek()) { - case (token.EQ) { + case (token::EQ) { p.bump(); // FIXME: turn this into parse+eval expr file_opt = some[filename](parse_str_lit_or_env_ident(p)); @@ -2373,21 +2374,21 @@ fn parse_crate_directive(parser p) -> ast.crate_directive // mod x = "foo.rs"; - case (token.SEMI) { + case (token::SEMI) { auto hi = p.get_hi_pos(); p.bump(); - ret spanned(lo, hi, ast.cdir_src_mod(id, file_opt)); + ret spanned(lo, hi, ast::cdir_src_mod(id, file_opt)); } // mod x = "foo_dir" { ...directives... } - case (token.LBRACE) { + case (token::LBRACE) { p.bump(); - auto cdirs = parse_crate_directives(p, token.RBRACE); + auto cdirs = parse_crate_directives(p, token::RBRACE); auto hi = p.get_hi_pos(); - expect(p, token.RBRACE); + expect(p, token::RBRACE); ret spanned(lo, hi, - ast.cdir_dir_mod(id, file_opt, cdirs)); + ast::cdir_dir_mod(id, file_opt, cdirs)); } case (?t) { @@ -2396,72 +2397,72 @@ fn parse_crate_directive(parser p) -> ast.crate_directive } } - case (token.LET) { + case (token::LET) { p.bump(); - expect(p, token.LPAREN); + expect(p, token::LPAREN); auto id = parse_ident(p); - expect(p, token.EQ); + expect(p, token::EQ); auto x = parse_expr(p); - expect(p, token.RPAREN); - expect(p, token.LBRACE); - auto v = parse_crate_directives(p, token.RBRACE); + expect(p, token::RPAREN); + expect(p, token::LBRACE); + auto v = parse_crate_directives(p, token::RBRACE); auto hi = p.get_hi_pos(); - expect(p, token.RBRACE); - ret spanned(lo, hi, ast.cdir_let(id, x, v)); + expect(p, token::RBRACE); + ret spanned(lo, hi, ast::cdir_let(id, x, v)); } - case (token.USE) { + case (token::USE) { auto vi = parse_view_item(p); - ret spanned(lo, vi.span.hi, ast.cdir_view_item(vi)); + ret spanned(lo, vi.span.hi, ast::cdir_view_item(vi)); } - case (token.IMPORT) { + case (token::IMPORT) { auto vi = parse_view_item(p); - ret spanned(lo, vi.span.hi, ast.cdir_view_item(vi)); + ret spanned(lo, vi.span.hi, ast::cdir_view_item(vi)); } - case (token.EXPORT) { + case (token::EXPORT) { auto vi = parse_view_item(p); - ret spanned(lo, vi.span.hi, ast.cdir_view_item(vi)); + ret spanned(lo, vi.span.hi, ast::cdir_view_item(vi)); } case (_) { auto x = parse_expr(p); - ret spanned(lo, x.span.hi, ast.cdir_expr(x)); + ret spanned(lo, x.span.hi, ast::cdir_expr(x)); } } fail; } -fn parse_crate_directives(parser p, token.token term) - -> vec[@ast.crate_directive] { +fn parse_crate_directives(parser p, token::token term) + -> vec[@ast::crate_directive] { - let vec[@ast.crate_directive] cdirs = vec(); + let vec[@ast::crate_directive] cdirs = vec(); while (p.peek() != term) { auto cdir = @parse_crate_directive(p); - Vec.push[@ast.crate_directive](cdirs, cdir); + _vec::push[@ast::crate_directive](cdirs, cdir); } ret cdirs; } -fn parse_crate_from_crate_file(parser p) -> @ast.crate { +fn parse_crate_from_crate_file(parser p) -> @ast::crate { auto lo = p.get_lo_pos(); - auto prefix = std.FS.dirname(p.get_filemap().name); - auto cdirs = parse_crate_directives(p, token.EOF); + auto prefix = std::fs::dirname(p.get_filemap().name); + auto cdirs = parse_crate_directives(p, token::EOF); let vec[str] deps = vec(); auto cx = @rec(p=p, - mode=eval.mode_parse, + mode=eval::mode_parse, mutable deps = deps, sess=p.get_session(), mutable chpos=p.get_chpos(), mutable next_ann=p.next_ann_num()); - auto m = eval.eval_crate_directives_to_mod(cx, p.get_env(), + auto m = eval::eval_crate_directives_to_mod(cx, p.get_env(), cdirs, prefix); auto hi = p.get_hi_pos(); - expect(p, token.EOF); + expect(p, token::EOF); ret @spanned(lo, hi, rec(directives=cdirs, module=m)); } diff --git a/src/comp/front/token.rs b/src/comp/front/token.rs index 43db0b16..60091afc 100644 --- a/src/comp/front/token.rs +++ b/src/comp/front/token.rs @@ -1,9 +1,9 @@ -import util.common.ty_mach; -import util.common.ty_mach_to_str; -import util.common.new_str_hash; -import std.Int; -import std.UInt; -import std.Str; +import util::common::ty_mach; +import util::common::ty_mach_to_str; +import util::common::new_str_hash; +import std::_int; +import std::_uint; +import std::_str; type str_num = uint; @@ -191,7 +191,7 @@ fn binop_to_str(binop o) -> str { } } -fn to_str(lexer.reader r, token t) -> str { +fn to_str(lexer::reader r, token t) -> str { alt (t) { case (EQ) { ret "="; } @@ -299,10 +299,10 @@ fn to_str(lexer.reader r, token t) -> str { case (JOIN) { ret "join"; } /* Literals */ - case (LIT_INT(?i)) { ret Int.to_str(i, 10u); } - case (LIT_UINT(?u)) { ret UInt.to_str(u, 10u); } + case (LIT_INT(?i)) { ret _int::to_str(i, 10u); } + case (LIT_UINT(?u)) { ret _uint::to_str(u, 10u); } case (LIT_MACH_INT(?tm, ?i)) { - ret Int.to_str(i, 10u) + ret _int::to_str(i, 10u) + "_" + ty_mach_to_str(tm); } case (LIT_MACH_FLOAT(?tm, ?s)) { @@ -317,8 +317,8 @@ fn to_str(lexer.reader r, token t) -> str { case (LIT_CHAR(?c)) { // FIXME: escape. auto tmp = "'"; - Str.push_char(tmp, c); - Str.push_byte(tmp, '\'' as u8); + _str::push_char(tmp, c); + _str::push_byte(tmp, '\'' as u8); ret tmp; } @@ -332,7 +332,7 @@ fn to_str(lexer.reader r, token t) -> str { si += r.get_str(s); ret si; } - case (IDX(?i)) { ret "_" + Int.to_str(i, 10u); } + case (IDX(?i)) { ret "_" + _int::to_str(i, 10u); } case (UNDERSCORE) { ret "_"; } /* Reserved type names */ -- cgit v1.2.3