aboutsummaryrefslogtreecommitdiff
path: root/src/comp/front
diff options
context:
space:
mode:
Diffstat (limited to 'src/comp/front')
-rw-r--r--src/comp/front/ast.rs54
-rw-r--r--src/comp/front/codemap.rs8
-rw-r--r--src/comp/front/creader.rs202
-rw-r--r--src/comp/front/eval.rs30
-rw-r--r--src/comp/front/extenv.rs10
-rw-r--r--src/comp/front/extfmt.rs36
-rw-r--r--src/comp/front/lexer.rs80
-rw-r--r--src/comp/front/parser.rs74
-rw-r--r--src/comp/front/token.rs18
9 files changed, 256 insertions, 256 deletions
diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs
index 574ebd4a..0e15c964 100644
--- a/src/comp/front/ast.rs
+++ b/src/comp/front/ast.rs
@@ -1,8 +1,8 @@
-import std.map.hashmap;
-import std.option;
-import std._str;
-import std._vec;
+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;
@@ -24,8 +24,8 @@ type ty_param = ident;
tag ann {
ann_none;
ann_type(middle.ty.t,
- option.t[vec[middle.ty.t]], /* ty param substs */
- option.t[@ts_ann]); /* pre- and postcondition for typestate */
+ Option.t[vec[middle.ty.t]], /* ty param substs */
+ Option.t[@ts_ann]); /* pre- and postcondition for typestate */
}
tag def {
@@ -79,8 +79,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);
@@ -100,7 +100,7 @@ tag block_index_entry {
bie_tag_variant(@item /* tag item */, uint /* variant index */);
}
type block_ = rec(vec[@stmt] stmts,
- option.t[@expr] expr,
+ Option.t[@expr] expr,
hashmap[ident,block_index_entry] index,
ann a); /* ann is only meaningful for the ts_ann field */
@@ -111,7 +111,7 @@ tag pat_ {
pat_wild(ann);
pat_bind(ident, def_id, ann);
pat_lit(@lit, ann);
- pat_tag(path, vec[@pat], option.t[variant_def], ann);
+ pat_tag(path, vec[@pat], Option.t[variant_def], ann);
}
tag mutability {
@@ -226,10 +226,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);
@@ -253,16 +253,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);
@@ -275,13 +275,13 @@ tag expr_ {
expr_recv(@expr /* TODO: @expr|is_lval */, @expr, ann);
expr_field(@expr, ident, ann);
expr_index(@expr, @expr, ann);
- expr_path(path, option.t[def], ann);
- expr_ext(path, vec[@expr], option.t[str], @expr, ann);
+ expr_path(path, Option.t[def], 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 */
@@ -331,7 +331,7 @@ tag ty_ {
ty_rec(vec[ty_field]);
ty_fn(proto, vec[ty_arg], @ty);
ty_obj(vec[ty_method]);
- ty_path(path, option.t[def]);
+ ty_path(path, Option.t[def]);
ty_type;
ty_constr(@ty, vec[@constr]);
}
@@ -364,7 +364,7 @@ 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);
tag mod_index_entry {
mie_view_item(@view_item);
@@ -402,8 +402,8 @@ 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_import(ident, vec[ident], def_id, option.t[def]);
+ view_item_use(ident, vec[@meta_item], def_id, Option.t[int]);
+ view_item_import(ident, vec[ident], def_id, Option.t[def]);
view_item_export(ident);
}
@@ -423,7 +423,7 @@ tag item_ {
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);
}
@@ -542,7 +542,7 @@ fn is_exported(ident i, _mod m) -> bool {
for (@ast.view_item vi in m.view_items) {
alt (vi.node) {
case (ast.view_item_export(?id)) {
- if (_str.eq(i, id)) {
+ if (Str.eq(i, id)) {
ret true;
}
count += 1;
@@ -574,7 +574,7 @@ fn is_constraint_arg(@expr e) -> bool {
case (expr_lit(_,_)) {
ret true;
}
- case (expr_path(_, option.some[def](def_local(_)), _)) {
+ case (expr_path(_, Option.some[def](def_local(_)), _)) {
ret true;
}
case (_) {
diff --git a/src/comp/front/codemap.rs b/src/comp/front/codemap.rs
index 402b4884..578f574b 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 a9660bf5..d5067b25 100644
--- a/src/comp/front/creader.rs
+++ b/src/comp/front/creader.rs
@@ -14,17 +14,17 @@ 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 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(
@@ -122,7 +122,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
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)));
@@ -160,7 +160,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
}
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,
@@ -210,7 +210,7 @@ fn parse_mt(@pstate st, str_def sd) -> ty.mt {
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);
@@ -265,7 +265,7 @@ fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty.arg], ty.t) {
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,30 @@ 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 result = Option.none[EBML.doc];
auto belt = metadata.tag_index_buckets_bucket_elt;
- for each (ebml.doc elt in ebml.tagged_docs(bucket, belt)) {
+ 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 (_) {}
@@ -310,113 +310,113 @@ fn lookup_hash(&ebml.doc d, fn(vec[u8]) -> bool eq_fn, uint hash)
// definition the path refers to.
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)));
+ 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));
}
-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
// 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 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);
+ 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;
+ 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] {
+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));
+ 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]] {
+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]];}
+ (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 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));
+ auto cvbuf = cbuf as Vec.vbuf;
+ ret Option.some[vec[u8]](Vec.vec_from_vbuf[u8](cvbuf, csz));
}
llvm.LLVMMoveToNextSection(si.llsi);
}
- ret option.none[vec[u8]];
+ ret Option.none[vec[u8]];
}
@@ -426,9 +426,9 @@ fn load_crate(session.session sess,
vec[str] library_search_paths) {
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;
}
@@ -442,7 +442,7 @@ fn load_crate(session.session sess,
}
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)
+ 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)) {
@@ -497,7 +497,7 @@ 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] {
+ -> Option.t[ast.def] {
auto data = sess.get_external_crate(cnum).data;
auto did;
@@ -568,7 +568,7 @@ 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();
@@ -593,52 +593,52 @@ 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)) {
+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)) {
+ 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";}
alt (maybe_find_item(id._1 as int, items)) {
- case (option.some[ebml.doc](?item)) {
+ case (Option.some[EBML.doc](?item)) {
ret item_kind_to_str(item_kind(item));
}
- case (option.none[ebml.doc]) {
+ case (Option.none[EBML.doc]) {
ret "??"; // Native modules don't seem to get item entries.
}
}
diff --git a/src/comp/front/eval.rs b/src/comp/front/eval.rs
index a1b3392c..e1ad59bc 100644
--- a/src/comp/front/eval.rs
+++ b/src/comp/front/eval.rs
@@ -1,9 +1,9 @@
-import std._vec;
-import std._str;
-import std.option;
-import std.option.some;
-import std.option.none;
-import std.map.hashmap;
+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;
@@ -91,7 +91,7 @@ fn val_as_str(val v) -> str {
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;
}
}
@@ -114,8 +114,8 @@ fn eval_lit(ctx cx, span sp, @ast.lit lit) -> 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) {
+ 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");
@@ -224,7 +224,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");
@@ -388,7 +388,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);
@@ -405,7 +405,7 @@ fn eval_crate_directive(ctx cx,
auto im = ast.item_mod(id, m0, next_id);
auto i = @spanned(cdir.span.lo, cdir.span.hi, im);
ast.index_item(index, i);
- _vec.push[@ast.item](items, i);
+ Vec.push[@ast.item](items, i);
}
case (ast.cdir_dir_mod(?id, ?dir_opt, ?cdirs)) {
@@ -418,16 +418,16 @@ 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 i = @spanned(cdir.span.lo, cdir.span.hi, im);
ast.index_item(index, i);
- _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);
+ Vec.push[@ast.view_item](view_items, vi);
ast.index_view_item(index, vi);
}
diff --git a/src/comp/front/extenv.rs b/src/comp/front/extenv.rs
index 6dc9c5ec..a3fdde95 100644
--- a/src/comp/front/extenv.rs
+++ b/src/comp/front/extenv.rs
@@ -6,9 +6,9 @@
import util.common;
-import std._str;
-import std._vec;
-import std.option;
+import std.Str;
+import std.Vec;
+import std.Option;
import std.GenericOS;
export expand_syntax_ext;
@@ -17,9 +17,9 @@ export expand_syntax_ext;
fn expand_syntax_ext(parser.parser p,
common.span sp,
vec[@ast.expr] args,
- option.t[str] body) -> @ast.expr {
+ 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");
}
diff --git a/src/comp/front/extfmt.rs b/src/comp/front/extfmt.rs
index aea3e7df..8aedf587 100644
--- a/src/comp/front/extfmt.rs
+++ b/src/comp/front/extfmt.rs
@@ -6,11 +6,11 @@
import util.common;
-import std._str;
-import std._vec;
-import std.option;
-import std.option.none;
-import std.option.some;
+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;
@@ -47,9 +47,9 @@ export expand_syntax_ext;
// FIXME: Need to thread parser through here to handle errors correctly
fn expand_syntax_ext(vec[@ast.expr] args,
- option.t[str] body) -> @ast.expr {
+ Option.t[str] body) -> @ast.expr {
- if (_vec.len[@ast.expr](args) == 0u) {
+ if (Vec.len[@ast.expr](args) == 0u) {
log_err "malformed #fmt call";
fail;
}
@@ -60,8 +60,8 @@ fn expand_syntax_ext(vec[@ast.expr] args,
// 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(pieces, args);
}
@@ -148,7 +148,7 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
}
auto recexpr = ast.expr_rec(astfields,
- option.none[@ast.expr],
+ Option.none[@ast.expr],
ast.ann_none);
auto sp_recexpr = @rec(node=recexpr, span=sp);
ret sp_recexpr;
@@ -196,7 +196,7 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
// 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(sp, "flag_none"));
}
@@ -303,7 +303,7 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
auto unsupported = "conversion not supported in #fmt string";
alt (cnv.param) {
- case (option.none[int]) {
+ case (Option.none[int]) {
}
case (_) {
log_err unsupported;
@@ -398,7 +398,7 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
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";
@@ -425,10 +425,10 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
}
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";
@@ -439,10 +439,10 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
}
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";
@@ -498,7 +498,7 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
tmp_expr = make_add_expr(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;
}
diff --git a/src/comp/front/lexer.rs b/src/comp/front/lexer.rs
index 4153533a..a17dd514 100644
--- a/src/comp/front/lexer.rs
+++ b/src/comp/front/lexer.rs
@@ -1,12 +1,12 @@
-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 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 util.common;
import util.common.new_str_hash;
@@ -24,7 +24,7 @@ state type reader = state obj {
fn get_filemap() -> codemap.filemap;
};
-fn new_reader(io.reader rdr, str filename, codemap.filemap filemap)
+fn new_reader(IO.reader rdr, str filename, codemap.filemap filemap)
-> reader {
state obj reader(str file,
uint len,
@@ -49,13 +49,13 @@ fn new_reader(io.reader rdr, str filename, codemap.filemap filemap)
}
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;
}
@@ -67,7 +67,7 @@ fn new_reader(io.reader rdr, str filename, codemap.filemap filemap)
if (ch == '\n') {
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 {
@@ -87,8 +87,8 @@ fn new_reader(io.reader rdr, str filename, codemap.filemap filemap)
ret fm;
}
}
- auto file = _str.unsafe_from_bytes(rdr.read_whole_stream());
- auto rd = reader(file, _str.byte_len(file), 0u, -1 as char,
+ auto file = Str.unsafe_from_bytes(rdr.read_whole_stream());
+ auto rd = reader(file, Str.byte_len(file), 0u, -1 as char,
filemap.start_pos, filemap.start_pos,
keyword_table(),
reserved_word_table(),
@@ -97,7 +97,7 @@ fn new_reader(io.reader rdr, str filename, codemap.filemap filemap)
ret rd;
}
-fn keyword_table() -> std.map.hashmap[str, token.token] {
+fn keyword_table() -> std.Map.hashmap[str, token.token] {
auto keywords = new_str_hash[token.token]();
keywords.insert("mod", token.MOD);
@@ -205,7 +205,7 @@ fn keyword_table() -> std.map.hashmap[str, token.token] {
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'
@@ -341,20 +341,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 {
@@ -374,7 +374,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();
@@ -574,12 +574,12 @@ fn next_token(reader rdr) -> token.token {
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, "_")) {
+ if (Str.eq(accum_str, "_")) {
ret token.UNDERSCORE;
}
@@ -738,37 +738,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));
}
@@ -780,7 +780,7 @@ fn next_token(reader rdr) -> token.token {
}
}
case (_) {
- _str.push_char(accum_str, rdr.curr());
+ Str.push_char(accum_str, rdr.curr());
}
}
rdr.bump();
@@ -870,7 +870,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),
@@ -887,7 +887,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 {
@@ -895,13 +895,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()) {fail;}
@@ -912,16 +912,16 @@ fn read_block_comment(reader rdr) -> cmnt {
}
fn gather_comments(str path) -> vec[cmnt] {
- auto srdr = io.file_reader(path);
+ auto srdr = IO.file_reader(path);
auto rdr = new_reader(srdr, path, 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 e355290d..bcde1671 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -1,10 +1,10 @@
-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 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;
@@ -118,12 +118,12 @@ fn new_parser(session.session sess,
fn get_chpos() -> uint {ret rdr.get_chpos();}
}
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 srdr = IO.file_reader(path);
auto filemap = codemap.new_filemap(path, pos);
- _vec.push[codemap.filemap](sess.get_codemap().files, filemap);
+ Vec.push[codemap.filemap](sess.get_codemap().files, filemap);
auto rdr = lexer.new_reader(srdr, path, filemap);
// Make sure npos points at first actual token.
lexer.consume_any_whitespace(rdr);
@@ -320,7 +320,7 @@ fn parse_constrs(parser p) -> common.spanned[vec[@ast.constr]] {
case (token.IDENT(_)) {
auto constr = parse_ty_constr(p);
hi = constr.span.hi;
- _vec.push[@ast.constr](constrs, constr);
+ Vec.push[@ast.constr](constrs, constr);
if (p.peek() == token.COMMA) {
p.bump();
more = false;
@@ -496,7 +496,7 @@ fn parse_arg(parser p) -> ast.arg {
}
fn parse_seq_to_end[T](token.token ket,
- option.t[token.token] sep,
+ Option.t[token.token] sep,
(fn(parser) -> T) f,
uint hi,
parser p) -> vec[T] {
@@ -525,7 +525,7 @@ fn parse_seq_to_end[T](token.token ket,
fn parse_seq[T](token.token bra,
token.token ket,
- option.t[token.token] sep,
+ Option.t[token.token] sep,
(fn(parser) -> T) f,
parser p) -> util.common.spanned[vec[T]] {
auto lo = p.get_lo_pos();
@@ -764,7 +764,7 @@ fn parse_bottom_expr(parser p) -> @ast.expr {
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) {
p.bump();
@@ -777,7 +777,7 @@ fn parse_bottom_expr(parser p) -> @ast.expr {
}
auto pf = parse_expr_opt;
- auto es = parse_seq[option.t[@ast.expr]](token.LPAREN,
+ auto es = parse_seq[Option.t[@ast.expr]](token.LPAREN,
token.RPAREN,
some(token.COMMA),
pf, p);
@@ -939,18 +939,18 @@ fn parse_bottom_expr(parser p) -> @ast.expr {
fn expand_syntax_ext(parser p, ast.span sp,
&ast.path path, vec[@ast.expr] args,
- option.t[str] body) -> ast.expr_ {
+ 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")) {
+ if (Str.eq(extname, "fmt")) {
auto expanded = extfmt.expand_syntax_ext(args, body);
auto newexpr = ast.expr_ext(path, args, body,
expanded,
ast.ann_none);
ret newexpr;
- } else if (_str.eq(extname, "env")) {
+ } 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,
@@ -968,7 +968,7 @@ fn extend_expr_by_ident(parser p, uint lo, uint hi,
auto e_ = e.node;
alt (e.node) {
case (ast.expr_path(?pth, ?def, ?ann)) {
- if (_vec.len[@ast.ty](pth.node.types) == 0u) {
+ if (Vec.len[@ast.ty](pth.node.types) == 0u) {
auto idents_ = pth.node.idents;
idents_ += vec(i);
auto tys = parse_ty_args(p, hi);
@@ -1238,7 +1238,7 @@ fn parse_if_expr(parser p) -> @ast.expr {
auto cond = parse_expr(p);
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) {
@@ -1398,7 +1398,7 @@ fn parse_spawn_expr(parser p) -> @ast.expr {
pf, p);
auto hi = es.span.hi;
auto spawn_expr = ast.expr_spawn(ast.dom_implicit,
- option.none[str],
+ Option.none[str],
fn_expr,
es.node,
ast.ann_none);
@@ -1449,7 +1449,7 @@ 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) {
p.bump();
@@ -1521,7 +1521,7 @@ fn parse_pat(parser p) -> @ast.pat {
ret @spanned(lo, hi, pat);
}
-fn parse_local_full(&option.t[@ast.ty] tyopt,
+fn parse_local_full(&Option.t[@ast.ty] tyopt,
parser p) -> @ast.local {
auto ident = parse_ident(p);
auto init = parse_initializer(p);
@@ -1607,7 +1607,7 @@ fn parse_source_stmt(parser p) -> @ast.stmt {
fail;
}
-fn index_block(vec[@ast.stmt] stmts, option.t[@ast.expr] expr) -> ast.block_ {
+fn index_block(vec[@ast.stmt] stmts, Option.t[@ast.expr] expr) -> ast.block_ {
auto index = new_str_hash[ast.block_index_entry]();
for (@ast.stmt s in stmts) {
ast.index_stmt(index, s);
@@ -1634,7 +1634,7 @@ fn index_arm(@ast.pat pat) -> hashmap[ast.ident,ast.def_id] {
ret index;
}
-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 (_) { /* fall through */ }
@@ -1697,7 +1697,7 @@ 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 Option.t[@ast.expr] expr = none[@ast.expr];
expect(p, token.LBRACE);
while (p.peek() != token.RBRACE) {
@@ -1871,7 +1871,7 @@ fn parse_item_obj(parser p, ast.layer lyr) -> @ast.item {
pf, p);
let vec[@ast.method] meths = vec();
- let option.t[@ast.method] dtor = none[@ast.method];
+ let Option.t[@ast.method] dtor = none[@ast.method];
expect(p, token.LBRACE);
while (p.peek() != token.RBRACE) {
@@ -1880,7 +1880,7 @@ fn parse_item_obj(parser p, ast.layer lyr) -> @ast.item {
dtor = some[@ast.method](parse_dtor(p));
}
case (_) {
- _vec.push[@ast.method](meths,
+ Vec.push[@ast.method](meths,
parse_method(p));
}
}
@@ -2020,12 +2020,12 @@ fn parse_item_native_mod(parser p) -> @ast.item {
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")) {
+ if (Str.eq(t, "cdecl")) {
+ } else if (Str.eq(t, "rust")) {
abi = ast.native_abi_rust;
- } else if (_str.eq(t, "llvm")) {
+ } else if (Str.eq(t, "llvm")) {
abi = ast.native_abi_llvm;
- } else if (_str.eq(t, "rust-intrinsic")) {
+ } else if (Str.eq(t, "rust-intrinsic")) {
abi = ast.native_abi_rust_intrinsic;
} else {
p.err("unsupported abi: " + t);
@@ -2264,7 +2264,7 @@ fn parse_use(parser p) -> @ast.view_item {
}
fn parse_rest_import_name(parser p, ast.ident first,
- option.t[ast.ident] def_ident)
+ Option.t[ast.ident] def_ident)
-> @ast.view_item {
auto lo = p.get_lo_pos();
let vec[ast.ident] identifiers = vec(first);
@@ -2281,7 +2281,7 @@ fn parse_rest_import_name(parser p, ast.ident first,
defined_id = i;
}
case (_) {
- auto len = _vec.len[ast.ident](identifiers);
+ auto len = Vec.len[ast.ident](identifiers);
defined_id = identifiers.(len - 1u);
}
}
@@ -2506,7 +2506,7 @@ fn parse_crate_directives(parser p, token.token term)
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;
@@ -2514,7 +2514,7 @@ fn parse_crate_directives(parser p, token.token term)
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 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,
diff --git a/src/comp/front/token.rs b/src/comp/front/token.rs
index b0fa0588..f0b6c4be 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 std.Int;
+import std.UInt;
+import std.Str;
tag binop {
PLUS;
@@ -295,10 +295,10 @@ fn to_str(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_FLOAT(?s)) { ret s; }
@@ -309,8 +309,8 @@ fn to_str(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;
}
@@ -320,7 +320,7 @@ fn to_str(token t) -> str {
/* Name components */
case (IDENT(?s)) { auto si = "ident:"; si += 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 */
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-11 13:14:47 +0000