";
}
case (ty_param(?id)) {
- s += "'" + Str.unsafe_from_bytes(vec(('a' as u8) + (id as u8)));
+ s += "'" + _str::unsafe_from_bytes(vec(('a' as u8) + (id as u8)));
}
case (ty_bound_param(?id)) {
- s += "''" + Str.unsafe_from_bytes(vec(('a' as u8) + (id as u8)));
+ s += "''" + _str::unsafe_from_bytes(vec(('a' as u8) +
+ (id as u8)));
}
}
@@ -646,9 +648,9 @@ fn ty_to_str(ctxt cx, &t typ) -> str {
fn ty_to_short_str(ctxt cx, t typ) -> str {
auto f = def_to_str;
- auto ecx = @rec(ds=f, tcx=cx, abbrevs=metadata.ac_no_abbrevs);
- auto s = metadata.Encode.ty_str(ecx, typ);
- if (Str.byte_len(s) >= 32u) { s = Str.substr(s, 0u, 32u); }
+ auto ecx = @rec(ds=f, tcx=cx, abbrevs=metadata::ac_no_abbrevs);
+ auto s = metadata::Encode::ty_str(ecx, typ);
+ if (_str::byte_len(s) >= 32u) { s = _str::substr(s, 0u, 32u); }
ret s;
}
@@ -862,7 +864,7 @@ fn type_is_sequence(&ctxt cx, &t ty) -> bool {
fn sequence_element_type(&ctxt cx, &t ty) -> t {
alt (struct(cx, ty)) {
- case (ty_str) { ret mk_mach(cx, common.ty_u8); }
+ case (ty_str) { ret mk_mach(cx, common::ty_u8); }
case (ty_vec(?mt)) { ret mt.ty; }
}
fail;
@@ -943,14 +945,14 @@ fn type_has_dynamic_size(&ctxt cx, &t ty) -> bool {
alt (struct(cx, ty)) {
case (ty_tup(?mts)) {
auto i = 0u;
- while (i < Vec.len[mt](mts)) {
+ while (i < _vec::len[mt](mts)) {
if (type_has_dynamic_size(cx, mts.(i).ty)) { ret true; }
i += 1u;
}
}
case (ty_rec(?fields)) {
auto i = 0u;
- while (i < Vec.len[field](fields)) {
+ while (i < _vec::len[field](fields)) {
if (type_has_dynamic_size(cx, fields.(i).mt.ty)) {
ret true;
}
@@ -959,7 +961,7 @@ fn type_has_dynamic_size(&ctxt cx, &t ty) -> bool {
}
case (ty_tag(_, ?subtys)) {
auto i = 0u;
- while (i < Vec.len[t](subtys)) {
+ while (i < _vec::len[t](subtys)) {
if (type_has_dynamic_size(cx, subtys.(i))) { ret true; }
i += 1u;
}
@@ -976,15 +978,15 @@ fn type_is_integral(&ctxt cx, &t ty) -> bool {
case (ty_uint) { ret true; }
case (ty_machine(?m)) {
alt (m) {
- case (common.ty_i8) { ret true; }
- case (common.ty_i16) { ret true; }
- case (common.ty_i32) { ret true; }
- case (common.ty_i64) { ret true; }
-
- case (common.ty_u8) { ret true; }
- case (common.ty_u16) { ret true; }
- case (common.ty_u32) { ret true; }
- case (common.ty_u64) { ret true; }
+ case (common::ty_i8) { ret true; }
+ case (common::ty_i16) { ret true; }
+ case (common::ty_i32) { ret true; }
+ case (common::ty_i64) { ret true; }
+
+ case (common::ty_u8) { ret true; }
+ case (common::ty_u16) { ret true; }
+ case (common::ty_u32) { ret true; }
+ case (common::ty_u64) { ret true; }
case (_) { ret false; }
}
}
@@ -998,8 +1000,8 @@ fn type_is_fp(&ctxt cx, &t ty) -> bool {
alt (struct(cx, ty)) {
case (ty_machine(?tm)) {
alt (tm) {
- case (common.ty_f32) { ret true; }
- case (common.ty_f64) { ret true; }
+ case (common::ty_f32) { ret true; }
+ case (common::ty_f64) { ret true; }
case (_) { ret false; }
}
}
@@ -1016,10 +1018,10 @@ fn type_is_signed(&ctxt cx, &t ty) -> bool {
case (ty_int) { ret true; }
case (ty_machine(?tm)) {
alt (tm) {
- case (common.ty_i8) { ret true; }
- case (common.ty_i16) { ret true; }
- case (common.ty_i32) { ret true; }
- case (common.ty_i64) { ret true; }
+ case (common::ty_i8) { ret true; }
+ case (common::ty_i16) { ret true; }
+ case (common::ty_i32) { ret true; }
+ case (common::ty_i64) { ret true; }
case (_) { ret false; }
}
}
@@ -1028,7 +1030,7 @@ fn type_is_signed(&ctxt cx, &t ty) -> bool {
fail;
}
-fn type_param(&ctxt cx, &t ty) -> Option.t[uint] {
+fn type_param(&ctxt cx, &t ty) -> option::t[uint] {
alt (struct(cx, ty)) {
case (ty_param(?id)) { ret some[uint](id); }
case (_) { /* fall through */ }
@@ -1036,7 +1038,7 @@ fn type_param(&ctxt cx, &t ty) -> Option.t[uint] {
ret none[uint];
}
-fn def_to_str(&ast.def_id did) -> str {
+fn def_to_str(&ast::def_id did) -> str {
ret #fmt("%d:%d", did._0, did._1);
}
@@ -1050,7 +1052,7 @@ fn hash_type_structure(&sty st) -> uint {
ret h;
}
- fn hash_def(uint id, ast.def_id did) -> uint {
+ fn hash_def(uint id, ast::def_id did) -> uint {
auto h = id;
h += h << 5u + (did._0 as uint);
h += h << 5u + (did._1 as uint);
@@ -1080,18 +1082,18 @@ fn hash_type_structure(&sty st) -> uint {
case (ty_uint) { ret 4u; }
case (ty_machine(?tm)) {
alt (tm) {
- case (common.ty_i8) { ret 5u; }
- case (common.ty_i16) { ret 6u; }
- case (common.ty_i32) { ret 7u; }
- case (common.ty_i64) { ret 8u; }
+ case (common::ty_i8) { ret 5u; }
+ case (common::ty_i16) { ret 6u; }
+ case (common::ty_i32) { ret 7u; }
+ case (common::ty_i64) { ret 8u; }
- case (common.ty_u8) { ret 9u; }
- case (common.ty_u16) { ret 10u; }
- case (common.ty_u32) { ret 11u; }
- case (common.ty_u64) { ret 12u; }
+ case (common::ty_u8) { ret 9u; }
+ case (common::ty_u16) { ret 10u; }
+ case (common::ty_u32) { ret 11u; }
+ case (common::ty_u64) { ret 12u; }
- case (common.ty_f32) { ret 13u; }
- case (common.ty_f64) { ret 14u; }
+ case (common::ty_f32) { ret 13u; }
+ case (common::ty_f64) { ret 14u; }
}
}
case (ty_char) { ret 15u; }
@@ -1127,7 +1129,7 @@ fn hash_type_structure(&sty st) -> uint {
case (ty_obj(?methods)) {
auto h = 27u;
for (method m in methods) {
- h += h << 5u + Str.hash(m.ident);
+ h += h << 5u + _str::hash(m.ident);
}
ret h;
}
@@ -1140,11 +1142,11 @@ fn hash_type_structure(&sty st) -> uint {
}
}
-fn hash_type_info(&sty st, &Option.t[str] cname_opt) -> uint {
+fn hash_type_info(&sty st, &option::t[str] cname_opt) -> uint {
auto h = hash_type_structure(st);
alt (cname_opt) {
case (none[str]) { /* no-op */ }
- case (some[str](?s)) { h += h << 5u + Str.hash(s); }
+ case (some[str](?s)) { h += h << 5u + _str::hash(s); }
}
ret h;
}
@@ -1165,8 +1167,8 @@ fn equal_type_structures(&sty a, &sty b) -> bool {
&vec[arg] args_b, &t rty_b) -> bool {
if (!eq_ty(rty_a, rty_b)) { ret false; }
- auto len = Vec.len[arg](args_a);
- if (len != Vec.len[arg](args_b)) { ret false; }
+ auto len = _vec::len[arg](args_a);
+ if (len != _vec::len[arg](args_b)) { ret false; }
auto i = 0u;
while (i < len) {
@@ -1178,7 +1180,7 @@ fn equal_type_structures(&sty a, &sty b) -> bool {
ret true;
}
- fn equal_def(&ast.def_id did_a, &ast.def_id did_b) -> bool {
+ fn equal_def(&ast::def_id did_a, &ast::def_id did_b) -> bool {
ret did_a._0 == did_b._0 && did_a._1 == did_b._1;
}
@@ -1238,8 +1240,8 @@ fn equal_type_structures(&sty a, &sty b) -> bool {
case (ty_tag(?id_b, ?tys_b)) {
if (!equal_def(id_a, id_b)) { ret false; }
- auto len = Vec.len[t](tys_a);
- if (len != Vec.len[t](tys_b)) { ret false; }
+ auto len = _vec::len[t](tys_a);
+ if (len != _vec::len[t](tys_b)) { ret false; }
auto i = 0u;
while (i < len) {
if (!eq_ty(tys_a.(i), tys_b.(i))) { ret false; }
@@ -1283,8 +1285,8 @@ fn equal_type_structures(&sty a, &sty b) -> bool {
case (ty_tup(?mts_a)) {
alt (b) {
case (ty_tup(?mts_b)) {
- auto len = Vec.len[mt](mts_a);
- if (len != Vec.len[mt](mts_b)) { ret false; }
+ auto len = _vec::len[mt](mts_a);
+ if (len != _vec::len[mt](mts_b)) { ret false; }
auto i = 0u;
while (i < len) {
if (!equal_mt(mts_a.(i), mts_b.(i))) { ret false; }
@@ -1298,12 +1300,12 @@ fn equal_type_structures(&sty a, &sty b) -> bool {
case (ty_rec(?flds_a)) {
alt (b) {
case (ty_rec(?flds_b)) {
- auto len = Vec.len[field](flds_a);
- if (len != Vec.len[field](flds_b)) { ret false; }
+ auto len = _vec::len[field](flds_a);
+ if (len != _vec::len[field](flds_b)) { ret false; }
auto i = 0u;
while (i < len) {
auto fld_a = flds_a.(i); auto fld_b = flds_b.(i);
- if (!Str.eq(fld_a.ident, fld_b.ident) ||
+ if (!_str::eq(fld_a.ident, fld_b.ident) ||
!equal_mt(fld_a.mt, fld_b.mt)) {
ret false;
}
@@ -1335,13 +1337,13 @@ fn equal_type_structures(&sty a, &sty b) -> bool {
case (ty_obj(?methods_a)) {
alt (b) {
case (ty_obj(?methods_b)) {
- auto len = Vec.len[method](methods_a);
- if (len != Vec.len[method](methods_b)) { ret false; }
+ auto len = _vec::len[method](methods_a);
+ if (len != _vec::len[method](methods_b)) { ret false; }
auto i = 0u;
while (i < len) {
auto m_a = methods_a.(i); auto m_b = methods_b.(i);
if (m_a.proto != m_b.proto ||
- !Str.eq(m_a.ident, m_b.ident) ||
+ !_str::eq(m_a.ident, m_b.ident) ||
!equal_fn(m_a.inputs, m_a.output,
m_b.inputs, m_b.output)) {
ret false;
@@ -1413,7 +1415,7 @@ fn eq_raw_ty(&raw_t a, &raw_t b) -> bool {
case (some[str](?s_a)) {
alt (b.cname) {
case (some[str](?s_b)) {
- if (!Str.eq(s_a, s_b)) { ret false; }
+ if (!_str::eq(s_a, s_b)) { ret false; }
}
case (_) { ret false; }
}
@@ -1429,25 +1431,25 @@ fn eq_raw_ty(&raw_t a, &raw_t b) -> bool {
fn eq_ty(&t a, &t b) -> bool { ret a == b; }
-fn ann_to_type(&ast.ann ann) -> t {
+fn ann_to_type(&ast::ann ann) -> t {
alt (ann) {
- case (ast.ann_none(_)) {
+ case (ast::ann_none(_)) {
log_err "ann_to_type() called on node with no type";
fail;
}
- case (ast.ann_type(_, ?ty, _, _)) {
+ case (ast::ann_type(_, ?ty, _, _)) {
ret ty;
}
}
}
-fn ann_to_type_params(&ast.ann ann) -> vec[t] {
+fn ann_to_type_params(&ast::ann ann) -> vec[t] {
alt (ann) {
- case (ast.ann_none(_)) {
+ case (ast::ann_none(_)) {
log_err "ann_to_type_params() called on node with no type params";
fail;
}
- case (ast.ann_type(_, _, ?tps, _)) {
+ case (ast::ann_type(_, _, ?tps, _)) {
alt (tps) {
case (none[vec[t]]) {
let vec[t] result = vec();
@@ -1461,15 +1463,15 @@ fn ann_to_type_params(&ast.ann ann) -> vec[t] {
// Returns the type of an annotation, with type parameter substitutions
// performed if applicable.
-fn ann_to_monotype(ctxt cx, ast.ann a) -> t {
+fn ann_to_monotype(ctxt cx, ast::ann a) -> t {
// TODO: Refactor to use recursive pattern matching when we're more
// confident that it works.
alt (a) {
- case (ast.ann_none(_)) {
+ case (ast::ann_none(_)) {
log_err "ann_to_monotype() called on expression with no type!";
fail;
}
- case (ast.ann_type(_, ?typ, ?tps_opt, _)) {
+ case (ast::ann_type(_, ?typ, ?tps_opt, _)) {
alt (tps_opt) {
case (none[vec[t]]) { ret typ; }
case (some[vec[t]](?tps)) {
@@ -1481,8 +1483,8 @@ fn ann_to_monotype(ctxt cx, ast.ann a) -> t {
}
// Turns a type into an ann_type, using defaults for other fields.
-fn triv_ann(&ast.ann old, t typ) -> ast.ann {
- ret ast.ann_type(ast.ann_tag(old), typ, none[vec[t]], none[@ts_ann]);
+fn triv_ann(&ast::ann old, t typ) -> ast::ann {
+ ret ast::ann_type(ast::ann_tag(old), typ, none[vec[t]], none[@ts_ann]);
}
// Returns the number of distinct type parameters in the given type.
@@ -1508,7 +1510,7 @@ fn count_ty_params(ctxt cx, t ty) -> uint {
let @mutable vec[uint] param_indices = @mutable v;
auto f = bind counter(cx, param_indices, _);
walk_ty(cx, f, ty);
- ret Vec.len[uint](*param_indices);
+ ret _vec::len[uint](*param_indices);
}
fn type_contains_vars(&ctxt cx, &t typ) -> bool {
@@ -1531,38 +1533,38 @@ fn type_contains_bound_params(&ctxt cx, &t typ) -> bool {
fn ty_fn_args(&ctxt cx, &t fty) -> vec[arg] {
alt (struct(cx, fty)) {
- case (ty.ty_fn(_, ?a, _)) { ret a; }
- case (ty.ty_native_fn(_, ?a, _)) { ret a; }
+ case (ty::ty_fn(_, ?a, _)) { ret a; }
+ case (ty::ty_native_fn(_, ?a, _)) { ret a; }
}
fail;
}
-fn ty_fn_proto(&ctxt cx, &t fty) -> ast.proto {
+fn ty_fn_proto(&ctxt cx, &t fty) -> ast::proto {
alt (struct(cx, fty)) {
- case (ty.ty_fn(?p, _, _)) { ret p; }
+ case (ty::ty_fn(?p, _, _)) { ret p; }
}
fail;
}
-fn ty_fn_abi(&ctxt cx, &t fty) -> ast.native_abi {
+fn ty_fn_abi(&ctxt cx, &t fty) -> ast::native_abi {
alt (struct(cx, fty)) {
- case (ty.ty_native_fn(?a, _, _)) { ret a; }
+ case (ty::ty_native_fn(?a, _, _)) { ret a; }
}
fail;
}
fn ty_fn_ret(&ctxt cx, &t fty) -> t {
alt (struct(cx, fty)) {
- case (ty.ty_fn(_, _, ?r)) { ret r; }
- case (ty.ty_native_fn(_, _, ?r)) { ret r; }
+ case (ty::ty_fn(_, _, ?r)) { ret r; }
+ case (ty::ty_native_fn(_, _, ?r)) { ret r; }
}
fail;
}
fn is_fn_ty(&ctxt cx, &t fty) -> bool {
alt (struct(cx, fty)) {
- case (ty.ty_fn(_, _, _)) { ret true; }
- case (ty.ty_native_fn(_, _, _)) { ret true; }
+ case (ty::ty_fn(_, _, _)) { ret true; }
+ case (ty::ty_native_fn(_, _, _)) { ret true; }
case (_) { ret false; }
}
ret false;
@@ -1573,43 +1575,43 @@ fn is_fn_ty(&ctxt cx, &t fty) -> bool {
// Given an item, returns the associated type as well as the number of type
// parameters it has.
-fn native_item_ty(&@ast.native_item it) -> ty_param_count_and_ty {
+fn native_item_ty(&@ast::native_item it) -> ty_param_count_and_ty {
auto ty_param_count;
auto result_ty;
alt (it.node) {
- case (ast.native_item_fn(_, _, _, ?tps, _, ?ann)) {
- ty_param_count = Vec.len[ast.ty_param](tps);
+ case (ast::native_item_fn(_, _, _, ?tps, _, ?ann)) {
+ ty_param_count = _vec::len[ast::ty_param](tps);
result_ty = ann_to_type(ann);
}
}
ret tup(ty_param_count, result_ty);
}
-fn item_ty(&@ast.item it) -> ty_param_count_and_ty {
+fn item_ty(&@ast::item it) -> ty_param_count_and_ty {
auto ty_param_count;
auto result_ty;
alt (it.node) {
- case (ast.item_const(_, _, _, _, ?ann)) {
+ case (ast::item_const(_, _, _, _, ?ann)) {
ty_param_count = 0u;
result_ty = ann_to_type(ann);
}
- case (ast.item_fn(_, _, ?tps, _, ?ann)) {
- ty_param_count = Vec.len[ast.ty_param](tps);
+ case (ast::item_fn(_, _, ?tps, _, ?ann)) {
+ ty_param_count = _vec::len[ast::ty_param](tps);
result_ty = ann_to_type(ann);
}
- case (ast.item_mod(_, _, _)) {
+ case (ast::item_mod(_, _, _)) {
fail; // modules are typeless
}
- case (ast.item_ty(_, _, ?tps, _, ?ann)) {
- ty_param_count = Vec.len[ast.ty_param](tps);
+ case (ast::item_ty(_, _, ?tps, _, ?ann)) {
+ ty_param_count = _vec::len[ast::ty_param](tps);
result_ty = ann_to_type(ann);
}
- case (ast.item_tag(_, _, ?tps, ?did, ?ann)) {
- ty_param_count = Vec.len[ast.ty_param](tps);
+ case (ast::item_tag(_, _, ?tps, ?did, ?ann)) {
+ ty_param_count = _vec::len[ast::ty_param](tps);
result_ty = ann_to_type(ann);
}
- case (ast.item_obj(_, _, ?tps, _, ?ann)) {
- ty_param_count = Vec.len[ast.ty_param](tps);
+ case (ast::item_obj(_, _, ?tps, _, ?ann)) {
+ ty_param_count = _vec::len[ast::ty_param](tps);
result_ty = ann_to_type(ann);
}
}
@@ -1617,9 +1619,9 @@ fn item_ty(&@ast.item it) -> ty_param_count_and_ty {
ret tup(ty_param_count, result_ty);
}
-fn stmt_ty(&ctxt cx, &@ast.stmt s) -> t {
+fn stmt_ty(&ctxt cx, &@ast::stmt s) -> t {
alt (s.node) {
- case (ast.stmt_expr(?e,_)) {
+ case (ast::stmt_expr(?e,_)) {
ret expr_ty(cx, e);
}
case (_) {
@@ -1628,133 +1630,133 @@ fn stmt_ty(&ctxt cx, &@ast.stmt s) -> t {
}
}
-fn block_ty(&ctxt cx, &ast.block b) -> t {
+fn block_ty(&ctxt cx, &ast::block b) -> t {
alt (b.node.expr) {
- case (some[@ast.expr](?e)) { ret expr_ty(cx, e); }
- case (none[@ast.expr]) { ret mk_nil(cx); }
+ case (some[@ast::expr](?e)) { ret expr_ty(cx, e); }
+ case (none[@ast::expr]) { ret mk_nil(cx); }
}
}
// Returns the type of a pattern as a monotype. Like @expr_ty, this function
// doesn't provide type parameter substitutions.
-fn pat_ty(&ctxt cx, &@ast.pat pat) -> t {
+fn pat_ty(&ctxt cx, &@ast::pat pat) -> t {
alt (pat.node) {
- case (ast.pat_wild(?ann)) { ret ann_to_monotype(cx, ann); }
- case (ast.pat_lit(_, ?ann)) { ret ann_to_monotype(cx, ann); }
- case (ast.pat_bind(_, _, ?ann)) { ret ann_to_monotype(cx, ann); }
- case (ast.pat_tag(_, _, ?ann)) { ret ann_to_monotype(cx, ann); }
+ case (ast::pat_wild(?ann)) { ret ann_to_monotype(cx, ann); }
+ case (ast::pat_lit(_, ?ann)) { ret ann_to_monotype(cx, ann); }
+ case (ast::pat_bind(_, _, ?ann)) { ret ann_to_monotype(cx, ann); }
+ case (ast::pat_tag(_, _, ?ann)) { ret ann_to_monotype(cx, ann); }
}
fail; // not reached
}
-fn expr_ann(&@ast.expr e) -> ast.ann {
+fn expr_ann(&@ast::expr e) -> ast::ann {
alt(e.node) {
- case (ast.expr_vec(_,_,?a)) {
+ case (ast::expr_vec(_,_,?a)) {
ret a;
}
- case (ast.expr_tup(_,?a)) {
+ case (ast::expr_tup(_,?a)) {
ret a;
}
- case (ast.expr_rec(_,_,?a)) {
+ case (ast::expr_rec(_,_,?a)) {
ret a;
}
- case (ast.expr_call(_,_,?a)) {
+ case (ast::expr_call(_,_,?a)) {
ret a;
}
- case (ast.expr_bind(_,_,?a)) {
+ case (ast::expr_bind(_,_,?a)) {
ret a;
}
- case (ast.expr_binary(_,_,_,?a)) {
+ case (ast::expr_binary(_,_,_,?a)) {
ret a;
}
- case (ast.expr_unary(_,_,?a)) {
+ case (ast::expr_unary(_,_,?a)) {
ret a;
}
- case (ast.expr_lit(_,?a)) {
+ case (ast::expr_lit(_,?a)) {
ret a;
}
- case (ast.expr_cast(_,_,?a)) {
+ case (ast::expr_cast(_,_,?a)) {
ret a;
}
- case (ast.expr_if(_,_,_,?a)) {
+ case (ast::expr_if(_,_,_,?a)) {
ret a;
}
- case (ast.expr_while(_,_,?a)) {
+ case (ast::expr_while(_,_,?a)) {
ret a;
}
- case (ast.expr_for(_,_,_,?a)) {
+ case (ast::expr_for(_,_,_,?a)) {
ret a;
}
- case (ast.expr_for_each(_,_,_,?a)) {
+ case (ast::expr_for_each(_,_,_,?a)) {
ret a;
}
- case (ast.expr_do_while(_,_,?a)) {
+ case (ast::expr_do_while(_,_,?a)) {
ret a;
}
- case (ast.expr_alt(_,_,?a)) {
+ case (ast::expr_alt(_,_,?a)) {
ret a;
}
- case (ast.expr_block(_,?a)) {
+ case (ast::expr_block(_,?a)) {
ret a;
}
- case (ast.expr_assign(_,_,?a)) {
+ case (ast::expr_assign(_,_,?a)) {
ret a;
}
- case (ast.expr_assign_op(_,_,_,?a)) {
+ case (ast::expr_assign_op(_,_,_,?a)) {
ret a;
}
- case (ast.expr_send(_,_,?a)) {
+ case (ast::expr_send(_,_,?a)) {
ret a;
}
- case (ast.expr_recv(_,_,?a)) {
+ case (ast::expr_recv(_,_,?a)) {
ret a;
}
- case (ast.expr_field(_,_,?a)) {
+ case (ast::expr_field(_,_,?a)) {
ret a;
}
- case (ast.expr_index(_,_,?a)) {
+ case (ast::expr_index(_,_,?a)) {
ret a;
}
- case (ast.expr_path(_,?a)) {
+ case (ast::expr_path(_,?a)) {
ret a;
}
- case (ast.expr_ext(_,_,_,_,?a)) {
+ case (ast::expr_ext(_,_,_,_,?a)) {
ret a;
}
- case (ast.expr_fail(?a)) {
+ case (ast::expr_fail(?a)) {
ret a;
}
- case (ast.expr_ret(_,?a)) {
+ case (ast::expr_ret(_,?a)) {
ret a;
}
- case (ast.expr_put(_,?a)) {
+ case (ast::expr_put(_,?a)) {
ret a;
}
- case (ast.expr_be(_,?a)) {
+ case (ast::expr_be(_,?a)) {
ret a;
}
- case (ast.expr_log(_,_,?a)) {
+ case (ast::expr_log(_,_,?a)) {
ret a;
}
- case (ast.expr_assert(_,?a)) {
+ case (ast::expr_assert(_,?a)) {
ret a;
}
- case (ast.expr_check(_,?a)) {
+ case (ast::expr_check(_,?a)) {
ret a;
}
- case (ast.expr_port(?a)) {
+ case (ast::expr_port(?a)) {
ret a;
}
- case (ast.expr_chan(_,?a)) {
+ case (ast::expr_chan(_,?a)) {
ret a;
}
- case (ast.expr_break(?a)) {
+ case (ast::expr_break(?a)) {
ret a;
}
- case (ast.expr_cont(?a)) {
+ case (ast::expr_cont(?a)) {
ret a;
}
- case (ast.expr_self_method(_, ?a)) {
+ case (ast::expr_self_method(_, ?a)) {
ret a;
}
}
@@ -1766,29 +1768,29 @@ fn expr_ann(&@ast.expr e) -> ast.ann {
// ask for the type of "id" in "id(3)", it will return "fn(&int) -> int"
// instead of "fn(&T) -> T with T = int". If this isn't what you want, see
// expr_ty_params_and_ty() below.
-fn expr_ty(&ctxt cx, &@ast.expr expr) -> t {
+fn expr_ty(&ctxt cx, &@ast::expr expr) -> t {
ret ann_to_monotype(cx, expr_ann(expr));
}
-fn expr_ty_params_and_ty(&ctxt cx, &@ast.expr expr) -> tup(vec[t], t) {
+fn expr_ty_params_and_ty(&ctxt cx, &@ast::expr expr) -> tup(vec[t], t) {
auto a = expr_ann(expr);
ret tup(ann_to_type_params(a), ann_to_type(a));
}
-fn expr_has_ty_params(&@ast.expr expr) -> bool {
+fn expr_has_ty_params(&@ast::expr expr) -> bool {
// FIXME: Rewrite using complex patterns when they're trustworthy.
alt (expr_ann(expr)) {
- case (ast.ann_none(_)) { fail; }
- case (ast.ann_type(_, _, ?tps_opt, _)) {
- ret !Option.is_none[vec[t]](tps_opt);
+ case (ast::ann_none(_)) { fail; }
+ case (ast::ann_type(_, _, ?tps_opt, _)) {
+ ret !option::is_none[vec[t]](tps_opt);
}
}
}
// FIXME: At the moment this works only for call, bind, and path expressions.
-fn replace_expr_type(&@ast.expr expr,
- &tup(vec[t], t) new_tyt) -> @ast.expr {
+fn replace_expr_type(&@ast::expr expr,
+ &tup(vec[t], t) new_tyt) -> @ast::expr {
auto new_tps;
if (expr_has_ty_params(expr)) {
new_tps = some[vec[t]](new_tyt._0);
@@ -1796,35 +1798,35 @@ fn replace_expr_type(&@ast.expr expr,
new_tps = none[vec[t]];
}
- fn mkann_fn(t tyt, Option.t[vec[t]] tps, &ast.ann old_ann) -> ast.ann {
- ret ast.ann_type(ast.ann_tag(old_ann), tyt, tps, none[@ts_ann]);
+ fn mkann_fn(t tyt, option::t[vec[t]] tps, &ast::ann old_ann) -> ast::ann {
+ ret ast::ann_type(ast::ann_tag(old_ann), tyt, tps, none[@ts_ann]);
}
auto mkann = bind mkann_fn(new_tyt._1, new_tps, _);
alt (expr.node) {
- case (ast.expr_call(?callee, ?args, ?a)) {
- ret @fold.respan(expr.span,
- ast.expr_call(callee, args, mkann(a)));
+ case (ast::expr_call(?callee, ?args, ?a)) {
+ ret @fold::respan(expr.span,
+ ast::expr_call(callee, args, mkann(a)));
}
- case (ast.expr_self_method(?ident, ?a)) {
- ret @fold.respan(expr.span,
- ast.expr_self_method(ident, mkann(a)));
+ case (ast::expr_self_method(?ident, ?a)) {
+ ret @fold::respan(expr.span,
+ ast::expr_self_method(ident, mkann(a)));
}
- case (ast.expr_bind(?callee, ?args, ?a)) {
- ret @fold.respan(expr.span,
- ast.expr_bind(callee, args, mkann(a)));
+ case (ast::expr_bind(?callee, ?args, ?a)) {
+ ret @fold::respan(expr.span,
+ ast::expr_bind(callee, args, mkann(a)));
}
- case (ast.expr_field(?e, ?i, ?a)) {
- ret @fold.respan(expr.span,
- ast.expr_field(e, i, mkann(a)));
+ case (ast::expr_field(?e, ?i, ?a)) {
+ ret @fold::respan(expr.span,
+ ast::expr_field(e, i, mkann(a)));
}
- case (ast.expr_path(?p, ?a)) {
- ret @fold.respan(expr.span,
- ast.expr_path(p, mkann(a)));
+ case (ast::expr_path(?p, ?a)) {
+ ret @fold::respan(expr.span,
+ ast::expr_path(p, mkann(a)));
}
case (_) {
log_err "unhandled expr type in replace_expr_type(): " +
- util.common.expr_to_str(expr);
+ util::common::expr_to_str(expr);
fail;
}
}
@@ -1832,8 +1834,8 @@ fn replace_expr_type(&@ast.expr expr,
// Expression utilities
-fn field_num(&session.session sess, &span sp,
- &ast.ident id) -> uint {
+fn field_num(&session::session sess, &span sp,
+ &ast::ident id) -> uint {
let uint accum = 0u;
let uint i = 0u;
for (u8 c in id) {
@@ -1849,7 +1851,7 @@ fn field_num(&session.session sess, &span sp,
accum += (c as uint) - ('0' as uint);
} else {
auto s = "";
- s += Str.unsafe_from_byte(c);
+ s += _str::unsafe_from_byte(c);
sess.span_err(sp,
"bad numeric field on tuple: "
+ " non-digit character: "
@@ -1861,11 +1863,11 @@ fn field_num(&session.session sess, &span sp,
ret accum;
}
-fn field_idx(&session.session sess, &span sp,
- &ast.ident id, &vec[field] fields) -> uint {
+fn field_idx(&session::session sess, &span sp,
+ &ast::ident id, &vec[field] fields) -> uint {
let uint i = 0u;
for (field f in fields) {
- if (Str.eq(f.ident, id)) {
+ if (_str::eq(f.ident, id)) {
ret i;
}
i += 1u;
@@ -1874,11 +1876,11 @@ fn field_idx(&session.session sess, &span sp,
fail;
}
-fn method_idx(&session.session sess, &span sp,
- &ast.ident id, &vec[method] meths) -> uint {
+fn method_idx(&session::session sess, &span sp,
+ &ast::ident id, &vec[method] meths) -> uint {
let uint i = 0u;
for (method m in meths) {
- if (Str.eq(m.ident, id)) {
+ if (_str::eq(m.ident, id)) {
ret i;
}
i += 1u;
@@ -1889,18 +1891,18 @@ fn method_idx(&session.session sess, &span sp,
fn sort_methods(&vec[method] meths) -> vec[method] {
fn method_lteq(&method a, &method b) -> bool {
- ret Str.lteq(a.ident, b.ident);
+ ret _str::lteq(a.ident, b.ident);
}
- ret std.Sort.merge_sort[method](bind method_lteq(_,_), meths);
+ ret std::sort::merge_sort[method](bind method_lteq(_,_), meths);
}
-fn is_lval(&@ast.expr expr) -> bool {
+fn is_lval(&@ast::expr expr) -> bool {
alt (expr.node) {
- case (ast.expr_field(_,_,_)) { ret true; }
- case (ast.expr_index(_,_,_)) { ret true; }
- case (ast.expr_path(_,_)) { ret true; }
- case (ast.expr_unary(ast.deref,_,_)) { ret true; }
+ case (ast::expr_field(_,_,_)) { ret true; }
+ case (ast::expr_index(_,_,_)) { ret true; }
+ case (ast::expr_path(_,_)) { ret true; }
+ case (ast::expr_unary(ast::deref,_,_)) { ret true; }
case (_) { ret false; }
}
}
@@ -1916,7 +1918,7 @@ mod Unify {
ures_err(type_err, t, t);
}
- type ctxt = rec(UFind.ufind sets,
+ type ctxt = rec(ufind::ufind sets,
hashmap[int,uint] var_ids,
mutable vec[mutable vec[t]] types,
unify_handler handler,
@@ -1939,18 +1941,18 @@ mod Unify {
}
// Unifies two mutability flags.
- fn unify_mut(ast.mutability expected, ast.mutability actual)
- -> Option.t[ast.mutability] {
+ fn unify_mut(ast::mutability expected, ast::mutability actual)
+ -> option::t[ast::mutability] {
if (expected == actual) {
- ret some[ast.mutability](expected);
+ ret some[ast::mutability](expected);
}
- if (expected == ast.maybe_mut) {
- ret some[ast.mutability](actual);
+ if (expected == ast::maybe_mut) {
+ ret some[ast::mutability](actual);
}
- if (actual == ast.maybe_mut) {
- ret some[ast.mutability](expected);
+ if (actual == ast::maybe_mut) {
+ ret some[ast::mutability](expected);
}
- ret none[ast.mutability];
+ ret none[ast::mutability];
}
tag fn_common_res {
@@ -1964,8 +1966,8 @@ mod Unify {
&vec[arg] expected_inputs, &t expected_output,
&vec[arg] actual_inputs, &t actual_output)
-> fn_common_res {
- auto expected_len = Vec.len[arg](expected_inputs);
- auto actual_len = Vec.len[arg](actual_inputs);
+ auto expected_len = _vec::len[arg](expected_inputs);
+ auto actual_len = _vec::len[arg](actual_inputs);
if (expected_len != actual_len) {
ret fn_common_res_err(ures_err(terr_arg_count,
expected, actual));
@@ -2020,8 +2022,8 @@ mod Unify {
}
fn unify_fn(&@ctxt cx,
- &ast.proto e_proto,
- &ast.proto a_proto,
+ &ast::proto e_proto,
+ &ast::proto a_proto,
&t expected,
&t actual,
&vec[arg] expected_inputs, &t expected_output,
@@ -2046,8 +2048,8 @@ mod Unify {
}
fn unify_native_fn(&@ctxt cx,
- &ast.native_abi e_abi,
- &ast.native_abi a_abi,
+ &ast::native_abi e_abi,
+ &ast::native_abi a_abi,
&t expected,
&t actual,
&vec[arg] expected_inputs, &t expected_output,
@@ -2079,8 +2081,8 @@ mod Unify {
&vec[method] actual_meths) -> result {
let vec[method] result_meths = vec();
let uint i = 0u;
- let uint expected_len = Vec.len[method](expected_meths);
- let uint actual_len = Vec.len[method](actual_meths);
+ let uint expected_len = _vec::len[method](expected_meths);
+ let uint actual_len = _vec::len[method](actual_meths);
if (expected_len != actual_len) {
ret ures_err(terr_meth_count, expected, actual);
@@ -2089,7 +2091,7 @@ mod Unify {
while (i < expected_len) {
auto e_meth = expected_meths.(i);
auto a_meth = actual_meths.(i);
- if (! Str.eq(e_meth.ident, a_meth.ident)) {
+ if (! _str::eq(e_meth.ident, a_meth.ident)) {
ret ures_err(terr_obj_meths(e_meth.ident, a_meth.ident),
expected, actual);
}
@@ -2122,7 +2124,7 @@ mod Unify {
auto set_num;
alt (cx.var_ids.find(id)) {
case (none[uint]) {
- set_num = UFind.make_set(cx.sets);
+ set_num = ufind::make_set(cx.sets);
cx.var_ids.insert(id, set_num);
}
case (some[uint](?n)) { set_num = n; }
@@ -2143,17 +2145,17 @@ mod Unify {
alt (struct(cx.tcx, actual)) {
// If the RHS is a variable type, then just do the appropriate
// binding.
- case (ty.ty_var(?actual_id)) {
+ case (ty::ty_var(?actual_id)) {
auto actual_n = get_or_create_set(cx, actual_id);
alt (struct(cx.tcx, expected)) {
- case (ty.ty_var(?expected_id)) {
+ case (ty::ty_var(?expected_id)) {
auto expected_n = get_or_create_set(cx, expected_id);
- UFind.union(cx.sets, expected_n, actual_n);
+ ufind::union(cx.sets, expected_n, actual_n);
}
case (_) {
// Just bind the type variable to the expected type.
- auto vlen = Vec.len[vec[t]](cx.types);
+ auto vlen = _vec::len[vec[t]](cx.types);
if (actual_n < vlen) {
cx.types.(actual_n) += vec(expected);
} else {
@@ -2164,7 +2166,7 @@ mod Unify {
}
ret ures_ok(actual);
}
- case (ty.ty_local(?actual_id)) {
+ case (ty::ty_local(?actual_id)) {
auto result_ty;
alt (cx.handler.resolve_local(actual_id)) {
case (none[t]) { result_ty = expected; }
@@ -2180,9 +2182,9 @@ mod Unify {
cx.handler.record_local(actual_id, result_ty);
ret ures_ok(result_ty);
}
- case (ty.ty_bound_param(?actual_id)) {
+ case (ty::ty_bound_param(?actual_id)) {
alt (struct(cx.tcx, expected)) {
- case (ty.ty_local(_)) {
+ case (ty::ty_local(_)) {
log_err "TODO: bound param unifying with local";
fail;
}
@@ -2196,31 +2198,31 @@ mod Unify {
}
alt (struct(cx.tcx, expected)) {
- case (ty.ty_nil) { ret struct_cmp(cx, expected, actual); }
- case (ty.ty_bool) { ret struct_cmp(cx, expected, actual); }
- case (ty.ty_int) { ret struct_cmp(cx, expected, actual); }
- case (ty.ty_uint) { ret struct_cmp(cx, expected, actual); }
- case (ty.ty_machine(_)) { ret struct_cmp(cx, expected, actual); }
- case (ty.ty_float) { ret struct_cmp(cx, expected, actual); }
- case (ty.ty_char) { ret struct_cmp(cx, expected, actual); }
- case (ty.ty_str) { ret struct_cmp(cx, expected, actual); }
- case (ty.ty_type) { ret struct_cmp(cx, expected, actual); }
- case (ty.ty_native) { ret struct_cmp(cx, expected, actual); }
- case (ty.ty_param(_)) { ret struct_cmp(cx, expected, actual); }
-
- case (ty.ty_tag(?expected_id, ?expected_tps)) {
+ case (ty::ty_nil) { ret struct_cmp(cx, expected, actual); }
+ case (ty::ty_bool) { ret struct_cmp(cx, expected, actual); }
+ case (ty::ty_int) { ret struct_cmp(cx, expected, actual); }
+ case (ty::ty_uint) { ret struct_cmp(cx, expected, actual); }
+ case (ty::ty_machine(_)) { ret struct_cmp(cx, expected, actual); }
+ case (ty::ty_float) { ret struct_cmp(cx, expected, actual); }
+ case (ty::ty_char) { ret struct_cmp(cx, expected, actual); }
+ case (ty::ty_str) { ret struct_cmp(cx, expected, actual); }
+ case (ty::ty_type) { ret struct_cmp(cx, expected, actual); }
+ case (ty::ty_native) { ret struct_cmp(cx, expected, actual); }
+ case (ty::ty_param(_)) { ret struct_cmp(cx, expected, actual); }
+
+ case (ty::ty_tag(?expected_id, ?expected_tps)) {
alt (struct(cx.tcx, actual)) {
- case (ty.ty_tag(?actual_id, ?actual_tps)) {
+ case (ty::ty_tag(?actual_id, ?actual_tps)) {
if (expected_id._0 != actual_id._0 ||
expected_id._1 != actual_id._1) {
ret ures_err(terr_mismatch, expected, actual);
}
// TODO: factor this cruft out, see the TODO in the
- // ty.ty_tup case
+ // ty::ty_tup case
let vec[t] result_tps = vec();
auto i = 0u;
- auto expected_len = Vec.len[t](expected_tps);
+ auto expected_len = _vec::len[t](expected_tps);
while (i < expected_len) {
auto expected_tp = expected_tps.(i);
auto actual_tp = actual_tps.(i);
@@ -2231,7 +2233,7 @@ mod Unify {
alt (result) {
case (ures_ok(?rty)) {
- Vec.push[t](result_tps, rty);
+ _vec::push[t](result_tps, rty);
}
case (_) {
ret result;
@@ -2249,16 +2251,16 @@ mod Unify {
ret ures_err(terr_mismatch, expected, actual);
}
- case (ty.ty_box(?expected_mt)) {
+ case (ty::ty_box(?expected_mt)) {
alt (struct(cx.tcx, actual)) {
- case (ty.ty_box(?actual_mt)) {
+ case (ty::ty_box(?actual_mt)) {
auto mut;
alt (unify_mut(expected_mt.mut, actual_mt.mut)) {
- case (none[ast.mutability]) {
+ case (none[ast::mutability]) {
ret ures_err(terr_box_mutability, expected,
actual);
}
- case (some[ast.mutability](?m)) { mut = m; }
+ case (some[ast::mutability](?m)) { mut = m; }
}
auto result = unify_step(cx,
@@ -2281,16 +2283,16 @@ mod Unify {
}
}
- case (ty.ty_vec(?expected_mt)) {
+ case (ty::ty_vec(?expected_mt)) {
alt (struct(cx.tcx, actual)) {
- case (ty.ty_vec(?actual_mt)) {
+ case (ty::ty_vec(?actual_mt)) {
auto mut;
alt (unify_mut(expected_mt.mut, actual_mt.mut)) {
- case (none[ast.mutability]) {
+ case (none[ast::mutability]) {
ret ures_err(terr_vec_mutability, expected,
actual);
}
- case (some[ast.mutability](?m)) { mut = m; }
+ case (some[ast::mutability](?m)) { mut = m; }
}
auto result = unify_step(cx,
@@ -2313,9 +2315,9 @@ mod Unify {
}
}
- case (ty.ty_port(?expected_sub)) {
+ case (ty::ty_port(?expected_sub)) {
alt (struct(cx.tcx, actual)) {
- case (ty.ty_port(?actual_sub)) {
+ case (ty::ty_port(?actual_sub)) {
auto result = unify_step(cx,
expected_sub,
actual_sub);
@@ -2335,9 +2337,9 @@ mod Unify {
}
}
- case (ty.ty_chan(?expected_sub)) {
+ case (ty::ty_chan(?expected_sub)) {
alt (struct(cx.tcx, actual)) {
- case (ty.ty_chan(?actual_sub)) {
+ case (ty::ty_chan(?actual_sub)) {
auto result = unify_step(cx,
expected_sub,
actual_sub);
@@ -2357,11 +2359,11 @@ mod Unify {
}
}
- case (ty.ty_tup(?expected_elems)) {
+ case (ty::ty_tup(?expected_elems)) {
alt (struct(cx.tcx, actual)) {
- case (ty.ty_tup(?actual_elems)) {
- auto expected_len = Vec.len[ty.mt](expected_elems);
- auto actual_len = Vec.len[ty.mt](actual_elems);
+ case (ty::ty_tup(?actual_elems)) {
+ auto expected_len = _vec::len[ty::mt](expected_elems);
+ auto actual_len = _vec::len[ty::mt](actual_elems);
if (expected_len != actual_len) {
auto err = terr_tuple_size(expected_len,
actual_len);
@@ -2370,7 +2372,7 @@ mod Unify {
// TODO: implement an iterator that can iterate over
// two arrays simultaneously.
- let vec[ty.mt] result_elems = vec();
+ let vec[ty::mt] result_elems = vec();
auto i = 0u;
while (i < expected_len) {
auto expected_elem = expected_elems.(i);
@@ -2379,11 +2381,11 @@ mod Unify {
auto mut;
alt (unify_mut(expected_elem.mut,
actual_elem.mut)) {
- case (none[ast.mutability]) {
+ case (none[ast::mutability]) {
auto err = terr_tuple_mutability;
ret ures_err(err, expected, actual);
}
- case (some[ast.mutability](?m)) { mut = m; }
+ case (some[ast::mutability](?m)) { mut = m; }
}
auto result = unify_step(cx,
@@ -2411,11 +2413,11 @@ mod Unify {
}
}
- case (ty.ty_rec(?expected_fields)) {
+ case (ty::ty_rec(?expected_fields)) {
alt (struct(cx.tcx, actual)) {
- case (ty.ty_rec(?actual_fields)) {
- auto expected_len = Vec.len[field](expected_fields);
- auto actual_len = Vec.len[field](actual_fields);
+ case (ty::ty_rec(?actual_fields)) {
+ auto expected_len = _vec::len[field](expected_fields);
+ auto actual_len = _vec::len[field](actual_fields);
if (expected_len != actual_len) {
auto err = terr_record_size(expected_len,
actual_len);
@@ -2433,14 +2435,14 @@ mod Unify {
auto mut;
alt (unify_mut(expected_field.mt.mut,
actual_field.mt.mut)) {
- case (none[ast.mutability]) {
+ case (none[ast::mutability]) {
ret ures_err(terr_record_mutability,
expected, actual);
}
- case (some[ast.mutability](?m)) { mut = m; }
+ case (some[ast::mutability](?m)) { mut = m; }
}
- if (!Str.eq(expected_field.ident,
+ if (!_str::eq(expected_field.ident,
actual_field.ident)) {
auto err =
terr_record_fields(expected_field.ident,
@@ -2454,7 +2456,7 @@ mod Unify {
alt (result) {
case (ures_ok(?rty)) {
auto mt = rec(ty=rty, mut=mut);
- Vec.push[field]
+ _vec::push[field]
(result_fields,
rec(mt=mt with expected_field));
}
@@ -2475,9 +2477,9 @@ mod Unify {
}
}
- case (ty.ty_fn(?ep, ?expected_inputs, ?expected_output)) {
+ case (ty::ty_fn(?ep, ?expected_inputs, ?expected_output)) {
alt (struct(cx.tcx, actual)) {
- case (ty.ty_fn(?ap, ?actual_inputs, ?actual_output)) {
+ case (ty::ty_fn(?ap, ?actual_inputs, ?actual_output)) {
ret unify_fn(cx, ep, ap,
expected, actual,
expected_inputs, expected_output,
@@ -2490,10 +2492,10 @@ mod Unify {
}
}
- case (ty.ty_native_fn(?e_abi, ?expected_inputs,
+ case (ty::ty_native_fn(?e_abi, ?expected_inputs,
?expected_output)) {
alt (struct(cx.tcx, actual)) {
- case (ty.ty_native_fn(?a_abi, ?actual_inputs,
+ case (ty::ty_native_fn(?a_abi, ?actual_inputs,
?actual_output)) {
ret unify_native_fn(cx, e_abi, a_abi,
expected, actual,
@@ -2506,9 +2508,9 @@ mod Unify {
}
}
- case (ty.ty_obj(?expected_meths)) {
+ case (ty::ty_obj(?expected_meths)) {
alt (struct(cx.tcx, actual)) {
- case (ty.ty_obj(?actual_meths)) {
+ case (ty::ty_obj(?actual_meths)) {
ret unify_obj(cx, expected, actual,
expected_meths, actual_meths);
}
@@ -2518,10 +2520,10 @@ mod Unify {
}
}
- case (ty.ty_var(?expected_id)) {
+ case (ty::ty_var(?expected_id)) {
// Add a binding.
auto expected_n = get_or_create_set(cx, expected_id);
- auto vlen = Vec.len[vec[t]](cx.types);
+ auto vlen = _vec::len[vec[t]](cx.types);
if (expected_n < vlen) {
cx.types.(expected_n) += vec(actual);
} else {
@@ -2531,7 +2533,7 @@ mod Unify {
ret ures_ok(expected);
}
- case (ty.ty_local(?expected_id)) {
+ case (ty::ty_local(?expected_id)) {
auto result_ty;
alt (cx.handler.resolve_local(expected_id)) {
case (none[t]) { result_ty = actual; }
@@ -2548,7 +2550,7 @@ mod Unify {
ret ures_ok(result_ty);
}
- case (ty.ty_bound_param(?expected_id)) {
+ case (ty::ty_bound_param(?expected_id)) {
ret cx.handler.record_param(expected_id, actual);
}
}
@@ -2568,7 +2570,7 @@ mod Unify {
case (ty_var(?id)) {
alt (cx.var_ids.find(id)) {
case (some[uint](?n)) {
- auto root = UFind.find(cx.sets, n);
+ auto root = ufind::find(cx.sets, n);
ret types.(root);
}
case (none[uint]) { ret typ; }
@@ -2585,23 +2587,23 @@ mod Unify {
fn unify_sets(&@ctxt cx) -> vec[t] {
let vec[t] throwaway = vec();
let vec[mutable vec[t]] set_types = vec(mutable throwaway);
- Vec.pop[vec[t]](set_types); // FIXME: botch
+ _vec::pop[vec[t]](set_types); // FIXME: botch
- for (UFind.node node in cx.sets.nodes) {
+ for (ufind::node node in cx.sets.nodes) {
let vec[t] v = vec();
set_types += vec(mutable v);
}
auto i = 0u;
- while (i < Vec.len[vec[t]](set_types)) {
- auto root = UFind.find(cx.sets, i);
+ while (i < _vec::len[vec[t]](set_types)) {
+ auto root = ufind::find(cx.sets, i);
set_types.(root) += cx.types.(i);
i += 1u;
}
let vec[t] result = vec();
for (vec[t] types in set_types) {
- if (Vec.len[t](types) > 1u) {
+ if (_vec::len[t](types) > 1u) {
log_err "unification of > 1 types in a type set is " +
"unimplemented";
fail;
@@ -2618,10 +2620,10 @@ mod Unify {
&ty_ctxt tcx) -> result {
let vec[t] throwaway = vec();
let vec[mutable vec[t]] types = vec(mutable throwaway);
- Vec.pop[vec[t]](types); // FIXME: botch
+ _vec::pop[vec[t]](types); // FIXME: botch
- auto cx = @rec(sets=UFind.make(),
- var_ids=common.new_int_hash[uint](),
+ auto cx = @rec(sets=ufind::make(),
+ var_ids=common::new_int_hash[uint](),
mutable types=types,
handler=handler,
tcx=tcx);
@@ -2631,7 +2633,7 @@ mod Unify {
case (ures_ok(?typ)) {
// Fast path: if there are no local variables, don't perform
// substitutions.
- if (Vec.len(cx.sets.nodes) == 0u) {
+ if (_vec::len(cx.sets.nodes) == 0u) {
ret ures_ok(typ);
}
@@ -2645,7 +2647,7 @@ mod Unify {
}
}
-fn type_err_to_str(&ty.type_err err) -> str {
+fn type_err_to_str(&ty::type_err err) -> str {
alt (err) {
case (terr_mismatch) {
ret "types differ";
@@ -2657,16 +2659,16 @@ fn type_err_to_str(&ty.type_err err) -> str {
ret "vectors differ in mutability";
}
case (terr_tuple_size(?e_sz, ?a_sz)) {
- ret "expected a tuple with " + UInt.to_str(e_sz, 10u) +
- " elements but found one with " + UInt.to_str(a_sz, 10u) +
+ ret "expected a tuple with " + _uint::to_str(e_sz, 10u) +
+ " elements but found one with " + _uint::to_str(a_sz, 10u) +
" elements";
}
case (terr_tuple_mutability) {
ret "tuple elements differ in mutability";
}
case (terr_record_size(?e_sz, ?a_sz)) {
- ret "expected a record with " + UInt.to_str(e_sz, 10u) +
- " fields but found one with " + UInt.to_str(a_sz, 10u) +
+ ret "expected a record with " + _uint::to_str(e_sz, 10u) +
+ " fields but found one with " + _uint::to_str(a_sz, 10u) +
" fields";
}
case (terr_record_mutability) {
@@ -2732,31 +2734,31 @@ fn bind_params_in_type(&ctxt cx, &t typ) -> t {
}
-fn def_has_ty_params(&ast.def def) -> bool {
+fn def_has_ty_params(&ast::def def) -> bool {
alt (def) {
- case (ast.def_fn(_)) { ret true; }
- case (ast.def_obj(_)) { ret true; }
- case (ast.def_obj_field(_)) { ret false; }
- case (ast.def_mod(_)) { ret false; }
- case (ast.def_const(_)) { ret false; }
- case (ast.def_arg(_)) { ret false; }
- case (ast.def_local(_)) { ret false; }
- case (ast.def_variant(_, _)) { ret true; }
- case (ast.def_ty(_)) { ret false; }
- case (ast.def_ty_arg(_)) { ret false; }
- case (ast.def_binding(_)) { ret false; }
- case (ast.def_use(_)) { ret false; }
- case (ast.def_native_ty(_)) { ret false; }
- case (ast.def_native_fn(_)) { ret true; }
+ case (ast::def_fn(_)) { ret true; }
+ case (ast::def_obj(_)) { ret true; }
+ case (ast::def_obj_field(_)) { ret false; }
+ case (ast::def_mod(_)) { ret false; }
+ case (ast::def_const(_)) { ret false; }
+ case (ast::def_arg(_)) { ret false; }
+ case (ast::def_local(_)) { ret false; }
+ case (ast::def_variant(_, _)) { ret true; }
+ case (ast::def_ty(_)) { ret false; }
+ case (ast::def_ty_arg(_)) { ret false; }
+ case (ast::def_binding(_)) { ret false; }
+ case (ast::def_use(_)) { ret false; }
+ case (ast::def_native_ty(_)) { ret false; }
+ case (ast::def_native_fn(_)) { ret true; }
}
}
// If the given item is in an external crate, looks up its type and adds it to
// the type cache. Returns the type parameters and type.
-fn lookup_item_type(session.session sess,
+fn lookup_item_type(session::session sess,
ctxt cx,
&type_cache cache,
- ast.def_id did) -> ty_param_count_and_ty {
+ ast::def_id did) -> ty_param_count_and_ty {
if (did._0 == sess.get_targ_crate_num()) {
// The item is in this crate. The caller should have added it to the
// type cache already; we simply return it.
@@ -2766,7 +2768,7 @@ fn lookup_item_type(session.session sess,
alt (cache.find(did)) {
case (some[ty_param_count_and_ty](?tpt)) { ret tpt; }
case (none[ty_param_count_and_ty]) {
- auto tyt = creader.get_type(sess, cx, did);
+ auto tyt = creader::get_type(sess, cx, did);
cache.insert(did, tyt);
ret tyt;
}
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index a8114cd174a5f..fb7634a2306f1 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -1,168 +1,168 @@
-import front.ast;
-import front.ast.ann;
-import front.ast.ann_none;
-import front.ast.mutability;
-import front.creader;
-import middle.fold;
-import driver.session;
-import util.common;
-import util.common.span;
-import util.common.plain_ann;
-import util.common.new_def_hash;
-import util.common.log_expr_err;
-
-import middle.ty;
-import middle.ty.ann_to_type;
-import middle.ty.arg;
-import middle.ty.bind_params_in_type;
-import middle.ty.block_ty;
-import middle.ty.expr_ty;
-import middle.ty.field;
-import middle.ty.method;
-import middle.ty.mo_val;
-import middle.ty.mo_alias;
-import middle.ty.mo_either;
-import middle.ty.pat_ty;
-import middle.ty.path_to_str;
-import middle.ty.struct;
-import middle.ty.triv_ann;
-import middle.ty.ty_to_str;
-import middle.ty.type_is_integral;
-import middle.ty.type_is_scalar;
-import middle.ty.ty_param_count_and_ty;
-import middle.ty.ty_nil;
-import middle.ty.Unify.ures_ok;
-import middle.ty.Unify.ures_err;
-
-import std.Str;
-import std.UInt;
-import std.Vec;
-import std.Map;
-import std.Map.hashmap;
-import std.Option;
-import std.Option.none;
-import std.Option.some;
-import std.Option.from_maybe;
-
-import util.typestate_ann.ts_ann;
-
-type ty_table = hashmap[ast.def_id, ty.t];
+import front::ast;
+import front::ast::ann;
+import front::ast::ann_none;
+import front::ast::mutability;
+import front::creader;
+import middle::fold;
+import driver::session;
+import util::common;
+import util::common::span;
+import util::common::plain_ann;
+import util::common::new_def_hash;
+import util::common::log_expr_err;
+
+import middle::ty;
+import middle::ty::ann_to_type;
+import middle::ty::arg;
+import middle::ty::bind_params_in_type;
+import middle::ty::block_ty;
+import middle::ty::expr_ty;
+import middle::ty::field;
+import middle::ty::method;
+import middle::ty::mo_val;
+import middle::ty::mo_alias;
+import middle::ty::mo_either;
+import middle::ty::pat_ty;
+import middle::ty::path_to_str;
+import middle::ty::struct;
+import middle::ty::triv_ann;
+import middle::ty::ty_to_str;
+import middle::ty::type_is_integral;
+import middle::ty::type_is_scalar;
+import middle::ty::ty_param_count_and_ty;
+import middle::ty::ty_nil;
+import middle::ty::Unify::ures_ok;
+import middle::ty::Unify::ures_err;
+
+import std::_str;
+import std::_uint;
+import std::_vec;
+import std::map;
+import std::map::hashmap;
+import std::option;
+import std::option::none;
+import std::option::some;
+import std::option::from_maybe;
+
+import util::typestate_ann::ts_ann;
+
+type ty_table = hashmap[ast::def_id, ty::t];
tag any_item {
- any_item_rust(@ast.item);
- any_item_native(@ast.native_item, ast.native_abi);
+ any_item_rust(@ast::item);
+ any_item_native(@ast::native_item, ast::native_abi);
}
-type ty_item_table = hashmap[ast.def_id,any_item];
-type fn_purity_table = hashmap[ast.def_id, ast.purity];
+type ty_item_table = hashmap[ast::def_id,any_item];
+type fn_purity_table = hashmap[ast::def_id, ast::purity];
-type unify_cache_entry = tup(ty.t,ty.t,vec[mutable ty.t]);
-type unify_cache = hashmap[unify_cache_entry,ty.Unify.result];
+type unify_cache_entry = tup(ty::t,ty::t,vec[mutable ty::t]);
+type unify_cache = hashmap[unify_cache_entry,ty::Unify::result];
-type crate_ctxt = rec(session.session sess,
- ty.type_cache type_cache,
+type crate_ctxt = rec(session::session sess,
+ ty::type_cache type_cache,
@ty_item_table item_items,
- vec[ast.obj_field] obj_fields,
- Option.t[ast.def_id] this_obj,
+ vec[ast::obj_field] obj_fields,
+ option::t[ast::def_id] this_obj,
@fn_purity_table fn_purity_table,
mutable int next_var_id,
unify_cache unify_cache,
mutable uint cache_hits,
mutable uint cache_misses,
- ty.ctxt tcx);
+ ty::ctxt tcx);
-type fn_ctxt = rec(ty.t ret_ty,
- ast.purity purity,
+type fn_ctxt = rec(ty::t ret_ty,
+ ast::purity purity,
@ty_table locals,
@crate_ctxt ccx);
// Used for ast_ty_to_ty() below.
-type ty_getter = fn(&ast.def_id) -> ty.ty_param_count_and_ty;
+type ty_getter = fn(&ast::def_id) -> ty::ty_param_count_and_ty;
// Substitutes the user's explicit types for the parameters in a path
// expression.
fn substitute_ty_params(&@crate_ctxt ccx,
- &ty.t typ,
+ &ty::t typ,
uint ty_param_count,
- &vec[ty.t] supplied,
- &span sp) -> ty.t {
- fn substituter(@crate_ctxt ccx, vec[ty.t] supplied, ty.t typ) -> ty.t {
+ &vec[ty::t] supplied,
+ &span sp) -> ty::t {
+ fn substituter(@crate_ctxt ccx, vec[ty::t] supplied, ty::t typ) -> ty::t {
alt (struct(ccx.tcx, typ)) {
- case (ty.ty_bound_param(?pid)) { ret supplied.(pid); }
+ case (ty::ty_bound_param(?pid)) { ret supplied.(pid); }
case (_) { ret typ; }
}
}
- auto supplied_len = Vec.len[ty.t](supplied);
+ auto supplied_len = _vec::len[ty::t](supplied);
if (ty_param_count != supplied_len) {
ccx.sess.span_err(sp, "expected " +
- UInt.to_str(ty_param_count, 10u) +
+ _uint::to_str(ty_param_count, 10u) +
" type parameter(s) but found " +
- UInt.to_str(supplied_len, 10u) + " parameter(s)");
+ _uint::to_str(supplied_len, 10u) + " parameter(s)");
fail;
}
- if (!ty.type_contains_bound_params(ccx.tcx, typ)) {
+ if (!ty::type_contains_bound_params(ccx.tcx, typ)) {
ret typ;
}
auto f = bind substituter(ccx, supplied, _);
- ret ty.fold_ty(ccx.tcx, f, typ);
+ ret ty::fold_ty(ccx.tcx, f, typ);
}
// Returns the type parameter count and the type for the given definition.
-fn ty_param_count_and_ty_for_def(&@fn_ctxt fcx, &ast.span sp, &ast.def defn)
+fn ty_param_count_and_ty_for_def(&@fn_ctxt fcx, &ast::span sp, &ast::def defn)
-> ty_param_count_and_ty {
alt (defn) {
- case (ast.def_arg(?id)) {
+ case (ast::def_arg(?id)) {
// assert (fcx.locals.contains_key(id));
ret tup(0u, fcx.locals.get(id));
}
- case (ast.def_local(?id)) {
+ case (ast::def_local(?id)) {
auto t;
alt (fcx.locals.find(id)) {
- case (some[ty.t](?t1)) { t = t1; }
- case (none[ty.t]) { t = ty.mk_local(fcx.ccx.tcx, id); }
+ case (some[ty::t](?t1)) { t = t1; }
+ case (none[ty::t]) { t = ty::mk_local(fcx.ccx.tcx, id); }
}
ret tup(0u, t);
}
- case (ast.def_obj_field(?id)) {
+ case (ast::def_obj_field(?id)) {
// assert (fcx.locals.contains_key(id));
ret tup(0u, fcx.locals.get(id));
}
- case (ast.def_fn(?id)) {
- ret ty.lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
+ case (ast::def_fn(?id)) {
+ ret ty::lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
fcx.ccx.type_cache, id);
}
- case (ast.def_native_fn(?id)) {
- ret ty.lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
+ case (ast::def_native_fn(?id)) {
+ ret ty::lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
fcx.ccx.type_cache, id);
}
- case (ast.def_const(?id)) {
- ret ty.lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
+ case (ast::def_const(?id)) {
+ ret ty::lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
fcx.ccx.type_cache, id);
}
- case (ast.def_variant(_, ?vid)) {
- ret ty.lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
+ case (ast::def_variant(_, ?vid)) {
+ ret ty::lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
fcx.ccx.type_cache, vid);
}
- case (ast.def_binding(?id)) {
+ case (ast::def_binding(?id)) {
// assert (fcx.locals.contains_key(id));
ret tup(0u, fcx.locals.get(id));
}
- case (ast.def_obj(?id)) {
- ret ty.lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
+ case (ast::def_obj(?id)) {
+ ret ty::lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
fcx.ccx.type_cache, id);
}
- case (ast.def_mod(_)) {
+ case (ast::def_mod(_)) {
// Hopefully part of a path.
// TODO: return a type that's more poisonous, perhaps?
- ret tup(0u, ty.mk_nil(fcx.ccx.tcx));
+ ret tup(0u, ty::mk_nil(fcx.ccx.tcx));
}
- case (ast.def_ty(_)) {
+ case (ast::def_ty(_)) {
fcx.ccx.sess.span_err(sp, "expected value but found type");
fail;
}
@@ -177,21 +177,21 @@ fn ty_param_count_and_ty_for_def(&@fn_ctxt fcx, &ast.span sp, &ast.def defn)
// Instantiates the given path, which must refer to an item with the given
// number of type parameters and type.
-fn instantiate_path(&@fn_ctxt fcx, &ast.path pth, &ty_param_count_and_ty tpt,
- &span sp, uint ann_tag) -> ast.ann {
+fn instantiate_path(&@fn_ctxt fcx, &ast::path pth, &ty_param_count_and_ty tpt,
+ &span sp, uint ann_tag) -> ast::ann {
auto ty_param_count = tpt._0;
auto t = bind_params_in_type(fcx.ccx.tcx, tpt._1);
auto ty_substs_opt;
- auto ty_substs_len = Vec.len[@ast.ty](pth.node.types);
+ auto ty_substs_len = _vec::len[@ast::ty](pth.node.types);
if (ty_substs_len > 0u) {
- let vec[ty.t] ty_substs = vec();
+ let vec[ty::t] ty_substs = vec();
auto i = 0u;
while (i < ty_substs_len) {
ty_substs += vec(ast_ty_to_ty_crate(fcx.ccx, pth.node.types.(i)));
i += 1u;
}
- ty_substs_opt = some[vec[ty.t]](ty_substs);
+ ty_substs_opt = some[vec[ty::t]](ty_substs);
if (ty_param_count == 0u) {
fcx.ccx.sess.span_err(sp, "this item does not take type " +
@@ -200,49 +200,49 @@ fn instantiate_path(&@fn_ctxt fcx, &ast.path pth, &ty_param_count_and_ty tpt,
}
} else {
// We will acquire the type parameters through unification.
- let vec[ty.t] ty_substs = vec();
+ let vec[ty::t] ty_substs = vec();
auto i = 0u;
while (i < ty_param_count) {
ty_substs += vec(next_ty_var(fcx.ccx));
i += 1u;
}
- ty_substs_opt = some[vec[ty.t]](ty_substs);
+ ty_substs_opt = some[vec[ty::t]](ty_substs);
}
- ret ast.ann_type(ann_tag, t, ty_substs_opt, none[@ts_ann]);
+ ret ast::ann_type(ann_tag, t, ty_substs_opt, none[@ts_ann]);
}
-fn ast_mode_to_mode(ast.mode mode) -> ty.mode {
+fn ast_mode_to_mode(ast::mode mode) -> ty::mode {
auto ty_mode;
alt (mode) {
- case (ast.val) { ty_mode = mo_val; }
- case (ast.alias) { ty_mode = mo_alias; }
+ case (ast::val) { ty_mode = mo_val; }
+ case (ast::alias) { ty_mode = mo_alias; }
}
ret ty_mode;
}
// Parses the programmer's textual representation of a type into our internal
// notion of a type. `getter` is a function that returns the type
-// corresponding to a definition ID.
-fn ast_ty_to_ty(&ty.ctxt tcx, &ty_getter getter, &@ast.ty ast_ty) -> ty.t {
- fn ast_arg_to_arg(&ty.ctxt tcx,
+// corresponding to a definition ID:
+fn ast_ty_to_ty(&ty::ctxt tcx, &ty_getter getter, &@ast::ty ast_ty) -> ty::t {
+ fn ast_arg_to_arg(&ty::ctxt tcx,
&ty_getter getter,
- &rec(ast.mode mode, @ast.ty ty) arg)
- -> rec(ty.mode mode, ty.t ty) {
+ &rec(ast::mode mode, @ast::ty ty) arg)
+ -> rec(ty::mode mode, ty::t ty) {
auto ty_mode = ast_mode_to_mode(arg.mode);
ret rec(mode=ty_mode, ty=ast_ty_to_ty(tcx, getter, arg.ty));
}
- fn ast_mt_to_mt(&ty.ctxt tcx,
+ fn ast_mt_to_mt(&ty::ctxt tcx,
&ty_getter getter,
- &ast.mt mt) -> ty.mt {
+ &ast::mt mt) -> ty::mt {
ret rec(ty=ast_ty_to_ty(tcx, getter, mt.ty), mut=mt.mut);
}
- fn instantiate(&ty.ctxt tcx,
+ fn instantiate(&ty::ctxt tcx,
&ty_getter getter,
- &ast.def_id id,
- &vec[@ast.ty] args) -> ty.t {
+ &ast::def_id id,
+ &vec[@ast::ty] args) -> ty::t {
// TODO: maybe record cname chains so we can do
// "foo = int" like OCaml?
auto params_opt_and_ty = getter(id);
@@ -256,73 +256,73 @@ fn ast_ty_to_ty(&ty.ctxt tcx, &ty_getter getter, &@ast.ty ast_ty) -> ty.t {
// TODO: Make sure the number of supplied bindings matches the number
// of type parameters in the typedef. Emit a friendly error otherwise.
auto bound_ty = bind_params_in_type(tcx, params_opt_and_ty._1);
- let vec[ty.t] param_bindings = vec();
- for (@ast.ty ast_ty in args) {
+ let vec[ty::t] param_bindings = vec();
+ for (@ast::ty ast_ty in args) {
param_bindings += vec(ast_ty_to_ty(tcx, getter, ast_ty));
}
- ret ty.substitute_type_params(tcx, param_bindings, bound_ty);
+ ret ty::substitute_type_params(tcx, param_bindings, bound_ty);
}
- auto mut = ast.imm;
+ auto mut = ast::imm;
auto typ;
auto cname = none[str];
alt (ast_ty.node) {
- case (ast.ty_nil) { typ = ty.mk_nil(tcx); }
- case (ast.ty_bool) { typ = ty.mk_bool(tcx); }
- case (ast.ty_int) { typ = ty.mk_int(tcx); }
- case (ast.ty_uint) { typ = ty.mk_uint(tcx); }
- case (ast.ty_float) { typ = ty.mk_float(tcx); }
- case (ast.ty_machine(?tm)) { typ = ty.mk_mach(tcx, tm); }
- case (ast.ty_char) { typ = ty.mk_char(tcx); }
- case (ast.ty_str) { typ = ty.mk_str(tcx); }
- case (ast.ty_box(?mt)) {
- typ = ty.mk_box(tcx, ast_mt_to_mt(tcx, getter, mt));
+ case (ast::ty_nil) { typ = ty::mk_nil(tcx); }
+ case (ast::ty_bool) { typ = ty::mk_bool(tcx); }
+ case (ast::ty_int) { typ = ty::mk_int(tcx); }
+ case (ast::ty_uint) { typ = ty::mk_uint(tcx); }
+ case (ast::ty_float) { typ = ty::mk_float(tcx); }
+ case (ast::ty_machine(?tm)) { typ = ty::mk_mach(tcx, tm); }
+ case (ast::ty_char) { typ = ty::mk_char(tcx); }
+ case (ast::ty_str) { typ = ty::mk_str(tcx); }
+ case (ast::ty_box(?mt)) {
+ typ = ty::mk_box(tcx, ast_mt_to_mt(tcx, getter, mt));
}
- case (ast.ty_vec(?mt)) {
- typ = ty.mk_vec(tcx, ast_mt_to_mt(tcx, getter, mt));
+ case (ast::ty_vec(?mt)) {
+ typ = ty::mk_vec(tcx, ast_mt_to_mt(tcx, getter, mt));
}
- case (ast.ty_port(?t)) {
- typ = ty.mk_port(tcx, ast_ty_to_ty(tcx, getter, t));
+ case (ast::ty_port(?t)) {
+ typ = ty::mk_port(tcx, ast_ty_to_ty(tcx, getter, t));
}
- case (ast.ty_chan(?t)) {
- typ = ty.mk_chan(tcx, ast_ty_to_ty(tcx, getter, t));
+ case (ast::ty_chan(?t)) {
+ typ = ty::mk_chan(tcx, ast_ty_to_ty(tcx, getter, t));
}
- case (ast.ty_tup(?fields)) {
- let vec[ty.mt] flds = vec();
- for (ast.mt field in fields) {
- Vec.push[ty.mt](flds, ast_mt_to_mt(tcx, getter, field));
+ case (ast::ty_tup(?fields)) {
+ let vec[ty::mt] flds = vec();
+ for (ast::mt field in fields) {
+ _vec::push[ty::mt](flds, ast_mt_to_mt(tcx, getter, field));
}
- typ = ty.mk_tup(tcx, flds);
+ typ = ty::mk_tup(tcx, flds);
}
- case (ast.ty_rec(?fields)) {
+ case (ast::ty_rec(?fields)) {
let vec[field] flds = vec();
- for (ast.ty_field f in fields) {
+ for (ast::ty_field f in fields) {
auto tm = ast_mt_to_mt(tcx, getter, f.mt);
- Vec.push[field](flds, rec(ident=f.ident, mt=tm));
+ _vec::push[field](flds, rec(ident=f.ident, mt=tm));
}
- typ = ty.mk_rec(tcx, flds);
+ typ = ty::mk_rec(tcx, flds);
}
- case (ast.ty_fn(?proto, ?inputs, ?output)) {
+ case (ast::ty_fn(?proto, ?inputs, ?output)) {
auto f = bind ast_arg_to_arg(tcx, getter, _);
- auto i = Vec.map[ast.ty_arg, arg](f, inputs);
+ auto i = _vec::map[ast::ty_arg, arg](f, inputs);
auto out_ty = ast_ty_to_ty(tcx, getter, output);
- typ = ty.mk_fn(tcx, proto, i, out_ty);
+ typ = ty::mk_fn(tcx, proto, i, out_ty);
}
- case (ast.ty_path(?path, ?ann)) {
- alt (tcx.def_map.get(ast.ann_tag(ann))) {
- case (ast.def_ty(?id)) {
+ case (ast::ty_path(?path, ?ann)) {
+ alt (tcx.def_map.get(ast::ann_tag(ann))) {
+ case (ast::def_ty(?id)) {
typ = instantiate(tcx, getter, id, path.node.types);
}
- case (ast.def_native_ty(?id)) { typ = getter(id)._1; }
- case (ast.def_obj(?id)) {
+ case (ast::def_native_ty(?id)) { typ = getter(id)._1; }
+ case (ast::def_obj(?id)) {
typ = instantiate(tcx, getter, id, path.node.types);
}
- case (ast.def_ty_arg(?id)) { typ = ty.mk_param(tcx, id); }
+ case (ast::def_ty_arg(?id)) { typ = ty::mk_param(tcx, id); }
case (_) {
tcx.sess.span_err(ast_ty.span,
"found type name used as a variable");
@@ -332,27 +332,27 @@ fn ast_ty_to_ty(&ty.ctxt tcx, &ty_getter getter, &@ast.ty ast_ty) -> ty.t {
cname = some(path_to_str(path));
}
- case (ast.ty_obj(?meths)) {
- let vec[ty.method] tmeths = vec();
+ case (ast::ty_obj(?meths)) {
+ let vec[ty::method] tmeths = vec();
auto f = bind ast_arg_to_arg(tcx, getter, _);
- for (ast.ty_method m in meths) {
- auto ins = Vec.map[ast.ty_arg, arg](f, m.inputs);
+ for (ast::ty_method m in meths) {
+ auto ins = _vec::map[ast::ty_arg, arg](f, m.inputs);
auto out = ast_ty_to_ty(tcx, getter, m.output);
- Vec.push[ty.method](tmeths,
+ _vec::push[ty::method](tmeths,
rec(proto=m.proto,
ident=m.ident,
inputs=ins,
output=out));
}
- typ = ty.mk_obj(tcx, ty.sort_methods(tmeths));
+ typ = ty::mk_obj(tcx, ty::sort_methods(tmeths));
}
}
alt (cname) {
case (none[str]) { /* no-op */ }
case (some[str](?cname_str)) {
- typ = ty.rename(tcx, typ, cname_str);
+ typ = ty::rename(tcx, typ, cname_str);
}
}
ret typ;
@@ -360,9 +360,9 @@ fn ast_ty_to_ty(&ty.ctxt tcx, &ty_getter getter, &@ast.ty ast_ty) -> ty.t {
// A convenience function to use a crate_ctxt to resolve names for
// ast_ty_to_ty.
-fn ast_ty_to_ty_crate(@crate_ctxt ccx, &@ast.ty ast_ty) -> ty.t {
- fn getter(@crate_ctxt ccx, &ast.def_id id) -> ty.ty_param_count_and_ty {
- ret ty.lookup_item_type(ccx.sess, ccx.tcx, ccx.type_cache, id);
+fn ast_ty_to_ty_crate(@crate_ctxt ccx, &@ast::ty ast_ty) -> ty::t {
+ fn getter(@crate_ctxt ccx, &ast::def_id id) -> ty::ty_param_count_and_ty {
+ ret ty::lookup_item_type(ccx.sess, ccx.tcx, ccx.type_cache, id);
}
auto f = bind getter(ccx, _);
ret ast_ty_to_ty(ccx.tcx, f, ast_ty);
@@ -381,49 +381,49 @@ fn ast_ty_to_ty_crate(@crate_ctxt ccx, &@ast.ty ast_ty) -> ty.t {
// AST, along with a table mapping item IDs to their types.
mod Collect {
- type ctxt = rec(session.session sess,
+ type ctxt = rec(session::session sess,
@ty_item_table id_to_ty_item,
- ty.type_cache type_cache,
- ty.ctxt tcx);
- type env = rec(@ctxt cx, ast.native_abi abi);
+ ty::type_cache type_cache,
+ ty::ctxt tcx);
+ type env = rec(@ctxt cx, ast::native_abi abi);
fn ty_of_fn_decl(&@ctxt cx,
- &fn(&@ast.ty ast_ty) -> ty.t convert,
- &fn(&ast.arg a) -> arg ty_of_arg,
- &ast.fn_decl decl,
- ast.proto proto,
- &vec[ast.ty_param] ty_params,
- &ast.def_id def_id) -> ty.ty_param_count_and_ty {
- auto input_tys = Vec.map[ast.arg,arg](ty_of_arg, decl.inputs);
+ &fn(&@ast::ty ast_ty) -> ty::t convert,
+ &fn(&ast::arg a) -> arg ty_of_arg,
+ &ast::fn_decl decl,
+ ast::proto proto,
+ &vec[ast::ty_param] ty_params,
+ &ast::def_id def_id) -> ty::ty_param_count_and_ty {
+ auto input_tys = _vec::map[ast::arg,arg](ty_of_arg, decl.inputs);
auto output_ty = convert(decl.output);
- auto t_fn = ty.mk_fn(cx.tcx, proto, input_tys, output_ty);
- auto ty_param_count = Vec.len[ast.ty_param](ty_params);
+ auto t_fn = ty::mk_fn(cx.tcx, proto, input_tys, output_ty);
+ auto ty_param_count = _vec::len[ast::ty_param](ty_params);
auto tpt = tup(ty_param_count, t_fn);
cx.type_cache.insert(def_id, tpt);
ret tpt;
}
fn ty_of_native_fn_decl(&@ctxt cx,
- &fn(&@ast.ty ast_ty) -> ty.t convert,
- &fn(&ast.arg a) -> arg ty_of_arg,
- &ast.fn_decl decl,
- ast.native_abi abi,
- &vec[ast.ty_param] ty_params,
- &ast.def_id def_id) -> ty.ty_param_count_and_ty {
- auto input_tys = Vec.map[ast.arg,arg](ty_of_arg, decl.inputs);
+ &fn(&@ast::ty ast_ty) -> ty::t convert,
+ &fn(&ast::arg a) -> arg ty_of_arg,
+ &ast::fn_decl decl,
+ ast::native_abi abi,
+ &vec[ast::ty_param] ty_params,
+ &ast::def_id def_id) -> ty::ty_param_count_and_ty{
+ auto input_tys = _vec::map[ast::arg,arg](ty_of_arg, decl.inputs);
auto output_ty = convert(decl.output);
- auto t_fn = ty.mk_native_fn(cx.tcx, abi, input_tys, output_ty);
- auto ty_param_count = Vec.len[ast.ty_param](ty_params);
+ auto t_fn = ty::mk_native_fn(cx.tcx, abi, input_tys, output_ty);
+ auto ty_param_count = _vec::len[ast::ty_param](ty_params);
auto tpt = tup(ty_param_count, t_fn);
cx.type_cache.insert(def_id, tpt);
ret tpt;
}
- fn getter(@ctxt cx, &ast.def_id id) -> ty.ty_param_count_and_ty {
+ fn getter(@ctxt cx, &ast::def_id id) -> ty::ty_param_count_and_ty {
if (id._0 != cx.sess.get_targ_crate_num()) {
// This is a type we need to load in from the crate reader.
- ret creader.get_type(cx.sess, cx.tcx, id);
+ ret creader::get_type(cx.sess, cx.tcx, id);
}
// assert (cx.id_to_ty_item.contains_key(id));
@@ -440,126 +440,126 @@ mod Collect {
ret tpt;
}
- fn ty_of_arg(@ctxt cx, &ast.arg a) -> arg {
+ fn ty_of_arg(@ctxt cx, &ast::arg a) -> arg {
auto ty_mode = ast_mode_to_mode(a.mode);
auto f = bind getter(cx, _);
ret rec(mode=ty_mode, ty=ast_ty_to_ty(cx.tcx, f, a.ty));
}
- fn ty_of_method(@ctxt cx, &@ast.method m) -> method {
+ fn ty_of_method(@ctxt cx, &@ast::method m) -> method {
auto get = bind getter(cx, _);
auto convert = bind ast_ty_to_ty(cx.tcx, get, _);
auto f = bind ty_of_arg(cx, _);
- auto inputs = Vec.map[ast.arg,arg](f, m.node.meth.decl.inputs);
+ auto inputs = _vec::map[ast::arg,arg](f, m.node.meth.decl.inputs);
auto output = convert(m.node.meth.decl.output);
ret rec(proto=m.node.meth.proto, ident=m.node.ident,
inputs=inputs, output=output);
}
fn ty_of_obj(@ctxt cx,
- &ast.ident id,
- &ast._obj obj_info,
- &vec[ast.ty_param] ty_params) -> ty.ty_param_count_and_ty {
+ &ast::ident id,
+ &ast::_obj obj_info,
+ &vec[ast::ty_param] ty_params) -> ty::ty_param_count_and_ty {
auto f = bind ty_of_method(cx, _);
- auto methods = Vec.map[@ast.method,method](f, obj_info.methods);
+ auto methods = _vec::map[@ast::method,method](f, obj_info.methods);
- auto t_obj = ty.mk_obj(cx.tcx, ty.sort_methods(methods));
- t_obj = ty.rename(cx.tcx, t_obj, id);
- auto ty_param_count = Vec.len[ast.ty_param](ty_params);
+ auto t_obj = ty::mk_obj(cx.tcx, ty::sort_methods(methods));
+ t_obj = ty::rename(cx.tcx, t_obj, id);
+ auto ty_param_count = _vec::len[ast::ty_param](ty_params);
ret tup(ty_param_count, t_obj);
}
fn ty_of_obj_ctor(@ctxt cx,
- &ast.ident id,
- &ast._obj obj_info,
- &ast.def_id obj_ty_id,
- &vec[ast.ty_param] ty_params)
- -> ty.ty_param_count_and_ty {
+ &ast::ident id,
+ &ast::_obj obj_info,
+ &ast::def_id obj_ty_id,
+ &vec[ast::ty_param] ty_params)
+ -> ty::ty_param_count_and_ty {
auto t_obj = ty_of_obj(cx, id, obj_info, ty_params);
let vec[arg] t_inputs = vec();
- for (ast.obj_field f in obj_info.fields) {
+ for (ast::obj_field f in obj_info.fields) {
auto g = bind getter(cx, _);
auto t_field = ast_ty_to_ty(cx.tcx, g, f.ty);
- Vec.push[arg](t_inputs, rec(mode=ty.mo_alias, ty=t_field));
+ _vec::push[arg](t_inputs, rec(mode=ty::mo_alias, ty=t_field));
}
cx.type_cache.insert(obj_ty_id, t_obj);
- auto t_fn = ty.mk_fn(cx.tcx, ast.proto_fn, t_inputs, t_obj._1);
+ auto t_fn = ty::mk_fn(cx.tcx, ast::proto_fn, t_inputs, t_obj._1);
ret tup(t_obj._0, t_fn);
}
- fn ty_of_item(&@ctxt cx, &@ast.item it) -> ty.ty_param_count_and_ty {
+ fn ty_of_item(&@ctxt cx, &@ast::item it) -> ty::ty_param_count_and_ty {
auto get = bind getter(cx, _);
auto convert = bind ast_ty_to_ty(cx.tcx, get, _);
alt (it.node) {
- case (ast.item_const(?ident, ?t, _, ?def_id, _)) {
+ case (ast::item_const(?ident, ?t, _, ?def_id, _)) {
auto typ = convert(t);
auto tpt = tup(0u, typ);
cx.type_cache.insert(def_id, tpt);
ret tpt;
}
- case (ast.item_fn(?ident, ?fn_info, ?tps, ?def_id, _)) {
+ case (ast::item_fn(?ident, ?fn_info, ?tps, ?def_id, _)) {
auto f = bind ty_of_arg(cx, _);
ret ty_of_fn_decl(cx, convert, f, fn_info.decl, fn_info.proto,
tps, def_id);
}
- case (ast.item_obj(?ident, ?obj_info, ?tps, ?odid, _)) {
+ case (ast::item_obj(?ident, ?obj_info, ?tps, ?odid, _)) {
auto t_ctor = ty_of_obj_ctor(cx, ident, obj_info, odid.ty,
tps);
cx.type_cache.insert(odid.ctor, t_ctor);
ret cx.type_cache.get(odid.ty);
}
- case (ast.item_ty(?ident, ?t, ?tps, ?def_id, _)) {
+ case (ast::item_ty(?ident, ?t, ?tps, ?def_id, _)) {
alt (cx.type_cache.find(def_id)) {
- case (some[ty.ty_param_count_and_ty](?tpt)) {
+ case (some[ty::ty_param_count_and_ty](?tpt)) {
ret tpt;
}
- case (none[ty.ty_param_count_and_ty]) {}
+ case (none[ty::ty_param_count_and_ty]) {}
}
// Tell ast_ty_to_ty() that we want to perform a recursive
// call to resolve any named types.
auto typ = convert(t);
- auto ty_param_count = Vec.len[ast.ty_param](tps);
+ auto ty_param_count = _vec::len[ast::ty_param](tps);
auto tpt = tup(ty_param_count, typ);
cx.type_cache.insert(def_id, tpt);
ret tpt;
}
- case (ast.item_tag(_, _, ?tps, ?def_id, _)) {
+ case (ast::item_tag(_, _, ?tps, ?def_id, _)) {
// Create a new generic polytype.
- let vec[ty.t] subtys = vec();
+ let vec[ty::t] subtys = vec();
auto i = 0u;
- for (ast.ty_param tp in tps) {
- subtys += vec(ty.mk_param(cx.tcx, i));
+ for (ast::ty_param tp in tps) {
+ subtys += vec(ty::mk_param(cx.tcx, i));
i += 1u;
}
- auto t = ty.mk_tag(cx.tcx, def_id, subtys);
+ auto t = ty::mk_tag(cx.tcx, def_id, subtys);
- auto ty_param_count = Vec.len[ast.ty_param](tps);
+ auto ty_param_count = _vec::len[ast::ty_param](tps);
auto tpt = tup(ty_param_count, t);
cx.type_cache.insert(def_id, tpt);
ret tpt;
}
- case (ast.item_mod(_, _, _)) { fail; }
- case (ast.item_native_mod(_, _, _)) { fail; }
+ case (ast::item_mod(_, _, _)) { fail; }
+ case (ast::item_native_mod(_, _, _)) { fail; }
}
}
- fn ty_of_native_item(&@ctxt cx, &@ast.native_item it, ast.native_abi abi)
- -> ty.ty_param_count_and_ty {
+ fn ty_of_native_item(&@ctxt cx, &@ast::native_item it,
+ ast::native_abi abi) -> ty::ty_param_count_and_ty {
alt (it.node) {
- case (ast.native_item_fn(?ident, ?lname, ?fn_decl,
+ case (ast::native_item_fn(?ident, ?lname, ?fn_decl,
?params, ?def_id, _)) {
auto get = bind getter(cx, _);
auto convert = bind ast_ty_to_ty(cx.tcx, get, _);
@@ -567,15 +567,15 @@ mod Collect {
ret ty_of_native_fn_decl(cx, convert, f, fn_decl, abi, params,
def_id);
}
- case (ast.native_item_ty(_, ?def_id)) {
+ case (ast::native_item_ty(_, ?def_id)) {
alt (cx.type_cache.find(def_id)) {
- case (some[ty.ty_param_count_and_ty](?tpt)) {
+ case (some[ty::ty_param_count_and_ty](?tpt)) {
ret tpt;
}
- case (none[ty.ty_param_count_and_ty]) {}
+ case (none[ty::ty_param_count_and_ty]) {}
}
- auto t = ty.mk_native(cx.tcx);
+ auto t = ty::mk_native(cx.tcx);
auto tpt = tup(0u, t);
cx.type_cache.insert(def_id, tpt);
ret tpt;
@@ -583,40 +583,40 @@ mod Collect {
}
}
- fn get_tag_variant_types(&@ctxt cx, &ast.def_id tag_id,
- &vec[ast.variant] variants,
- &vec[ast.ty_param] ty_params)
- -> vec[ast.variant] {
- let vec[ast.variant] result = vec();
+ fn get_tag_variant_types(&@ctxt cx, &ast::def_id tag_id,
+ &vec[ast::variant] variants,
+ &vec[ast::ty_param] ty_params)
+ -> vec[ast::variant] {
+ let vec[ast::variant] result = vec();
// Create a set of parameter types shared among all the variants.
- let vec[ty.t] ty_param_tys = vec();
+ let vec[ty::t] ty_param_tys = vec();
auto i = 0u;
- for (ast.ty_param tp in ty_params) {
- ty_param_tys += vec(ty.mk_param(cx.tcx, i));
+ for (ast::ty_param tp in ty_params) {
+ ty_param_tys += vec(ty::mk_param(cx.tcx, i));
i += 1u;
}
- auto ty_param_count = Vec.len[ast.ty_param](ty_params);
+ auto ty_param_count = _vec::len[ast::ty_param](ty_params);
- for (ast.variant variant in variants) {
+ for (ast::variant variant in variants) {
// Nullary tag constructors get turned into constants; n-ary tag
// constructors get turned into functions.
auto result_ty;
- if (Vec.len[ast.variant_arg](variant.node.args) == 0u) {
- result_ty = ty.mk_tag(cx.tcx, tag_id, ty_param_tys);
+ if (_vec::len[ast::variant_arg](variant.node.args) == 0u) {
+ result_ty = ty::mk_tag(cx.tcx, tag_id, ty_param_tys);
} else {
// As above, tell ast_ty_to_ty() that trans_ty_item_to_ty()
// should be called to resolve named types.
auto f = bind getter(cx, _);
let vec[arg] args = vec();
- for (ast.variant_arg va in variant.node.args) {
+ for (ast::variant_arg va in variant.node.args) {
auto arg_ty = ast_ty_to_ty(cx.tcx, f, va.ty);
- args += vec(rec(mode=ty.mo_alias, ty=arg_ty));
+ args += vec(rec(mode=ty::mo_alias, ty=arg_ty));
}
- auto tag_t = ty.mk_tag(cx.tcx, tag_id, ty_param_tys);
- result_ty = ty.mk_fn(cx.tcx, ast.proto_fn, args, tag_t);
+ auto tag_t = ty::mk_tag(cx.tcx, tag_id, ty_param_tys);
+ result_ty = ty::mk_fn(cx.tcx, ast::proto_fn, args, tag_t);
}
auto tpt = tup(ty_param_count, result_ty);
@@ -624,22 +624,22 @@ mod Collect {
auto variant_t = rec(ann=triv_ann(variant.node.ann, result_ty)
with variant.node
);
- result += vec(fold.respan[ast.variant_](variant.span, variant_t));
+ result += vec(fold::respan(variant.span, variant_t));
}
ret result;
}
- fn collect(&@ty_item_table id_to_ty_item, &@ast.item i)
+ fn collect(&@ty_item_table id_to_ty_item, &@ast::item i)
-> @ty_item_table {
alt (i.node) {
- case (ast.item_ty(_, _, _, ?def_id, _)) {
+ case (ast::item_ty(_, _, _, ?def_id, _)) {
id_to_ty_item.insert(def_id, any_item_rust(i));
}
- case (ast.item_tag(_, _, _, ?def_id, _)) {
+ case (ast::item_tag(_, _, _, ?def_id, _)) {
id_to_ty_item.insert(def_id, any_item_rust(i));
}
- case (ast.item_obj(_, _, _, ?odid, _)) {
+ case (ast::item_obj(_, _, _, ?odid, _)) {
id_to_ty_item.insert(odid.ty, any_item_rust(i));
}
case (_) { /* empty */ }
@@ -647,14 +647,14 @@ mod Collect {
ret id_to_ty_item;
}
- fn collect_native(&@ty_item_table id_to_ty_item, &@ast.native_item i)
+ fn collect_native(&@ty_item_table id_to_ty_item, &@ast::native_item i)
-> @ty_item_table {
alt (i.node) {
- case (ast.native_item_ty(_, ?def_id)) {
+ case (ast::native_item_ty(_, ?def_id)) {
// The abi of types is not used.
id_to_ty_item.insert(def_id,
any_item_native(i,
- ast.native_abi_cdecl));
+ ast::native_abi_cdecl));
}
case (_) {
}
@@ -662,13 +662,13 @@ mod Collect {
ret id_to_ty_item;
}
- fn convert(&@env e, &@ast.item i) -> @env {
+ fn convert(&@env e, &@ast::item i) -> @env {
auto abi = e.abi;
alt (i.node) {
- case (ast.item_mod(_, _, _)) {
+ case (ast::item_mod(_, _, _)) {
// ignore item_mod, it has no type.
}
- case (ast.item_native_mod(_, ?native_mod, _)) {
+ case (ast::item_native_mod(_, ?native_mod, _)) {
// ignore item_native_mod, it has no type.
abi = native_mod.abi;
}
@@ -681,44 +681,45 @@ mod Collect {
ret @rec(abi=abi with *e);
}
- fn convert_native(&@env e, &@ast.native_item i) -> @env {
+ fn convert_native(&@env e, &@ast::native_item i) -> @env {
ty_of_native_item(e.cx, i, e.abi);
ret e;
}
- fn fold_item_const(&@env e, &span sp, &ast.ident i,
- &@ast.ty t, &@ast.expr ex,
- &ast.def_id id, &ast.ann a) -> @ast.item {
+ fn fold_item_const(&@env e, &span sp, &ast::ident i,
+ &@ast::ty t, &@ast::expr ex,
+ &ast::def_id id, &ast::ann a) -> @ast::item {
// assert (e.cx.type_cache.contains_key(id));
auto typ = e.cx.type_cache.get(id)._1;
- auto item = ast.item_const(i, t, ex, id, triv_ann(a, typ));
- ret @fold.respan[ast.item_](sp, item);
+ auto item = ast::item_const(i, t, ex, id, triv_ann(a, typ));
+ ret @fold::respan[ast::item_](sp, item);
}
- fn fold_item_fn(&@env e, &span sp, &ast.ident i,
- &ast._fn f, &vec[ast.ty_param] ty_params,
- &ast.def_id id, &ast.ann a) -> @ast.item {
+ fn fold_item_fn(&@env e, &span sp, &ast::ident i,
+ &ast::_fn f, &vec[ast::ty_param] ty_params,
+ &ast::def_id id, &ast::ann a) -> @ast::item {
// assert (e.cx.type_cache.contains_key(id));
auto typ = e.cx.type_cache.get(id)._1;
- auto item = ast.item_fn(i, f, ty_params, id, triv_ann(a, typ));
- ret @fold.respan[ast.item_](sp, item);
+ auto item = ast::item_fn(i, f, ty_params, id, triv_ann(a, typ));
+ ret @fold::respan[ast::item_](sp, item);
}
- fn fold_native_item_fn(&@env e, &span sp, &ast.ident i, &Option.t[str] ln,
- &ast.fn_decl d, &vec[ast.ty_param] ty_params,
- &ast.def_id id, &ast.ann a) -> @ast.native_item {
+ fn fold_native_item_fn(&@env e, &span sp, &ast::ident i,
+ &option::t[str] ln,
+ &ast::fn_decl d, &vec[ast::ty_param] ty_params,
+ &ast::def_id id, &ast::ann a) -> @ast::native_item{
// assert (e.cx.type_cache.contains_key(id));
auto typ = e.cx.type_cache.get(id)._1;
- auto item = ast.native_item_fn(i, ln, d, ty_params, id,
+ auto item = ast::native_item_fn(i, ln, d, ty_params, id,
triv_ann(a, typ));
- ret @fold.respan[ast.native_item_](sp, item);
+ ret @fold::respan[ast::native_item_](sp, item);
}
- fn get_ctor_obj_methods(&@env e, &ty.t t) -> vec[method] {
+ fn get_ctor_obj_methods(&@env e, &ty::t t) -> vec[method] {
alt (struct(e.cx.tcx, t)) {
- case (ty.ty_fn(_,_,?tobj)) {
+ case (ty::ty_fn(_,_,?tobj)) {
alt (struct(e.cx.tcx, tobj)) {
- case (ty.ty_obj(?tm)) {
+ case (ty::ty_obj(?tm)) {
ret tm;
}
case (_) {
@@ -735,23 +736,23 @@ mod Collect {
}
- fn fold_item_obj(&@env e, &span sp, &ast.ident i,
- &ast._obj ob, &vec[ast.ty_param] ty_params,
- &ast.obj_def_ids odid, &ast.ann a) -> @ast.item {
+ fn fold_item_obj(&@env e, &span sp, &ast::ident i,
+ &ast::_obj ob, &vec[ast::ty_param] ty_params,
+ &ast::obj_def_ids odid, &ast::ann a) -> @ast::item {
// assert (e.cx.type_cache.contains_key(odid.ctor));
auto t = e.cx.type_cache.get(odid.ctor)._1;
let vec[method] meth_tys = get_ctor_obj_methods(e, t);
- let vec[@ast.method] methods = vec();
- let vec[ast.obj_field] fields = vec();
+ let vec[@ast::method] methods = vec();
+ let vec[ast::obj_field] fields = vec();
- for (@ast.method meth in ob.methods) {
- let uint ix = ty.method_idx(e.cx.sess,
+ for (@ast::method meth in ob.methods) {
+ let uint ix = ty::method_idx(e.cx.sess,
sp, meth.node.ident,
meth_tys);
let method meth_ty = meth_tys.(ix);
- let ast.method_ m_;
- let @ast.method m;
- auto meth_tfn = ty.mk_fn(e.cx.tcx,
+ let ast::method_ m_;
+ let @ast::method m;
+ auto meth_tfn = ty::mk_fn(e.cx.tcx,
meth_ty.proto,
meth_ty.inputs,
meth_ty.output);
@@ -759,85 +760,85 @@ mod Collect {
with meth.node
);
m = @rec(node=m_ with *meth);
- Vec.push[@ast.method](methods, m);
+ _vec::push[@ast::method](methods, m);
}
auto g = bind getter(e.cx, _);
- for (ast.obj_field fld in ob.fields) {
- let ty.t fty = ast_ty_to_ty(e.cx.tcx, g, fld.ty);
- let ast.obj_field f = rec(ann=triv_ann(fld.ann, fty)
+ for (ast::obj_field fld in ob.fields) {
+ let ty::t fty = ast_ty_to_ty(e.cx.tcx, g, fld.ty);
+ let ast::obj_field f = rec(ann=triv_ann(fld.ann, fty)
with fld
);
- Vec.push[ast.obj_field](fields, f);
+ _vec::push[ast::obj_field](fields, f);
}
- auto dtor = none[@ast.method];
+ auto dtor = none[@ast::method];
alt (ob.dtor) {
- case (some[@ast.method](?d)) {
+ case (some[@ast::method](?d)) {
let vec[arg] inputs = vec();
- let ty.t output = ty.mk_nil(e.cx.tcx);
- auto dtor_tfn = ty.mk_fn(e.cx.tcx, ast.proto_fn, inputs,
+ let ty::t output = ty::mk_nil(e.cx.tcx);
+ auto dtor_tfn = ty::mk_fn(e.cx.tcx, ast::proto_fn, inputs,
output);
auto d_ = rec(ann=triv_ann(d.node.ann, dtor_tfn) with d.node);
- dtor = some[@ast.method](@rec(node=d_ with *d));
+ dtor = some[@ast::method](@rec(node=d_ with *d));
}
- case (none[@ast.method]) { }
+ case (none[@ast::method]) { }
}
auto ob_ = rec(methods = methods,
fields = fields,
dtor = dtor
with ob);
- auto item = ast.item_obj(i, ob_, ty_params, odid, triv_ann(a, t));
- ret @fold.respan[ast.item_](sp, item);
+ auto item = ast::item_obj(i, ob_, ty_params, odid, triv_ann(a, t));
+ ret @fold::respan[ast::item_](sp, item);
}
- fn fold_item_ty(&@env e, &span sp, &ast.ident i,
- &@ast.ty t, &vec[ast.ty_param] ty_params,
- &ast.def_id id, &ast.ann a) -> @ast.item {
+ fn fold_item_ty(&@env e, &span sp, &ast::ident i,
+ &@ast::ty t, &vec[ast::ty_param] ty_params,
+ &ast::def_id id, &ast::ann a) -> @ast::item {
// assert (e.cx.type_cache.contains_key(id));
auto typ = e.cx.type_cache.get(id)._1;
- auto item = ast.item_ty(i, t, ty_params, id, triv_ann(a, typ));
- ret @fold.respan[ast.item_](sp, item);
+ auto item = ast::item_ty(i, t, ty_params, id, triv_ann(a, typ));
+ ret @fold::respan[ast::item_](sp, item);
}
- fn fold_item_tag(&@env e, &span sp, &ast.ident i,
- &vec[ast.variant] variants,
- &vec[ast.ty_param] ty_params,
- &ast.def_id id, &ast.ann a) -> @ast.item {
+ fn fold_item_tag(&@env e, &span sp, &ast::ident i,
+ &vec[ast::variant] variants,
+ &vec[ast::ty_param] ty_params,
+ &ast::def_id id, &ast::ann a) -> @ast::item {
auto variants_t = get_tag_variant_types(e.cx, id, variants,
ty_params);
auto typ = e.cx.type_cache.get(id)._1;
- auto item = ast.item_tag(i, variants_t, ty_params, id,
- ast.ann_type(ast.ann_tag(a), typ,
- none[vec[ty.t]],
+ auto item = ast::item_tag(i, variants_t, ty_params, id,
+ ast::ann_type(ast::ann_tag(a), typ,
+ none[vec[ty::t]],
none[@ts_ann]));
- ret @fold.respan[ast.item_](sp, item);
+ ret @fold::respan[ast::item_](sp, item);
}
- fn collect_item_types(&session.session sess, &ty.ctxt tcx,
- &@ast.crate crate)
- -> tup(@ast.crate, ty.type_cache, @ty_item_table) {
- // First pass: collect all type item IDs.
+ fn collect_item_types(&session::session sess, &ty::ctxt tcx,
+ &@ast::crate crate)
+ -> tup(@ast::crate, ty::type_cache, @ty_item_table) {
+ // First pass: collect all type item IDs:
auto module = crate.node.module;
- auto id_to_ty_item = @common.new_def_hash[any_item]();
+ auto id_to_ty_item = @common::new_def_hash[any_item]();
- auto fld_1 = fold.new_identity_fold[@ty_item_table]();
+ auto fld_1 = fold::new_identity_fold[@ty_item_table]();
fld_1 = @rec(update_env_for_item = bind collect(_, _),
update_env_for_native_item = bind collect_native(_, _)
with *fld_1);
- fold.fold_crate[@ty_item_table](id_to_ty_item, fld_1, crate);
+ fold::fold_crate[@ty_item_table](id_to_ty_item, fld_1, crate);
// Second pass: translate the types of all items.
- auto type_cache = common.new_def_hash[ty.ty_param_count_and_ty]();
+ auto type_cache = common::new_def_hash[ty::ty_param_count_and_ty]();
auto cx = @rec(sess=sess,
id_to_ty_item=id_to_ty_item,
type_cache=type_cache,
tcx=tcx);
- let @env e = @rec(cx=cx, abi=ast.native_abi_cdecl);
+ let @env e = @rec(cx=cx, abi=ast::native_abi_cdecl);
- auto fld_2 = fold.new_identity_fold[@env]();
+ auto fld_2 = fold::new_identity_fold[@env]();
fld_2 =
@rec(update_env_for_item = bind convert(_,_),
update_env_for_native_item = bind convert_native(_,_),
@@ -849,7 +850,7 @@ mod Collect {
fold_item_ty = bind fold_item_ty(_,_,_,_,_,_,_),
fold_item_tag = bind fold_item_tag(_,_,_,_,_,_,_)
with *fld_2);
- auto crate_ = fold.fold_crate[@env](e, fld_2, crate);
+ auto crate_ = fold::fold_crate[@env](e, fld_2, crate);
ret tup(crate_, type_cache, id_to_ty_item);
}
}
@@ -858,48 +859,48 @@ mod Collect {
// Type unification
mod Unify {
- fn simple(&@fn_ctxt fcx, &ty.t expected,
- &ty.t actual) -> ty.Unify.result {
+ fn simple(&@fn_ctxt fcx, &ty::t expected,
+ &ty::t actual) -> ty::Unify::result {
// FIXME: horrid botch
- let vec[mutable ty.t] param_substs =
- vec(mutable ty.mk_nil(fcx.ccx.tcx));
- Vec.pop(param_substs);
+ let vec[mutable ty::t] param_substs =
+ vec(mutable ty::mk_nil(fcx.ccx.tcx));
+ _vec::pop(param_substs);
ret with_params(fcx, expected, actual, param_substs);
}
- fn with_params(&@fn_ctxt fcx, &ty.t expected, &ty.t actual,
- &vec[mutable ty.t] param_substs) -> ty.Unify.result {
+ fn with_params(&@fn_ctxt fcx, &ty::t expected, &ty::t actual,
+ &vec[mutable ty::t] param_substs) -> ty::Unify::result {
auto cache_key = tup(expected, actual, param_substs);
alt (fcx.ccx.unify_cache.find(cache_key)) {
- case (some[ty.Unify.result](?r)) {
+ case (some[ty::Unify::result](?r)) {
fcx.ccx.cache_hits += 1u;
ret r;
}
- case (none[ty.Unify.result]) {
+ case (none[ty::Unify::result]) {
fcx.ccx.cache_misses += 1u;
}
}
- obj unify_handler(@fn_ctxt fcx, vec[mutable ty.t] param_substs) {
- fn resolve_local(ast.def_id id) -> Option.t[ty.t] {
+ obj unify_handler(@fn_ctxt fcx, vec[mutable ty::t] param_substs) {
+ fn resolve_local(ast::def_id id) -> option::t[ty::t] {
alt (fcx.locals.find(id)) {
- case (none[ty.t]) { ret none[ty.t]; }
- case (some[ty.t](?existing_type)) {
- if (ty.type_contains_vars(fcx.ccx.tcx,
+ case (none[ty::t]) { ret none[ty::t]; }
+ case (some[ty::t](?existing_type)) {
+ if (ty::type_contains_vars(fcx.ccx.tcx,
existing_type)) {
// Not fully resolved yet. The writeback phase
// will mop up.
- ret none[ty.t];
+ ret none[ty::t];
}
- ret some[ty.t](existing_type);
+ ret some[ty::t](existing_type);
}
}
}
- fn record_local(ast.def_id id, ty.t new_type) {
+ fn record_local(ast::def_id id, ty::t new_type) {
auto unified_type;
alt (fcx.locals.find(id)) {
- case (none[ty.t]) { unified_type = new_type; }
- case (some[ty.t](?old_type)) {
+ case (none[ty::t]) { unified_type = new_type; }
+ case (some[ty::t](?old_type)) {
alt (with_params(fcx, old_type, new_type,
param_substs)) {
case (ures_ok(?ut)) { unified_type = ut; }
@@ -909,19 +910,19 @@ mod Unify {
}
// TODO: "freeze"
- let vec[ty.t] param_substs_1 = vec();
- for (ty.t subst in param_substs) {
+ let vec[ty::t] param_substs_1 = vec();
+ for (ty::t subst in param_substs) {
param_substs_1 += vec(subst);
}
unified_type =
- ty.substitute_type_params(fcx.ccx.tcx, param_substs_1,
+ ty::substitute_type_params(fcx.ccx.tcx, param_substs_1,
unified_type);
fcx.locals.insert(id, unified_type);
}
- fn record_param(uint index, ty.t binding) -> ty.Unify.result {
+ fn record_param(uint index, ty::t binding) -> ty::Unify::result {
// Unify with the appropriate type in the parameter
- // substitution List.
+ // substitution list:
auto old_subst = param_substs.(index);
auto result = with_params(fcx, old_subst, binding,
@@ -929,7 +930,7 @@ mod Unify {
alt (result) {
case (ures_ok(?new_subst)) {
param_substs.(index) = new_subst;
- ret ures_ok(ty.mk_bound_param(fcx.ccx.tcx, index));
+ ret ures_ok(ty::mk_bound_param(fcx.ccx.tcx, index));
}
case (_) { ret result; }
}
@@ -938,7 +939,8 @@ mod Unify {
auto handler = unify_handler(fcx, param_substs);
- auto result = ty.Unify.unify(expected, actual, handler, fcx.ccx.tcx);
+ auto result = ty::Unify::unify(expected, actual, handler,
+ fcx.ccx.tcx);
fcx.ccx.unify_cache.insert(cache_key, result);
ret result;
}
@@ -950,33 +952,33 @@ tag autoderef_kind {
NO_AUTODEREF;
}
-fn strip_boxes(&ty.ctxt tcx, &ty.t t) -> ty.t {
+fn strip_boxes(&ty::ctxt tcx, &ty::t t) -> ty::t {
auto t1 = t;
while (true) {
alt (struct(tcx, t1)) {
- case (ty.ty_box(?inner)) { t1 = inner.ty; }
+ case (ty::ty_box(?inner)) { t1 = inner.ty; }
case (_) { ret t1; }
}
}
fail;
}
-fn add_boxes(&@crate_ctxt ccx, uint n, &ty.t t) -> ty.t {
+fn add_boxes(&@crate_ctxt ccx, uint n, &ty::t t) -> ty::t {
auto t1 = t;
while (n != 0u) {
- t1 = ty.mk_imm_box(ccx.tcx, t1);
+ t1 = ty::mk_imm_box(ccx.tcx, t1);
n -= 1u;
}
ret t1;
}
-fn count_boxes(&ty.ctxt tcx, &ty.t t) -> uint {
+fn count_boxes(&ty::ctxt tcx, &ty::t t) -> uint {
auto n = 0u;
auto t1 = t;
while (true) {
alt (struct(tcx, t1)) {
- case (ty.ty_box(?inner)) { n += 1u; t1 = inner.ty; }
+ case (ty::ty_box(?inner)) { n += 1u; t1 = inner.ty; }
case (_) { ret n; }
}
}
@@ -987,25 +989,26 @@ fn count_boxes(&ty.ctxt tcx, &ty.t t) -> uint {
// Demands - procedures that require that two types unify and emit an error
// message if they don't.
-type ty_param_substs_and_ty = tup(vec[ty.t], ty.t);
+type ty_param_substs_and_ty = tup(vec[ty::t], ty::t);
mod Demand {
- fn simple(&@fn_ctxt fcx, &span sp, &ty.t expected, &ty.t actual) -> ty.t {
- let vec[ty.t] tps = vec();
+ fn simple(&@fn_ctxt fcx, &span sp, &ty::t expected, &ty::t actual)
+ -> ty::t {
+ let vec[ty::t] tps = vec();
ret full(fcx, sp, expected, actual, tps, NO_AUTODEREF)._1;
}
- fn autoderef(&@fn_ctxt fcx, &span sp, &ty.t expected, &ty.t actual,
- autoderef_kind adk) -> ty.t {
- let vec[ty.t] tps = vec();
+ fn autoderef(&@fn_ctxt fcx, &span sp, &ty::t expected, &ty::t actual,
+ autoderef_kind adk) -> ty::t {
+ let vec[ty::t] tps = vec();
ret full(fcx, sp, expected, actual, tps, adk)._1;
}
// Requires that the two types unify, and prints an error message if they
// don't. Returns the unified type and the type parameter substitutions.
- fn full(&@fn_ctxt fcx, &span sp, &ty.t expected, &ty.t actual,
- &vec[ty.t] ty_param_substs_0, autoderef_kind adk)
+ fn full(&@fn_ctxt fcx, &span sp, &ty::t expected, &ty::t actual,
+ &vec[ty::t] ty_param_substs_0, autoderef_kind adk)
-> ty_param_substs_and_ty {
auto expected_1 = expected;
@@ -1018,18 +1021,18 @@ mod Demand {
implicit_boxes = count_boxes(fcx.ccx.tcx, actual);
}
- let vec[mutable ty.t] ty_param_substs =
- vec(mutable ty.mk_nil(fcx.ccx.tcx));
- Vec.pop(ty_param_substs); // FIXME: horrid botch
- for (ty.t ty_param_subst in ty_param_substs_0) {
+ let vec[mutable ty::t] ty_param_substs =
+ vec(mutable ty::mk_nil(fcx.ccx.tcx));
+ _vec::pop(ty_param_substs); // FIXME: horrid botch
+ for (ty::t ty_param_subst in ty_param_substs_0) {
ty_param_substs += vec(mutable ty_param_subst);
}
- alt (Unify.with_params(fcx, expected_1, actual_1, ty_param_substs)) {
+ alt (Unify::with_params(fcx, expected_1, actual_1, ty_param_substs)) {
case (ures_ok(?t)) {
// TODO: Use "freeze", when we have it.
- let vec[ty.t] result_ty_param_substs = vec();
- for (ty.t ty_param_subst in ty_param_substs) {
+ let vec[ty::t] result_ty_param_substs = vec();
+ for (ty::t ty_param_subst in ty_param_substs) {
result_ty_param_substs += vec(ty_param_subst);
}
@@ -1041,7 +1044,7 @@ mod Demand {
fcx.ccx.sess.span_err(sp, "mismatched types: expected "
+ ty_to_str(fcx.ccx.tcx, expected) + " but found "
+ ty_to_str(fcx.ccx.tcx, actual) + " ("
- + ty.type_err_to_str(err) + ")");
+ + ty::type_err_to_str(err) + ")");
// TODO: In the future, try returning "expected", reporting
// the error, and continue.
@@ -1053,25 +1056,25 @@ mod Demand {
// Returns true if the two types unify and false if they don't.
-fn are_compatible(&@fn_ctxt fcx, &ty.t expected, &ty.t actual) -> bool {
- alt (Unify.simple(fcx, expected, actual)) {
+fn are_compatible(&@fn_ctxt fcx, &ty::t expected, &ty::t actual) -> bool {
+ alt (Unify::simple(fcx, expected, actual)) {
case (ures_ok(_)) { ret true; }
case (ures_err(_, _, _)) { ret false; }
}
}
// Returns the types of the arguments to a tag variant.
-fn variant_arg_types(&@crate_ctxt ccx, &span sp, &ast.def_id vid,
- &vec[ty.t] tag_ty_params) -> vec[ty.t] {
- auto ty_param_count = Vec.len[ty.t](tag_ty_params);
+fn variant_arg_types(&@crate_ctxt ccx, &span sp, &ast::def_id vid,
+ &vec[ty::t] tag_ty_params) -> vec[ty::t] {
+ auto ty_param_count = _vec::len[ty::t](tag_ty_params);
- let vec[ty.t] result = vec();
+ let vec[ty::t] result = vec();
- auto tpt = ty.lookup_item_type(ccx.sess, ccx.tcx, ccx.type_cache, vid);
+ auto tpt = ty::lookup_item_type(ccx.sess, ccx.tcx, ccx.type_cache, vid);
alt (struct(ccx.tcx, tpt._1)) {
- case (ty.ty_fn(_, ?ins, _)) {
+ case (ty::ty_fn(_, ?ins, _)) {
// N-ary variant.
- for (ty.arg arg in ins) {
+ for (ty::arg arg in ins) {
auto arg_ty = bind_params_in_type(ccx.tcx, arg.ty);
arg_ty = substitute_ty_params(ccx, arg_ty, ty_param_count,
tag_ty_params, sp);
@@ -1109,39 +1112,40 @@ mod Pushdown {
//
// TODO: enforce this via a predicate.
- fn pushdown_pat(&@fn_ctxt fcx, &ty.t expected,
- &@ast.pat pat) -> @ast.pat {
+ fn pushdown_pat(&@fn_ctxt fcx, &ty::t expected,
+ &@ast::pat pat) -> @ast::pat {
auto p_1;
alt (pat.node) {
- case (ast.pat_wild(?ann)) {
- auto t = Demand.simple(fcx, pat.span, expected,
+ case (ast::pat_wild(?ann)) {
+ auto t = Demand::simple(fcx, pat.span, expected,
ann_to_type(ann));
- p_1 = ast.pat_wild(ast.ann_type(ast.ann_tag(ann), t,
- none[vec[ty.t]],
+ p_1 = ast::pat_wild(ast::ann_type(ast::ann_tag(ann), t,
+ none[vec[ty::t]],
none[@ts_ann]));
}
- case (ast.pat_lit(?lit, ?ann)) {
- auto t = Demand.simple(fcx, pat.span, expected,
+ case (ast::pat_lit(?lit, ?ann)) {
+ auto t = Demand::simple(fcx, pat.span, expected,
ann_to_type(ann));
- p_1 = ast.pat_lit(lit, ast.ann_type(ast.ann_tag(ann), t,
- none[vec[ty.t]],
+ p_1 = ast::pat_lit(lit, ast::ann_type(ast::ann_tag(ann), t,
+ none[vec[ty::t]],
none[@ts_ann]));
}
- case (ast.pat_bind(?id, ?did, ?ann)) {
- auto t = Demand.simple(fcx, pat.span, expected,
+ case (ast::pat_bind(?id, ?did, ?ann)) {
+ auto t = Demand::simple(fcx, pat.span, expected,
ann_to_type(ann));
fcx.locals.insert(did, t);
- p_1 = ast.pat_bind(id, did, ast.ann_type(ast.ann_tag(ann), t,
- none[vec[ty.t]],
- none[@ts_ann]));
+ p_1 = ast::pat_bind(id, did, ast::ann_type(ast::ann_tag(ann),
+ t,
+ none[vec[ty::t]],
+ none[@ts_ann]));
}
- case (ast.pat_tag(?id, ?subpats, ?ann)) {
+ case (ast::pat_tag(?id, ?subpats, ?ann)) {
// Take the variant's type parameters out of the expected
// type.
auto tag_tps;
alt (struct(fcx.ccx.tcx, expected)) {
- case (ty.ty_tag(_, ?tps)) { tag_tps = tps; }
+ case (ty::ty_tag(_, ?tps)) { tag_tps = tps; }
case (_) {
log_err "tag pattern type not actually a tag?!";
fail;
@@ -1150,26 +1154,26 @@ mod Pushdown {
// Get the types of the arguments of the variant.
auto arg_tys;
- alt (fcx.ccx.tcx.def_map.get(ast.ann_tag(ann))) {
- case (ast.def_variant(_, ?vdefid)) {
+ alt (fcx.ccx.tcx.def_map.get(ast::ann_tag(ann))) {
+ case (ast::def_variant(_, ?vdefid)) {
arg_tys = variant_arg_types(fcx.ccx, pat.span, vdefid,
tag_tps);
}
}
- let vec[@ast.pat] subpats_1 = vec();
+ let vec[@ast::pat] subpats_1 = vec();
auto i = 0u;
- for (@ast.pat subpat in subpats) {
+ for (@ast::pat subpat in subpats) {
subpats_1 += vec(pushdown_pat(fcx, arg_tys.(i), subpat));
i += 1u;
}
// TODO: push down type from "expected".
- p_1 = ast.pat_tag(id, subpats_1, ann);
+ p_1 = ast::pat_tag(id, subpats_1, ann);
}
}
- ret @fold.respan[ast.pat_](pat.span, p_1);
+ ret @fold::respan[ast::pat_](pat.span, p_1);
}
// Push-down over typed expressions. Note that the expression that you
@@ -1178,25 +1182,25 @@ mod Pushdown {
// TODO: enforce this via a predicate.
// TODO: This function is incomplete.
- fn pushdown_expr(&@fn_ctxt fcx, &ty.t expected, &@ast.expr e)
- -> @ast.expr {
+ fn pushdown_expr(&@fn_ctxt fcx, &ty::t expected, &@ast::expr e)
+ -> @ast::expr {
be pushdown_expr_full(fcx, expected, e, NO_AUTODEREF);
}
- fn pushdown_expr_full(&@fn_ctxt fcx, &ty.t expected, &@ast.expr e,
- autoderef_kind adk) -> @ast.expr {
+ fn pushdown_expr_full(&@fn_ctxt fcx, &ty::t expected, &@ast::expr e,
+ autoderef_kind adk) -> @ast::expr {
auto e_1;
alt (e.node) {
- case (ast.expr_vec(?es_0, ?mut, ?ann)) {
+ case (ast::expr_vec(?es_0, ?mut, ?ann)) {
// TODO: enforce mutability
- auto t = Demand.simple(fcx, e.span, expected,
+ auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(ann));
- let vec[@ast.expr] es_1 = vec();
+ let vec[@ast::expr] es_1 = vec();
alt (struct(fcx.ccx.tcx, t)) {
- case (ty.ty_vec(?mt)) {
- for (@ast.expr e_0 in es_0) {
+ case (ty::ty_vec(?mt)) {
+ for (@ast::expr e_0 in es_0) {
es_1 += vec(pushdown_expr(fcx, mt.ty, e_0));
}
}
@@ -1205,16 +1209,16 @@ mod Pushdown {
fail;
}
}
- e_1 = ast.expr_vec(es_1, mut, triv_ann(ann, t));
+ e_1 = ast::expr_vec(es_1, mut, triv_ann(ann, t));
}
- case (ast.expr_tup(?es_0, ?ann)) {
- auto t = Demand.simple(fcx, e.span, expected,
+ case (ast::expr_tup(?es_0, ?ann)) {
+ auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(ann));
- let vec[ast.elt] elts_1 = vec();
+ let vec[ast::elt] elts_1 = vec();
alt (struct(fcx.ccx.tcx, t)) {
- case (ty.ty_tup(?mts)) {
+ case (ty::ty_tup(?mts)) {
auto i = 0u;
- for (ast.elt elt_0 in es_0) {
+ for (ast::elt elt_0 in es_0) {
auto e_1 = pushdown_expr(fcx, mts.(i).ty,
elt_0.expr);
elts_1 += vec(rec(mut=elt_0.mut, expr=e_1));
@@ -1226,22 +1230,22 @@ mod Pushdown {
fail;
}
}
- e_1 = ast.expr_tup(elts_1, triv_ann(ann, t));
+ e_1 = ast::expr_tup(elts_1, triv_ann(ann, t));
}
- case (ast.expr_rec(?fields_0, ?base_0, ?ann)) {
+ case (ast::expr_rec(?fields_0, ?base_0, ?ann)) {
auto base_1 = base_0;
- auto t = Demand.simple(fcx, e.span, expected,
+ auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(ann));
- let vec[ast.field] fields_1 = vec();
+ let vec[ast::field] fields_1 = vec();
alt (struct(fcx.ccx.tcx, t)) {
- case (ty.ty_rec(?field_mts)) {
+ case (ty::ty_rec(?field_mts)) {
alt (base_0) {
- case (none[@ast.expr]) {
+ case (none[@ast::expr]) {
auto i = 0u;
- for (ast.field field_0 in fields_0) {
- assert (Str.eq(field_0.ident,
+ for (ast::field field_0 in fields_0) {
+ assert (_str::eq(field_0.ident,
field_mts.(i).ident));
auto e_1 =
pushdown_expr(fcx,
@@ -1253,17 +1257,17 @@ mod Pushdown {
i += 1u;
}
}
- case (some[@ast.expr](?bx)) {
+ case (some[@ast::expr](?bx)) {
- base_1 = some[@ast.expr](pushdown_expr(fcx, t,
- bx));
+ base_1 = some[@ast::expr]
+ (pushdown_expr(fcx, t, bx));
let vec[field] base_fields = vec();
- for (ast.field field_0 in fields_0) {
+ for (ast::field field_0 in fields_0) {
- for (ty.field ft in field_mts) {
- if (Str.eq(field_0.ident,
+ for (ty::field ft in field_mts) {
+ if (_str::eq(field_0.ident,
ft.ident)) {
auto e_1 =
pushdown_expr(fcx, ft.mt.ty,
@@ -1283,118 +1287,118 @@ mod Pushdown {
fail;
}
}
- e_1 = ast.expr_rec(fields_1, base_1, triv_ann(ann, t));
+ e_1 = ast::expr_rec(fields_1, base_1, triv_ann(ann, t));
}
- case (ast.expr_bind(?sube, ?es, ?ann)) {
- auto t = Demand.simple(fcx, e.span, expected,
+ case (ast::expr_bind(?sube, ?es, ?ann)) {
+ auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(ann));
- e_1 = ast.expr_bind(sube, es, triv_ann(ann, t));
+ e_1 = ast::expr_bind(sube, es, triv_ann(ann, t));
}
- case (ast.expr_call(?sube, ?es, ?ann)) {
- // NB: we call 'Demand.autoderef' and pass in adk only in
+ case (ast::expr_call(?sube, ?es, ?ann)) {
+ // NB: we call 'Demand::autoderef' and pass in adk only in
// cases where e is an expression that could *possibly*
// produce a box; things like expr_binary or expr_bind can't,
// so there's no need.
- auto t = Demand.autoderef(fcx, e.span, expected,
+ auto t = Demand::autoderef(fcx, e.span, expected,
ann_to_type(ann), adk);
- e_1 = ast.expr_call(sube, es, triv_ann(ann, t));
+ e_1 = ast::expr_call(sube, es, triv_ann(ann, t));
}
- case (ast.expr_self_method(?id, ?ann)) {
- auto t = Demand.simple(fcx, e.span, expected,
+ case (ast::expr_self_method(?id, ?ann)) {
+ auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(ann));
- e_1 = ast.expr_self_method(id, triv_ann(ann, t));
+ e_1 = ast::expr_self_method(id, triv_ann(ann, t));
}
- case (ast.expr_binary(?bop, ?lhs, ?rhs, ?ann)) {
- auto t = Demand.simple(fcx, e.span, expected,
+ case (ast::expr_binary(?bop, ?lhs, ?rhs, ?ann)) {
+ auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(ann));
- e_1 = ast.expr_binary(bop, lhs, rhs, triv_ann(ann, t));
+ e_1 = ast::expr_binary(bop, lhs, rhs, triv_ann(ann, t));
}
- case (ast.expr_unary(?uop, ?sube, ?ann)) {
+ case (ast::expr_unary(?uop, ?sube, ?ann)) {
// See note in expr_unary for why we're calling
- // Demand.autoderef.
- auto t = Demand.autoderef(fcx, e.span, expected,
+ // Demand::autoderef.
+ auto t = Demand::autoderef(fcx, e.span, expected,
ann_to_type(ann), adk);
- e_1 = ast.expr_unary(uop, sube, triv_ann(ann, t));
+ e_1 = ast::expr_unary(uop, sube, triv_ann(ann, t));
}
- case (ast.expr_lit(?lit, ?ann)) {
- auto t = Demand.simple(fcx, e.span, expected,
+ case (ast::expr_lit(?lit, ?ann)) {
+ auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(ann));
- e_1 = ast.expr_lit(lit, triv_ann(ann, t));
+ e_1 = ast::expr_lit(lit, triv_ann(ann, t));
}
- case (ast.expr_cast(?sube, ?ast_ty, ?ann)) {
- auto t = Demand.simple(fcx, e.span, expected,
+ case (ast::expr_cast(?sube, ?ast_ty, ?ann)) {
+ auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(ann));
- e_1 = ast.expr_cast(sube, ast_ty, triv_ann(ann, t));
+ e_1 = ast::expr_cast(sube, ast_ty, triv_ann(ann, t));
}
- case (ast.expr_if(?cond, ?then_0, ?else_0, ?ann)) {
- auto t = Demand.autoderef(fcx, e.span, expected,
+ case (ast::expr_if(?cond, ?then_0, ?else_0, ?ann)) {
+ auto t = Demand::autoderef(fcx, e.span, expected,
ann_to_type(ann), adk);
auto then_1 = pushdown_block(fcx, expected, then_0);
auto else_1;
alt (else_0) {
- case (none[@ast.expr]) { else_1 = none[@ast.expr]; }
- case (some[@ast.expr](?e_0)) {
+ case (none[@ast::expr]) { else_1 = none[@ast::expr]; }
+ case (some[@ast::expr](?e_0)) {
auto e_1 = pushdown_expr(fcx, expected, e_0);
- else_1 = some[@ast.expr](e_1);
+ else_1 = some[@ast::expr](e_1);
}
}
- e_1 = ast.expr_if(cond, then_1, else_1, triv_ann(ann, t));
+ e_1 = ast::expr_if(cond, then_1, else_1, triv_ann(ann, t));
}
- case (ast.expr_for(?decl, ?seq, ?bloc, ?ann)) {
- auto t = Demand.simple(fcx, e.span, expected,
+ case (ast::expr_for(?decl, ?seq, ?bloc, ?ann)) {
+ auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(ann));
- e_1 = ast.expr_for(decl, seq, bloc, triv_ann(ann, t));
+ e_1 = ast::expr_for(decl, seq, bloc, triv_ann(ann, t));
}
- case (ast.expr_for_each(?decl, ?seq, ?bloc, ?ann)) {
- auto t = Demand.simple(fcx, e.span, expected,
+ case (ast::expr_for_each(?decl, ?seq, ?bloc, ?ann)) {
+ auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(ann));
- e_1 = ast.expr_for_each(decl, seq, bloc, triv_ann(ann, t));
+ e_1 = ast::expr_for_each(decl, seq, bloc, triv_ann(ann, t));
}
- case (ast.expr_while(?cond, ?bloc, ?ann)) {
- auto t = Demand.simple(fcx, e.span, expected,
+ case (ast::expr_while(?cond, ?bloc, ?ann)) {
+ auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(ann));
- e_1 = ast.expr_while(cond, bloc, triv_ann(ann, t));
+ e_1 = ast::expr_while(cond, bloc, triv_ann(ann, t));
}
- case (ast.expr_do_while(?bloc, ?cond, ?ann)) {
- auto t = Demand.simple(fcx, e.span, expected,
+ case (ast::expr_do_while(?bloc, ?cond, ?ann)) {
+ auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(ann));
- e_1 = ast.expr_do_while(bloc, cond, triv_ann(ann, t));
+ e_1 = ast::expr_do_while(bloc, cond, triv_ann(ann, t));
}
- case (ast.expr_block(?bloc, ?ann)) {
- auto t = Demand.autoderef(fcx, e.span, expected,
+ case (ast::expr_block(?bloc, ?ann)) {
+ auto t = Demand::autoderef(fcx, e.span, expected,
ann_to_type(ann), adk);
- e_1 = ast.expr_block(bloc, triv_ann(ann, t));
+ e_1 = ast::expr_block(bloc, triv_ann(ann, t));
}
- case (ast.expr_assign(?lhs_0, ?rhs_0, ?ann)) {
- auto t = Demand.autoderef(fcx, e.span, expected,
+ case (ast::expr_assign(?lhs_0, ?rhs_0, ?ann)) {
+ auto t = Demand::autoderef(fcx, e.span, expected,
ann_to_type(ann), adk);
auto lhs_1 = pushdown_expr(fcx, expected, lhs_0);
auto rhs_1 = pushdown_expr(fcx, expected, rhs_0);
- e_1 = ast.expr_assign(lhs_1, rhs_1, triv_ann(ann, t));
+ e_1 = ast::expr_assign(lhs_1, rhs_1, triv_ann(ann, t));
}
- case (ast.expr_assign_op(?op, ?lhs_0, ?rhs_0, ?ann)) {
- auto t = Demand.autoderef(fcx, e.span, expected,
+ case (ast::expr_assign_op(?op, ?lhs_0, ?rhs_0, ?ann)) {
+ auto t = Demand::autoderef(fcx, e.span, expected,
ann_to_type(ann), adk);
auto lhs_1 = pushdown_expr(fcx, expected, lhs_0);
auto rhs_1 = pushdown_expr(fcx, expected, rhs_0);
- e_1 = ast.expr_assign_op(op, lhs_1, rhs_1, triv_ann(ann, t));
+ e_1 = ast::expr_assign_op(op, lhs_1, rhs_1, triv_ann(ann, t));
}
- case (ast.expr_field(?lhs, ?rhs, ?ann)) {
- auto t = Demand.autoderef(fcx, e.span, expected,
+ case (ast::expr_field(?lhs, ?rhs, ?ann)) {
+ auto t = Demand::autoderef(fcx, e.span, expected,
ann_to_type(ann), adk);
- e_1 = ast.expr_field(lhs, rhs, triv_ann(ann, t));
+ e_1 = ast::expr_field(lhs, rhs, triv_ann(ann, t));
}
- case (ast.expr_index(?base, ?index, ?ann)) {
- auto t = Demand.autoderef(fcx, e.span, expected,
+ case (ast::expr_index(?base, ?index, ?ann)) {
+ auto t = Demand::autoderef(fcx, e.span, expected,
ann_to_type(ann), adk);
- e_1 = ast.expr_index(base, index, triv_ann(ann, t));
+ e_1 = ast::expr_index(base, index, triv_ann(ann, t));
}
- case (ast.expr_path(?pth, ?ann)) {
- auto tp_substs_0 = ty.ann_to_type_params(ann);
+ case (ast::expr_path(?pth, ?ann)) {
+ auto tp_substs_0 = ty::ann_to_type_params(ann);
auto t_0 = ann_to_type(ann);
- auto result_0 = Demand.full(fcx, e.span, expected, t_0,
+ auto result_0 = Demand::full(fcx, e.span, expected, t_0,
tp_substs_0, adk);
auto t = result_0._1;
@@ -1402,57 +1406,58 @@ mod Pushdown {
// provided by the programmer.
auto ty_params_opt;
alt (ann) {
- case (ast.ann_none(_)) {
+ case (ast::ann_none(_)) {
log_err "pushdown_expr(): no type annotation for " +
"path expr; did you pass it to check_expr()?";
fail;
}
- case (ast.ann_type(_, _, ?tps_opt, _)) {
+ case (ast::ann_type(_, _, ?tps_opt, _)) {
alt (tps_opt) {
- case (none[vec[ty.t]]) {
- ty_params_opt = none[vec[ty.t]];
+ case (none[vec[ty::t]]) {
+ ty_params_opt = none[vec[ty::t]];
}
- case (some[vec[ty.t]](?tps)) {
- ty_params_opt = some[vec[ty.t]](tps);
+ case (some[vec[ty::t]](?tps)) {
+ ty_params_opt = some[vec[ty::t]](tps);
}
}
}
}
- e_1 = ast.expr_path(pth,
- ast.ann_type(ast.ann_tag(ann), t,
+ e_1 = ast::expr_path(pth,
+ ast::ann_type(ast::ann_tag(ann), t,
ty_params_opt,
none[@ts_ann]));
}
- case (ast.expr_ext(?p, ?args, ?body, ?expanded, ?ann)) {
- auto t = Demand.autoderef(fcx, e.span, expected,
+ case (ast::expr_ext(?p, ?args, ?body, ?expanded, ?ann)) {
+ auto t = Demand::autoderef(fcx, e.span, expected,
ann_to_type(ann), adk);
- e_1 = ast.expr_ext(p, args, body, expanded, triv_ann(ann, t));
+ e_1 = ast::expr_ext(p, args, body, expanded,
+ triv_ann(ann, t));
}
/* FIXME: should this check the type annotations? */
- case (ast.expr_fail(_)) { e_1 = e.node; }
- case (ast.expr_log(_,_,_)) { e_1 = e.node; }
- case (ast.expr_break(_)) { e_1 = e.node; }
- case (ast.expr_cont(_)) { e_1 = e.node; }
- case (ast.expr_ret(_,_)) { e_1 = e.node; }
- case (ast.expr_put(_,_)) { e_1 = e.node; }
- case (ast.expr_be(_,_)) { e_1 = e.node; }
- case (ast.expr_check(_,_)) { e_1 = e.node; }
- case (ast.expr_assert(_,_)) { e_1 = e.node; }
-
- case (ast.expr_port(?ann)) {
- auto t = Demand.simple(fcx, e.span, expected,
+ case (ast::expr_fail(_)) { e_1 = e.node; }
+ case (ast::expr_log(_,_,_)) { e_1 = e.node; }
+ case (ast::expr_break(_)) { e_1 = e.node; }
+ case (ast::expr_cont(_)) { e_1 = e.node; }
+ case (ast::expr_ret(_,_)) { e_1 = e.node; }
+ case (ast::expr_put(_,_)) { e_1 = e.node; }
+ case (ast::expr_be(_,_)) { e_1 = e.node; }
+ case (ast::expr_check(_,_)) { e_1 = e.node; }
+ case (ast::expr_assert(_,_)) { e_1 = e.node; }
+
+ case (ast::expr_port(?ann)) {
+ auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(ann));
- e_1 = ast.expr_port(triv_ann(ann, t));
+ e_1 = ast::expr_port(triv_ann(ann, t));
}
- case (ast.expr_chan(?es, ?ann)) {
- auto t = Demand.simple(fcx, e.span, expected,
+ case (ast::expr_chan(?es, ?ann)) {
+ auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(ann));
- let @ast.expr es_1;
+ let @ast::expr es_1;
alt (struct(fcx.ccx.tcx, t)) {
- case (ty.ty_chan(?subty)) {
- auto pt = ty.mk_port(fcx.ccx.tcx, subty);
+ case (ty::ty_chan(?subty)) {
+ auto pt = ty::mk_port(fcx.ccx.tcx, subty);
es_1 = pushdown_expr(fcx, pt, es);
}
case (_) {
@@ -1460,66 +1465,66 @@ mod Pushdown {
fail;
}
}
- e_1 = ast.expr_chan(es_1, triv_ann(ann, t));
+ e_1 = ast::expr_chan(es_1, triv_ann(ann, t));
}
- case (ast.expr_alt(?discrim, ?arms_0, ?ann)) {
+ case (ast::expr_alt(?discrim, ?arms_0, ?ann)) {
auto t = expected;
- let vec[ast.arm] arms_1 = vec();
- for (ast.arm arm_0 in arms_0) {
+ let vec[ast::arm] arms_1 = vec();
+ for (ast::arm arm_0 in arms_0) {
auto block_1 = pushdown_block(fcx, expected, arm_0.block);
- t = Demand.simple(fcx, e.span, t,
+ t = Demand::simple(fcx, e.span, t,
block_ty(fcx.ccx.tcx, block_1));
auto arm_1 = rec(pat=arm_0.pat, block=block_1);
arms_1 += vec(arm_1);
}
- e_1 = ast.expr_alt(discrim, arms_1, triv_ann(ann, t));
+ e_1 = ast::expr_alt(discrim, arms_1, triv_ann(ann, t));
}
- case (ast.expr_recv(?lval_0, ?expr_0, ?ann)) {
+ case (ast::expr_recv(?lval_0, ?expr_0, ?ann)) {
auto lval_1 = pushdown_expr(fcx, next_ty_var(fcx.ccx),
lval_0);
auto t = expr_ty(fcx.ccx.tcx, lval_1);
- auto expr_1 = pushdown_expr(fcx, ty.mk_port(fcx.ccx.tcx, t),
+ auto expr_1 = pushdown_expr(fcx, ty::mk_port(fcx.ccx.tcx, t),
expr_0);
- e_1 = ast.expr_recv(lval_1, expr_1, ann);
+ e_1 = ast::expr_recv(lval_1, expr_1, ann);
}
- case (ast.expr_send(?lval_0, ?expr_0, ?ann)) {
+ case (ast::expr_send(?lval_0, ?expr_0, ?ann)) {
auto expr_1 = pushdown_expr(fcx, next_ty_var(fcx.ccx),
expr_0);
auto t = expr_ty(fcx.ccx.tcx, expr_1);
- auto lval_1 = pushdown_expr(fcx, ty.mk_chan(fcx.ccx.tcx, t),
+ auto lval_1 = pushdown_expr(fcx, ty::mk_chan(fcx.ccx.tcx, t),
lval_0);
- e_1 = ast.expr_send(lval_1, expr_1, ann);
+ e_1 = ast::expr_send(lval_1, expr_1, ann);
}
case (_) {
fcx.ccx.sess.span_unimpl(e.span,
#fmt("type unification for expression variant: %s",
- util.common.expr_to_str(e)));
+ util::common::expr_to_str(e)));
fail;
}
}
- ret @fold.respan[ast.expr_](e.span, e_1);
+ ret @fold::respan[ast::expr_](e.span, e_1);
}
// Push-down over typed blocks.
- fn pushdown_block(&@fn_ctxt fcx, &ty.t expected, &ast.block bloc)
- -> ast.block {
+ fn pushdown_block(&@fn_ctxt fcx, &ty::t expected, &ast::block bloc)
+ -> ast::block {
alt (bloc.node.expr) {
- case (some[@ast.expr](?e_0)) {
+ case (some[@ast::expr](?e_0)) {
auto e_1 = pushdown_expr(fcx, expected, e_0);
auto block_ = rec(stmts=bloc.node.stmts,
- expr=some[@ast.expr](e_1),
+ expr=some[@ast::expr](e_1),
a=plain_ann(bloc.node.a, fcx.ccx.tcx));
- ret fold.respan[ast.block_](bloc.span, block_);
+ ret fold::respan[ast::block_](bloc.span, block_);
}
- case (none[@ast.expr]) {
- Demand.simple(fcx, bloc.span, expected,
- ty.mk_nil(fcx.ccx.tcx));
- ret fold.respan(bloc.span,
+ case (none[@ast::expr]) {
+ Demand::simple(fcx, bloc.span, expected,
+ ty::mk_nil(fcx.ccx.tcx));
+ ret fold::respan(bloc.span,
rec(a = plain_ann(bloc.node.a, fcx.ccx.tcx)
with bloc.node));
@@ -1532,18 +1537,18 @@ mod Pushdown {
// Local variable resolution: the phase that finds all the types in the AST
// and replaces opaque "ty_local" types with the resolved local types.
-fn writeback_local(&Option.t[@fn_ctxt] env, &span sp, &@ast.local local)
- -> @ast.decl {
- auto fcx = Option.get[@fn_ctxt](env);
+fn writeback_local(&option::t[@fn_ctxt] env, &span sp, &@ast::local local)
+ -> @ast::decl {
+ auto fcx = option::get[@fn_ctxt](env);
auto local_ty;
alt (fcx.locals.find(local.id)) {
- case (none[ty.t]) {
+ case (none[ty::t]) {
fcx.ccx.sess.span_err(sp, "unable to determine type of local: "
+ local.ident);
fail;
}
- case (some[ty.t](?lt)) {
+ case (some[ty::t](?lt)) {
local_ty = lt;
}
}
@@ -1551,48 +1556,48 @@ fn writeback_local(&Option.t[@fn_ctxt] env, &span sp, &@ast.local local)
auto local_wb = @rec(ann=triv_ann(local.ann, local_ty)
with *local
);
- ret @fold.respan[ast.decl_](sp, ast.decl_local(local_wb));
+ ret @fold::respan[ast::decl_](sp, ast::decl_local(local_wb));
}
-fn resolve_local_types_in_annotation(&Option.t[@fn_ctxt] env, &ast.ann ann)
- -> ast.ann {
- fn resolver(@fn_ctxt fcx, ty.t typ) -> ty.t {
+fn resolve_local_types_in_annotation(&option::t[@fn_ctxt] env, &ast::ann ann)
+ -> ast::ann {
+ fn resolver(@fn_ctxt fcx, ty::t typ) -> ty::t {
alt (struct(fcx.ccx.tcx, typ)) {
- case (ty.ty_local(?lid)) { ret fcx.locals.get(lid); }
+ case (ty::ty_local(?lid)) { ret fcx.locals.get(lid); }
case (_) { ret typ; }
}
}
- auto fcx = Option.get[@fn_ctxt](env);
+ auto fcx = option::get[@fn_ctxt](env);
alt (ann) {
- case (ast.ann_none(_)) {
+ case (ast::ann_none(_)) {
log "warning: no type for expression";
ret ann;
}
- case (ast.ann_type(?tg, ?typ, ?tps, ?ts_info)) {
+ case (ast::ann_type(?tg, ?typ, ?tps, ?ts_info)) {
auto tt = ann_to_type(ann);
- if (!ty.type_contains_locals(fcx.ccx.tcx, tt)) {
+ if (!ty::type_contains_locals(fcx.ccx.tcx, tt)) {
ret ann;
}
auto f = bind resolver(fcx, _);
- auto new_type = ty.fold_ty(fcx.ccx.tcx, f, ann_to_type(ann));
- ret ast.ann_type(tg, new_type, tps, ts_info);
+ auto new_type = ty::fold_ty(fcx.ccx.tcx, f, ann_to_type(ann));
+ ret ast::ann_type(tg, new_type, tps, ts_info);
}
}
}
-fn resolve_local_types_in_block(&@fn_ctxt fcx, &ast.block block)
- -> ast.block {
- fn update_env_for_item(&Option.t[@fn_ctxt] env, &@ast.item i)
- -> Option.t[@fn_ctxt] {
+fn resolve_local_types_in_block(&@fn_ctxt fcx, &ast::block block)
+ -> ast::block {
+ fn update_env_for_item(&option::t[@fn_ctxt] env, &@ast::item i)
+ -> option::t[@fn_ctxt] {
ret none[@fn_ctxt];
}
- fn keep_going(&Option.t[@fn_ctxt] env) -> bool {
- ret !Option.is_none[@fn_ctxt](env);
+ fn keep_going(&option::t[@fn_ctxt] env) -> bool {
+ ret !option::is_none[@fn_ctxt](env);
}
// FIXME: rustboot bug prevents us from using these functions directly
- auto fld = fold.new_identity_fold[Option.t[@fn_ctxt]]();
+ auto fld = fold::new_identity_fold[option::t[@fn_ctxt]]();
auto wbl = writeback_local;
auto rltia = bind resolve_local_types_in_annotation(_,_);
auto uefi = update_env_for_item;
@@ -1602,137 +1607,137 @@ fn resolve_local_types_in_block(&@fn_ctxt fcx, &ast.block block)
update_env_for_item = uefi,
keep_going = kg
with *fld);
- ret fold.fold_block[Option.t[@fn_ctxt]](some[@fn_ctxt](fcx), fld, block);
+ ret fold::fold_block[option::t[@fn_ctxt]](some(fcx), fld, block);
}
// AST fragment checking
-fn check_lit(@crate_ctxt ccx, &@ast.lit lit) -> ty.t {
+fn check_lit(@crate_ctxt ccx, &@ast::lit lit) -> ty::t {
alt (lit.node) {
- case (ast.lit_str(_)) { ret ty.mk_str(ccx.tcx); }
- case (ast.lit_char(_)) { ret ty.mk_char(ccx.tcx); }
- case (ast.lit_int(_)) { ret ty.mk_int(ccx.tcx); }
- case (ast.lit_float(_)) { ret ty.mk_float(ccx.tcx); }
- case (ast.lit_mach_float(?tm, _))
- { ret ty.mk_mach(ccx.tcx, tm); }
- case (ast.lit_uint(_)) { ret ty.mk_uint(ccx.tcx); }
- case (ast.lit_mach_int(?tm, _)) { ret ty.mk_mach(ccx.tcx, tm); }
- case (ast.lit_nil) { ret ty.mk_nil(ccx.tcx); }
- case (ast.lit_bool(_)) { ret ty.mk_bool(ccx.tcx); }
+ case (ast::lit_str(_)) { ret ty::mk_str(ccx.tcx); }
+ case (ast::lit_char(_)) { ret ty::mk_char(ccx.tcx); }
+ case (ast::lit_int(_)) { ret ty::mk_int(ccx.tcx); }
+ case (ast::lit_float(_)) { ret ty::mk_float(ccx.tcx); }
+ case (ast::lit_mach_float(?tm, _))
+ { ret ty::mk_mach(ccx.tcx, tm); }
+ case (ast::lit_uint(_)) { ret ty::mk_uint(ccx.tcx); }
+ case (ast::lit_mach_int(?tm, _)) { ret ty::mk_mach(ccx.tcx, tm); }
+ case (ast::lit_nil) { ret ty::mk_nil(ccx.tcx); }
+ case (ast::lit_bool(_)) { ret ty::mk_bool(ccx.tcx); }
}
fail; // not reached
}
-fn check_pat(&@fn_ctxt fcx, &@ast.pat pat) -> @ast.pat {
+fn check_pat(&@fn_ctxt fcx, &@ast::pat pat) -> @ast::pat {
auto new_pat;
alt (pat.node) {
- case (ast.pat_wild(?ann)) {
- new_pat = ast.pat_wild(triv_ann(ann, next_ty_var(fcx.ccx)));
+ case (ast::pat_wild(?ann)) {
+ new_pat = ast::pat_wild(triv_ann(ann, next_ty_var(fcx.ccx)));
}
- case (ast.pat_lit(?lt, ?ann)) {
- new_pat = ast.pat_lit(lt, triv_ann(ann, check_lit(fcx.ccx, lt)));
+ case (ast::pat_lit(?lt, ?ann)) {
+ new_pat = ast::pat_lit(lt, triv_ann(ann, check_lit(fcx.ccx, lt)));
}
- case (ast.pat_bind(?id, ?def_id, ?a)) {
+ case (ast::pat_bind(?id, ?def_id, ?a)) {
auto ann = triv_ann(a, next_ty_var(fcx.ccx));
- new_pat = ast.pat_bind(id, def_id, ann);
+ new_pat = ast::pat_bind(id, def_id, ann);
}
- case (ast.pat_tag(?p, ?subpats, ?old_ann)) {
- auto vdef = ast.variant_def_ids
- (fcx.ccx.tcx.def_map.get(ast.ann_tag(old_ann)));
- auto t = ty.lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
+ case (ast::pat_tag(?p, ?subpats, ?old_ann)) {
+ auto vdef = ast::variant_def_ids
+ (fcx.ccx.tcx.def_map.get(ast::ann_tag(old_ann)));
+ auto t = ty::lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
fcx.ccx.type_cache, vdef._1)._1;
- auto len = Vec.len[ast.ident](p.node.idents);
+ auto len = _vec::len[ast::ident](p.node.idents);
auto last_id = p.node.idents.(len - 1u);
- auto tpt = ty.lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
+ auto tpt = ty::lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
fcx.ccx.type_cache, vdef._0);
auto ann = instantiate_path(fcx, p, tpt, pat.span,
- ast.ann_tag(old_ann));
+ ast::ann_tag(old_ann));
alt (struct(fcx.ccx.tcx, t)) {
// N-ary variants have function types.
- case (ty.ty_fn(_, ?args, ?tag_ty)) {
- auto arg_len = Vec.len[arg](args);
- auto subpats_len = Vec.len[@ast.pat](subpats);
+ case (ty::ty_fn(_, ?args, ?tag_ty)) {
+ auto arg_len = _vec::len[arg](args);
+ auto subpats_len = _vec::len[@ast::pat](subpats);
if (arg_len != subpats_len) {
// TODO: pluralize properly
auto err_msg = "tag type " + last_id + " has " +
- UInt.to_str(subpats_len, 10u) +
+ _uint::to_str(subpats_len, 10u) +
" field(s), but this pattern has " +
- UInt.to_str(arg_len, 10u) +
+ _uint::to_str(arg_len, 10u) +
" field(s)";
fcx.ccx.sess.span_err(pat.span, err_msg);
fail; // TODO: recover
}
- let vec[@ast.pat] new_subpats = vec();
- for (@ast.pat subpat in subpats) {
+ let vec[@ast::pat] new_subpats = vec();
+ for (@ast::pat subpat in subpats) {
new_subpats += vec(check_pat(fcx, subpat));
}
- new_pat = ast.pat_tag(p, new_subpats, ann);
+ new_pat = ast::pat_tag(p, new_subpats, ann);
}
// Nullary variants have tag types.
- case (ty.ty_tag(?tid, _)) {
- auto subpats_len = Vec.len[@ast.pat](subpats);
+ case (ty::ty_tag(?tid, _)) {
+ auto subpats_len = _vec::len[@ast::pat](subpats);
if (subpats_len > 0u) {
// TODO: pluralize properly
auto err_msg = "tag type " + last_id +
" has no field(s)," +
" but this pattern has " +
- UInt.to_str(subpats_len, 10u) +
+ _uint::to_str(subpats_len, 10u) +
" field(s)";
fcx.ccx.sess.span_err(pat.span, err_msg);
fail; // TODO: recover
}
- new_pat = ast.pat_tag(p, subpats, ann);
+ new_pat = ast::pat_tag(p, subpats, ann);
}
}
}
}
- ret @fold.respan[ast.pat_](pat.span, new_pat);
+ ret @fold::respan[ast::pat_](pat.span, new_pat);
}
-fn require_impure(&session.session sess,
- &ast.purity f_purity, &span sp) -> () {
+fn require_impure(&session::session sess,
+ &ast::purity f_purity, &span sp) -> () {
alt (f_purity) {
- case (ast.impure_fn) {
+ case (ast::impure_fn) {
ret;
}
- case (ast.pure_fn) {
+ case (ast::pure_fn) {
sess.span_err(sp,
"Found impure expression in pure function decl");
}
}
}
-fn get_function_purity(@crate_ctxt ccx, &ast.def_id d_id) -> ast.purity {
- let Option.t[ast.purity] o = ccx.fn_purity_table.find(d_id);
- ret from_maybe[ast.purity](ast.impure_fn, o);
+fn get_function_purity(@crate_ctxt ccx, &ast::def_id d_id) -> ast::purity {
+ let option::t[ast::purity] o = ccx.fn_purity_table.find(d_id);
+ ret from_maybe[ast::purity](ast::impure_fn, o);
}
fn require_pure_call(@crate_ctxt ccx,
- &ast.purity caller_purity,
- &@ast.expr callee, &span sp) -> () {
+ &ast::purity caller_purity,
+ &@ast::expr callee, &span sp) -> () {
alt (caller_purity) {
- case (ast.impure_fn) {
+ case (ast::impure_fn) {
ret;
}
- case (ast.pure_fn) {
+ case (ast::pure_fn) {
alt (callee.node) {
- case (ast.expr_path(_, ?ann)) {
+ case (ast::expr_path(_, ?ann)) {
auto d_id;
- alt (ccx.tcx.def_map.get(ast.ann_tag(ann))) {
- case (ast.def_fn(?_d_id)) { d_id = _d_id; }
+ alt (ccx.tcx.def_map.get(ast::ann_tag(ann))) {
+ case (ast::def_fn(?_d_id)) { d_id = _d_id; }
}
alt (get_function_purity(ccx, d_id)) {
- case (ast.pure_fn) {
+ case (ast::pure_fn) {
ret;
}
case (_) {
@@ -1751,46 +1756,46 @@ fn require_pure_call(@crate_ctxt ccx,
}
}
-fn require_pure_function(@crate_ctxt ccx, &ast.def_id d_id, &span sp) -> () {
+fn require_pure_function(@crate_ctxt ccx, &ast::def_id d_id, &span sp) -> () {
alt (get_function_purity(ccx, d_id)) {
- case (ast.impure_fn) {
+ case (ast::impure_fn) {
ccx.sess.span_err(sp, "Found non-predicate in check expression");
}
case (_) { ret; }
}
}
-fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
+fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
//fcx.ccx.sess.span_warn(expr.span, "typechecking expr " +
- // util.common.expr_to_str(expr));
+ // util::common::expr_to_str(expr));
// A generic function to factor out common logic from call and bind
// expressions.
- fn check_call_or_bind(&@fn_ctxt fcx, &@ast.expr f,
- &vec[Option.t[@ast.expr]] args)
- -> tup(@ast.expr, vec[Option.t[@ast.expr]]) {
+ fn check_call_or_bind(&@fn_ctxt fcx, &@ast::expr f,
+ &vec[option::t[@ast::expr]] args)
+ -> tup(@ast::expr, vec[option::t[@ast::expr]]) {
// Check the function.
auto f_0 = check_expr(fcx, f);
// Check the arguments and generate the argument signature.
- let vec[Option.t[@ast.expr]] args_0 = vec();
+ let vec[option::t[@ast::expr]] args_0 = vec();
let vec[arg] arg_tys_0 = vec();
- for (Option.t[@ast.expr] a_opt in args) {
+ for (option::t[@ast::expr] a_opt in args) {
alt (a_opt) {
- case (some[@ast.expr](?a)) {
+ case (some[@ast::expr](?a)) {
auto a_0 = check_expr(fcx, a);
- args_0 += vec(some[@ast.expr](a_0));
+ args_0 += vec(some[@ast::expr](a_0));
auto arg_ty = rec(mode=mo_either,
ty=expr_ty(fcx.ccx.tcx, a_0));
- Vec.push[arg](arg_tys_0, arg_ty);
+ _vec::push[arg](arg_tys_0, arg_ty);
}
- case (none[@ast.expr]) {
- args_0 += vec(none[@ast.expr]);
+ case (none[@ast::expr]) {
+ args_0 += vec(none[@ast::expr]);
auto typ = next_ty_var(fcx.ccx);
- Vec.push[arg](arg_tys_0, rec(mode=mo_either, ty=typ));
+ _vec::push[arg](arg_tys_0, rec(mode=mo_either, ty=typ));
}
}
}
@@ -1798,11 +1803,11 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
auto rt_0 = next_ty_var(fcx.ccx);
auto t_0;
alt (struct(fcx.ccx.tcx, expr_ty(fcx.ccx.tcx, f_0))) {
- case (ty.ty_fn(?proto, _, _)) {
- t_0 = ty.mk_fn(fcx.ccx.tcx, proto, arg_tys_0, rt_0);
+ case (ty::ty_fn(?proto, _, _)) {
+ t_0 = ty::mk_fn(fcx.ccx.tcx, proto, arg_tys_0, rt_0);
}
- case (ty.ty_native_fn(?abi, _, _)) {
- t_0 = ty.mk_native_fn(fcx.ccx.tcx, abi, arg_tys_0, rt_0);
+ case (ty::ty_native_fn(?abi, _, _)) {
+ t_0 = ty::mk_native_fn(fcx.ccx.tcx, abi, arg_tys_0, rt_0);
}
case (_) {
log_err "check_call_or_bind(): fn expr doesn't have fn type";
@@ -1811,25 +1816,25 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
}
// Unify the callee and arguments.
- auto tpt_0 = ty.expr_ty_params_and_ty(fcx.ccx.tcx, f_0);
- auto tpt_1 = Demand.full(fcx, f.span, tpt_0._1, t_0, tpt_0._0,
+ auto tpt_0 = ty::expr_ty_params_and_ty(fcx.ccx.tcx, f_0);
+ auto tpt_1 = Demand::full(fcx, f.span, tpt_0._1, t_0, tpt_0._0,
NO_AUTODEREF);
- auto f_1 = ty.replace_expr_type(f_0, tpt_1);
+ auto f_1 = ty::replace_expr_type(f_0, tpt_1);
ret tup(f_1, args_0);
}
// A generic function for checking assignment expressions
- fn check_assignment(&@fn_ctxt fcx, &@ast.expr lhs, &@ast.expr rhs,
- &ast.ann a)
- -> tup(@ast.expr, @ast.expr, ast.ann) {
+ fn check_assignment(&@fn_ctxt fcx, &@ast::expr lhs, &@ast::expr rhs,
+ &ast::ann a)
+ -> tup(@ast::expr, @ast::expr, ast::ann) {
auto lhs_0 = check_expr(fcx, lhs);
auto rhs_0 = check_expr(fcx, rhs);
auto lhs_t0 = expr_ty(fcx.ccx.tcx, lhs_0);
auto rhs_t0 = expr_ty(fcx.ccx.tcx, rhs_0);
- auto lhs_1 = Pushdown.pushdown_expr(fcx, rhs_t0, lhs_0);
- auto rhs_1 = Pushdown.pushdown_expr(fcx, expr_ty(fcx.ccx.tcx, lhs_1),
+ auto lhs_1 = Pushdown::pushdown_expr(fcx, rhs_t0, lhs_0);
+ auto rhs_1 = Pushdown::pushdown_expr(fcx, expr_ty(fcx.ccx.tcx, lhs_1),
rhs_0);
auto ann = triv_ann(a, expr_ty(fcx.ccx.tcx, rhs_1));
@@ -1837,77 +1842,77 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
}
// A generic function for checking call expressions
- fn check_call(&@fn_ctxt fcx, &@ast.expr f, &vec[@ast.expr] args)
- -> tup(@ast.expr, vec[@ast.expr]) {
+ fn check_call(&@fn_ctxt fcx, &@ast::expr f, &vec[@ast::expr] args)
+ -> tup(@ast::expr, vec[@ast::expr]) {
- let vec[Option.t[@ast.expr]] args_opt_0 = vec();
- for (@ast.expr arg in args) {
- args_opt_0 += vec(some[@ast.expr](arg));
+ let vec[option::t[@ast::expr]] args_opt_0 = vec();
+ for (@ast::expr arg in args) {
+ args_opt_0 += vec(some[@ast::expr](arg));
}
// Call the generic checker.
auto result = check_call_or_bind(fcx, f, args_opt_0);
// Pull out the arguments.
- let vec[@ast.expr] args_1 = vec();
- for (Option.t[@ast.expr] arg in result._1) {
- args_1 += vec(Option.get[@ast.expr](arg));
+ let vec[@ast::expr] args_1 = vec();
+ for (option::t[@ast::expr] arg in result._1) {
+ args_1 += vec(option::get[@ast::expr](arg));
}
ret tup(result._0, args_1);
}
alt (expr.node) {
- case (ast.expr_lit(?lit, ?a)) {
+ case (ast::expr_lit(?lit, ?a)) {
auto typ = check_lit(fcx.ccx, lit);
auto ann = triv_ann(a, typ);
- ret @fold.respan[ast.expr_](expr.span, ast.expr_lit(lit, ann));
+ ret @fold::respan[ast::expr_](expr.span, ast::expr_lit(lit, ann));
}
- case (ast.expr_binary(?binop, ?lhs, ?rhs, ?a)) {
+ case (ast::expr_binary(?binop, ?lhs, ?rhs, ?a)) {
auto lhs_0 = check_expr(fcx, lhs);
auto rhs_0 = check_expr(fcx, rhs);
auto lhs_t0 = expr_ty(fcx.ccx.tcx, lhs_0);
auto rhs_t0 = expr_ty(fcx.ccx.tcx, rhs_0);
// FIXME: Binops have a bit more subtlety than this.
- auto lhs_1 = Pushdown.pushdown_expr_full(fcx, rhs_t0, lhs_0,
+ auto lhs_1 = Pushdown::pushdown_expr_full(fcx, rhs_t0, lhs_0,
AUTODEREF_OK);
auto rhs_1 =
- Pushdown.pushdown_expr_full(fcx,
+ Pushdown::pushdown_expr_full(fcx,
expr_ty(fcx.ccx.tcx, lhs_1),
rhs_0, AUTODEREF_OK);
auto t = strip_boxes(fcx.ccx.tcx, lhs_t0);
alt (binop) {
- case (ast.eq) { t = ty.mk_bool(fcx.ccx.tcx); }
- case (ast.lt) { t = ty.mk_bool(fcx.ccx.tcx); }
- case (ast.le) { t = ty.mk_bool(fcx.ccx.tcx); }
- case (ast.ne) { t = ty.mk_bool(fcx.ccx.tcx); }
- case (ast.ge) { t = ty.mk_bool(fcx.ccx.tcx); }
- case (ast.gt) { t = ty.mk_bool(fcx.ccx.tcx); }
+ case (ast::eq) { t = ty::mk_bool(fcx.ccx.tcx); }
+ case (ast::lt) { t = ty::mk_bool(fcx.ccx.tcx); }
+ case (ast::le) { t = ty::mk_bool(fcx.ccx.tcx); }
+ case (ast::ne) { t = ty::mk_bool(fcx.ccx.tcx); }
+ case (ast::ge) { t = ty::mk_bool(fcx.ccx.tcx); }
+ case (ast::gt) { t = ty::mk_bool(fcx.ccx.tcx); }
case (_) { /* fall through */ }
}
auto ann = triv_ann(a, t);
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_binary(binop, lhs_1, rhs_1,
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_binary(binop, lhs_1, rhs_1,
ann));
}
- case (ast.expr_unary(?unop, ?oper, ?a)) {
+ case (ast::expr_unary(?unop, ?oper, ?a)) {
auto oper_1 = check_expr(fcx, oper);
auto oper_t = expr_ty(fcx.ccx.tcx, oper_1);
alt (unop) {
- case (ast.box(?mut)) {
- oper_t = ty.mk_box(fcx.ccx.tcx,
+ case (ast::box(?mut)) {
+ oper_t = ty::mk_box(fcx.ccx.tcx,
rec(ty=oper_t, mut=mut));
}
- case (ast.deref) {
+ case (ast::deref) {
alt (struct(fcx.ccx.tcx, oper_t)) {
- case (ty.ty_box(?inner)) {
+ case (ty::ty_box(?inner)) {
oper_t = inner.ty;
}
case (_) {
@@ -1922,144 +1927,144 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
}
auto ann = triv_ann(a, oper_t);
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_unary(unop, oper_1, ann));
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_unary(unop, oper_1, ann));
}
- case (ast.expr_path(?pth, ?old_ann)) {
- auto t = ty.mk_nil(fcx.ccx.tcx);
- auto defn = fcx.ccx.tcx.def_map.get(ast.ann_tag(old_ann));
+ case (ast::expr_path(?pth, ?old_ann)) {
+ auto t = ty::mk_nil(fcx.ccx.tcx);
+ auto defn = fcx.ccx.tcx.def_map.get(ast::ann_tag(old_ann));
auto tpt = ty_param_count_and_ty_for_def(fcx, expr.span, defn);
- if (ty.def_has_ty_params(defn)) {
+ if (ty::def_has_ty_params(defn)) {
auto ann = instantiate_path(fcx, pth, tpt, expr.span,
- ast.ann_tag(old_ann));
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_path(pth, ann));
+ ast::ann_tag(old_ann));
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_path(pth, ann));
}
// The definition doesn't take type parameters. If the programmer
// supplied some, that's an error.
- if (Vec.len[@ast.ty](pth.node.types) > 0u) {
+ if (_vec::len[@ast::ty](pth.node.types) > 0u) {
fcx.ccx.sess.span_err(expr.span, "this kind of value does " +
"not take type parameters");
fail;
}
- auto e = ast.expr_path(pth, triv_ann(old_ann, tpt._1));
- ret @fold.respan[ast.expr_](expr.span, e);
+ auto e = ast::expr_path(pth, triv_ann(old_ann, tpt._1));
+ ret @fold::respan[ast::expr_](expr.span, e);
}
- case (ast.expr_ext(?p, ?args, ?body, ?expanded, ?a)) {
+ case (ast::expr_ext(?p, ?args, ?body, ?expanded, ?a)) {
auto exp_ = check_expr(fcx, expanded);
auto t = expr_ty(fcx.ccx.tcx, exp_);
auto ann = triv_ann(a, t);
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_ext(p, args, body, exp_,
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_ext(p, args, body, exp_,
ann));
}
- case (ast.expr_fail(?a)) {
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_fail(plain_ann(a, fcx.ccx.tcx)));
+ case (ast::expr_fail(?a)) {
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_fail(plain_ann(a, fcx.ccx.tcx)));
}
- case (ast.expr_break(?a)) {
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_break(plain_ann(a, fcx.ccx.tcx)));
+ case (ast::expr_break(?a)) {
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_break(plain_ann(a, fcx.ccx.tcx)));
}
- case (ast.expr_cont(?a)) {
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_cont(plain_ann(a, fcx.ccx.tcx)));
+ case (ast::expr_cont(?a)) {
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_cont(plain_ann(a, fcx.ccx.tcx)));
}
- case (ast.expr_ret(?expr_opt, ?a)) {
+ case (ast::expr_ret(?expr_opt, ?a)) {
alt (expr_opt) {
- case (none[@ast.expr]) {
- auto nil = ty.mk_nil(fcx.ccx.tcx);
+ case (none[@ast::expr]) {
+ auto nil = ty::mk_nil(fcx.ccx.tcx);
if (!are_compatible(fcx, fcx.ret_ty, nil)) {
fcx.ccx.sess.err("ret; in function "
+ "returning non-nil");
}
- ret @fold.respan[ast.expr_]
+ ret @fold::respan[ast::expr_]
(expr.span,
- ast.expr_ret(none[@ast.expr],
+ ast::expr_ret(none[@ast::expr],
plain_ann(a, fcx.ccx.tcx)));
}
- case (some[@ast.expr](?e)) {
+ case (some[@ast::expr](?e)) {
auto expr_0 = check_expr(fcx, e);
- auto expr_1 = Pushdown.pushdown_expr(fcx, fcx.ret_ty,
+ auto expr_1 = Pushdown::pushdown_expr(fcx, fcx.ret_ty,
expr_0);
- ret @fold.respan[ast.expr_]
- (expr.span, ast.expr_ret(some(expr_1),
+ ret @fold::respan[ast::expr_]
+ (expr.span, ast::expr_ret(some(expr_1),
plain_ann(a, fcx.ccx.tcx)));
}
}
}
- case (ast.expr_put(?expr_opt, ?a)) {
+ case (ast::expr_put(?expr_opt, ?a)) {
require_impure(fcx.ccx.sess, fcx.purity, expr.span);
alt (expr_opt) {
- case (none[@ast.expr]) {
- auto nil = ty.mk_nil(fcx.ccx.tcx);
+ case (none[@ast::expr]) {
+ auto nil = ty::mk_nil(fcx.ccx.tcx);
if (!are_compatible(fcx, fcx.ret_ty, nil)) {
fcx.ccx.sess.err("put; in function "
+ "putting non-nil");
}
- ret @fold.respan[ast.expr_]
- (expr.span, ast.expr_put(none[@ast.expr],
+ ret @fold::respan[ast::expr_]
+ (expr.span, ast::expr_put(none[@ast::expr],
plain_ann(a, fcx.ccx.tcx)));
}
- case (some[@ast.expr](?e)) {
+ case (some[@ast::expr](?e)) {
auto expr_0 = check_expr(fcx, e);
- auto expr_1 = Pushdown.pushdown_expr(fcx, fcx.ret_ty,
+ auto expr_1 = Pushdown::pushdown_expr(fcx, fcx.ret_ty,
expr_0);
- ret @fold.respan[ast.expr_]
- (expr.span, ast.expr_put(some(expr_1),
+ ret @fold::respan[ast::expr_]
+ (expr.span, ast::expr_put(some(expr_1),
plain_ann(a, fcx.ccx.tcx)));
}
}
}
- case (ast.expr_be(?e, ?a)) {
+ case (ast::expr_be(?e, ?a)) {
/* FIXME: prove instead of check */
- assert (ast.is_call_expr(e));
+ assert (ast::is_call_expr(e));
auto expr_0 = check_expr(fcx, e);
- auto expr_1 = Pushdown.pushdown_expr(fcx, fcx.ret_ty, expr_0);
- ret @fold.respan(expr.span,
- ast.expr_be(expr_1, plain_ann(a, fcx.ccx.tcx)));
+ auto expr_1 = Pushdown::pushdown_expr(fcx, fcx.ret_ty, expr_0);
+ ret @fold::respan(expr.span,
+ ast::expr_be(expr_1, plain_ann(a, fcx.ccx.tcx)));
}
- case (ast.expr_log(?l, ?e, ?a)) {
+ case (ast::expr_log(?l, ?e, ?a)) {
auto expr_t = check_expr(fcx, e);
- ret @fold.respan[ast.expr_]
- (expr.span, ast.expr_log(l, expr_t,
+ ret @fold::respan[ast::expr_]
+ (expr.span, ast::expr_log(l, expr_t,
plain_ann(a, fcx.ccx.tcx)));
}
- case (ast.expr_check(?e, ?a)) {
+ case (ast::expr_check(?e, ?a)) {
auto expr_t = check_expr(fcx, e);
- Demand.simple(fcx, expr.span, ty.mk_bool(fcx.ccx.tcx),
+ Demand::simple(fcx, expr.span, ty::mk_bool(fcx.ccx.tcx),
expr_ty(fcx.ccx.tcx, expr_t));
/* e must be a call expr where all arguments are either
literals or slots */
alt (e.node) {
- case (ast.expr_call(?operator, ?operands, _)) {
+ case (ast::expr_call(?operator, ?operands, _)) {
alt (operator.node) {
- case (ast.expr_path(?oper_name, ?ann)) {
+ case (ast::expr_path(?oper_name, ?ann)) {
auto d_id;
- alt (fcx.ccx.tcx.def_map.get(ast.ann_tag(ann))) {
- case (ast.def_fn(?_d_id)) { d_id = _d_id; }
+ alt (fcx.ccx.tcx.def_map.get(ast::ann_tag(ann))) {
+ case (ast::def_fn(?_d_id)) { d_id = _d_id; }
}
- for (@ast.expr operand in operands) {
- if (! ast.is_constraint_arg(operand)) {
+ for (@ast::expr operand in operands) {
+ if (! ast::is_constraint_arg(operand)) {
fcx.ccx.sess.span_err(expr.span,
"Constraint args must be "
+ "slot variables or literals");
@@ -2068,8 +2073,8 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
require_pure_function(fcx.ccx, d_id, expr.span);
- ret @fold.respan[ast.expr_]
- (expr.span, ast.expr_check(expr_t,
+ ret @fold::respan[ast::expr_]
+ (expr.span, ast::expr_check(expr_t,
plain_ann(a, fcx.ccx.tcx)));
}
case (_) {
@@ -2086,90 +2091,91 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
}
}
- case (ast.expr_assert(?e, ?a)) {
+ case (ast::expr_assert(?e, ?a)) {
auto expr_t = check_expr(fcx, e);
- Demand.simple(fcx, expr.span, ty.mk_bool(fcx.ccx.tcx),
+ Demand::simple(fcx, expr.span, ty::mk_bool(fcx.ccx.tcx),
expr_ty(fcx.ccx.tcx, expr_t));
- ret @fold.respan[ast.expr_]
- (expr.span, ast.expr_assert(expr_t,
+ ret @fold::respan[ast::expr_]
+ (expr.span, ast::expr_assert(expr_t,
plain_ann(a, fcx.ccx.tcx)));
}
- case (ast.expr_assign(?lhs, ?rhs, ?a)) {
+ case (ast::expr_assign(?lhs, ?rhs, ?a)) {
require_impure(fcx.ccx.sess, fcx.purity, expr.span);
auto checked = check_assignment(fcx, lhs, rhs, a);
- auto newexpr = ast.expr_assign(checked._0,
+ auto newexpr = ast::expr_assign(checked._0,
checked._1,
checked._2);
- ret @fold.respan[ast.expr_](expr.span, newexpr);
+ ret @fold::respan[ast::expr_](expr.span, newexpr);
}
- case (ast.expr_assign_op(?op, ?lhs, ?rhs, ?a)) {
+ case (ast::expr_assign_op(?op, ?lhs, ?rhs, ?a)) {
require_impure(fcx.ccx.sess, fcx.purity, expr.span);
auto checked = check_assignment(fcx, lhs, rhs, a);
- auto newexpr = ast.expr_assign_op(op,
+ auto newexpr = ast::expr_assign_op(op,
checked._0,
checked._1,
checked._2);
- ret @fold.respan[ast.expr_](expr.span, newexpr);
+ ret @fold::respan[ast::expr_](expr.span, newexpr);
}
- case (ast.expr_send(?lhs, ?rhs, ?a)) {
+ case (ast::expr_send(?lhs, ?rhs, ?a)) {
require_impure(fcx.ccx.sess, fcx.purity, expr.span);
auto lhs_0 = check_expr(fcx, lhs);
auto rhs_0 = check_expr(fcx, rhs);
auto rhs_t = expr_ty(fcx.ccx.tcx, rhs_0);
- auto chan_t = ty.mk_chan(fcx.ccx.tcx, rhs_t);
- auto lhs_1 = Pushdown.pushdown_expr(fcx, chan_t, lhs_0);
+ auto chan_t = ty::mk_chan(fcx.ccx.tcx, rhs_t);
+ auto lhs_1 = Pushdown::pushdown_expr(fcx, chan_t, lhs_0);
auto item_t;
alt (struct(fcx.ccx.tcx, expr_ty(fcx.ccx.tcx, lhs_1))) {
- case (ty.ty_chan(?it)) {
+ case (ty::ty_chan(?it)) {
item_t = it;
}
case (_) {
fail;
}
}
- auto rhs_1 = Pushdown.pushdown_expr(fcx, item_t, rhs_0);
+ auto rhs_1 = Pushdown::pushdown_expr(fcx, item_t, rhs_0);
auto ann = triv_ann(a, chan_t);
- auto newexpr = ast.expr_send(lhs_1, rhs_1, ann);
- ret @fold.respan[ast.expr_](expr.span, newexpr);
+ auto newexpr = ast::expr_send(lhs_1, rhs_1, ann);
+ ret @fold::respan[ast::expr_](expr.span, newexpr);
}
- case (ast.expr_recv(?lhs, ?rhs, ?a)) {
+ case (ast::expr_recv(?lhs, ?rhs, ?a)) {
require_impure(fcx.ccx.sess, fcx.purity, expr.span);
auto lhs_0 = check_expr(fcx, lhs);
auto rhs_0 = check_expr(fcx, rhs);
auto lhs_t1 = expr_ty(fcx.ccx.tcx, lhs_0);
- auto port_t = ty.mk_port(fcx.ccx.tcx, lhs_t1);
- auto rhs_1 = Pushdown.pushdown_expr(fcx, port_t, rhs_0);
+ auto port_t = ty::mk_port(fcx.ccx.tcx, lhs_t1);
+ auto rhs_1 = Pushdown::pushdown_expr(fcx, port_t, rhs_0);
auto item_t;
alt (struct(fcx.ccx.tcx, expr_ty(fcx.ccx.tcx, rhs_0))) {
- case (ty.ty_port(?it)) {
+ case (ty::ty_port(?it)) {
item_t = it;
}
case (_) {
fail;
}
}
- auto lhs_1 = Pushdown.pushdown_expr(fcx, item_t, lhs_0);
+ auto lhs_1 = Pushdown::pushdown_expr(fcx, item_t, lhs_0);
auto ann = triv_ann(a, item_t);
- auto newexpr = ast.expr_recv(lhs_1, rhs_1, ann);
- ret @fold.respan[ast.expr_](expr.span, newexpr);
+ auto newexpr = ast::expr_recv(lhs_1, rhs_1, ann);
+ ret @fold::respan[ast::expr_](expr.span, newexpr);
}
- case (ast.expr_if(?cond, ?thn, ?elsopt, ?a)) {
+ case (ast::expr_if(?cond, ?thn, ?elsopt, ?a)) {
auto cond_0 = check_expr(fcx, cond);
- auto cond_1 = Pushdown.pushdown_expr(fcx, ty.mk_bool(fcx.ccx.tcx),
- cond_0);
+ auto cond_1 = Pushdown::pushdown_expr(fcx,
+ ty::mk_bool(fcx.ccx.tcx),
+ cond_0);
auto thn_0 = check_block(fcx, thn);
auto thn_t = block_ty(fcx.ccx.tcx, thn_0);
@@ -2177,27 +2183,27 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
auto elsopt_1;
auto elsopt_t;
alt (elsopt) {
- case (some[@ast.expr](?els)) {
+ case (some[@ast::expr](?els)) {
auto els_0 = check_expr(fcx, els);
- auto els_1 = Pushdown.pushdown_expr(fcx, thn_t, els_0);
- elsopt_1 = some[@ast.expr](els_1);
+ auto els_1 = Pushdown::pushdown_expr(fcx, thn_t, els_0);
+ elsopt_1 = some[@ast::expr](els_1);
elsopt_t = expr_ty(fcx.ccx.tcx, els_1);
}
- case (none[@ast.expr]) {
- elsopt_1 = none[@ast.expr];
- elsopt_t = ty.mk_nil(fcx.ccx.tcx);
+ case (none[@ast::expr]) {
+ elsopt_1 = none[@ast::expr];
+ elsopt_t = ty::mk_nil(fcx.ccx.tcx);
}
}
- auto thn_1 = Pushdown.pushdown_block(fcx, elsopt_t, thn_0);
+ auto thn_1 = Pushdown::pushdown_block(fcx, elsopt_t, thn_0);
auto ann = triv_ann(a, elsopt_t);
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_if(cond_1, thn_1,
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_if(cond_1, thn_1,
elsopt_1, ann));
}
- case (ast.expr_for(?decl, ?seq, ?body, ?a)) {
+ case (ast::expr_for(?decl, ?seq, ?body, ?a)) {
auto decl_1 = check_decl_local(fcx, decl);
auto seq_1 = check_expr(fcx, seq);
auto body_1 = check_block(fcx, body);
@@ -2205,81 +2211,83 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
// FIXME: enforce that the type of the decl is the element type
// of the seq.
- auto ann = triv_ann(a, ty.mk_nil(fcx.ccx.tcx));
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_for(decl_1, seq_1,
+ auto ann = triv_ann(a, ty::mk_nil(fcx.ccx.tcx));
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_for(decl_1, seq_1,
body_1, ann));
}
- case (ast.expr_for_each(?decl, ?seq, ?body, ?a)) {
+ case (ast::expr_for_each(?decl, ?seq, ?body, ?a)) {
auto decl_1 = check_decl_local(fcx, decl);
auto seq_1 = check_expr(fcx, seq);
auto body_1 = check_block(fcx, body);
- auto ann = triv_ann(a, ty.mk_nil(fcx.ccx.tcx));
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_for_each(decl_1, seq_1,
+ auto ann = triv_ann(a, ty::mk_nil(fcx.ccx.tcx));
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_for_each(decl_1, seq_1,
body_1, ann));
}
- case (ast.expr_while(?cond, ?body, ?a)) {
+ case (ast::expr_while(?cond, ?body, ?a)) {
auto cond_0 = check_expr(fcx, cond);
- auto cond_1 = Pushdown.pushdown_expr(fcx, ty.mk_bool(fcx.ccx.tcx),
- cond_0);
+ auto cond_1 = Pushdown::pushdown_expr(fcx,
+ ty::mk_bool(fcx.ccx.tcx),
+ cond_0);
auto body_1 = check_block(fcx, body);
- auto ann = triv_ann(a, ty.mk_nil(fcx.ccx.tcx));
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_while(cond_1, body_1, ann));
+ auto ann = triv_ann(a, ty::mk_nil(fcx.ccx.tcx));
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_while(cond_1, body_1, ann));
}
- case (ast.expr_do_while(?body, ?cond, ?a)) {
+ case (ast::expr_do_while(?body, ?cond, ?a)) {
auto cond_0 = check_expr(fcx, cond);
- auto cond_1 = Pushdown.pushdown_expr(fcx, ty.mk_bool(fcx.ccx.tcx),
- cond_0);
+ auto cond_1 = Pushdown::pushdown_expr(fcx,
+ ty::mk_bool(fcx.ccx.tcx),
+ cond_0);
auto body_1 = check_block(fcx, body);
auto ann = triv_ann(a, block_ty(fcx.ccx.tcx, body_1));
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_do_while(body_1, cond_1,
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_do_while(body_1, cond_1,
ann));
}
- case (ast.expr_alt(?expr, ?arms, ?a)) {
+ case (ast::expr_alt(?expr, ?arms, ?a)) {
auto expr_0 = check_expr(fcx, expr);
// Typecheck the patterns first, so that we get types for all the
// bindings.
auto pattern_ty = expr_ty(fcx.ccx.tcx, expr_0);
- let vec[@ast.pat] pats_0 = vec();
- for (ast.arm arm in arms) {
+ let vec[@ast::pat] pats_0 = vec();
+ for (ast::arm arm in arms) {
auto pat_0 = check_pat(fcx, arm.pat);
- pattern_ty = Demand.simple(fcx, pat_0.span, pattern_ty,
+ pattern_ty = Demand::simple(fcx, pat_0.span, pattern_ty,
pat_ty(fcx.ccx.tcx, pat_0));
pats_0 += vec(pat_0);
}
- let vec[@ast.pat] pats_1 = vec();
- for (@ast.pat pat_0 in pats_0) {
- pats_1 += vec(Pushdown.pushdown_pat(fcx, pattern_ty, pat_0));
+ let vec[@ast::pat] pats_1 = vec();
+ for (@ast::pat pat_0 in pats_0) {
+ pats_1 += vec(Pushdown::pushdown_pat(fcx, pattern_ty, pat_0));
}
// Now typecheck the blocks.
auto result_ty = next_ty_var(fcx.ccx);
- let vec[ast.block] blocks_0 = vec();
- for (ast.arm arm in arms) {
+ let vec[ast::block] blocks_0 = vec();
+ for (ast::arm arm in arms) {
auto block_0 = check_block(fcx, arm.block);
- result_ty = Demand.simple(fcx, block_0.span, result_ty,
+ result_ty = Demand::simple(fcx, block_0.span, result_ty,
block_ty(fcx.ccx.tcx, block_0));
blocks_0 += vec(block_0);
}
- let vec[ast.arm] arms_1 = vec();
+ let vec[ast::arm] arms_1 = vec();
auto i = 0u;
- for (ast.block block_0 in blocks_0) {
- auto block_1 = Pushdown.pushdown_block(fcx, result_ty,
+ for (ast::block block_0 in blocks_0) {
+ auto block_1 = Pushdown::pushdown_block(fcx, result_ty,
block_0);
auto pat_1 = pats_1.(i);
auto arm = arms.(i);
@@ -2288,47 +2296,47 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
i += 1u;
}
- auto expr_1 = Pushdown.pushdown_expr(fcx, pattern_ty, expr_0);
+ auto expr_1 = Pushdown::pushdown_expr(fcx, pattern_ty, expr_0);
auto ann = triv_ann(a, result_ty);
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_alt(expr_1, arms_1, ann));
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_alt(expr_1, arms_1, ann));
}
- case (ast.expr_block(?b, ?a)) {
+ case (ast::expr_block(?b, ?a)) {
auto b_0 = check_block(fcx, b);
auto ann;
alt (b_0.node.expr) {
- case (some[@ast.expr](?expr)) {
+ case (some[@ast::expr](?expr)) {
ann = triv_ann(a, expr_ty(fcx.ccx.tcx, expr));
}
- case (none[@ast.expr]) {
- ann = triv_ann(a, ty.mk_nil(fcx.ccx.tcx));
+ case (none[@ast::expr]) {
+ ann = triv_ann(a, ty::mk_nil(fcx.ccx.tcx));
}
}
- ret @fold.respan[ast.expr_](expr.span, ast.expr_block(b_0, ann));
+ ret @fold::respan(expr.span, ast::expr_block(b_0, ann));
}
- case (ast.expr_bind(?f, ?args, ?a)) {
+ case (ast::expr_bind(?f, ?args, ?a)) {
// Call the generic checker.
auto result = check_call_or_bind(fcx, f, args);
// Pull the argument and return types out.
auto proto_1;
- let vec[ty.arg] arg_tys_1 = vec();
+ let vec[ty::arg] arg_tys_1 = vec();
auto rt_1;
alt (struct(fcx.ccx.tcx, expr_ty(fcx.ccx.tcx, result._0))) {
- case (ty.ty_fn(?proto, ?arg_tys, ?rt)) {
+ case (ty::ty_fn(?proto, ?arg_tys, ?rt)) {
proto_1 = proto;
rt_1 = rt;
// For each blank argument, add the type of that argument
// to the resulting function type.
auto i = 0u;
- while (i < Vec.len[Option.t[@ast.expr]](args)) {
+ while (i < _vec::len[option::t[@ast::expr]](args)) {
alt (args.(i)) {
- case (some[@ast.expr](_)) { /* no-op */ }
- case (none[@ast.expr]) {
+ case (some[@ast::expr](_)) { /* no-op */ }
+ case (none[@ast::expr]) {
arg_tys_1 += vec(arg_tys.(i));
}
}
@@ -2341,14 +2349,14 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
}
}
- auto t_1 = ty.mk_fn(fcx.ccx.tcx, proto_1, arg_tys_1, rt_1);
+ auto t_1 = ty::mk_fn(fcx.ccx.tcx, proto_1, arg_tys_1, rt_1);
auto ann = triv_ann(a, t_1);
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_bind(result._0, result._1,
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_bind(result._0, result._1,
ann));
}
- case (ast.expr_call(?f, ?args, ?a)) {
+ case (ast::expr_call(?f, ?args, ?a)) {
/* here we're kind of hosed, as f can be any expr
need to restrict it to being an explicit expr_path if we're
inside a pure function, and need an environment mapping from
@@ -2360,10 +2368,10 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
auto args_1 = result._1;
// Pull the return type out of the type of the function.
- auto rt_1 = ty.mk_nil(fcx.ccx.tcx); // FIXME: typestate botch
+ auto rt_1 = ty::mk_nil(fcx.ccx.tcx); // FIXME: typestate botch
alt (struct(fcx.ccx.tcx, expr_ty(fcx.ccx.tcx, f_1))) {
- case (ty.ty_fn(_,_,?rt)) { rt_1 = rt; }
- case (ty.ty_native_fn(_, _, ?rt)) { rt_1 = rt; }
+ case (ty::ty_fn(_,_,?rt)) { rt_1 = rt; }
+ case (ty::ty_native_fn(_, _, ?rt)) { rt_1 = rt; }
case (_) {
log_err "LHS of call expr didn't have a function type?!";
fail;
@@ -2371,19 +2379,19 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
}
auto ann = triv_ann(a, rt_1);
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_call(f_1, args_1, ann));
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_call(f_1, args_1, ann));
}
- case (ast.expr_self_method(?id, ?a)) {
- auto t = ty.mk_nil(fcx.ccx.tcx);
- let ty.t this_obj_ty;
+ case (ast::expr_self_method(?id, ?a)) {
+ auto t = ty::mk_nil(fcx.ccx.tcx);
+ let ty::t this_obj_ty;
// Grab the type of the current object
auto this_obj_id = fcx.ccx.this_obj;
alt (this_obj_id) {
- case (some[ast.def_id](?def_id)) {
- this_obj_ty = ty.lookup_item_type(fcx.ccx.sess,
+ case (some[ast::def_id](?def_id)) {
+ this_obj_ty = ty::lookup_item_type(fcx.ccx.sess,
fcx.ccx.tcx, fcx.ccx.type_cache, def_id)._1;
}
case (_) { fail; }
@@ -2392,12 +2400,12 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
// Grab this method's type out of the current object type
- // this_obj_ty is an ty.t
+ // this_obj_ty is an ty::t
alt (struct(fcx.ccx.tcx, this_obj_ty)) {
- case (ty.ty_obj(?methods)) {
- for (ty.method method in methods) {
+ case (ty::ty_obj(?methods)) {
+ for (ty::method method in methods) {
if (method.ident == id) {
- t = ty.method_ty_to_fn_ty(fcx.ccx.tcx,
+ t = ty::method_ty_to_fn_ty(fcx.ccx.tcx,
method);
}
}
@@ -2409,20 +2417,20 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
require_impure(fcx.ccx.sess, fcx.purity, expr.span);
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_self_method(id, ann));
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_self_method(id, ann));
}
- case (ast.expr_spawn(?dom, ?name, ?f, ?args, ?a)) {
+ case (ast::expr_spawn(?dom, ?name, ?f, ?args, ?a)) {
auto result = check_call(fcx, f, args);
auto f_1 = result._0;
auto args_1 = result._1;
// Check the return type
alt (struct(fcx.ccx.tcx, expr_ty(fcx.ccx.tcx, f_1))) {
- case (ty.ty_fn(_,_,?rt)) {
+ case (ty::ty_fn(_,_,?rt)) {
alt (struct(fcx.ccx.tcx, rt)) {
- case (ty.ty_nil) {
+ case (ty::ty_nil) {
// This is acceptable
}
case (_) {
@@ -2437,13 +2445,13 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
// FIXME: Other typechecks needed
- auto ann = triv_ann(a, ty.mk_task(fcx.ccx.tcx));
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_spawn(dom, name,
+ auto ann = triv_ann(a, ty::mk_task(fcx.ccx.tcx));
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_spawn(dom, name,
f_1, args_1, ann));
}
- case (ast.expr_cast(?e, ?t, ?a)) {
+ case (ast::expr_cast(?e, ?t, ?a)) {
auto e_1 = check_expr(fcx, e);
auto t_1 = ast_ty_to_ty_crate(fcx.ccx, t);
// FIXME: there are more forms of cast to support, eventually.
@@ -2456,87 +2464,87 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
}
auto ann = triv_ann(a, t_1);
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_cast(e_1, t, ann));
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_cast(e_1, t, ann));
}
- case (ast.expr_vec(?args, ?mut, ?a)) {
- let vec[@ast.expr] args_1 = vec();
+ case (ast::expr_vec(?args, ?mut, ?a)) {
+ let vec[@ast::expr] args_1 = vec();
- let ty.t t;
- if (Vec.len[@ast.expr](args) == 0u) {
+ let ty::t t;
+ if (_vec::len[@ast::expr](args) == 0u) {
t = next_ty_var(fcx.ccx);
} else {
auto expr_1 = check_expr(fcx, args.(0));
t = expr_ty(fcx.ccx.tcx, expr_1);
}
- for (@ast.expr e in args) {
+ for (@ast::expr e in args) {
auto expr_1 = check_expr(fcx, e);
auto expr_t = expr_ty(fcx.ccx.tcx, expr_1);
- Demand.simple(fcx, expr.span, t, expr_t);
- Vec.push[@ast.expr](args_1,expr_1);
+ Demand::simple(fcx, expr.span, t, expr_t);
+ _vec::push[@ast::expr](args_1,expr_1);
}
- auto ann = triv_ann(a, ty.mk_vec(fcx.ccx.tcx,
+ auto ann = triv_ann(a, ty::mk_vec(fcx.ccx.tcx,
rec(ty=t, mut=mut)));
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_vec(args_1, mut, ann));
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_vec(args_1, mut, ann));
}
- case (ast.expr_tup(?elts, ?a)) {
- let vec[ast.elt] elts_1 = vec();
- let vec[ty.mt] elts_mt = vec();
+ case (ast::expr_tup(?elts, ?a)) {
+ let vec[ast::elt] elts_1 = vec();
+ let vec[ty::mt] elts_mt = vec();
- for (ast.elt e in elts) {
+ for (ast::elt e in elts) {
auto expr_1 = check_expr(fcx, e.expr);
auto expr_t = expr_ty(fcx.ccx.tcx, expr_1);
- Vec.push[ast.elt](elts_1, rec(expr=expr_1 with e));
+ _vec::push[ast::elt](elts_1, rec(expr=expr_1 with e));
elts_mt += vec(rec(ty=expr_t, mut=e.mut));
}
- auto ann = triv_ann(a, ty.mk_tup(fcx.ccx.tcx, elts_mt));
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_tup(elts_1, ann));
+ auto ann = triv_ann(a, ty::mk_tup(fcx.ccx.tcx, elts_mt));
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_tup(elts_1, ann));
}
- case (ast.expr_rec(?fields, ?base, ?a)) {
+ case (ast::expr_rec(?fields, ?base, ?a)) {
auto base_1;
alt (base) {
- case (none[@ast.expr]) { base_1 = none[@ast.expr]; }
- case (some[@ast.expr](?b_0)) {
- base_1 = some[@ast.expr](check_expr(fcx, b_0));
+ case (none[@ast::expr]) { base_1 = none[@ast::expr]; }
+ case (some[@ast::expr](?b_0)) {
+ base_1 = some[@ast::expr](check_expr(fcx, b_0));
}
}
- let vec[ast.field] fields_1 = vec();
+ let vec[ast::field] fields_1 = vec();
let vec[field] fields_t = vec();
- for (ast.field f in fields) {
+ for (ast::field f in fields) {
auto expr_1 = check_expr(fcx, f.expr);
auto expr_t = expr_ty(fcx.ccx.tcx, expr_1);
- Vec.push[ast.field](fields_1, rec(expr=expr_1 with f));
+ _vec::push[ast::field](fields_1, rec(expr=expr_1 with f));
auto expr_mt = rec(ty=expr_t, mut=f.mut);
- Vec.push[field](fields_t, rec(ident=f.ident, mt=expr_mt));
+ _vec::push[field](fields_t, rec(ident=f.ident, mt=expr_mt));
}
auto ann;
alt (base) {
- case (none[@ast.expr]) {
- ann = triv_ann(a, ty.mk_rec(fcx.ccx.tcx, fields_t));
+ case (none[@ast::expr]) {
+ ann = triv_ann(a, ty::mk_rec(fcx.ccx.tcx, fields_t));
}
- case (some[@ast.expr](?bexpr)) {
+ case (some[@ast::expr](?bexpr)) {
auto bexpr_1 = check_expr(fcx, bexpr);
auto bexpr_t = expr_ty(fcx.ccx.tcx, bexpr_1);
let vec[field] base_fields = vec();
alt (struct(fcx.ccx.tcx, bexpr_t)) {
- case (ty.ty_rec(?flds)) {
+ case (ty::ty_rec(?flds)) {
base_fields = flds;
}
case (_) {
@@ -2548,11 +2556,11 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
ann = triv_ann(a, bexpr_t);
- for (ty.field f in fields_t) {
+ for (ty::field f in fields_t) {
auto found = false;
- for (ty.field bf in base_fields) {
- if (Str.eq(f.ident, bf.ident)) {
- Demand.simple(fcx, expr.span, f.mt.ty,
+ for (ty::field bf in base_fields) {
+ if (_str::eq(f.ident, bf.ident)) {
+ Demand::simple(fcx, expr.span, f.mt.ty,
bf.mt.ty);
found = true;
}
@@ -2567,69 +2575,69 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
}
}
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_rec(fields_1, base_1, ann));
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_rec(fields_1, base_1, ann));
}
- case (ast.expr_field(?base, ?field, ?a)) {
+ case (ast::expr_field(?base, ?field, ?a)) {
auto base_1 = check_expr(fcx, base);
auto base_t = strip_boxes(fcx.ccx.tcx,
expr_ty(fcx.ccx.tcx, base_1));
alt (struct(fcx.ccx.tcx, base_t)) {
- case (ty.ty_tup(?args)) {
- let uint ix = ty.field_num(fcx.ccx.sess,
+ case (ty::ty_tup(?args)) {
+ let uint ix = ty::field_num(fcx.ccx.sess,
expr.span, field);
- if (ix >= Vec.len[ty.mt](args)) {
+ if (ix >= _vec::len[ty::mt](args)) {
fcx.ccx.sess.span_err(expr.span,
"bad index on tuple");
}
auto ann = triv_ann(a, args.(ix).ty);
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_field(base_1,
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_field(base_1,
field,
ann));
}
- case (ty.ty_rec(?fields)) {
- let uint ix = ty.field_idx(fcx.ccx.sess,
+ case (ty::ty_rec(?fields)) {
+ let uint ix = ty::field_idx(fcx.ccx.sess,
expr.span, field, fields);
- if (ix >= Vec.len[typeck.field](fields)) {
+ if (ix >= _vec::len[typeck::field](fields)) {
fcx.ccx.sess.span_err(expr.span,
"bad index on record");
}
auto ann = triv_ann(a, fields.(ix).mt.ty);
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_field(base_1,
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_field(base_1,
field,
ann));
}
- case (ty.ty_obj(?methods)) {
- let uint ix = ty.method_idx(fcx.ccx.sess,
+ case (ty::ty_obj(?methods)) {
+ let uint ix = ty::method_idx(fcx.ccx.sess,
expr.span, field, methods);
- if (ix >= Vec.len[typeck.method](methods)) {
+ if (ix >= _vec::len[typeck::method](methods)) {
fcx.ccx.sess.span_err(expr.span,
"bad index on obj");
}
auto meth = methods.(ix);
- auto t = ty.mk_fn(fcx.ccx.tcx, meth.proto,
+ auto t = ty::mk_fn(fcx.ccx.tcx, meth.proto,
meth.inputs, meth.output);
auto ann = triv_ann(a, t);
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_field(base_1,
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_field(base_1,
field,
ann));
}
case (_) {
fcx.ccx.sess.span_unimpl(expr.span,
- "base type for expr_field in typeck.check_expr: " +
+ "base type for expr_field in typeck::check_expr: " +
ty_to_str(fcx.ccx.tcx, base_t));
}
}
}
- case (ast.expr_index(?base, ?idx, ?a)) {
+ case (ast::expr_index(?base, ?idx, ?a)) {
auto base_1 = check_expr(fcx, base);
auto base_t = strip_boxes(fcx.ccx.tcx,
expr_ty(fcx.ccx.tcx, base_1));
@@ -2637,7 +2645,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
auto idx_1 = check_expr(fcx, idx);
auto idx_t = expr_ty(fcx.ccx.tcx, idx_1);
alt (struct(fcx.ccx.tcx, base_t)) {
- case (ty.ty_vec(?mt)) {
+ case (ty::ty_vec(?mt)) {
if (! type_is_integral(fcx.ccx.tcx, idx_t)) {
fcx.ccx.sess.span_err
(idx.span,
@@ -2645,22 +2653,22 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
+ ty_to_str(fcx.ccx.tcx, idx_t));
}
auto ann = triv_ann(a, mt.ty);
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_index(base_1,
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_index(base_1,
idx_1,
ann));
}
- case (ty.ty_str) {
+ case (ty::ty_str) {
if (! type_is_integral(fcx.ccx.tcx, idx_t)) {
fcx.ccx.sess.span_err
(idx.span,
"non-integral type of str index: "
+ ty_to_str(fcx.ccx.tcx, idx_t));
}
- auto ann = triv_ann(a, ty.mk_mach(fcx.ccx.tcx,
- common.ty_u8));
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_index(base_1,
+ auto ann = triv_ann(a, ty::mk_mach(fcx.ccx.tcx,
+ common::ty_u8));
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_index(base_1,
idx_1,
ann));
}
@@ -2673,22 +2681,22 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
}
}
- case (ast.expr_port(?a)) {
+ case (ast::expr_port(?a)) {
auto t = next_ty_var(fcx.ccx);
- auto pt = ty.mk_port(fcx.ccx.tcx, t);
+ auto pt = ty::mk_port(fcx.ccx.tcx, t);
auto ann = triv_ann(a, pt);
- ret @fold.respan[ast.expr_](expr.span, ast.expr_port(ann));
+ ret @fold::respan[ast::expr_](expr.span, ast::expr_port(ann));
}
- case (ast.expr_chan(?x, ?a)) {
+ case (ast::expr_chan(?x, ?a)) {
auto expr_1 = check_expr(fcx, x);
auto port_t = expr_ty(fcx.ccx.tcx, expr_1);
alt (struct(fcx.ccx.tcx, port_t)) {
- case (ty.ty_port(?subtype)) {
- auto ct = ty.mk_chan(fcx.ccx.tcx, subtype);
+ case (ty::ty_port(?subtype)) {
+ auto ct = ty::mk_chan(fcx.ccx.tcx, subtype);
auto ann = triv_ann(a, ct);
- ret @fold.respan[ast.expr_](expr.span,
- ast.expr_chan(expr_1, ann));
+ ret @fold::respan[ast::expr_](expr.span,
+ ast::expr_chan(expr_1, ann));
}
case (_) {
fcx.ccx.sess.span_err(expr.span,
@@ -2698,33 +2706,33 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
}
case (_) {
- fcx.ccx.sess.unimpl("expr type in typeck.check_expr");
+ fcx.ccx.sess.unimpl("expr type in typeck::check_expr");
// TODO
ret expr;
}
}
}
-fn next_ty_var(&@crate_ctxt ccx) -> ty.t {
- auto t = ty.mk_var(ccx.tcx, ccx.next_var_id);
+fn next_ty_var(&@crate_ctxt ccx) -> ty::t {
+ auto t = ty::mk_var(ccx.tcx, ccx.next_var_id);
ccx.next_var_id += 1;
ret t;
}
-fn check_decl_local(&@fn_ctxt fcx, &@ast.decl decl) -> @ast.decl {
+fn check_decl_local(&@fn_ctxt fcx, &@ast::decl decl) -> @ast::decl {
alt (decl.node) {
- case (ast.decl_local(?local)) {
+ case (ast::decl_local(?local)) {
auto t;
- t = ty.mk_nil(fcx.ccx.tcx);
+ t = ty::mk_nil(fcx.ccx.tcx);
alt (local.ty) {
- case (none[@ast.ty]) {
+ case (none[@ast::ty]) {
// Auto slot. Do nothing for now.
}
- case (some[@ast.ty](?ast_ty)) {
+ case (some[@ast::ty](?ast_ty)) {
auto local_ty = ast_ty_to_ty_crate(fcx.ccx, ast_ty);
fcx.locals.insert(local.id, local_ty);
t = local_ty;
@@ -2741,48 +2749,49 @@ fn check_decl_local(&@fn_ctxt fcx, &@ast.decl decl) -> @ast.decl {
auto initopt = local.init;
alt (local.init) {
- case (some[ast.initializer](?init)) {
+ case (some[ast::initializer](?init)) {
auto expr_0 = check_expr(fcx, init.expr);
- auto lty = ty.mk_local(fcx.ccx.tcx, local.id);
+ auto lty = ty::mk_local(fcx.ccx.tcx, local.id);
auto expr_1;
alt (init.op) {
- case (ast.init_assign) {
- expr_1 = Pushdown.pushdown_expr(fcx, lty, expr_0);
+ case (ast::init_assign) {
+ expr_1 = Pushdown::pushdown_expr(fcx, lty,
+ expr_0);
}
- case (ast.init_recv) {
- auto port_ty = ty.mk_port(fcx.ccx.tcx, lty);
- expr_1 = Pushdown.pushdown_expr(fcx, port_ty,
+ case (ast::init_recv) {
+ auto port_ty = ty::mk_port(fcx.ccx.tcx, lty);
+ expr_1 = Pushdown::pushdown_expr(fcx, port_ty,
expr_0);
}
}
auto init_0 = rec(expr = expr_1 with init);
- initopt = some[ast.initializer](init_0);
+ initopt = some[ast::initializer](init_0);
}
case (_) { /* fall through */ }
}
auto local_1 = @rec(init = initopt, ann = a_res with *local);
- ret @rec(node=ast.decl_local(local_1)
+ ret @rec(node=ast::decl_local(local_1)
with *decl);
}
}
}
-fn check_stmt(&@fn_ctxt fcx, &@ast.stmt stmt) -> @ast.stmt {
+fn check_stmt(&@fn_ctxt fcx, &@ast::stmt stmt) -> @ast::stmt {
alt (stmt.node) {
- case (ast.stmt_decl(?decl,?a)) {
+ case (ast::stmt_decl(?decl,?a)) {
alt (decl.node) {
- case (ast.decl_local(_)) {
+ case (ast::decl_local(_)) {
auto decl_1 = check_decl_local(fcx, decl);
- ret @fold.respan[ast.stmt_](stmt.span,
- ast.stmt_decl(decl_1,
+ ret @fold::respan[ast::stmt_](stmt.span,
+ ast::stmt_decl(decl_1,
plain_ann(a, fcx.ccx.tcx)));
}
- case (ast.decl_item(_)) {
+ case (ast::decl_item(_)) {
// Ignore for now. We'll return later.
- ret @fold.respan[ast.stmt_](stmt.span,
- ast.stmt_decl(decl,
+ ret @fold::respan[ast::stmt_](stmt.span,
+ ast::stmt_decl(decl,
plain_ann(a, fcx.ccx.tcx)));
}
}
@@ -2790,73 +2799,75 @@ fn check_stmt(&@fn_ctxt fcx, &@ast.stmt stmt) -> @ast.stmt {
// ret stmt;
}
- case (ast.stmt_expr(?expr,?a)) {
+ case (ast::stmt_expr(?expr,?a)) {
auto expr_t = check_expr(fcx, expr);
- expr_t = Pushdown.pushdown_expr(fcx, expr_ty(fcx.ccx.tcx, expr_t),
- expr_t);
- ret @fold.respan(stmt.span,
- ast.stmt_expr(expr_t, plain_ann(a, fcx.ccx.tcx)));
+ expr_t = Pushdown::pushdown_expr(fcx,
+ expr_ty(fcx.ccx.tcx, expr_t),
+ expr_t);
+ ret @fold::respan(stmt.span,
+ ast::stmt_expr(expr_t,
+ plain_ann(a, fcx.ccx.tcx)));
}
}
fail;
}
-fn check_block(&@fn_ctxt fcx, &ast.block block) -> ast.block {
- let vec[@ast.stmt] stmts = vec();
- for (@ast.stmt s in block.node.stmts) {
- Vec.push[@ast.stmt](stmts, check_stmt(fcx, s));
+fn check_block(&@fn_ctxt fcx, &ast::block block) -> ast::block {
+ let vec[@ast::stmt] stmts = vec();
+ for (@ast::stmt s in block.node.stmts) {
+ _vec::push[@ast::stmt](stmts, check_stmt(fcx, s));
}
- auto expr = none[@ast.expr];
+ auto expr = none[@ast::expr];
alt (block.node.expr) {
- case (none[@ast.expr]) { /* empty */ }
- case (some[@ast.expr](?e)) {
+ case (none[@ast::expr]) { /* empty */ }
+ case (some[@ast::expr](?e)) {
auto expr_t = check_expr(fcx, e);
- expr_t = Pushdown.pushdown_expr(fcx,
+ expr_t = Pushdown::pushdown_expr(fcx,
expr_ty(fcx.ccx.tcx, expr_t),
expr_t);
- expr = some[@ast.expr](expr_t);
+ expr = some[@ast::expr](expr_t);
}
}
- ret fold.respan(block.span,
+ ret fold::respan(block.span,
rec(stmts=stmts, expr=expr,
a=plain_ann(block.node.a, fcx.ccx.tcx)));
}
-fn check_const(&@crate_ctxt ccx, &span sp, &ast.ident ident, &@ast.ty t,
- &@ast.expr e, &ast.def_id id, &ast.ann ann) -> @ast.item {
+fn check_const(&@crate_ctxt ccx, &span sp, &ast::ident ident, &@ast::ty t,
+ &@ast::expr e, &ast::def_id id, &ast::ann ann) -> @ast::item {
// FIXME: this is kinda a kludge; we manufacture a fake "function context"
// for checking the initializer expression.
auto rty = ann_to_type(ann);
let @fn_ctxt fcx = @rec(ret_ty = rty,
- purity = ast.pure_fn,
- locals = @common.new_def_hash[ty.t](),
+ purity = ast::pure_fn,
+ locals = @common::new_def_hash[ty::t](),
ccx = ccx);
auto e_ = check_expr(fcx, e);
// FIXME: necessary? Correct sequence?
- Pushdown.pushdown_expr(fcx, rty, e_);
- auto item = ast.item_const(ident, t, e_, id, ann);
- ret @fold.respan[ast.item_](sp, item);
+ Pushdown::pushdown_expr(fcx, rty, e_);
+ auto item = ast::item_const(ident, t, e_, id, ann);
+ ret @fold::respan[ast::item_](sp, item);
}
-fn check_fn(&@crate_ctxt ccx, &ast.fn_decl decl, ast.proto proto,
- &ast.block body) -> ast._fn {
- auto local_ty_table = @common.new_def_hash[ty.t]();
+fn check_fn(&@crate_ctxt ccx, &ast::fn_decl decl, ast::proto proto,
+ &ast::block body) -> ast::_fn {
+ auto local_ty_table = @common::new_def_hash[ty::t]();
// FIXME: duplicate work: the item annotation already has the arg types
- // and return type translated to typeck.ty values. We don't need do to it
+ // and return type translated to typeck::ty values. We don't need do to it
// again here, we can extract them.
- for (ast.obj_field f in ccx.obj_fields) {
- auto field_ty = ty.ann_to_type(f.ann);
+ for (ast::obj_field f in ccx.obj_fields) {
+ auto field_ty = ty::ann_to_type(f.ann);
local_ty_table.insert(f.id, field_ty);
}
// Store the type of each argument in the table.
- for (ast.arg arg in decl.inputs) {
+ for (ast::arg arg in decl.inputs) {
auto input_ty = ast_ty_to_ty_crate(ccx, arg.ty);
local_ty_table.insert(arg.id, input_ty);
}
@@ -2869,10 +2880,10 @@ fn check_fn(&@crate_ctxt ccx, &ast.fn_decl decl, ast.proto proto,
// TODO: Make sure the type of the block agrees with the function type.
auto block_t = check_block(fcx, body);
alt (decl.purity) {
- case (ast.pure_fn) {
+ case (ast::pure_fn) {
// per the previous comment, this just checks that the declared
// type is bool, and trusts that that's the actual return type.
- if (!ty.type_is_bool(ccx.tcx, fcx.ret_ty)) {
+ if (!ty::type_is_bool(ccx.tcx, fcx.ret_ty)) {
ccx.sess.span_err(body.span, "Non-boolean return type in pred");
}
}
@@ -2887,34 +2898,34 @@ fn check_fn(&@crate_ctxt ccx, &ast.fn_decl decl, ast.proto proto,
ret fn_t;
}
-fn check_item_fn(&@crate_ctxt ccx, &span sp, &ast.ident ident, &ast._fn f,
- &vec[ast.ty_param] ty_params, &ast.def_id id,
- &ast.ann ann) -> @ast.item {
+fn check_item_fn(&@crate_ctxt ccx, &span sp, &ast::ident ident, &ast::_fn f,
+ &vec[ast::ty_param] ty_params, &ast::def_id id,
+ &ast::ann ann) -> @ast::item {
// FIXME: duplicate work: the item annotation already has the arg types
- // and return type translated to typeck.ty values. We don't need do to it
+ // and return type translated to typeck::ty values. We don't need do to it
// again here, we can extract them.
let vec[arg] inputs = vec();
- for (ast.arg arg in f.decl.inputs) {
+ for (ast::arg arg in f.decl.inputs) {
auto input_ty = ast_ty_to_ty_crate(ccx, arg.ty);
inputs += vec(rec(mode=ast_mode_to_mode(arg.mode), ty=input_ty));
}
auto output_ty = ast_ty_to_ty_crate(ccx, f.decl.output);
- auto fn_ann = triv_ann(ann, ty.mk_fn(ccx.tcx, f.proto, inputs,
+ auto fn_ann = triv_ann(ann, ty::mk_fn(ccx.tcx, f.proto, inputs,
output_ty));
- auto item = ast.item_fn(ident, f, ty_params, id, fn_ann);
- ret @fold.respan[ast.item_](sp, item);
+ auto item = ast::item_fn(ident, f, ty_params, id, fn_ann);
+ ret @fold::respan[ast::item_](sp, item);
}
-fn update_obj_fields(&@crate_ctxt ccx, &@ast.item i) -> @crate_ctxt {
+fn update_obj_fields(&@crate_ctxt ccx, &@ast::item i) -> @crate_ctxt {
alt (i.node) {
- case (ast.item_obj(_, ?ob, _, ?obj_def_ids, _)) {
- let ast.def_id di = obj_def_ids.ty;
+ case (ast::item_obj(_, ?ob, _, ?obj_def_ids, _)) {
+ let ast::def_id di = obj_def_ids.ty;
ret @rec(obj_fields = ob.fields,
- this_obj = some[ast.def_id](di) with *ccx);
+ this_obj = some[ast::def_id](di) with *ccx);
}
case (_) {
}
@@ -2926,13 +2937,13 @@ fn update_obj_fields(&@crate_ctxt ccx, &@ast.item i) -> @crate_ctxt {
// Utilities for the unification cache
fn hash_unify_cache_entry(&unify_cache_entry uce) -> uint {
- auto h = ty.hash_ty(uce._0);
- h += h << 5u + ty.hash_ty(uce._1);
+ auto h = ty::hash_ty(uce._0);
+ h += h << 5u + ty::hash_ty(uce._1);
auto i = 0u;
- auto tys_len = Vec.len(uce._2);
+ auto tys_len = _vec::len(uce._2);
while (i < tys_len) {
- h += h << 5u + ty.hash_ty(uce._2.(i));
+ h += h << 5u + ty::hash_ty(uce._2.(i));
i += 1u;
}
@@ -2940,26 +2951,26 @@ fn hash_unify_cache_entry(&unify_cache_entry uce) -> uint {
}
fn eq_unify_cache_entry(&unify_cache_entry a, &unify_cache_entry b) -> bool {
- if (!ty.eq_ty(a._0, b._0) || !ty.eq_ty(a._1, b._1)) { ret false; }
+ if (!ty::eq_ty(a._0, b._0) || !ty::eq_ty(a._1, b._1)) { ret false; }
auto i = 0u;
- auto tys_len = Vec.len(a._2);
- if (Vec.len(b._2) != tys_len) { ret false; }
+ auto tys_len = _vec::len(a._2);
+ if (_vec::len(b._2) != tys_len) { ret false; }
while (i < tys_len) {
- if (!ty.eq_ty(a._2.(i), b._2.(i))) { ret false; }
+ if (!ty::eq_ty(a._2.(i), b._2.(i))) { ret false; }
i += 1u;
}
ret true;
}
-fn mk_fn_purity_table(&@ast.crate crate) -> @fn_purity_table {
- auto res = @new_def_hash[ast.purity]();
+fn mk_fn_purity_table(&@ast::crate crate) -> @fn_purity_table {
+ auto res = @new_def_hash[ast::purity]();
- fn do_one(@fn_purity_table t, &@ast.item i) -> () {
+ fn do_one(@fn_purity_table t, &@ast::item i) -> () {
alt (i.node) {
- case (ast.item_fn(_, ?f, _, ?d_id, _)) {
+ case (ast::item_fn(_, ?f, _, ?d_id, _)) {
t.insert(d_id, f.decl.purity);
}
case (_) {}
@@ -2967,26 +2978,26 @@ fn mk_fn_purity_table(&@ast.crate crate) -> @fn_purity_table {
}
auto do_one_fn = bind do_one(res,_);
- auto v = walk.default_visitor();
+ auto v = walk::default_visitor();
auto add_fn_entry_visitor = rec(visit_item_post=do_one_fn with v);
- walk.walk_crate(add_fn_entry_visitor, *crate);
+ walk::walk_crate(add_fn_entry_visitor, *crate);
ret res;
}
-type typecheck_result = tup(@ast.crate, ty.type_cache);
+type typecheck_result = tup(@ast::crate, ty::type_cache);
-fn check_crate(&ty.ctxt tcx, &@ast.crate crate) -> typecheck_result {
+fn check_crate(&ty::ctxt tcx, &@ast::crate crate) -> typecheck_result {
auto sess = tcx.sess;
- auto result = Collect.collect_item_types(sess, tcx, crate);
+ auto result = Collect::collect_item_types(sess, tcx, crate);
- let vec[ast.obj_field] fields = vec();
+ let vec[ast::obj_field] fields = vec();
auto hasher = hash_unify_cache_entry;
auto eqer = eq_unify_cache_entry;
auto unify_cache =
- Map.mk_hashmap[unify_cache_entry,ty.Unify.result](hasher, eqer);
+ map::mk_hashmap[unify_cache_entry,ty::Unify::result](hasher, eqer);
auto fpt =
mk_fn_purity_table(crate); // use a variation on Collect
@@ -2994,7 +3005,7 @@ fn check_crate(&ty.ctxt tcx, &@ast.crate crate) -> typecheck_result {
type_cache=result._1,
item_items=result._2,
obj_fields=fields,
- this_obj=none[ast.def_id],
+ this_obj=none[ast::def_id],
fn_purity_table = fpt,
mutable next_var_id=0,
unify_cache=unify_cache,
@@ -3002,14 +3013,14 @@ fn check_crate(&ty.ctxt tcx, &@ast.crate crate) -> typecheck_result {
mutable cache_misses=0u,
tcx=tcx);
- auto fld = fold.new_identity_fold[@crate_ctxt]();
+ auto fld = fold::new_identity_fold[@crate_ctxt]();
fld = @rec(update_env_for_item = bind update_obj_fields(_, _),
fold_fn = bind check_fn(_,_,_,_),
fold_item_fn = bind check_item_fn(_,_,_,_,_,_,_)
with *fld);
- auto crate_1 = fold.fold_crate[@crate_ctxt](ccx, fld, result._0);
+ auto crate_1 = fold::fold_crate[@crate_ctxt](ccx, fld, result._0);
log #fmt("cache hit rate: %u/%u", ccx.cache_hits,
ccx.cache_hits + ccx.cache_misses);
diff --git a/src/comp/middle/typestate_check.rs b/src/comp/middle/typestate_check.rs
index b13364184fe73..2d46309adbcdd 100644
--- a/src/comp/middle/typestate_check.rs
+++ b/src/comp/middle/typestate_check.rs
@@ -1,214 +1,214 @@
-import front.ast;
-import front.ast.ann;
-import front.ast.method;
-import front.ast.ty;
-import front.ast.mutability;
-import front.ast.item;
-import front.ast.block;
-import front.ast.block_;
-import front.ast.obj_field;
-import front.ast.decl;
-import front.ast.arm;
-import front.ast.stmt;
-import front.ast.stmt_;
-import front.ast.stmt_decl;
-import front.ast.stmt_expr;
-import front.ast.stmt_crate_directive;
-import front.ast.decl_local;
-import front.ast.decl_item;
-import front.ast.ident;
-import front.ast.def_id;
-import front.ast.ann;
-import front.ast.field;
-import front.ast.expr;
-import front.ast.expr_call;
-import front.ast.expr_vec;
-import front.ast.expr_tup;
-import front.ast.expr_path;
-import front.ast.expr_field;
-import front.ast.expr_index;
-import front.ast.expr_log;
-import front.ast.expr_block;
-import front.ast.expr_rec;
-import front.ast.expr_if;
-import front.ast.expr_binary;
-import front.ast.expr_unary;
-import front.ast.expr_assign;
-import front.ast.expr_assign_op;
-import front.ast.expr_while;
-import front.ast.expr_do_while;
-import front.ast.expr_alt;
-import front.ast.expr_lit;
-import front.ast.expr_ret;
-import front.ast.expr_self_method;
-import front.ast.expr_bind;
-import front.ast.expr_spawn;
-import front.ast.expr_ext;
-import front.ast.expr_fail;
-import front.ast.expr_break;
-import front.ast.expr_cont;
-import front.ast.expr_send;
-import front.ast.expr_recv;
-import front.ast.expr_put;
-import front.ast.expr_port;
-import front.ast.expr_chan;
-import front.ast.expr_be;
-import front.ast.expr_check;
-import front.ast.expr_assert;
-import front.ast.expr_cast;
-import front.ast.expr_for;
-import front.ast.expr_for_each;
-import front.ast.path;
-import front.ast.elt;
-import front.ast.crate_directive;
-import front.ast.fn_decl;
-import front.ast._obj;
-import front.ast.native_mod;
-import front.ast.variant;
-import front.ast.ty_param;
-import front.ast.ty;
-import front.ast.proto;
-import front.ast.pat;
-import front.ast.binop;
-import front.ast.unop;
-import front.ast.def;
-import front.ast.lit;
-import front.ast.init_op;
-import front.ast.initializer;
-import front.ast.local;
-import front.ast._fn;
-import front.ast.ann_none;
-import front.ast.ann_type;
-import front.ast._obj;
-import front.ast._mod;
-import front.ast.crate;
-import front.ast.item_fn;
-import front.ast.item_obj;
-import front.ast.def_local;
-
-import middle.fold;
-import middle.fold.respan;
-import driver.session;
-import util.common;
-import util.common.span;
-import util.common.spanned;
-import util.common.new_str_hash;
-import util.common.new_def_hash;
-import util.common.uistr;
-import util.common.elt_exprs;
-import util.common.field_exprs;
-import util.common.log_expr;
-import util.common.log_expr_err;
-import util.common.log_stmt;
-import util.common.log_block;
-import util.common.log_stmt_err;
-import util.common.log_fn_err;
-import util.common.log_fn;
-import util.common.log_block_err;
-import util.common.has_nonlocal_exits;
-import util.common.decl_lhs;
-import util.typestate_ann;
-import util.typestate_ann.ts_ann;
-import util.typestate_ann.empty_pre_post;
-import util.typestate_ann.empty_poststate;
-import util.typestate_ann.true_precond;
-import util.typestate_ann.true_postcond;
-import util.typestate_ann.false_postcond;
-import util.typestate_ann.postcond;
-import util.typestate_ann.precond;
-import util.typestate_ann.poststate;
-import util.typestate_ann.prestate;
-import util.typestate_ann.pre_and_post;
-import util.typestate_ann.get_pre;
-import util.typestate_ann.get_post;
-import util.typestate_ann.ann_precond;
-import util.typestate_ann.ann_prestate;
-import util.typestate_ann.set_precondition;
-import util.typestate_ann.set_postcondition;
-import util.typestate_ann.set_prestate;
-import util.typestate_ann.set_poststate;
-import util.typestate_ann.set_in_postcond;
-import util.typestate_ann.set_in_poststate;
-import util.typestate_ann.implies;
-import util.typestate_ann.pre_and_post_state;
-import util.typestate_ann.empty_states;
-import util.typestate_ann.empty_prestate;
-import util.typestate_ann.empty_ann;
-import util.typestate_ann.extend_prestate;
-import util.typestate_ann.extend_poststate;
-import util.typestate_ann.relax_prestate;
-import util.typestate_ann.intersect;
-import util.typestate_ann.pp_clone;
-import util.typestate_ann.clone;
-
-import middle.ty;
-import middle.ty.ann_to_type;
-import middle.ty.arg;
-import middle.ty.expr_ann;
-import middle.ty.ty_to_str;
-
-import pretty.pprust.print_block;
-import pretty.pprust.print_expr;
-import pretty.pprust.print_decl;
-import pretty.pp.mkstate;
-import std.IO.stdout;
-import std.IO.str_writer;
-import std.IO.string_writer;
-import std.Vec.map;
-import std.Vec;
-import std.Vec.len;
-import std.Vec.pop;
-import std.Vec.push;
-import std.Vec.slice;
-import std.Vec.unzip;
-import std.Vec.plus_option;
-import std.Vec.cat_options;
-import std.Option;
-import std.Option.t;
-import std.Option.some;
-import std.Option.none;
-import std.Option.from_maybe;
-import std.Option.maybe;
-import std.Option.is_none;
-import std.Option.get;
-import std.Map.hashmap;
-import std.List;
-import std.List.list;
-import std.List.cons;
-import std.List.nil;
-import std.List.foldl;
-import std.List.find;
-import std.UInt;
-import std.BitV;
-import std.Util.fst;
-import std.Util.snd;
-
-import util.typestate_ann;
-import util.typestate_ann.difference;
-import util.typestate_ann.union;
-import util.typestate_ann.pps_len;
-import util.typestate_ann.require_and_preserve;
-
-import resolve.def_map;
+import front::ast;
+import front::ast::ann;
+import front::ast::method;
+import front::ast::ty;
+import front::ast::mutability;
+import front::ast::item;
+import front::ast::block;
+import front::ast::block_;
+import front::ast::obj_field;
+import front::ast::decl;
+import front::ast::arm;
+import front::ast::stmt;
+import front::ast::stmt_;
+import front::ast::stmt_decl;
+import front::ast::stmt_expr;
+import front::ast::stmt_crate_directive;
+import front::ast::decl_local;
+import front::ast::decl_item;
+import front::ast::ident;
+import front::ast::def_id;
+import front::ast::ann;
+import front::ast::field;
+import front::ast::expr;
+import front::ast::expr_call;
+import front::ast::expr_vec;
+import front::ast::expr_tup;
+import front::ast::expr_path;
+import front::ast::expr_field;
+import front::ast::expr_index;
+import front::ast::expr_log;
+import front::ast::expr_block;
+import front::ast::expr_rec;
+import front::ast::expr_if;
+import front::ast::expr_binary;
+import front::ast::expr_unary;
+import front::ast::expr_assign;
+import front::ast::expr_assign_op;
+import front::ast::expr_while;
+import front::ast::expr_do_while;
+import front::ast::expr_alt;
+import front::ast::expr_lit;
+import front::ast::expr_ret;
+import front::ast::expr_self_method;
+import front::ast::expr_bind;
+import front::ast::expr_spawn;
+import front::ast::expr_ext;
+import front::ast::expr_fail;
+import front::ast::expr_break;
+import front::ast::expr_cont;
+import front::ast::expr_send;
+import front::ast::expr_recv;
+import front::ast::expr_put;
+import front::ast::expr_port;
+import front::ast::expr_chan;
+import front::ast::expr_be;
+import front::ast::expr_check;
+import front::ast::expr_assert;
+import front::ast::expr_cast;
+import front::ast::expr_for;
+import front::ast::expr_for_each;
+import front::ast::path;
+import front::ast::elt;
+import front::ast::crate_directive;
+import front::ast::fn_decl;
+import front::ast::_obj;
+import front::ast::native_mod;
+import front::ast::variant;
+import front::ast::ty_param;
+import front::ast::ty;
+import front::ast::proto;
+import front::ast::pat;
+import front::ast::binop;
+import front::ast::unop;
+import front::ast::def;
+import front::ast::lit;
+import front::ast::init_op;
+import front::ast::initializer;
+import front::ast::local;
+import front::ast::_fn;
+import front::ast::ann_none;
+import front::ast::ann_type;
+import front::ast::_obj;
+import front::ast::_mod;
+import front::ast::crate;
+import front::ast::item_fn;
+import front::ast::item_obj;
+import front::ast::def_local;
+
+import middle::fold;
+import middle::fold::respan;
+import driver::session;
+import util::common;
+import util::common::span;
+import util::common::spanned;
+import util::common::new_str_hash;
+import util::common::new_def_hash;
+import util::common::uistr;
+import util::common::elt_exprs;
+import util::common::field_exprs;
+import util::common::log_expr;
+import util::common::log_expr_err;
+import util::common::log_stmt;
+import util::common::log_block;
+import util::common::log_stmt_err;
+import util::common::log_fn_err;
+import util::common::log_fn;
+import util::common::log_block_err;
+import util::common::has_nonlocal_exits;
+import util::common::decl_lhs;
+import util::typestate_ann;
+import util::typestate_ann::ts_ann;
+import util::typestate_ann::empty_pre_post;
+import util::typestate_ann::empty_poststate;
+import util::typestate_ann::true_precond;
+import util::typestate_ann::true_postcond;
+import util::typestate_ann::false_postcond;
+import util::typestate_ann::postcond;
+import util::typestate_ann::precond;
+import util::typestate_ann::poststate;
+import util::typestate_ann::prestate;
+import util::typestate_ann::pre_and_post;
+import util::typestate_ann::get_pre;
+import util::typestate_ann::get_post;
+import util::typestate_ann::ann_precond;
+import util::typestate_ann::ann_prestate;
+import util::typestate_ann::set_precondition;
+import util::typestate_ann::set_postcondition;
+import util::typestate_ann::set_prestate;
+import util::typestate_ann::set_poststate;
+import util::typestate_ann::set_in_postcond;
+import util::typestate_ann::set_in_poststate;
+import util::typestate_ann::implies;
+import util::typestate_ann::pre_and_post_state;
+import util::typestate_ann::empty_states;
+import util::typestate_ann::empty_prestate;
+import util::typestate_ann::empty_ann;
+import util::typestate_ann::extend_prestate;
+import util::typestate_ann::extend_poststate;
+import util::typestate_ann::relax_prestate;
+import util::typestate_ann::intersect;
+import util::typestate_ann::pp_clone;
+import util::typestate_ann::clone;
+
+import middle::ty;
+import middle::ty::ann_to_type;
+import middle::ty::arg;
+import middle::ty::expr_ann;
+import middle::ty::ty_to_str;
+
+import pretty::pprust::print_block;
+import pretty::pprust::print_expr;
+import pretty::pprust::print_decl;
+import pretty::pp::mkstate;
+import std::io::stdout;
+import std::io::str_writer;
+import std::io::string_writer;
+import std::_vec::map;
+import std::_vec;
+import std::_vec::len;
+import std::_vec::pop;
+import std::_vec::push;
+import std::_vec::slice;
+import std::_vec::unzip;
+import std::_vec::plus_option;
+import std::_vec::cat_options;
+import std::option;
+import std::option::t;
+import std::option::some;
+import std::option::none;
+import std::option::from_maybe;
+import std::option::maybe;
+import std::option::is_none;
+import std::option::get;
+import std::map::hashmap;
+import std::list;
+import std::list::list;
+import std::list::cons;
+import std::list::nil;
+import std::list::foldl;
+import std::list::find;
+import std::_uint;
+import std::bitv;
+import std::util::fst;
+import std::util::snd;
+
+import util::typestate_ann;
+import util::typestate_ann::difference;
+import util::typestate_ann::union;
+import util::typestate_ann::pps_len;
+import util::typestate_ann::require_and_preserve;
+
+import resolve::def_map;
/**** debugging junk ****/
-fn bitv_to_str(fn_info enclosing, BitV.t v) -> str {
+fn bitv_to_str(fn_info enclosing, bitv::t v) -> str {
auto s = "";
for each (@tup(def_id, tup(uint, ident)) p in enclosing.items()) {
- if (BitV.get(v, p._1._0)) {
+ if (bitv::get(v, p._1._0)) {
s += " " + p._1._1 + " ";
}
}
ret s;
}
-fn log_bitv(fn_info enclosing, BitV.t v) {
+fn log_bitv(fn_info enclosing, bitv::t v) {
log(bitv_to_str(enclosing, v));
}
-fn log_bitv_err(fn_info enclosing, BitV.t v) {
+fn log_bitv_err(fn_info enclosing, bitv::t v) {
log_err(bitv_to_str(enclosing, v));
}
@@ -233,8 +233,8 @@ fn log_cond_err(vec[uint] v) -> () {
}
fn log_pp(&pre_and_post pp) -> () {
- auto p1 = BitV.to_vec(pp.precondition);
- auto p2 = BitV.to_vec(pp.postcondition);
+ auto p1 = bitv::to_vec(pp.precondition);
+ auto p2 = bitv::to_vec(pp.postcondition);
log("pre:");
log_cond(p1);
log("post:");
@@ -242,8 +242,8 @@ fn log_pp(&pre_and_post pp) -> () {
}
fn log_pp_err(&pre_and_post pp) -> () {
- auto p1 = BitV.to_vec(pp.precondition);
- auto p2 = BitV.to_vec(pp.postcondition);
+ auto p1 = bitv::to_vec(pp.precondition);
+ auto p2 = bitv::to_vec(pp.postcondition);
log_err("pre:");
log_cond_err(p1);
log_err("post:");
@@ -251,8 +251,8 @@ fn log_pp_err(&pre_and_post pp) -> () {
}
fn log_states(&pre_and_post_state pp) -> () {
- auto p1 = BitV.to_vec(pp.prestate);
- auto p2 = BitV.to_vec(pp.poststate);
+ auto p1 = bitv::to_vec(pp.prestate);
+ auto p2 = bitv::to_vec(pp.poststate);
log("prestate:");
log_cond(p1);
log("poststate:");
@@ -260,8 +260,8 @@ fn log_states(&pre_and_post_state pp) -> () {
}
fn log_states_err(&pre_and_post_state pp) -> () {
- auto p1 = BitV.to_vec(pp.prestate);
- auto p2 = BitV.to_vec(pp.poststate);
+ auto p1 = bitv::to_vec(pp.prestate);
+ auto p2 = bitv::to_vec(pp.poststate);
log_err("prestate:");
log_cond_err(p1);
log_err("poststate:");
@@ -286,9 +286,9 @@ fn print_idents(vec[ident] idents) -> () {
variable in a given function) to bit number
(also remembers the ident for error-logging purposes) */
type var_info = tup(uint, ident);
-type fn_info = std.Map.hashmap[def_id, var_info];
+type fn_info = std::map::hashmap[def_id, var_info];
/* mapping from function name to fn_info map */
-type fn_info_map = std.Map.hashmap[def_id, fn_info];
+type fn_info_map = std::map::hashmap[def_id, fn_info];
fn bit_num(def_id v, fn_info m) -> uint {
assert (m.contains_key(v));
@@ -307,25 +307,25 @@ fn num_locals(fn_info m) -> uint {
ret m.size();
}
-fn collect_local(&@vec[tup(ident, def_id)] vars, &span sp, &@ast.local loc)
+fn collect_local(&@vec[tup(ident, def_id)] vars, &span sp, &@ast::local loc)
-> @decl {
log("collect_local: pushing " + loc.ident);
- Vec.push[tup(ident, def_id)](*vars, tup(loc.ident, loc.id));
+ _vec::push[tup(ident, def_id)](*vars, tup(loc.ident, loc.id));
ret @respan(sp, decl_local(loc));
}
fn find_locals(_fn f) -> @vec[tup(ident,def_id)] {
- auto res = @Vec.alloc[tup(ident,def_id)](0u);
+ auto res = @_vec::alloc[tup(ident,def_id)](0u);
- auto fld = fold.new_identity_fold[@vec[tup(ident, def_id)]]();
+ auto fld = fold::new_identity_fold[@vec[tup(ident, def_id)]]();
fld = @rec(fold_decl_local = bind collect_local(_,_,_) with *fld);
- auto ignore = fold.fold_fn[@vec[tup(ident, def_id)]](res, fld, f);
+ auto ignore = fold::fold_fn[@vec[tup(ident, def_id)]](res, fld, f);
ret res;
}
fn add_var(def_id v, ident nm, uint next, fn_info tbl) -> uint {
- log(nm + " |-> " + util.common.uistr(next));
+ log(nm + " |-> " + util::common::uistr(next));
tbl.insert(v, tup(next,nm));
ret (next + 1u);
}
@@ -335,13 +335,13 @@ fn add_var(def_id v, ident nm, uint next, fn_info tbl) -> uint {
fn mk_fn_info(_fn f) -> fn_info {
auto res = new_def_hash[var_info]();
let uint next = 0u;
- let vec[ast.arg] f_args = f.decl.inputs;
+ let vec[ast::arg] f_args = f.decl.inputs;
/* ignore args, which we know are initialized;
just collect locally declared vars */
let @vec[tup(ident,def_id)] locals = find_locals(f);
- log(uistr(Vec.len[tup(ident, def_id)](*locals)) + " locals");
+ log(uistr(_vec::len[tup(ident, def_id)](*locals)) + " locals");
for (tup(ident,def_id) p in *locals) {
next = add_var(p._1, p._0, next, res);
}
@@ -351,8 +351,8 @@ fn mk_fn_info(_fn f) -> fn_info {
/* extends mk_fn_info to a function item, side-effecting the map fi from
function IDs to fn_info maps */
-fn mk_fn_info_item_fn(&fn_info_map fi, &span sp, &ident i, &ast._fn f,
- &vec[ast.ty_param] ty_params, &def_id id, &ann a) -> @item {
+fn mk_fn_info_item_fn(&fn_info_map fi, &span sp, &ident i, &ast::_fn f,
+ &vec[ast::ty_param] ty_params, &def_id id, &ann a) -> @item {
fi.insert(id, mk_fn_info(f));
log(i + " has " + uistr(num_locals(mk_fn_info(f))) + " local vars");
ret @respan(sp, item_fn(i, f, ty_params, id, a));
@@ -360,10 +360,10 @@ fn mk_fn_info_item_fn(&fn_info_map fi, &span sp, &ident i, &ast._fn f,
/* extends mk_fn_info to an obj item, side-effecting the map fi from
function IDs to fn_info maps */
-fn mk_fn_info_item_obj(&fn_info_map fi, &span sp, &ident i, &ast._obj o,
- &vec[ast.ty_param] ty_params,
- &ast.obj_def_ids odid, &ann a) -> @item {
- auto all_methods = Vec.clone[@method](o.methods);
+fn mk_fn_info_item_obj(&fn_info_map fi, &span sp, &ident i, &ast::_obj o,
+ &vec[ast::ty_param] ty_params,
+ &ast::obj_def_ids odid, &ann a) -> @item {
+ auto all_methods = _vec::clone[@method](o.methods);
plus_option[@method](all_methods, o.dtor);
for (@method m in all_methods) {
fi.insert(m.node.id, mk_fn_info(m.node.meth));
@@ -376,14 +376,14 @@ fn mk_fn_info_item_obj(&fn_info_map fi, &span sp, &ident i, &ast._obj o,
/* initializes the global fn_info_map (mapping each function ID, including
nested locally defined functions, onto a mapping from local variable name
to bit number) */
-fn mk_f_to_fn_info(@ast.crate c) -> fn_info_map {
+fn mk_f_to_fn_info(@ast::crate c) -> fn_info_map {
auto res = new_def_hash[fn_info]();
- auto fld = fold.new_identity_fold[fn_info_map]();
+ auto fld = fold::new_identity_fold[fn_info_map]();
fld = @rec(fold_item_fn = bind mk_fn_info_item_fn(_,_,_,_,_,_,_),
fold_item_obj = bind mk_fn_info_item_obj(_,_,_,_,_,_,_)
with *fld);
- fold.fold_crate[fn_info_map](res, fld, c);
+ fold::fold_crate[fn_info_map](res, fld, c);
ret res;
}
@@ -402,7 +402,7 @@ fn ann_to_ts_ann(ann a, uint nv) -> ts_ann {
}
}
-fn ann_to_ts_ann_fail(ann a) -> Option.t[@ts_ann] {
+fn ann_to_ts_ann_fail(ann a) -> option::t[@ts_ann] {
alt (a) {
case (ann_none(_)) {
log("ann_to_ts_ann_fail: didn't expect ann_none here");
@@ -431,7 +431,7 @@ fn ann_to_poststate(ann a) -> poststate {
ret (ann_to_ts_ann_fail_more(a)).states.poststate;
}
-fn stmt_to_ann(&stmt s) -> Option.t[@ts_ann] {
+fn stmt_to_ann(&stmt s) -> option::t[@ts_ann] {
alt (s.node) {
case (stmt_decl(_,?a)) {
ret ann_to_ts_ann_fail(a);
@@ -651,7 +651,7 @@ fn seq_preconds(fn_info enclosing, vec[pre_and_post] pps) -> precond {
/* works on either postconds or preconds
should probably rethink the whole type synonym situation */
fn union_postconds_go(&postcond first, &vec[postcond] rest) -> postcond {
- auto sz = Vec.len[postcond](rest);
+ auto sz = _vec::len[postcond](rest);
if (sz > 0u) {
auto other = rest.(0);
@@ -664,7 +664,7 @@ fn union_postconds_go(&postcond first, &vec[postcond] rest) -> postcond {
fn union_postconds(uint nv, &vec[postcond] pcs) -> postcond {
if (len[postcond](pcs) > 0u) {
- ret union_postconds_go(BitV.clone(pcs.(0)), pcs);
+ ret union_postconds_go(bitv::clone(pcs.(0)), pcs);
}
else {
ret empty_prestate(nv);
@@ -673,7 +673,7 @@ fn union_postconds(uint nv, &vec[postcond] pcs) -> postcond {
/* Gee, maybe we could use foldl or something */
fn intersect_postconds_go(&postcond first, &vec[postcond] rest) -> postcond {
- auto sz = Vec.len[postcond](rest);
+ auto sz = _vec::len[postcond](rest);
if (sz > 0u) {
auto other = rest.(0);
@@ -688,7 +688,7 @@ fn intersect_postconds_go(&postcond first, &vec[postcond] rest) -> postcond {
fn intersect_postconds(&vec[postcond] pcs) -> postcond {
assert (len[postcond](pcs) > 0u);
- ret intersect_postconds_go(BitV.clone(pcs.(0)), pcs);
+ ret intersect_postconds_go(bitv::clone(pcs.(0)), pcs);
}
/******* AST-traversing code ********/
@@ -719,8 +719,8 @@ fn find_pre_post_obj(&def_map dm, &fn_info_map fm, _obj o) -> () {
find_pre_post_fn(dm, fm, fm.get(m.node.id), m.node.meth);
}
auto f = bind do_a_method(dm, fm, _);
- Vec.map[@method, ()](f, o.methods);
- Option.map[@method, ()](f, o.dtor);
+ _vec::map[@method, ()](f, o.methods);
+ option::map[@method, ()](f, o.dtor);
}
fn find_pre_post_state_obj(&def_map dm, &fn_info_map fm, _obj o) -> bool {
@@ -729,8 +729,8 @@ fn find_pre_post_state_obj(&def_map dm, &fn_info_map fm, _obj o) -> bool {
ret find_pre_post_state_fn(dm, fm, fm.get(m.node.id), m.node.meth);
}
auto f = bind do_a_method(dm, fm, _);
- auto flags = Vec.map[@method, bool](f, o.methods);
- auto changed = Vec.or(flags);
+ auto flags = _vec::map[@method, bool](f, o.methods);
+ auto changed = _vec::or(flags);
changed = changed || maybe[@method, bool](false, f, o.dtor);
ret changed;
}
@@ -738,26 +738,26 @@ fn find_pre_post_state_obj(&def_map dm, &fn_info_map fm, _obj o) -> bool {
fn find_pre_post_item(&def_map dm, &fn_info_map fm, &fn_info enclosing,
&item i) -> () {
alt (i.node) {
- case (ast.item_const(?id, ?t, ?e, ?di, ?a)) {
+ case (ast::item_const(?id, ?t, ?e, ?di, ?a)) {
find_pre_post_expr(dm, fm, enclosing, e);
}
- case (ast.item_fn(?id, ?f, ?ps, ?di, ?a)) {
+ case (ast::item_fn(?id, ?f, ?ps, ?di, ?a)) {
assert (fm.contains_key(di));
find_pre_post_fn(dm, fm, fm.get(di), f);
}
- case (ast.item_mod(?id, ?m, ?di)) {
+ case (ast::item_mod(?id, ?m, ?di)) {
find_pre_post_mod(m);
}
- case (ast.item_native_mod(?id, ?nm, ?di)) {
+ case (ast::item_native_mod(?id, ?nm, ?di)) {
find_pre_post_native_mod(nm);
}
- case (ast.item_ty(_,_,_,_,_)) {
+ case (ast::item_ty(_,_,_,_,_)) {
ret;
}
- case (ast.item_tag(_,_,_,_,_)) {
+ case (ast::item_tag(_,_,_,_,_)) {
ret;
}
- case (ast.item_obj(?id, ?o, ?ps, ?di, ?a)) {
+ case (ast::item_obj(?id, ?o, ?ps, ?di, ?a)) {
find_pre_post_obj(dm, fm, o);
}
}
@@ -777,19 +777,19 @@ fn find_pre_post_exprs(&def_map dm, &fn_info_map fm, &fn_info enclosing,
}
auto f = bind do_one(dm, fm, enclosing, _);
- Vec.map[@expr, ()](f, args);
+ _vec::map[@expr, ()](f, args);
fn get_pp(&@expr e) -> pre_and_post {
ret expr_pp(e);
}
auto g = get_pp;
- auto pps = Vec.map[@expr, pre_and_post](g, args);
+ auto pps = _vec::map[@expr, pre_and_post](g, args);
auto h = get_post;
set_pre_and_post(a,
rec(precondition=seq_preconds(enclosing, pps),
postcondition=union_postconds
- (nv, (Vec.map[pre_and_post, postcond](h, pps)))));
+ (nv, (_vec::map[pre_and_post, postcond](h, pps)))));
}
fn find_pre_post_loop(&def_map dm, &fn_info_map fm, &fn_info enclosing,
@@ -816,13 +816,13 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
alt (e.node) {
case (expr_call(?operator, ?operands, ?a)) {
- auto args = Vec.clone[@expr](operands);
- Vec.push[@expr](args, operator);
+ auto args = _vec::clone[@expr](operands);
+ _vec::push[@expr](args, operator);
find_pre_post_exprs(dm, fm, enclosing, args, a);
}
case (expr_spawn(_, _, ?operator, ?operands, ?a)) {
- auto args = Vec.clone[@expr](operands);
- Vec.push[@expr](args, operator);
+ auto args = _vec::clone[@expr](operands);
+ _vec::push[@expr](args, operator);
find_pre_post_exprs(dm, fm, enclosing, args, a);
}
case (expr_vec(?args, _, ?a)) {
@@ -834,7 +834,7 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
case (expr_path(?p, ?a)) {
auto res = empty_pre_post(num_local_vars);
- alt (dm.get(ast.ann_tag(a))) {
+ alt (dm.get(ast::ann_tag(a))) {
case (def_local(?d_id)) {
auto i = bit_num(d_id, enclosing);
require_and_preserve(i, res);
@@ -875,13 +875,13 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
}
case (expr_rec(?fields,?maybe_base,?a)) {
auto es = field_exprs(fields);
- Vec.plus_option[@expr](es, maybe_base);
+ _vec::plus_option[@expr](es, maybe_base);
find_pre_post_exprs(dm, fm, enclosing, es, a);
}
case (expr_assign(?lhs, ?rhs, ?a)) {
alt (lhs.node) {
case (expr_path(?p, ?a_lhs)) {
- alt (dm.get(ast.ann_tag(a_lhs))) {
+ alt (dm.get(ast::ann_tag(a_lhs))) {
case (def_local(?d_id)) {
find_pre_post_expr(dm, fm, enclosing, rhs);
set_pre_and_post(a, expr_pp(rhs));
@@ -902,7 +902,7 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
case (expr_recv(?lhs, ?rhs, ?a)) {
alt (lhs.node) {
case (expr_path(?p, ?a_lhs)) {
- alt (dm.get(ast.ann_tag(a_lhs))) {
+ alt (dm.get(ast::ann_tag(a_lhs))) {
case (def_local(?d_id)) {
find_pre_post_expr(dm, fm, enclosing, rhs);
set_pre_and_post(a, expr_pp(rhs));
@@ -1048,7 +1048,7 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
ret block_pp(an_alt.block);
}
auto f = bind do_an_alt(dm, fm, enclosing, _);
- auto alt_pps = Vec.map[arm, pre_and_post](f, alts);
+ auto alt_pps = _vec::map[arm, pre_and_post](f, alts);
fn combine_pp(pre_and_post antec,
fn_info enclosing, &pre_and_post pp,
&pre_and_post next) -> pre_and_post {
@@ -1062,7 +1062,7 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
postcondition=false_postcond(num_local_vars));
auto g = bind combine_pp(antec_pp, enclosing, _, _);
- auto alts_overall_pp = Vec.foldl[pre_and_post, pre_and_post]
+ auto alts_overall_pp = _vec::foldl[pre_and_post, pre_and_post]
(g, e_pp, alt_pps);
set_pre_and_post(a, alts_overall_pp);
@@ -1088,8 +1088,8 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
set_pre_and_post(a, expr_pp(p));
}
case(expr_bind(?operator, ?maybe_args, ?a)) {
- auto args = Vec.cat_options[@expr](maybe_args);
- Vec.push[@expr](args, operator); /* ??? order of eval? */
+ auto args = _vec::cat_options[@expr](maybe_args);
+ _vec::push[@expr](args, operator); /* ??? order of eval? */
find_pre_post_exprs(dm, fm, enclosing, args, a);
}
case (expr_break(?a)) {
@@ -1131,17 +1131,17 @@ fn gen_poststate(&fn_info enclosing, &ann a, def_id id) -> bool {
}
fn find_pre_post_stmt(&def_map dm, fn_info_map fm, &fn_info enclosing,
- &ast.stmt s) -> () {
+ &ast::stmt s) -> () {
log("stmt =");
log_stmt(s);
auto num_local_vars = num_locals(enclosing);
alt(s.node) {
- case(ast.stmt_decl(?adecl, ?a)) {
+ case(ast::stmt_decl(?adecl, ?a)) {
alt(adecl.node) {
- case(ast.decl_local(?alocal)) {
+ case(ast::decl_local(?alocal)) {
alt(alocal.init) {
- case(some[ast.initializer](?an_init)) {
+ case(some[ast::initializer](?an_init)) {
find_pre_post_expr(dm, fm, enclosing, an_init.expr);
auto rhs_pp = expr_pp(an_init.expr);
set_pre_and_post(alocal.ann, rhs_pp);
@@ -1157,7 +1157,7 @@ fn find_pre_post_stmt(&def_map dm, fn_info_map fm, &fn_info enclosing,
log_err("pp = ");
log_pp(stmt_pp(s)); */
}
- case(none[ast.initializer]) {
+ case(none[ast::initializer]) {
auto pp = empty_pre_post(num_local_vars);
set_pre_and_post(alocal.ann, pp);
set_pre_and_post(a, pp);
@@ -1207,12 +1207,12 @@ fn find_pre_post_block(&def_map dm, &fn_info_map fm, &fn_info enclosing,
}
auto do_one = bind do_one_(dm, fm, enclosing, _);
- Vec.map[@stmt, ()](do_one, b.node.stmts);
+ _vec::map[@stmt, ()](do_one, b.node.stmts);
fn do_inner_(def_map dm, fn_info_map fm, fn_info i, &@expr e) -> () {
find_pre_post_expr(dm, fm, i, e);
}
auto do_inner = bind do_inner_(dm, fm, enclosing, _);
- Option.map[@expr, ()](do_inner, b.node.expr);
+ option::map[@expr, ()](do_inner, b.node.expr);
let vec[pre_and_post] pps = vec();
@@ -1220,20 +1220,20 @@ fn find_pre_post_block(&def_map dm, &fn_info_map fm, &fn_info enclosing,
ret stmt_pp(*s);
}
auto f = get_pp_stmt;
- pps += Vec.map[@stmt, pre_and_post](f, b.node.stmts);
+ pps += _vec::map[@stmt, pre_and_post](f, b.node.stmts);
fn get_pp_expr(&@expr e) -> pre_and_post {
ret expr_pp(e);
}
auto g = get_pp_expr;
plus_option[pre_and_post](pps,
- Option.map[@expr, pre_and_post](g, b.node.expr));
+ option::map[@expr, pre_and_post](g, b.node.expr));
auto block_precond = seq_preconds(enclosing, pps);
auto h = get_post;
- auto postconds = Vec.map[pre_and_post, postcond](h, pps);
+ auto postconds = _vec::map[pre_and_post, postcond](h, pps);
/* A block may be empty, so this next line ensures that the postconds
vector is non-empty. */
- Vec.push[postcond](postconds, block_precond);
+ _vec::push[postcond](postconds, block_precond);
auto block_postcond = empty_poststate(nv);
/* conservative approximation */
if (! has_nonlocal_exits(b)) {
@@ -1248,8 +1248,8 @@ fn find_pre_post_fn(&def_map dm, &fn_info_map fm, &fn_info fi, &_fn f) -> () {
find_pre_post_block(dm, fm, fi, f.body);
}
-fn check_item_fn(&def_map dm, &fn_info_map fm, &span sp, &ident i, &ast._fn f,
- &vec[ast.ty_param] ty_params,
+fn check_item_fn(&def_map dm, &fn_info_map fm, &span sp, &ident i,
+ &ast::_fn f, &vec[ast::ty_param] ty_params,
&def_id id, &ann a) -> @item {
log("check_item_fn:");
@@ -1258,33 +1258,33 @@ fn check_item_fn(&def_map dm, &fn_info_map fm, &span sp, &ident i, &ast._fn f,
assert (fm.contains_key(id));
find_pre_post_fn(dm, fm, fm.get(id), f);
- ret @respan(sp, ast.item_fn(i, f, ty_params, id, a));
+ ret @respan(sp, ast::item_fn(i, f, ty_params, id, a));
}
fn find_pre_post_state_item(&def_map dm, &fn_info_map fm, &fn_info enclosing,
@item i) -> bool {
alt (i.node) {
- case (ast.item_const(?id, ?t, ?e, ?di, ?a)) {
+ case (ast::item_const(?id, ?t, ?e, ?di, ?a)) {
ret find_pre_post_state_expr(dm, fm, enclosing,
empty_prestate(num_locals(enclosing)), e);
}
- case (ast.item_fn(?id, ?f, ?ps, ?di, ?a)) {
+ case (ast::item_fn(?id, ?f, ?ps, ?di, ?a)) {
assert (fm.contains_key(di));
ret find_pre_post_state_fn(dm, fm, fm.get(di), f);
}
- case (ast.item_mod(?id, ?m, ?di)) {
+ case (ast::item_mod(?id, ?m, ?di)) {
ret find_pre_post_state_mod(m);
}
- case (ast.item_native_mod(?id, ?nm, ?di)) {
+ case (ast::item_native_mod(?id, ?nm, ?di)) {
ret find_pre_post_state_native_mod(nm);
}
- case (ast.item_ty(_,_,_,_,_)) {
+ case (ast::item_ty(_,_,_,_,_)) {
ret false;
}
- case (ast.item_tag(_,_,_,_,_)) {
+ case (ast::item_tag(_,_,_,_,_)) {
ret false;
}
- case (ast.item_obj(?id, ?o, ?ps, ?di, ?a)) {
+ case (ast::item_obj(?id, ?o, ?ps, ?di, ?a)) {
ret find_pre_post_state_obj(dm, fm, o);
}
}
@@ -1518,7 +1518,7 @@ fn find_pre_post_state_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
alt (lhs.node) {
case (expr_path(_, ?a_lhs)) {
- alt (dm.get(ast.ann_tag(a_lhs))) {
+ alt (dm.get(ast::ann_tag(a_lhs))) {
case (def_local(?d_id)) {
// assignment to local var
changed = pure_exp(a_lhs, pres) || changed;
@@ -1546,7 +1546,7 @@ fn find_pre_post_state_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
alt (lhs.node) {
case (expr_path(?p, ?a_lhs)) {
- alt (dm.get(ast.ann_tag(a_lhs))) {
+ alt (dm.get(ast::ann_tag(a_lhs))) {
case (def_local(?d_id)) {
// receive to local var
changed = pure_exp(a_lhs, pres) || changed;
@@ -1708,7 +1708,7 @@ fn find_pre_post_state_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
|| changed;
auto e_post = expr_poststate(e);
auto a_post;
- if (Vec.len[arm](alts) > 0u) {
+ if (_vec::len[arm](alts) > 0u) {
a_post = false_postcond(num_local_vars);
for (arm an_alt in alts) {
changed = find_pre_post_state_block(dm, fm, enclosing, e_post,
@@ -1788,18 +1788,18 @@ fn find_pre_post_state_stmt(&def_map dm, &fn_info_map fm, &fn_info enclosing,
log("*At beginning: stmt = ");
log_stmt(*s);
log("*prestate = ");
- log(BitV.to_str(stmt_ann.states.prestate));
+ log(bitv::to_str(stmt_ann.states.prestate));
log("*poststate =");
- log(BitV.to_str(stmt_ann.states.poststate));
+ log(bitv::to_str(stmt_ann.states.poststate));
log("*changed =");
log(changed);
alt (s.node) {
case (stmt_decl(?adecl, ?a)) {
alt (adecl.node) {
- case (ast.decl_local(?alocal)) {
+ case (ast::decl_local(?alocal)) {
alt (alocal.init) {
- case (some[ast.initializer](?an_init)) {
+ case (some[ast::initializer](?an_init)) {
changed = extend_prestate(stmt_ann.states.prestate, pres)
|| changed;
changed = find_pre_post_state_expr
@@ -1811,7 +1811,7 @@ fn find_pre_post_state_stmt(&def_map dm, &fn_info_map fm, &fn_info enclosing,
log("Summary: stmt = ");
log_stmt(*s);
log("prestate = ");
- log(BitV.to_str(stmt_ann.states.prestate));
+ log(bitv::to_str(stmt_ann.states.prestate));
log_bitv(enclosing, stmt_ann.states.prestate);
log("poststate =");
log_bitv(enclosing, stmt_ann.states.poststate);
@@ -1820,7 +1820,7 @@ fn find_pre_post_state_stmt(&def_map dm, &fn_info_map fm, &fn_info enclosing,
ret changed;
}
- case (none[ast.initializer]) {
+ case (none[ast::initializer]) {
changed = extend_prestate(stmt_ann.states.prestate, pres)
|| changed;
changed = extend_poststate(stmt_ann.states.poststate, pres)
@@ -1829,7 +1829,7 @@ fn find_pre_post_state_stmt(&def_map dm, &fn_info_map fm, &fn_info enclosing,
}
}
}
- case (ast.decl_item(?an_item)) {
+ case (ast::decl_item(?an_item)) {
changed = extend_prestate(stmt_ann.states.prestate, pres)
|| changed;
changed = extend_poststate(stmt_ann.states.poststate, pres)
@@ -1850,10 +1850,10 @@ fn find_pre_post_state_stmt(&def_map dm, &fn_info_map fm, &fn_info enclosing,
log("Summary: stmt = ");
log_stmt(*s);
log("prestate = ");
- log(BitV.to_str(stmt_ann.states.prestate));
+ log(bitv::to_str(stmt_ann.states.prestate));
log_bitv(enclosing, stmt_ann.states.prestate);
log("poststate =");
- log(BitV.to_str(stmt_ann.states.poststate));
+ log(bitv::to_str(stmt_ann.states.poststate));
log_bitv(enclosing, stmt_ann.states.poststate);
log("changed =");
log(changed);
@@ -1926,7 +1926,7 @@ fn find_pre_post_state_block(&def_map dm, &fn_info_map fm, &fn_info enclosing,
}
fn find_pre_post_state_fn(&def_map dm, &fn_info_map f_info, &fn_info fi,
- &ast._fn f) -> bool {
+ &ast::_fn f) -> bool {
/* FIXME: where do we set args as being initialized?
What about for methods? */
auto num_local_vars = num_locals(fi);
@@ -1981,23 +1981,23 @@ fn check_states_stmt(fn_info enclosing, &stmt s) -> () {
}
}
-fn check_states_against_conditions(fn_info enclosing, &ast._fn f) -> () {
+fn check_states_against_conditions(fn_info enclosing, &ast::_fn f) -> () {
fn do_one_(fn_info i, &@stmt s) -> () {
check_states_stmt(i, *s);
}
auto do_one = bind do_one_(enclosing, _);
- Vec.map[@stmt, ()](do_one, f.body.node.stmts);
+ _vec::map[@stmt, ()](do_one, f.body.node.stmts);
fn do_inner_(fn_info i, &@expr e) -> () {
check_states_expr(i, e);
}
auto do_inner = bind do_inner_(enclosing, _);
- Option.map[@expr, ()](do_inner, f.body.node.expr);
+ option::map[@expr, ()](do_inner, f.body.node.expr);
}
fn check_fn_states(&def_map dm, &fn_info_map f_info_map, &fn_info f_info,
- &ast._fn f) -> () {
+ &ast::_fn f) -> () {
/* Compute the pre- and post-states for this function */
// (Fixpoint iteration)
while (find_pre_post_state_fn(dm, f_info_map, f_info, f)) {}
@@ -2008,7 +2008,7 @@ fn check_fn_states(&def_map dm, &fn_info_map f_info_map, &fn_info f_info,
}
fn check_item_fn_state(def_map dm, &fn_info_map f_info_map, &span sp,
- &ident i, &ast._fn f, &vec[ast.ty_param] ty_params,
+ &ident i, &ast::_fn f, &vec[ast::ty_param] ty_params,
&def_id id, &ann a) -> @item {
/* Look up the var-to-bit-num map for this function */
@@ -2018,7 +2018,7 @@ fn check_item_fn_state(def_map dm, &fn_info_map f_info_map, &span sp,
check_fn_states(dm, f_info_map, f_info, f);
/* Rebuild the same function */
- ret @respan(sp, ast.item_fn(i, f, ty_params, id, a));
+ ret @respan(sp, ast::item_fn(i, f, ty_params, id, a));
}
fn check_method_states(&def_map dm, &fn_info_map f_info_map, @method m) {
@@ -2029,13 +2029,13 @@ fn check_method_states(&def_map dm, &fn_info_map f_info_map, @method m) {
fn check_obj_state(def_map dm, &fn_info_map f_info_map,
&vec[obj_field] fields, &vec[@method] methods,
- &Option.t[@method] dtor) -> ast._obj {
+ &option::t[@method] dtor) -> ast::_obj {
fn one(def_map dm, fn_info_map fm, &@method m) -> () {
ret check_method_states(dm, fm, m);
}
auto f = bind one(dm, f_info_map,_);
- Vec.map[@method, ()](f, methods);
- Option.map[@method, ()](f, dtor);
+ _vec::map[@method, ()](f, methods);
+ option::map[@method, ()](f, dtor);
ret rec(fields=fields, methods=methods, dtor=dtor);
}
@@ -2079,34 +2079,34 @@ fn init_block(&fn_info fi, &span sp, &block_ b) -> block {
fail;
}
case (ann_type(_, ?t,?ps,_)) {
- auto fld0 = fold.new_identity_fold[fn_info]();
+ auto fld0 = fold::new_identity_fold[fn_info]();
fld0 = @rec(fold_ann = bind init_ann(_,_) with *fld0);
- ret fold.fold_block[fn_info](fi, fld0, respan(sp, b));
+ ret fold::fold_block[fn_info](fi, fld0, respan(sp, b));
}
}
}
-fn item_fn_anns(&fn_info_map fm, &span sp, ident i, &ast._fn f,
- vec[ast.ty_param] ty_params, def_id id, ann a) -> @item {
+fn item_fn_anns(&fn_info_map fm, &span sp, ident i, &ast::_fn f,
+ vec[ast::ty_param] ty_params, def_id id, ann a) -> @item {
assert (fm.contains_key(id));
auto f_info = fm.get(id);
log(i + " has " + uistr(num_locals(f_info)) + " local vars");
- auto fld0 = fold.new_identity_fold[fn_info]();
+ auto fld0 = fold::new_identity_fold[fn_info]();
fld0 = @rec(fold_ann = bind init_ann(_,_)
with *fld0);
- ret fold.fold_item[fn_info]
+ ret fold::fold_item[fn_info]
(f_info, fld0, @respan(sp, item_fn(i, f, ty_params, id, a)));
}
/* This is painstakingly written as an explicit recursion b/c the
- standard ast.fold doesn't traverse in the correct order:
+ standard ast::fold doesn't traverse in the correct order:
consider
fn foo() {
fn bar() {
@@ -2125,7 +2125,7 @@ fn annotate_exprs(&fn_info_map fm, &vec[@expr] es) -> vec[@expr] {
ret annotate_expr(fm, e);
}
auto f = bind one(fm,_);
- ret Vec.map[@expr, @expr](f, es);
+ ret _vec::map[@expr, @expr](f, es);
}
fn annotate_elts(&fn_info_map fm, &vec[elt] es) -> vec[elt] {
fn one(fn_info_map fm, &elt e) -> elt {
@@ -2133,7 +2133,7 @@ fn annotate_elts(&fn_info_map fm, &vec[elt] es) -> vec[elt] {
expr=annotate_expr(fm, e.expr));
}
auto f = bind one(fm,_);
- ret Vec.map[elt, elt](f, es);
+ ret _vec::map[elt, elt](f, es);
}
fn annotate_fields(&fn_info_map fm, &vec[field] fs) -> vec[field] {
fn one(fn_info_map fm, &field f) -> field {
@@ -2142,23 +2142,23 @@ fn annotate_fields(&fn_info_map fm, &vec[field] fs) -> vec[field] {
expr=annotate_expr(fm, f.expr));
}
auto f = bind one(fm,_);
- ret Vec.map[field, field](f, fs);
+ ret _vec::map[field, field](f, fs);
}
-fn annotate_option_exp(&fn_info_map fm, &Option.t[@expr] o)
- -> Option.t[@expr] {
+fn annotate_option_exp(&fn_info_map fm, &option::t[@expr] o)
+ -> option::t[@expr] {
fn one(fn_info_map fm, &@expr e) -> @expr {
ret annotate_expr(fm, e);
}
auto f = bind one(fm,_);
- ret Option.map[@expr, @expr](f, o);
+ ret option::map[@expr, @expr](f, o);
}
-fn annotate_option_exprs(&fn_info_map fm, &vec[Option.t[@expr]] es)
- -> vec[Option.t[@expr]] {
- fn one(fn_info_map fm, &Option.t[@expr] o) -> Option.t[@expr] {
+fn annotate_option_exprs(&fn_info_map fm, &vec[option::t[@expr]] es)
+ -> vec[option::t[@expr]] {
+ fn one(fn_info_map fm, &option::t[@expr] o) -> option::t[@expr] {
ret annotate_option_exp(fm, o);
}
auto f = bind one(fm,_);
- ret Vec.map[Option.t[@expr], Option.t[@expr]](f, es);
+ ret _vec::map[option::t[@expr], option::t[@expr]](f, es);
}
fn annotate_decl(&fn_info_map fm, &@decl d) -> @decl {
auto d1 = d.node;
@@ -2166,7 +2166,7 @@ fn annotate_decl(&fn_info_map fm, &@decl d) -> @decl {
case (decl_local(?l)) {
alt(l.init) {
case (some[initializer](?init)) {
- let Option.t[initializer] an_i =
+ let option::t[initializer] an_i =
some[initializer]
(rec(expr=annotate_expr(fm, init.expr)
with init));
@@ -2188,7 +2188,7 @@ fn annotate_alts(&fn_info_map fm, &vec[arm] alts) -> vec[arm] {
block=annotate_block(fm, a.block));
}
auto f = bind one(fm,_);
- ret Vec.map[arm, arm](f, alts);
+ ret _vec::map[arm, arm](f, alts);
}
fn annotate_expr(&fn_info_map fm, &@expr e) -> @expr {
@@ -2339,153 +2339,154 @@ fn annotate_block(&fn_info_map fm, &block b) -> block {
for (@stmt s in b.node.stmts) {
auto new_s = annotate_stmt(fm, s);
- Vec.push[@stmt](new_stmts, new_s);
+ _vec::push[@stmt](new_stmts, new_s);
}
fn ann_e(fn_info_map fm, &@expr e) -> @expr {
ret annotate_expr(fm, e);
}
auto f = bind ann_e(fm,_);
- auto new_e = Option.map[@expr, @expr](f, b.node.expr);
+ auto new_e = option::map[@expr, @expr](f, b.node.expr);
ret respan(b.span,
rec(stmts=new_stmts, expr=new_e with b.node));
}
-fn annotate_fn(&fn_info_map fm, &ast._fn f) -> ast._fn {
+fn annotate_fn(&fn_info_map fm, &ast::_fn f) -> ast::_fn {
// subexps have *already* been annotated based on
// f's number-of-locals
ret rec(body=annotate_block(fm, f.body) with f);
}
-fn annotate_mod(&fn_info_map fm, &ast._mod m) -> ast._mod {
+fn annotate_mod(&fn_info_map fm, &ast::_mod m) -> ast::_mod {
let vec[@item] new_items = vec();
for (@item i in m.items) {
auto new_i = annotate_item(fm, i);
- Vec.push[@item](new_items, new_i);
+ _vec::push[@item](new_items, new_i);
}
ret rec(items=new_items with m);
}
fn annotate_method(&fn_info_map fm, &@method m) -> @method {
auto f_info = get_fn_info(fm, m.node.id);
- auto fld0 = fold.new_identity_fold[fn_info]();
+ auto fld0 = fold::new_identity_fold[fn_info]();
fld0 = @rec(fold_ann = bind init_ann(_,_)
with *fld0);
- auto outer = fold.fold_method[fn_info](f_info, fld0, m);
+ auto outer = fold::fold_method[fn_info](f_info, fld0, m);
auto new_fn = annotate_fn(fm, outer.node.meth);
ret @respan(m.span,
rec(meth=new_fn with m.node));
}
-fn annotate_obj(&fn_info_map fm, &ast._obj o) -> ast._obj {
+fn annotate_obj(&fn_info_map fm, &ast::_obj o) -> ast::_obj {
fn one(fn_info_map fm, &@method m) -> @method {
ret annotate_method(fm, m);
}
auto f = bind one(fm,_);
- auto new_methods = Vec.map[@method, @method](f, o.methods);
- auto new_dtor = Option.map[@method, @method](f, o.dtor);
+ auto new_methods = _vec::map[@method, @method](f, o.methods);
+ auto new_dtor = option::map[@method, @method](f, o.dtor);
ret rec(methods=new_methods, dtor=new_dtor with o);
}
// Only annotates the components of the item recursively.
-fn annotate_item_inner(&fn_info_map fm, &@ast.item item) -> @ast.item {
+fn annotate_item_inner(&fn_info_map fm, &@ast::item item) -> @ast::item {
alt (item.node) {
/* FIXME can't skip this case -- exprs contain blocks contain stmts,
which contain decls */
- case (ast.item_const(_,_,_,_,_)) {
+ case (ast::item_const(_,_,_,_,_)) {
// this has already been annotated by annotate_item
ret item;
}
- case (ast.item_fn(?ident, ?ff, ?tps, ?id, ?ann)) {
+ case (ast::item_fn(?ident, ?ff, ?tps, ?id, ?ann)) {
ret @respan(item.span,
- ast.item_fn(ident, annotate_fn(fm, ff), tps, id, ann));
+ ast::item_fn(ident, annotate_fn(fm, ff),
+ tps, id, ann));
}
- case (ast.item_mod(?ident, ?mm, ?id)) {
+ case (ast::item_mod(?ident, ?mm, ?id)) {
ret @respan(item.span,
- ast.item_mod(ident, annotate_mod(fm, mm), id));
+ ast::item_mod(ident, annotate_mod(fm, mm), id));
}
- case (ast.item_native_mod(?ident, ?mm, ?id)) {
+ case (ast::item_native_mod(?ident, ?mm, ?id)) {
ret item;
}
- case (ast.item_ty(_,_,_,_,_)) {
+ case (ast::item_ty(_,_,_,_,_)) {
ret item;
}
- case (ast.item_tag(_,_,_,_,_)) {
+ case (ast::item_tag(_,_,_,_,_)) {
ret item;
}
- case (ast.item_obj(?ident, ?ob, ?tps, ?odid, ?ann)) {
+ case (ast::item_obj(?ident, ?ob, ?tps, ?odid, ?ann)) {
ret @respan(item.span,
- ast.item_obj(ident, annotate_obj(fm, ob), tps, odid, ann));
+ ast::item_obj(ident, annotate_obj(fm, ob), tps, odid, ann));
}
}
}
-fn annotate_item(&fn_info_map fm, &@ast.item item) -> @ast.item {
+fn annotate_item(&fn_info_map fm, &@ast::item item) -> @ast::item {
// Using a fold, recursively set all anns in this item
// to be blank.
// *Then*, call annotate_item recursively to do the right
// thing for any nested items inside this one.
alt (item.node) {
- case (ast.item_const(_,_,_,_,_)) {
- auto fld0 = fold.new_identity_fold[()]();
+ case (ast::item_const(_,_,_,_,_)) {
+ auto fld0 = fold::new_identity_fold[()]();
fld0 = @rec(fold_ann = bind init_blank_ann(_,_)
with *fld0);
- ret fold.fold_item[()]((), fld0, item);
+ ret fold::fold_item[()]((), fld0, item);
}
- case (ast.item_fn(?i,?ff,?tps,?id,?ann)) {
+ case (ast::item_fn(?i,?ff,?tps,?id,?ann)) {
auto f_info = get_fn_info(fm, id);
- auto fld0 = fold.new_identity_fold[fn_info]();
+ auto fld0 = fold::new_identity_fold[fn_info]();
fld0 = @rec(fold_ann = bind init_ann(_,_)
with *fld0);
- auto outer = fold.fold_item[fn_info](f_info, fld0, item);
+ auto outer = fold::fold_item[fn_info](f_info, fld0, item);
// now recurse into any nested items
ret annotate_item_inner(fm, outer);
}
- case (ast.item_mod(?i, ?mm, ?id)) {
- auto fld0 = fold.new_identity_fold[()]();
+ case (ast::item_mod(?i, ?mm, ?id)) {
+ auto fld0 = fold::new_identity_fold[()]();
fld0 = @rec(fold_ann = bind init_blank_ann(_,_)
with *fld0);
- auto outer = fold.fold_item[()]((), fld0, item);
+ auto outer = fold::fold_item[()]((), fld0, item);
ret annotate_item_inner(fm, outer);
}
- case (ast.item_native_mod(?i, ?nm, ?id)) {
+ case (ast::item_native_mod(?i, ?nm, ?id)) {
ret item;
}
- case (ast.item_ty(_,_,_,_,_)) {
+ case (ast::item_ty(_,_,_,_,_)) {
ret item;
}
- case (ast.item_tag(_,_,_,_,_)) {
+ case (ast::item_tag(_,_,_,_,_)) {
ret item;
}
- case (ast.item_obj(?i,?ob,?tps,?odid,?ann)) {
- auto fld0 = fold.new_identity_fold[()]();
+ case (ast::item_obj(?i,?ob,?tps,?odid,?ann)) {
+ auto fld0 = fold::new_identity_fold[()]();
fld0 = @rec(fold_ann = bind init_blank_ann(_,_)
with *fld0);
- auto outer = fold.fold_item[()]((), fld0, item);
+ auto outer = fold::fold_item[()]((), fld0, item);
ret annotate_item_inner(fm, outer);
}
}
}
-fn annotate_module(&fn_info_map fm, &ast._mod module) -> ast._mod {
+fn annotate_module(&fn_info_map fm, &ast::_mod module) -> ast::_mod {
let vec[@item] new_items = vec();
for (@item i in module.items) {
auto new_item = annotate_item(fm, i);
- Vec.push[@item](new_items, new_item);
+ _vec::push[@item](new_items, new_item);
}
ret rec(items = new_items with module);
}
-fn annotate_crate(&fn_info_map fm, &@ast.crate crate) -> @ast.crate {
+fn annotate_crate(&fn_info_map fm, &@ast::crate crate) -> @ast::crate {
ret @respan(crate.span,
rec(module = annotate_module(fm, crate.node.module)
with crate.node));
}
-fn check_crate(@ast.crate crate, def_map dm) -> @ast.crate {
+fn check_crate(@ast::crate crate, def_map dm) -> @ast::crate {
/* Build the global map from function id to var-to-bit-num-map */
auto fm = mk_f_to_fn_info(crate);
@@ -2493,18 +2494,18 @@ fn check_crate(@ast.crate crate, def_map dm) -> @ast.crate {
auto with_anns = annotate_crate(fm, crate);
/* Compute the pre and postcondition for every subexpression */
- auto fld = fold.new_identity_fold[fn_info_map]();
+ auto fld = fold::new_identity_fold[fn_info_map]();
fld = @rec(fold_item_fn = bind check_item_fn(dm,_,_,_,_,_,_,_) with *fld);
- auto with_pre_postconditions = fold.fold_crate[fn_info_map]
+ auto with_pre_postconditions = fold::fold_crate[fn_info_map]
(fm, fld, with_anns);
- auto fld1 = fold.new_identity_fold[fn_info_map]();
+ auto fld1 = fold::new_identity_fold[fn_info_map]();
fld1 = @rec(fold_item_fn = bind check_item_fn_state(dm,_,_,_,_,_,_,_),
fold_obj = bind check_obj_state(dm,_,_,_,_)
with *fld1);
- ret fold.fold_crate[fn_info_map](fm, fld1,
+ ret fold::fold_crate[fn_info_map](fm, fld1,
with_pre_postconditions);
}
diff --git a/src/comp/middle/walk.rs b/src/comp/middle/walk.rs
index e684924adc77d..848c43385d52f 100644
--- a/src/comp/middle/walk.rs
+++ b/src/comp/middle/walk.rs
@@ -1,120 +1,120 @@
-import front.ast;
+import front::ast;
-import std.Option;
-import std.Option.some;
-import std.Option.none;
+import std::option;
+import std::option::some;
+import std::option::none;
type ast_visitor =
rec(fn () -> bool keep_going,
fn () -> bool want_crate_directives,
- fn (&ast.crate c) visit_crate_pre,
- fn (&ast.crate c) visit_crate_post,
- fn (&@ast.crate_directive cd) visit_crate_directive_pre,
- fn (&@ast.crate_directive cd) visit_crate_directive_post,
- fn (&@ast.view_item i) visit_view_item_pre,
- fn (&@ast.view_item i) visit_view_item_post,
- fn (&@ast.native_item i) visit_native_item_pre,
- fn (&@ast.native_item i) visit_native_item_post,
- fn (&@ast.item i) visit_item_pre,
- fn (&@ast.item i) visit_item_post,
- fn (&ast.block b) visit_block_pre,
- fn (&ast.block b) visit_block_post,
- fn (&@ast.stmt s) visit_stmt_pre,
- fn (&@ast.stmt s) visit_stmt_post,
- fn (&@ast.decl d) visit_decl_pre,
- fn (&@ast.decl d) visit_decl_post,
- fn (&@ast.expr e) visit_expr_pre,
- fn (&@ast.expr e) visit_expr_post,
- fn (&@ast.ty t) visit_ty_pre,
- fn (&@ast.ty t) visit_ty_post);
+ fn (&ast::crate c) visit_crate_pre,
+ fn (&ast::crate c) visit_crate_post,
+ fn (&@ast::crate_directive cd) visit_crate_directive_pre,
+ fn (&@ast::crate_directive cd) visit_crate_directive_post,
+ fn (&@ast::view_item i) visit_view_item_pre,
+ fn (&@ast::view_item i) visit_view_item_post,
+ fn (&@ast::native_item i) visit_native_item_pre,
+ fn (&@ast::native_item i) visit_native_item_post,
+ fn (&@ast::item i) visit_item_pre,
+ fn (&@ast::item i) visit_item_post,
+ fn (&ast::block b) visit_block_pre,
+ fn (&ast::block b) visit_block_post,
+ fn (&@ast::stmt s) visit_stmt_pre,
+ fn (&@ast::stmt s) visit_stmt_post,
+ fn (&@ast::decl d) visit_decl_pre,
+ fn (&@ast::decl d) visit_decl_post,
+ fn (&@ast::expr e) visit_expr_pre,
+ fn (&@ast::expr e) visit_expr_post,
+ fn (&@ast::ty t) visit_ty_pre,
+ fn (&@ast::ty t) visit_ty_post);
-fn walk_crate(&ast_visitor v, &ast.crate c) {
+fn walk_crate(&ast_visitor v, &ast::crate c) {
if (!v.keep_going()) { ret; }
v.visit_crate_pre(c);
walk_mod(v, c.node.module);
v.visit_crate_post(c);
}
-fn walk_crate_directive(&ast_visitor v, @ast.crate_directive cd) {
+fn walk_crate_directive(&ast_visitor v, @ast::crate_directive cd) {
if (!v.keep_going()) { ret; }
if (!v.want_crate_directives()) { ret; }
v.visit_crate_directive_pre(cd);
alt (cd.node) {
- case (ast.cdir_let(_, ?e, ?cdirs)) {
+ case (ast::cdir_let(_, ?e, ?cdirs)) {
walk_expr(v, e);
- for (@ast.crate_directive cdir in cdirs) {
+ for (@ast::crate_directive cdir in cdirs) {
walk_crate_directive(v, cdir);
}
}
- case (ast.cdir_src_mod(_, _)) {}
- case (ast.cdir_dir_mod(_, _, ?cdirs)) {
- for (@ast.crate_directive cdir in cdirs) {
+ case (ast::cdir_src_mod(_, _)) {}
+ case (ast::cdir_dir_mod(_, _, ?cdirs)) {
+ for (@ast::crate_directive cdir in cdirs) {
walk_crate_directive(v, cdir);
}
}
- case (ast.cdir_view_item(?vi)) {
+ case (ast::cdir_view_item(?vi)) {
walk_view_item(v, vi);
}
- case (ast.cdir_meta(_)) {}
- case (ast.cdir_syntax(_)) {}
- case (ast.cdir_auth(_, _)) {}
+ case (ast::cdir_meta(_)) {}
+ case (ast::cdir_syntax(_)) {}
+ case (ast::cdir_auth(_, _)) {}
}
v.visit_crate_directive_post(cd);
}
-fn walk_mod(&ast_visitor v, &ast._mod m) {
+fn walk_mod(&ast_visitor v, &ast::_mod m) {
if (!v.keep_going()) { ret; }
- for (@ast.view_item vi in m.view_items) {
+ for (@ast::view_item vi in m.view_items) {
walk_view_item(v, vi);
}
- for (@ast.item i in m.items) {
+ for (@ast::item i in m.items) {
walk_item(v, i);
}
}
-fn walk_view_item(&ast_visitor v, @ast.view_item vi) {
+fn walk_view_item(&ast_visitor v, @ast::view_item vi) {
if (!v.keep_going()) { ret; }
v.visit_view_item_pre(vi);
v.visit_view_item_post(vi);
}
-fn walk_item(&ast_visitor v, @ast.item i) {
+fn walk_item(&ast_visitor v, @ast::item i) {
if (!v.keep_going()) { ret; }
v.visit_item_pre(i);
alt (i.node) {
- case (ast.item_const(_, ?t, ?e, _, _)) {
+ case (ast::item_const(_, ?t, ?e, _, _)) {
walk_ty(v, t);
walk_expr(v, e);
}
- case (ast.item_fn(_, ?f, _, _, _)) {
+ case (ast::item_fn(_, ?f, _, _, _)) {
walk_fn(v, f);
}
- case (ast.item_mod(_, ?m, _)) {
+ case (ast::item_mod(_, ?m, _)) {
walk_mod(v, m);
}
- case (ast.item_native_mod(_, ?nm, _)) {
+ case (ast::item_native_mod(_, ?nm, _)) {
walk_native_mod(v, nm);
}
- case (ast.item_ty(_, ?t, _, _, _)) {
+ case (ast::item_ty(_, ?t, _, _, _)) {
walk_ty(v, t);
}
- case (ast.item_tag(_, ?variants, _, _, _)) {
- for (ast.variant vr in variants) {
- for (ast.variant_arg va in vr.node.args) {
+ case (ast::item_tag(_, ?variants, _, _, _)) {
+ for (ast::variant vr in variants) {
+ for (ast::variant_arg va in vr.node.args) {
walk_ty(v, va.ty);
}
}
}
- case (ast.item_obj(_, ?ob, _, _, _)) {
- for (ast.obj_field f in ob.fields) {
+ case (ast::item_obj(_, ?ob, _, _, _)) {
+ for (ast::obj_field f in ob.fields) {
walk_ty(v, f.ty);
}
- for (@ast.method m in ob.methods) {
+ for (@ast::method m in ob.methods) {
walk_fn(v, m.node.meth);
}
alt (ob.dtor) {
- case (none[@ast.method]) {}
- case (some[@ast.method](?m)) {
+ case (none[@ast::method]) {}
+ case (some[@ast::method](?m)) {
walk_fn(v, m.node.meth);
}
}
@@ -124,282 +124,282 @@ fn walk_item(&ast_visitor v, @ast.item i) {
v.visit_item_post(i);
}
-fn walk_ty(&ast_visitor v, @ast.ty t) {
+fn walk_ty(&ast_visitor v, @ast::ty t) {
if (!v.keep_going()) { ret; }
v.visit_ty_pre(t);
alt (t.node) {
- case (ast.ty_nil) {}
- case (ast.ty_bool) {}
- case (ast.ty_int) {}
- case (ast.ty_uint) {}
- case (ast.ty_float) {}
- case (ast.ty_machine(_)) {}
- case (ast.ty_char) {}
- case (ast.ty_str) {}
- case (ast.ty_box(?mt)) { walk_ty(v, mt.ty); }
- case (ast.ty_vec(?mt)) { walk_ty(v, mt.ty); }
- case (ast.ty_port(?t)) { walk_ty(v, t); }
- case (ast.ty_chan(?t)) { walk_ty(v, t); }
- case (ast.ty_tup(?mts)) {
- for (ast.mt mt in mts) {
+ case (ast::ty_nil) {}
+ case (ast::ty_bool) {}
+ case (ast::ty_int) {}
+ case (ast::ty_uint) {}
+ case (ast::ty_float) {}
+ case (ast::ty_machine(_)) {}
+ case (ast::ty_char) {}
+ case (ast::ty_str) {}
+ case (ast::ty_box(?mt)) { walk_ty(v, mt.ty); }
+ case (ast::ty_vec(?mt)) { walk_ty(v, mt.ty); }
+ case (ast::ty_port(?t)) { walk_ty(v, t); }
+ case (ast::ty_chan(?t)) { walk_ty(v, t); }
+ case (ast::ty_tup(?mts)) {
+ for (ast::mt mt in mts) {
walk_ty(v, mt.ty);
}
}
- case (ast.ty_rec(?flds)) {
- for (ast.ty_field f in flds) {
+ case (ast::ty_rec(?flds)) {
+ for (ast::ty_field f in flds) {
walk_ty(v, f.mt.ty);
}
}
- case (ast.ty_fn(_, ?args, ?out)) {
- for (ast.ty_arg a in args) {
+ case (ast::ty_fn(_, ?args, ?out)) {
+ for (ast::ty_arg a in args) {
walk_ty(v, a.ty);
}
walk_ty(v, out);
}
- case (ast.ty_obj(?tmeths)) {
- for (ast.ty_method m in tmeths) {
- for (ast.ty_arg a in m.inputs) {
+ case (ast::ty_obj(?tmeths)) {
+ for (ast::ty_method m in tmeths) {
+ for (ast::ty_arg a in m.inputs) {
walk_ty(v, a.ty);
}
walk_ty(v, m.output);
}
}
- case (ast.ty_path(_, _)) {}
- case (ast.ty_type) {}
- case (ast.ty_constr(?t, _)) { walk_ty(v, t); }
+ case (ast::ty_path(_, _)) {}
+ case (ast::ty_type) {}
+ case (ast::ty_constr(?t, _)) { walk_ty(v, t); }
}
v.visit_ty_post(t);
}
-fn walk_native_mod(&ast_visitor v, &ast.native_mod nm) {
+fn walk_native_mod(&ast_visitor v, &ast::native_mod nm) {
if (!v.keep_going()) { ret; }
- for (@ast.view_item vi in nm.view_items) {
+ for (@ast::view_item vi in nm.view_items) {
walk_view_item(v, vi);
}
- for (@ast.native_item ni in nm.items) {
+ for (@ast::native_item ni in nm.items) {
walk_native_item(v, ni);
}
}
-fn walk_native_item(&ast_visitor v, @ast.native_item ni) {
+fn walk_native_item(&ast_visitor v, @ast::native_item ni) {
if (!v.keep_going()) { ret; }
v.visit_native_item_pre(ni);
alt (ni.node) {
- case (ast.native_item_fn(_, _, ?fd, _, _, _)) {
+ case (ast::native_item_fn(_, _, ?fd, _, _, _)) {
walk_fn_decl(v, fd);
}
- case (ast.native_item_ty(_, _)) {
+ case (ast::native_item_ty(_, _)) {
}
}
v.visit_native_item_post(ni);
}
-fn walk_fn_decl(&ast_visitor v, &ast.fn_decl fd) {
- for (ast.arg a in fd.inputs) {
+fn walk_fn_decl(&ast_visitor v, &ast::fn_decl fd) {
+ for (ast::arg a in fd.inputs) {
walk_ty(v, a.ty);
}
walk_ty(v, fd.output);
}
-fn walk_fn(&ast_visitor v, &ast._fn f) {
+fn walk_fn(&ast_visitor v, &ast::_fn f) {
if (!v.keep_going()) { ret; }
walk_fn_decl(v, f.decl);
walk_block(v, f.body);
}
-fn walk_block(&ast_visitor v, &ast.block b) {
+fn walk_block(&ast_visitor v, &ast::block b) {
if (!v.keep_going()) { ret; }
v.visit_block_pre(b);
- for (@ast.stmt s in b.node.stmts) {
+ for (@ast::stmt s in b.node.stmts) {
walk_stmt(v, s);
}
walk_expr_opt(v, b.node.expr);
v.visit_block_post(b);
}
-fn walk_stmt(&ast_visitor v, @ast.stmt s) {
+fn walk_stmt(&ast_visitor v, @ast::stmt s) {
if (!v.keep_going()) { ret; }
v.visit_stmt_pre(s);
alt (s.node) {
- case (ast.stmt_decl(?d, _)) {
+ case (ast::stmt_decl(?d, _)) {
walk_decl(v, d);
}
- case (ast.stmt_expr(?e, _)) {
+ case (ast::stmt_expr(?e, _)) {
walk_expr(v, e);
}
- case (ast.stmt_crate_directive(?cdir)) {
+ case (ast::stmt_crate_directive(?cdir)) {
walk_crate_directive(v, cdir);
}
}
v.visit_stmt_post(s);
}
-fn walk_decl(&ast_visitor v, @ast.decl d) {
+fn walk_decl(&ast_visitor v, @ast::decl d) {
if (!v.keep_going()) { ret; }
v.visit_decl_pre(d);
alt (d.node) {
- case (ast.decl_local(?loc)) {
+ case (ast::decl_local(?loc)) {
alt (loc.ty) {
- case (none[@ast.ty]) {}
- case (some[@ast.ty](?t)) { walk_ty(v, t); }
+ case (none[@ast::ty]) {}
+ case (some[@ast::ty](?t)) { walk_ty(v, t); }
}
alt (loc.init) {
- case (none[ast.initializer]) {}
- case (some[ast.initializer](?i)) {
+ case (none[ast::initializer]) {}
+ case (some[ast::initializer](?i)) {
walk_expr(v, i.expr);
}
}
}
- case (ast.decl_item(?it)) {
+ case (ast::decl_item(?it)) {
walk_item(v, it);
}
}
v.visit_decl_post(d);
}
-fn walk_expr_opt(&ast_visitor v, Option.t[@ast.expr] eo) {
+fn walk_expr_opt(&ast_visitor v, option::t[@ast::expr] eo) {
alt (eo) {
- case (none[@ast.expr]) {}
- case (some[@ast.expr](?e)) {
+ case (none[@ast::expr]) {}
+ case (some[@ast::expr](?e)) {
walk_expr(v, e);
}
}
}
-fn walk_exprs(&ast_visitor v, vec[@ast.expr] exprs) {
- for (@ast.expr e in exprs) {
+fn walk_exprs(&ast_visitor v, vec[@ast::expr] exprs) {
+ for (@ast::expr e in exprs) {
walk_expr(v, e);
}
}
-fn walk_expr(&ast_visitor v, @ast.expr e) {
+fn walk_expr(&ast_visitor v, @ast::expr e) {
if (!v.keep_going()) { ret; }
v.visit_expr_pre(e);
alt (e.node) {
- case (ast.expr_vec(?es, _, _)) {
+ case (ast::expr_vec(?es, _, _)) {
walk_exprs(v, es);
}
- case (ast.expr_tup(?elts, _)) {
- for (ast.elt e in elts) {
+ case (ast::expr_tup(?elts, _)) {
+ for (ast::elt e in elts) {
walk_expr(v, e.expr);
}
}
- case (ast.expr_rec(?flds, ?base, _)) {
- for (ast.field f in flds) {
+ case (ast::expr_rec(?flds, ?base, _)) {
+ for (ast::field f in flds) {
walk_expr(v, f.expr);
}
walk_expr_opt(v, base);
}
- case (ast.expr_call(?callee, ?args, _)) {
+ case (ast::expr_call(?callee, ?args, _)) {
walk_expr(v, callee);
walk_exprs(v, args);
}
- case (ast.expr_self_method(_, _)) { }
- case (ast.expr_bind(?callee, ?args, _)) {
+ case (ast::expr_self_method(_, _)) { }
+ case (ast::expr_bind(?callee, ?args, _)) {
walk_expr(v, callee);
- for (Option.t[@ast.expr] eo in args) {
+ for (option::t[@ast::expr] eo in args) {
walk_expr_opt(v, eo);
}
}
- case (ast.expr_spawn(_, _, ?callee, ?args, _)) {
+ case (ast::expr_spawn(_, _, ?callee, ?args, _)) {
walk_expr(v, callee);
walk_exprs(v, args);
}
- case (ast.expr_binary(_, ?a, ?b, _)) {
+ case (ast::expr_binary(_, ?a, ?b, _)) {
walk_expr(v, a);
walk_expr(v, b);
}
- case (ast.expr_unary(_, ?a, _)) {
+ case (ast::expr_unary(_, ?a, _)) {
walk_expr(v, a);
}
- case (ast.expr_lit(_, _)) { }
- case (ast.expr_cast(?x, ?t, _)) {
+ case (ast::expr_lit(_, _)) { }
+ case (ast::expr_cast(?x, ?t, _)) {
walk_expr(v, x);
walk_ty(v, t);
}
- case (ast.expr_if(?x, ?b, ?eo, _)) {
+ case (ast::expr_if(?x, ?b, ?eo, _)) {
walk_expr(v, x);
walk_block(v, b);
walk_expr_opt(v, eo);
}
- case (ast.expr_while(?x, ?b, _)) {
+ case (ast::expr_while(?x, ?b, _)) {
walk_expr(v, x);
walk_block(v, b);
}
- case (ast.expr_for(?dcl, ?x, ?b, _)) {
+ case (ast::expr_for(?dcl, ?x, ?b, _)) {
walk_decl(v, dcl);
walk_expr(v, x);
walk_block(v, b);
}
- case (ast.expr_for_each(?dcl, ?x, ?b, _)) {
+ case (ast::expr_for_each(?dcl, ?x, ?b, _)) {
walk_decl(v, dcl);
walk_expr(v, x);
walk_block(v, b);
}
- case (ast.expr_do_while(?b, ?x, _)) {
+ case (ast::expr_do_while(?b, ?x, _)) {
walk_block(v, b);
walk_expr(v, x);
}
- case (ast.expr_alt(?x, ?arms, _)) {
+ case (ast::expr_alt(?x, ?arms, _)) {
walk_expr(v, x);
- for (ast.arm a in arms) {
+ for (ast::arm a in arms) {
walk_block(v, a.block);
}
}
- case (ast.expr_block(?b, _)) {
+ case (ast::expr_block(?b, _)) {
walk_block(v, b);
}
- case (ast.expr_assign(?a, ?b, _)) {
+ case (ast::expr_assign(?a, ?b, _)) {
walk_expr(v, a);
walk_expr(v, b);
}
- case (ast.expr_assign_op(_, ?a, ?b, _)) {
+ case (ast::expr_assign_op(_, ?a, ?b, _)) {
walk_expr(v, a);
walk_expr(v, b);
}
- case (ast.expr_send(?a, ?b, _)) {
+ case (ast::expr_send(?a, ?b, _)) {
walk_expr(v, a);
walk_expr(v, b);
}
- case (ast.expr_recv(?a, ?b, _)) {
+ case (ast::expr_recv(?a, ?b, _)) {
walk_expr(v, a);
walk_expr(v, b);
}
- case (ast.expr_field(?x, _, _)) {
+ case (ast::expr_field(?x, _, _)) {
walk_expr(v, x);
}
- case (ast.expr_index(?a, ?b, _)) {
+ case (ast::expr_index(?a, ?b, _)) {
walk_expr(v, a);
walk_expr(v, b);
}
- case (ast.expr_path(_, _)) { }
- case (ast.expr_ext(_, ?args, ?body, ?expansion, _)) {
+ case (ast::expr_path(_, _)) { }
+ case (ast::expr_ext(_, ?args, ?body, ?expansion, _)) {
// Only walk expansion, not args/body.
walk_expr(v, expansion);
}
- case (ast.expr_fail(_)) { }
- case (ast.expr_break(_)) { }
- case (ast.expr_cont(_)) { }
- case (ast.expr_ret(?eo, _)) {
+ case (ast::expr_fail(_)) { }
+ case (ast::expr_break(_)) { }
+ case (ast::expr_cont(_)) { }
+ case (ast::expr_ret(?eo, _)) {
walk_expr_opt(v, eo);
}
- case (ast.expr_put(?eo, _)) {
+ case (ast::expr_put(?eo, _)) {
walk_expr_opt(v, eo);
}
- case (ast.expr_be(?x, _)) {
+ case (ast::expr_be(?x, _)) {
walk_expr(v, x);
}
- case (ast.expr_log(_,?x, _)) {
+ case (ast::expr_log(_,?x, _)) {
walk_expr(v, x);
}
- case (ast.expr_check(?x, _)) {
+ case (ast::expr_check(?x, _)) {
walk_expr(v, x);
}
- case (ast.expr_assert(?x, _)) {
+ case (ast::expr_assert(?x, _)) {
walk_expr(v, x);
}
- case (ast.expr_port(_)) { }
- case (ast.expr_chan(?x, _)) {
+ case (ast::expr_port(_)) { }
+ case (ast::expr_chan(?x, _)) {
walk_expr(v, x);
}
}
@@ -408,16 +408,16 @@ fn walk_expr(&ast_visitor v, @ast.expr e) {
fn def_keep_going() -> bool { ret true; }
fn def_want_crate_directives() -> bool { ret false; }
-fn def_visit_crate(&ast.crate c) { }
-fn def_visit_crate_directive(&@ast.crate_directive c) { }
-fn def_visit_view_item(&@ast.view_item vi) { }
-fn def_visit_native_item(&@ast.native_item ni) { }
-fn def_visit_item(&@ast.item i) { }
-fn def_visit_block(&ast.block b) { }
-fn def_visit_stmt(&@ast.stmt s) { }
-fn def_visit_decl(&@ast.decl d) { }
-fn def_visit_expr(&@ast.expr e) { }
-fn def_visit_ty(&@ast.ty t) { }
+fn def_visit_crate(&ast::crate c) { }
+fn def_visit_crate_directive(&@ast::crate_directive c) { }
+fn def_visit_view_item(&@ast::view_item vi) { }
+fn def_visit_native_item(&@ast::native_item ni) { }
+fn def_visit_item(&@ast::item i) { }
+fn def_visit_block(&ast::block b) { }
+fn def_visit_stmt(&@ast::stmt s) { }
+fn def_visit_decl(&@ast::decl d) { }
+fn def_visit_expr(&@ast::expr e) { }
+fn def_visit_ty(&@ast::ty t) { }
fn default_visitor() -> ast_visitor {
diff --git a/src/comp/pretty/pp.rs b/src/comp/pretty/pp.rs
index f966704253c89..aff0843d27d24 100644
--- a/src/comp/pretty/pp.rs
+++ b/src/comp/pretty/pp.rs
@@ -1,6 +1,6 @@
-import std.IO;
-import std.Vec;
-import std.Str;
+import std::io;
+import std::_vec;
+import std::_str;
tag boxtype {box_h; box_v; box_hv; box_align;}
tag contexttype {cx_h; cx_v;}
@@ -19,7 +19,7 @@ type context = rec(contexttype tp, uint indent);
type ps = @rec(mutable vec[context] context,
uint width,
- IO.writer out,
+ io::writer out,
mutable uint col,
mutable uint spaces,
mutable vec[token] buffered,
@@ -30,7 +30,7 @@ type ps = @rec(mutable vec[context] context,
mutable bool start_of_box,
mutable bool potential_brk);
-fn mkstate(IO.writer out, uint width) -> ps {
+fn mkstate(io::writer out, uint width) -> ps {
let vec[context] stack = vec(rec(tp=cx_v, indent=0u));
let vec[token] buff = vec();
let vec[boxtype] sd = vec();
@@ -57,12 +57,12 @@ fn write_spaces(ps p, uint i) {
fn push_context(ps p, contexttype tp, uint indent) {
before_print(p, false);
- Vec.push[context](p.context, rec(tp=tp, indent=indent));
+ _vec::push[context](p.context, rec(tp=tp, indent=indent));
p.start_of_box = true;
}
fn pop_context(ps p) {
- Vec.pop[context](p.context);
+ _vec::pop[context](p.context);
}
fn add_token(ps p, token tok) {
@@ -89,7 +89,7 @@ fn buffer_token(ps p, token tok) {
} else {
alt (tok) {
case (open(?tp,_)) {
- Vec.push[boxtype](p.scandepth, tp);
+ _vec::push[boxtype](p.scandepth, tp);
if (p.scanning == scan_h) {
if (tp == box_h) {
check_potential_brk(p);
@@ -97,14 +97,14 @@ fn buffer_token(ps p, token tok) {
}
}
case (close) {
- Vec.pop[boxtype](p.scandepth);
- if (Vec.len[boxtype](p.scandepth) == 0u) {
+ _vec::pop[boxtype](p.scandepth);
+ if (_vec::len[boxtype](p.scandepth) == 0u) {
finish_scan(p, true);
}
}
case (brk(_)) {
if (p.scanning == scan_h) {
- if (p.scandepth.(Vec.len[boxtype](p.scandepth)-1u) == box_v) {
+ if (p.scandepth.(_vec::len[boxtype](p.scandepth)-1u) == box_v) {
finish_scan(p, true);
}
}
@@ -123,7 +123,7 @@ fn check_potential_brk(ps p) {
fn finish_scan(ps p, bool fits) {
auto buf = p.buffered;
- auto front = Vec.shift[token](buf);
+ auto front = _vec::shift[token](buf);
auto chosen_tp = cx_h;
if (!fits) {chosen_tp = cx_v;}
alt (front) {
@@ -154,10 +154,10 @@ fn start_scan(ps p, token tok, scantype tp) {
}
fn cur_context(ps p) -> context {
- ret p.context.(Vec.len[context](p.context)-1u);
+ ret p.context.(_vec::len[context](p.context)-1u);
}
fn base_indent(ps p) -> uint {
- auto i = Vec.len[context](p.context);
+ auto i = _vec::len[context](p.context);
while (i > 0u) {
i -= 1u;
auto cx = p.context.(i);
@@ -190,7 +190,7 @@ fn do_token(ps p, token tok) {
line_break(p);
}
case (word(?w)) {
- auto len = Str.char_len(w);
+ auto len = _str::char_len(w);
if (len + p.col + p.spaces > p.width && !start_of_box &&
!p.start_of_line) {
line_break(p);
@@ -202,7 +202,7 @@ fn do_token(ps p, token tok) {
case (cword(?w)) {
before_print(p, true);
p.out.write_str(w);
- p.col += Str.char_len(w);
+ p.col += _str::char_len(w);
}
case (open(?tp, ?indent)) {
if (tp == box_v) {
@@ -247,8 +247,8 @@ fn token_size(token tok) -> uint {
alt (tok) {
case (brk(?sz)) {ret sz;}
case (hardbrk) {ret 0xFFFFFFu;}
- case (word(?w)) {ret Str.char_len(w);}
- case (cword(?w)) {ret Str.char_len(w);}
+ case (word(?w)) {ret _str::char_len(w);}
+ case (cword(?w)) {ret _str::char_len(w);}
case (open(_, _)) {ret 0u;}
case (close) {ret 0u;}
}
diff --git a/src/comp/pretty/pprust.rs b/src/comp/pretty/pprust.rs
index d380f0b7eeafb..3c959b999c2d2 100644
--- a/src/comp/pretty/pprust.rs
+++ b/src/comp/pretty/pprust.rs
@@ -1,58 +1,58 @@
-import std.Vec;
-import std.Str;
-import std.IO;
-import std.Option;
-import driver.session.session;
-import front.ast;
-import front.lexer;
-import util.common;
-import pp.end; import pp.wrd; import pp.space; import pp.line;
+import std::_vec;
+import std::_str;
+import std::io;
+import std::option;
+import driver::session::session;
+import front::ast;
+import front::lexer;
+import util::common;
+import pp::end; import pp::wrd; import pp::space; import pp::line;
const uint indent_unit = 4u;
const int as_prec = 5;
const uint default_columns = 78u;
-type ps = @rec(pp.ps s,
- Option.t[vec[lexer.cmnt]] comments,
+type ps = @rec(pp::ps s,
+ option::t[vec[lexer::cmnt]] comments,
mutable uint cur_cmnt);
-fn print_file(session sess, ast._mod _mod, str filename, IO.writer out) {
- auto cmnts = lexer.gather_comments(sess, filename);
- auto s = @rec(s=pp.mkstate(out, default_columns),
- comments=Option.some[vec[lexer.cmnt]](cmnts),
+fn print_file(session sess, ast::_mod _mod, str filename, io::writer out) {
+ auto cmnts = lexer::gather_comments(sess, filename);
+ auto s = @rec(s=pp::mkstate(out, default_columns),
+ comments=option::some[vec[lexer::cmnt]](cmnts),
mutable cur_cmnt=0u);
print_mod(s, _mod);
}
-fn ty_to_str(&@ast.ty ty) -> str {
- auto writer = IO.string_writer();
- auto s = @rec(s=pp.mkstate(writer.get_writer(), 0u),
- comments=Option.none[vec[lexer.cmnt]],
+fn ty_to_str(&@ast::ty ty) -> str {
+ auto writer = io::string_writer();
+ auto s = @rec(s=pp::mkstate(writer.get_writer(), 0u),
+ comments=option::none[vec[lexer::cmnt]],
mutable cur_cmnt=0u);
print_type(s, ty);
ret writer.get_str();
}
-fn block_to_str(&ast.block blk) -> str {
- auto writer = IO.string_writer();
- auto s = @rec(s=pp.mkstate(writer.get_writer(), 78u),
- comments=Option.none[vec[lexer.cmnt]],
+fn block_to_str(&ast::block blk) -> str {
+ auto writer = io::string_writer();
+ auto s = @rec(s=pp::mkstate(writer.get_writer(), 78u),
+ comments=option::none[vec[lexer::cmnt]],
mutable cur_cmnt=0u);
print_block(s, blk);
ret writer.get_str();
}
-fn pat_to_str(&@ast.pat p) -> str {
- auto writer = IO.string_writer();
- auto s = @rec(s=pp.mkstate(writer.get_writer(), 78u),
- comments=Option.none[vec[lexer.cmnt]],
+fn pat_to_str(&@ast::pat p) -> str {
+ auto writer = io::string_writer();
+ auto s = @rec(s=pp::mkstate(writer.get_writer(), 78u),
+ comments=option::none[vec[lexer::cmnt]],
mutable cur_cmnt=0u);
print_pat(s, p);
ret writer.get_str();
}
fn hbox(ps s) {
- pp.hbox(s.s, indent_unit);
+ pp::hbox(s.s, indent_unit);
}
fn wrd1(ps s, str word) {
wrd(s.s, word);
@@ -60,11 +60,11 @@ fn wrd1(ps s, str word) {
}
fn popen(ps s) {
wrd(s.s, "(");
- pp.abox(s.s);
+ pp::abox(s.s);
}
fn popen_h(ps s) {
wrd(s.s, "(");
- pp.hbox(s.s, 0u);
+ pp::hbox(s.s, 0u);
}
fn pclose(ps s) {
end(s.s);
@@ -72,14 +72,14 @@ fn pclose(ps s) {
}
fn bopen(ps s) {
wrd(s.s, "{");
- pp.vbox(s.s, indent_unit);
+ pp::vbox(s.s, indent_unit);
line(s.s);
}
fn bclose(ps s) {
end(s.s);
- pp.cwrd(s.s, "}");
+ pp::cwrd(s.s, "}");
}
-fn bclose_c(ps s, common.span span) {
+fn bclose_c(ps s, common::span span) {
maybe_print_comment(s, span.hi);
bclose(s);
}
@@ -92,8 +92,8 @@ fn commasep[IN](ps s, vec[IN] elts, fn(ps, &IN) op) {
}
}
fn commasep_cmnt[IN](ps s, vec[IN] elts, fn(ps, &IN) op,
- fn(&IN) -> common.span get_span) {
- auto len = Vec.len[IN](elts);
+ fn(&IN) -> common::span get_span) {
+ auto len = _vec::len[IN](elts);
auto i = 0u;
for (IN elt in elts) {
op(s, elt);
@@ -104,77 +104,79 @@ fn commasep_cmnt[IN](ps s, vec[IN] elts, fn(ps, &IN) op,
}
}
}
-fn commasep_exprs(ps s, vec[@ast.expr] exprs) {
- fn expr_span(&@ast.expr expr) -> common.span {ret expr.span;}
+fn commasep_exprs(ps s, vec[@ast::expr] exprs) {
+ fn expr_span(&@ast::expr expr) -> common::span {ret expr.span;}
auto f = print_expr;
auto gs = expr_span;
- commasep_cmnt[@ast.expr](s, exprs, f, gs);
+ commasep_cmnt[@ast::expr](s, exprs, f, gs);
}
-fn print_mod(ps s, ast._mod _mod) {
- for (@ast.view_item vitem in _mod.view_items) {print_view_item(s, vitem);}
+fn print_mod(ps s, ast::_mod _mod) {
+ for (@ast::view_item vitem in _mod.view_items) {
+ print_view_item(s, vitem);
+ }
line(s.s);
- for (@ast.item item in _mod.items) {print_item(s, item);}
+ for (@ast::item item in _mod.items) {print_item(s, item);}
print_remaining_comments(s);
}
-fn print_type(ps s, &@ast.ty ty) {
+fn print_type(ps s, &@ast::ty ty) {
maybe_print_comment(s, ty.span.lo);
hbox(s);
alt (ty.node) {
- case (ast.ty_nil) {wrd(s.s, "()");}
- case (ast.ty_bool) {wrd(s.s, "bool");}
- case (ast.ty_int) {wrd(s.s, "int");}
- case (ast.ty_uint) {wrd(s.s, "uint");}
- case (ast.ty_float) {wrd(s.s, "float");}
- case (ast.ty_machine(?tm)) {wrd(s.s, common.ty_mach_to_str(tm));}
- case (ast.ty_char) {wrd(s.s, "char");}
- case (ast.ty_str) {wrd(s.s, "str");}
- case (ast.ty_box(?mt)) {wrd(s.s, "@"); print_mt(s, mt);}
- case (ast.ty_vec(?mt)) {
+ case (ast::ty_nil) {wrd(s.s, "()");}
+ case (ast::ty_bool) {wrd(s.s, "bool");}
+ case (ast::ty_int) {wrd(s.s, "int");}
+ case (ast::ty_uint) {wrd(s.s, "uint");}
+ case (ast::ty_float) {wrd(s.s, "float");}
+ case (ast::ty_machine(?tm)) {wrd(s.s, common::ty_mach_to_str(tm));}
+ case (ast::ty_char) {wrd(s.s, "char");}
+ case (ast::ty_str) {wrd(s.s, "str");}
+ case (ast::ty_box(?mt)) {wrd(s.s, "@"); print_mt(s, mt);}
+ case (ast::ty_vec(?mt)) {
wrd(s.s, "vec["); print_mt(s, mt); wrd(s.s, "]");
}
- case (ast.ty_port(?t)) {
+ case (ast::ty_port(?t)) {
wrd(s.s, "port["); print_type(s, t); wrd(s.s, "]");
}
- case (ast.ty_chan(?t)) {
+ case (ast::ty_chan(?t)) {
wrd(s.s, "chan["); print_type(s, t); wrd(s.s, "]");
}
- case (ast.ty_type) {wrd(s.s, "type");}
- case (ast.ty_tup(?elts)) {
+ case (ast::ty_type) {wrd(s.s, "type");}
+ case (ast::ty_tup(?elts)) {
wrd(s.s, "tup");
popen(s);
auto f = print_mt;
- commasep[ast.mt](s, elts, f);
+ commasep[ast::mt](s, elts, f);
pclose(s);
}
- case (ast.ty_rec(?fields)) {
+ case (ast::ty_rec(?fields)) {
wrd(s.s, "rec");
popen(s);
- fn print_field(ps s, &ast.ty_field f) {
+ fn print_field(ps s, &ast::ty_field f) {
hbox(s);
print_mt(s, f.mt);
space(s.s);
wrd(s.s, f.ident);
end(s.s);
}
- fn get_span(&ast.ty_field f) -> common.span {
+ fn get_span(&ast::ty_field f) -> common::span {
// Try to reconstruct the span for this field
auto sp = f.mt.ty.span;
- auto hi = sp.hi + Str.char_len(f.ident) + 1u;
+ auto hi = sp.hi + _str::char_len(f.ident) + 1u;
ret rec(hi=hi with sp);
}
auto f = print_field;
auto gs = get_span;
- commasep_cmnt[ast.ty_field](s, fields, f, gs);
+ commasep_cmnt[ast::ty_field](s, fields, f, gs);
pclose(s);
}
- case (ast.ty_obj(?methods)) {
+ case (ast::ty_obj(?methods)) {
wrd1(s, "obj");
bopen(s);
- for (ast.ty_method m in methods) {
+ for (ast::ty_method m in methods) {
hbox(s);
- print_ty_fn(s, m.proto, Option.some[str](m.ident),
+ print_ty_fn(s, m.proto, option::some[str](m.ident),
m.inputs, m.output);
wrd(s.s, ";");
end(s.s);
@@ -182,21 +184,21 @@ fn print_type(ps s, &@ast.ty ty) {
}
bclose_c(s, ty.span);
}
- case (ast.ty_fn(?proto,?inputs,?output)) {
- print_ty_fn(s, proto, Option.none[str], inputs, output);
+ case (ast::ty_fn(?proto,?inputs,?output)) {
+ print_ty_fn(s, proto, option::none[str], inputs, output);
}
- case (ast.ty_path(?path,_)) {
+ case (ast::ty_path(?path,_)) {
print_path(s, path);
}
}
end(s.s);
}
-fn print_item(ps s, @ast.item item) {
+fn print_item(ps s, @ast::item item) {
maybe_print_comment(s, item.span.lo);
hbox(s);
alt (item.node) {
- case (ast.item_const(?id, ?ty, ?expr, _, _)) {
+ case (ast::item_const(?id, ?ty, ?expr, _, _)) {
wrd1(s, "const");
print_type(s, ty);
space(s.s);
@@ -205,44 +207,44 @@ fn print_item(ps s, @ast.item item) {
print_expr(s, expr);
wrd(s.s, ";");
}
- case (ast.item_fn(?name,?_fn,?typarams,_,_)) {
+ case (ast::item_fn(?name,?_fn,?typarams,_,_)) {
print_fn(s, _fn.decl, name, typarams);
space(s.s);
print_block(s, _fn.body);
}
- case (ast.item_mod(?id,?_mod,_)) {
+ case (ast::item_mod(?id,?_mod,_)) {
wrd1(s, "mod");
wrd1(s, id);
bopen(s);
- for (@ast.item itm in _mod.items) {print_item(s, itm);}
+ for (@ast::item itm in _mod.items) {print_item(s, itm);}
bclose_c(s, item.span);
}
- case (ast.item_native_mod(?id,?nmod,_)) {
+ case (ast::item_native_mod(?id,?nmod,_)) {
wrd1(s, "native");
alt (nmod.abi) {
- case (ast.native_abi_rust) {wrd1(s, "\"rust\"");}
- case (ast.native_abi_cdecl) {wrd1(s, "\"cdecl\"");}
- case (ast.native_abi_rust_intrinsic) {
+ case (ast::native_abi_rust) {wrd1(s, "\"rust\"");}
+ case (ast::native_abi_cdecl) {wrd1(s, "\"cdecl\"");}
+ case (ast::native_abi_rust_intrinsic) {
wrd1(s, "\"rust-intrinstic\"");
}
}
wrd1(s, "mod");
wrd1(s, id);
bopen(s);
- for (@ast.native_item item in nmod.items) {
+ for (@ast::native_item item in nmod.items) {
hbox(s);
maybe_print_comment(s, item.span.lo);
alt (item.node) {
- case (ast.native_item_ty(?id,_)) {
+ case (ast::native_item_ty(?id,_)) {
wrd1(s, "type");
wrd(s.s, id);
}
- case (ast.native_item_fn(?id,?lname,?decl,
+ case (ast::native_item_fn(?id,?lname,?decl,
?typarams,_,_)) {
print_fn(s, decl, id, typarams);
alt (lname) {
- case (Option.none[str]) {}
- case (Option.some[str](?ss)) {
+ case (option::none[str]) {}
+ case (option::some[str](?ss)) {
print_string(s, ss);
}
}
@@ -253,7 +255,7 @@ fn print_item(ps s, @ast.item item) {
}
bclose_c(s, item.span);
}
- case (ast.item_ty(?id,?ty,?params,_,_)) {
+ case (ast::item_ty(?id,?ty,?params,_,_)) {
wrd1(s, "type");
wrd(s.s, id);
print_type_params(s, params);
@@ -262,22 +264,22 @@ fn print_item(ps s, @ast.item item) {
print_type(s, ty);
wrd(s.s, ";");
}
- case (ast.item_tag(?id,?variants,?params,_,_)) {
+ case (ast::item_tag(?id,?variants,?params,_,_)) {
wrd1(s, "tag");
wrd(s.s, id);
print_type_params(s, params);
space(s.s);
bopen(s);
- for (ast.variant v in variants) {
+ for (ast::variant v in variants) {
maybe_print_comment(s, v.span.lo);
wrd(s.s, v.node.name);
- if (Vec.len[ast.variant_arg](v.node.args) > 0u) {
+ if (_vec::len[ast::variant_arg](v.node.args) > 0u) {
popen(s);
- fn print_variant_arg(ps s, &ast.variant_arg arg) {
+ fn print_variant_arg(ps s, &ast::variant_arg arg) {
print_type(s, arg.ty);
}
auto f = print_variant_arg;
- commasep[ast.variant_arg](s, v.node.args, f);
+ commasep[ast::variant_arg](s, v.node.args, f);
pclose(s);
}
wrd(s.s, ";");
@@ -285,28 +287,28 @@ fn print_item(ps s, @ast.item item) {
}
bclose_c(s, item.span);
}
- case (ast.item_obj(?id,?_obj,?params,_,_)) {
+ case (ast::item_obj(?id,?_obj,?params,_,_)) {
wrd1(s, "obj");
wrd(s.s, id);
print_type_params(s, params);
popen(s);
- fn print_field(ps s, &ast.obj_field field) {
+ fn print_field(ps s, &ast::obj_field field) {
hbox(s);
print_type(s, field.ty);
space(s.s);
wrd(s.s, field.ident);
end(s.s);
}
- fn get_span(&ast.obj_field f) -> common.span {ret f.ty.span;}
+ fn get_span(&ast::obj_field f) -> common::span {ret f.ty.span;}
auto f = print_field;
auto gs = get_span;
- commasep_cmnt[ast.obj_field](s, _obj.fields, f, gs);
+ commasep_cmnt[ast::obj_field](s, _obj.fields, f, gs);
pclose(s);
space(s.s);
bopen(s);
- for (@ast.method meth in _obj.methods) {
+ for (@ast::method meth in _obj.methods) {
hbox(s);
- let vec[ast.ty_param] typarams = vec();
+ let vec[ast::ty_param] typarams = vec();
maybe_print_comment(s, meth.span.lo);
print_fn(s, meth.node.meth.decl, meth.node.ident, typarams);
space(s.s);
@@ -315,7 +317,7 @@ fn print_item(ps s, @ast.item item) {
line(s.s);
}
alt (_obj.dtor) {
- case (Option.some[@ast.method](?dtor)) {
+ case (option::some[@ast::method](?dtor)) {
hbox(s);
wrd1(s, "close");
print_block(s, dtor.node.meth.body);
@@ -332,20 +334,20 @@ fn print_item(ps s, @ast.item item) {
line(s.s);
}
-fn print_block(ps s, ast.block blk) {
+fn print_block(ps s, ast::block blk) {
maybe_print_comment(s, blk.span.lo);
bopen(s);
- for (@ast.stmt st in blk.node.stmts) {
+ for (@ast::stmt st in blk.node.stmts) {
maybe_print_comment(s, st.span.lo);
alt (st.node) {
- case (ast.stmt_decl(?decl,_)) {print_decl(s, decl);}
- case (ast.stmt_expr(?expr,_)) {print_expr(s, expr);}
+ case (ast::stmt_decl(?decl,_)) {print_decl(s, decl);}
+ case (ast::stmt_expr(?expr,_)) {print_expr(s, expr);}
}
- if (front.parser.stmt_ends_with_semi(st)) {wrd(s.s, ";");}
+ if (front::parser::stmt_ends_with_semi(st)) {wrd(s.s, ";");}
if (!maybe_print_line_comment(s, st.span)) {line(s.s);}
}
alt (blk.node.expr) {
- case (Option.some[@ast.expr](?expr)) {
+ case (option::some[@ast::expr](?expr)) {
print_expr(s, expr);
if (!maybe_print_line_comment(s, expr.span)) {line(s.s);}
}
@@ -354,45 +356,45 @@ fn print_block(ps s, ast.block blk) {
bclose_c(s, blk.span);
}
-fn print_literal(ps s, @ast.lit lit) {
+fn print_literal(ps s, @ast::lit lit) {
maybe_print_comment(s, lit.span.lo);
alt (lit.node) {
- case (ast.lit_str(?st)) {print_string(s, st);}
- case (ast.lit_char(?ch)) {
- wrd(s.s, "'" + escape_str(Str.from_bytes(vec(ch as u8)), '\'')
+ case (ast::lit_str(?st)) {print_string(s, st);}
+ case (ast::lit_char(?ch)) {
+ wrd(s.s, "'" + escape_str(_str::from_bytes(vec(ch as u8)), '\'')
+ "'");
}
- case (ast.lit_int(?val)) {
- wrd(s.s, common.istr(val));
+ case (ast::lit_int(?val)) {
+ wrd(s.s, common::istr(val));
}
- case (ast.lit_uint(?val)) { // FIXME clipping? uistr?
- wrd(s.s, common.istr(val as int) + "u");
+ case (ast::lit_uint(?val)) { // FIXME clipping? uistr?
+ wrd(s.s, common::istr(val as int) + "u");
}
- case (ast.lit_float(?fstr)) {
+ case (ast::lit_float(?fstr)) {
wrd(s.s, fstr);
}
- case (ast.lit_mach_int(?mach,?val)) {
- wrd(s.s, common.istr(val as int));
- wrd(s.s, common.ty_mach_to_str(mach));
+ case (ast::lit_mach_int(?mach,?val)) {
+ wrd(s.s, common::istr(val as int));
+ wrd(s.s, common::ty_mach_to_str(mach));
}
- case (ast.lit_mach_float(?mach,?val)) {
+ case (ast::lit_mach_float(?mach,?val)) {
// val is already a str
wrd(s.s, val);
- wrd(s.s, common.ty_mach_to_str(mach));
+ wrd(s.s, common::ty_mach_to_str(mach));
}
- case (ast.lit_nil) {wrd(s.s, "()");}
- case (ast.lit_bool(?val)) {
+ case (ast::lit_nil) {wrd(s.s, "()");}
+ case (ast::lit_bool(?val)) {
if (val) {wrd(s.s, "true");} else {wrd(s.s, "false");}
}
}
}
-fn print_expr(ps s, &@ast.expr expr) {
+fn print_expr(ps s, &@ast::expr expr) {
maybe_print_comment(s, expr.span.lo);
hbox(s);
alt (expr.node) {
- case (ast.expr_vec(?exprs,?mut,_)) {
- if (mut == ast.mut) {
+ case (ast::expr_vec(?exprs,?mut,_)) {
+ if (mut == ast::mut) {
wrd1(s, "mutable");
}
wrd(s.s, "vec");
@@ -400,41 +402,41 @@ fn print_expr(ps s, &@ast.expr expr) {
commasep_exprs(s, exprs);
pclose(s);
}
- case (ast.expr_tup(?exprs,_)) {
- fn printElt(ps s, &ast.elt elt) {
+ case (ast::expr_tup(?exprs,_)) {
+ fn printElt(ps s, &ast::elt elt) {
hbox(s);
- if (elt.mut == ast.mut) {wrd1(s, "mutable");}
+ if (elt.mut == ast::mut) {wrd1(s, "mutable");}
print_expr(s, elt.expr);
end(s.s);
}
- fn get_span(&ast.elt elt) -> common.span {ret elt.expr.span;}
+ fn get_span(&ast::elt elt) -> common::span {ret elt.expr.span;}
wrd(s.s, "tup");
popen(s);
auto f = printElt;
auto gs = get_span;
- commasep_cmnt[ast.elt](s, exprs, f, gs);
+ commasep_cmnt[ast::elt](s, exprs, f, gs);
pclose(s);
}
- case (ast.expr_rec(?fields,?wth,_)) {
- fn print_field(ps s, &ast.field field) {
+ case (ast::expr_rec(?fields,?wth,_)) {
+ fn print_field(ps s, &ast::field field) {
hbox(s);
- if (field.mut == ast.mut) {wrd1(s, "mutable");}
+ if (field.mut == ast::mut) {wrd1(s, "mutable");}
wrd(s.s, field.ident);
wrd(s.s, "=");
print_expr(s, field.expr);
end(s.s);
}
- fn get_span(&ast.field field) -> common.span {
+ fn get_span(&ast::field field) -> common::span {
ret field.expr.span;
}
wrd(s.s, "rec");
popen(s);
auto f = print_field;
auto gs = get_span;
- commasep_cmnt[ast.field](s, fields, f, gs);
+ commasep_cmnt[ast::field](s, fields, f, gs);
alt (wth) {
- case (Option.some[@ast.expr](?expr)) {
- if (Vec.len[ast.field](fields) > 0u) {space(s.s);}
+ case (option::some[@ast::expr](?expr)) {
+ if (_vec::len[ast::field](fields) > 0u) {space(s.s);}
hbox(s);
wrd1(s, "with");
print_expr(s, expr);
@@ -444,20 +446,20 @@ fn print_expr(ps s, &@ast.expr expr) {
}
pclose(s);
}
- case (ast.expr_call(?func,?args,_)) {
+ case (ast::expr_call(?func,?args,_)) {
print_expr(s, func);
popen(s);
commasep_exprs(s, args);
pclose(s);
}
- case (ast.expr_self_method(?ident,_)) {
+ case (ast::expr_self_method(?ident,_)) {
wrd(s.s, "self.");
print_ident(s, ident);
}
- case (ast.expr_bind(?func,?args,_)) {
- fn print_opt(ps s, &Option.t[@ast.expr] expr) {
+ case (ast::expr_bind(?func,?args,_)) {
+ fn print_opt(ps s, &option::t[@ast::expr] expr) {
alt (expr) {
- case (Option.some[@ast.expr](?expr)) {
+ case (option::some[@ast::expr](?expr)) {
print_expr(s, expr);
}
case (_) {wrd(s.s, "_");}
@@ -467,37 +469,37 @@ fn print_expr(ps s, &@ast.expr expr) {
print_expr(s, func);
popen(s);
auto f = print_opt;
- commasep[Option.t[@ast.expr]](s, args, f);
+ commasep[option::t[@ast::expr]](s, args, f);
pclose(s);
}
- case (ast.expr_spawn(_,_,?e,?es,_)) {
+ case (ast::expr_spawn(_,_,?e,?es,_)) {
wrd1(s, "spawn");
print_expr(s, e);
popen(s);
commasep_exprs(s, es);
pclose(s);
}
- case (ast.expr_binary(?op,?lhs,?rhs,_)) {
+ case (ast::expr_binary(?op,?lhs,?rhs,_)) {
auto prec = operator_prec(op);
print_maybe_parens(s, lhs, prec);
space(s.s);
- wrd1(s, ast.binop_to_str(op));
+ wrd1(s, ast::binop_to_str(op));
print_maybe_parens(s, rhs, prec + 1);
}
- case (ast.expr_unary(?op,?expr,_)) {
- wrd(s.s, ast.unop_to_str(op));
+ case (ast::expr_unary(?op,?expr,_)) {
+ wrd(s.s, ast::unop_to_str(op));
print_expr(s, expr);
}
- case (ast.expr_lit(?lit,_)) {
+ case (ast::expr_lit(?lit,_)) {
print_literal(s, lit);
}
- case (ast.expr_cast(?expr,?ty,_)) {
+ case (ast::expr_cast(?expr,?ty,_)) {
print_maybe_parens(s, expr, as_prec);
space(s.s);
wrd1(s, "as");
print_type(s, ty);
}
- case (ast.expr_if(?test,?block,?elseopt,_)) {
+ case (ast::expr_if(?test,?block,?elseopt,_)) {
wrd1(s, "if");
popen_h(s);
print_expr(s, test);
@@ -505,7 +507,7 @@ fn print_expr(ps s, &@ast.expr expr) {
space(s.s);
print_block(s, block);
alt (elseopt) {
- case (Option.some[@ast.expr](?_else)) {
+ case (option::some[@ast::expr](?_else)) {
space(s.s);
wrd1(s, "else");
print_expr(s, _else);
@@ -513,7 +515,7 @@ fn print_expr(ps s, &@ast.expr expr) {
case (_) { /* fall through */ }
}
}
- case (ast.expr_while(?test,?block,_)) {
+ case (ast::expr_while(?test,?block,_)) {
wrd1(s, "while");
popen_h(s);
print_expr(s, test);
@@ -521,7 +523,7 @@ fn print_expr(ps s, &@ast.expr expr) {
space(s.s);
print_block(s, block);
}
- case (ast.expr_for(?decl,?expr,?block,_)) {
+ case (ast::expr_for(?decl,?expr,?block,_)) {
wrd1(s, "for");
popen_h(s);
print_for_decl(s, decl);
@@ -532,7 +534,7 @@ fn print_expr(ps s, &@ast.expr expr) {
space(s.s);
print_block(s, block);
}
- case (ast.expr_for_each(?decl,?expr,?block,_)) {
+ case (ast::expr_for_each(?decl,?expr,?block,_)) {
wrd1(s, "for each");
popen_h(s);
print_for_decl(s, decl);
@@ -543,7 +545,7 @@ fn print_expr(ps s, &@ast.expr expr) {
space(s.s);
print_block(s, block);
}
- case (ast.expr_do_while(?block,?expr,_)) {
+ case (ast::expr_do_while(?block,?expr,_)) {
wrd1(s, "do");
space(s.s);
print_block(s, block);
@@ -553,14 +555,14 @@ fn print_expr(ps s, &@ast.expr expr) {
print_expr(s, expr);
pclose(s);
}
- case (ast.expr_alt(?expr,?arms,_)) {
+ case (ast::expr_alt(?expr,?arms,_)) {
wrd1(s, "alt");
popen_h(s);
print_expr(s, expr);
pclose(s);
space(s.s);
bopen(s);
- for (ast.arm arm in arms) {
+ for (ast::arm arm in arms) {
hbox(s);
wrd1(s, "case");
popen_h(s);
@@ -573,117 +575,117 @@ fn print_expr(ps s, &@ast.expr expr) {
}
bclose_c(s, expr.span);
}
- case (ast.expr_block(?block,_)) {
+ case (ast::expr_block(?block,_)) {
print_block(s, block);
}
- case (ast.expr_assign(?lhs,?rhs,_)) {
+ case (ast::expr_assign(?lhs,?rhs,_)) {
print_expr(s, lhs);
space(s.s);
wrd1(s, "=");
print_expr(s, rhs);
}
- case (ast.expr_assign_op(?op,?lhs,?rhs,_)) {
+ case (ast::expr_assign_op(?op,?lhs,?rhs,_)) {
print_expr(s, lhs);
space(s.s);
- wrd(s.s, ast.binop_to_str(op));
+ wrd(s.s, ast::binop_to_str(op));
wrd1(s, "=");
print_expr(s, rhs);
}
- case (ast.expr_send(?lhs, ?rhs, _)) {
+ case (ast::expr_send(?lhs, ?rhs, _)) {
print_expr(s, lhs);
space(s.s);
wrd1(s, "<|");
print_expr(s, rhs);
}
- case (ast.expr_recv(?lhs, ?rhs, _)) {
+ case (ast::expr_recv(?lhs, ?rhs, _)) {
print_expr(s, lhs);
space(s.s);
wrd1(s, "<-");
print_expr(s, rhs);
}
- case (ast.expr_field(?expr,?id,_)) {
+ case (ast::expr_field(?expr,?id,_)) {
print_expr(s, expr);
wrd(s.s, ".");
wrd(s.s, id);
}
- case (ast.expr_index(?expr,?index,_)) {
+ case (ast::expr_index(?expr,?index,_)) {
print_expr(s, expr);
wrd(s.s, ".");
popen_h(s);
print_expr(s, index);
pclose(s);
}
- case (ast.expr_path(?path,_)) {
+ case (ast::expr_path(?path,_)) {
print_path(s, path);
}
- case (ast.expr_fail(_)) {
+ case (ast::expr_fail(_)) {
wrd(s.s, "fail");
}
- case (ast.expr_break(_)) {
+ case (ast::expr_break(_)) {
wrd(s.s, "break");
}
- case (ast.expr_cont(_)) {
+ case (ast::expr_cont(_)) {
wrd(s.s, "cont");
}
- case (ast.expr_ret(?result,_)) {
+ case (ast::expr_ret(?result,_)) {
wrd(s.s, "ret");
alt (result) {
- case (Option.some[@ast.expr](?expr)) {
+ case (option::some[@ast::expr](?expr)) {
space(s.s);
print_expr(s, expr);
}
case (_) {}
}
}
- case (ast.expr_put(?result,_)) {
+ case (ast::expr_put(?result,_)) {
wrd(s.s, "put");
alt (result) {
- case (Option.some[@ast.expr](?expr)) {
+ case (option::some[@ast::expr](?expr)) {
space(s.s);
print_expr(s, expr);
}
case (_) {}
}
}
- case (ast.expr_be(?result,_)) {
+ case (ast::expr_be(?result,_)) {
wrd1(s, "be");
print_expr(s, result);
}
- case (ast.expr_log(?lvl,?expr,_)) {
+ case (ast::expr_log(?lvl,?expr,_)) {
alt (lvl) {
case (1) {wrd1(s, "log");}
case (0) {wrd1(s, "log_err");}
}
print_expr(s, expr);
}
- case (ast.expr_check(?expr,_)) {
+ case (ast::expr_check(?expr,_)) {
wrd1(s, "check");
popen_h(s);
print_expr(s, expr);
pclose(s);
}
- case (ast.expr_assert(?expr,_)) {
+ case (ast::expr_assert(?expr,_)) {
wrd1(s, "assert");
popen_h(s);
print_expr(s, expr);
pclose(s);
}
- case (ast.expr_ext(?path, ?args, ?body, _, _)) {
+ case (ast::expr_ext(?path, ?args, ?body, _, _)) {
wrd(s.s, "#");
print_path(s, path);
- if (Vec.len[@ast.expr](args) > 0u) {
+ if (_vec::len[@ast::expr](args) > 0u) {
popen(s);
commasep_exprs(s, args);
pclose(s);
}
// FIXME: extension 'body'
}
- case (ast.expr_port(_)) {
+ case (ast::expr_port(_)) {
wrd(s.s, "port");
popen_h(s);
pclose(s);
}
- case (ast.expr_chan(?expr, _)) {
+ case (ast::expr_chan(?expr, _)) {
wrd(s.s, "chan");
popen_h(s);
print_expr(s, expr);
@@ -693,13 +695,13 @@ fn print_expr(ps s, &@ast.expr expr) {
end(s.s);
}
-fn print_decl(ps s, @ast.decl decl) {
+fn print_decl(ps s, @ast::decl decl) {
maybe_print_comment(s, decl.span.lo);
hbox(s);
alt (decl.node) {
- case (ast.decl_local(?loc)) {
+ case (ast::decl_local(?loc)) {
alt (loc.ty) {
- case (Option.some[@ast.ty](?ty)) {
+ case (option::some[@ast::ty](?ty)) {
wrd1(s, "let");
print_type(s, ty);
space(s.s);
@@ -710,13 +712,13 @@ fn print_decl(ps s, @ast.decl decl) {
}
wrd(s.s, loc.ident);
alt (loc.init) {
- case (Option.some[ast.initializer](?init)) {
+ case (option::some[ast::initializer](?init)) {
space(s.s);
alt (init.op) {
- case (ast.init_assign) {
+ case (ast::init_assign) {
wrd1(s, "=");
}
- case (ast.init_recv) {
+ case (ast::init_recv) {
wrd1(s, "<-");
}
}
@@ -725,65 +727,65 @@ fn print_decl(ps s, @ast.decl decl) {
case (_) {}
}
}
- case (ast.decl_item(?item)) {
+ case (ast::decl_item(?item)) {
print_item(s, item);
}
}
end(s.s);
}
-fn print_ident(ps s, ast.ident ident) {
+fn print_ident(ps s, ast::ident ident) {
wrd(s.s, ident);
}
-fn print_for_decl(ps s, @ast.decl decl) {
+fn print_for_decl(ps s, @ast::decl decl) {
alt (decl.node) {
- case (ast.decl_local(?loc)) {
- print_type(s, Option.get[@ast.ty](loc.ty));
+ case (ast::decl_local(?loc)) {
+ print_type(s, option::get[@ast::ty](loc.ty));
space(s.s);
wrd(s.s, loc.ident);
}
}
}
-fn print_path(ps s, ast.path path) {
+fn print_path(ps s, ast::path path) {
maybe_print_comment(s, path.span.lo);
auto first = true;
for (str id in path.node.idents) {
if (first) {first = false;}
- else {wrd(s.s, ".");}
+ else {wrd(s.s, "::");}
wrd(s.s, id);
}
- if (Vec.len[@ast.ty](path.node.types) > 0u) {
+ if (_vec::len[@ast::ty](path.node.types) > 0u) {
wrd(s.s, "[");
auto f = print_type;
- commasep[@ast.ty](s, path.node.types, f);
+ commasep[@ast::ty](s, path.node.types, f);
wrd(s.s, "]");
}
}
-fn print_pat(ps s, &@ast.pat pat) {
+fn print_pat(ps s, &@ast::pat pat) {
maybe_print_comment(s, pat.span.lo);
alt (pat.node) {
- case (ast.pat_wild(_)) {wrd(s.s, "_");}
- case (ast.pat_bind(?id,_,_)) {wrd(s.s, "?" + id);}
- case (ast.pat_lit(?lit,_)) {print_literal(s, lit);}
- case (ast.pat_tag(?path,?args,_)) {
+ case (ast::pat_wild(_)) {wrd(s.s, "_");}
+ case (ast::pat_bind(?id,_,_)) {wrd(s.s, "?" + id);}
+ case (ast::pat_lit(?lit,_)) {print_literal(s, lit);}
+ case (ast::pat_tag(?path,?args,_)) {
print_path(s, path);
- if (Vec.len[@ast.pat](args) > 0u) {
+ if (_vec::len[@ast::pat](args) > 0u) {
popen_h(s);
auto f = print_pat;
- commasep[@ast.pat](s, args, f);
+ commasep[@ast::pat](s, args, f);
pclose(s);
}
}
}
}
-fn print_fn(ps s, ast.fn_decl decl, str name,
- vec[ast.ty_param] typarams) {
+fn print_fn(ps s, ast::fn_decl decl, str name,
+ vec[ast::ty_param] typarams) {
alt (decl.purity) {
- case (ast.impure_fn) {
+ case (ast::impure_fn) {
wrd1(s, "fn");
}
case (_) {
@@ -793,19 +795,19 @@ fn print_fn(ps s, ast.fn_decl decl, str name,
wrd(s.s, name);
print_type_params(s, typarams);
popen(s);
- fn print_arg(ps s, &ast.arg x) {
+ fn print_arg(ps s, &ast::arg x) {
hbox(s);
- if (x.mode == ast.alias) {wrd(s.s, "&");}
+ if (x.mode == ast::alias) {wrd(s.s, "&");}
print_type(s, x.ty);
space(s.s);
wrd(s.s, x.ident);
end(s.s);
}
auto f = print_arg;
- commasep[ast.arg](s, decl.inputs, f);
+ commasep[ast::arg](s, decl.inputs, f);
pclose(s);
maybe_print_comment(s, decl.output.span.lo);
- if (decl.output.node != ast.ty_nil) {
+ if (decl.output.node != ast::ty_nil) {
space(s.s);
hbox(s);
wrd1(s, "->");
@@ -814,28 +816,28 @@ fn print_fn(ps s, ast.fn_decl decl, str name,
}
}
-fn print_type_params(ps s, vec[ast.ty_param] params) {
- if (Vec.len[ast.ty_param](params) > 0u) {
+fn print_type_params(ps s, vec[ast::ty_param] params) {
+ if (_vec::len[ast::ty_param](params) > 0u) {
wrd(s.s, "[");
- fn printParam(ps s, &ast.ty_param param) {
+ fn printParam(ps s, &ast::ty_param param) {
wrd(s.s, param);
}
auto f = printParam;
- commasep[ast.ty_param](s, params, f);
+ commasep[ast::ty_param](s, params, f);
wrd(s.s, "]");
}
}
-fn print_view_item(ps s, @ast.view_item item) {
+fn print_view_item(ps s, @ast::view_item item) {
maybe_print_comment(s, item.span.lo);
hbox(s);
alt (item.node) {
- case (ast.view_item_use(?id,?mta,_,_)) {
+ case (ast::view_item_use(?id,?mta,_,_)) {
wrd1(s, "use");
wrd(s.s, id);
- if (Vec.len[@ast.meta_item](mta) > 0u) {
+ if (_vec::len[@ast::meta_item](mta) > 0u) {
popen(s);
- fn print_meta(ps s, &@ast.meta_item item) {
+ fn print_meta(ps s, &@ast::meta_item item) {
hbox(s);
wrd1(s, item.node.name);
wrd1(s, "=");
@@ -843,24 +845,24 @@ fn print_view_item(ps s, @ast.view_item item) {
end(s.s);
}
auto f = print_meta;
- commasep[@ast.meta_item](s, mta, f);
+ commasep[@ast::meta_item](s, mta, f);
pclose(s);
}
}
- case (ast.view_item_import(?id,?ids,_)) {
+ case (ast::view_item_import(?id,?ids,_)) {
wrd1(s, "import");
- if (!Str.eq(id, ids.(Vec.len[str](ids)-1u))) {
+ if (!_str::eq(id, ids.(_vec::len[str](ids)-1u))) {
wrd1(s, id);
wrd1(s, "=");
}
auto first = true;
for (str elt in ids) {
if (first) {first = false;}
- else {wrd(s.s, ".");}
+ else {wrd(s.s, ":");}
wrd(s.s, elt);
}
}
- case (ast.view_item_export(?id)) {
+ case (ast::view_item_export(?id)) {
wrd1(s, "export");
wrd(s.s, id);
}
@@ -872,20 +874,20 @@ fn print_view_item(ps s, @ast.view_item item) {
// FIXME: The fact that this builds up the table anew for every call is
// not good. Eventually, table should be a const.
-fn operator_prec(ast.binop op) -> int {
- for (front.parser.op_spec spec in front.parser.prec_table()) {
+fn operator_prec(ast::binop op) -> int {
+ for (front::parser::op_spec spec in front::parser::prec_table()) {
if (spec.op == op) {ret spec.prec;}
}
fail;
}
-fn print_maybe_parens(ps s, @ast.expr expr, int outer_prec) {
+fn print_maybe_parens(ps s, @ast::expr expr, int outer_prec) {
auto add_them;
alt (expr.node) {
- case (ast.expr_binary(?op,_,_,_)) {
+ case (ast::expr_binary(?op,_,_,_)) {
add_them = operator_prec(op) < outer_prec;
}
- case (ast.expr_cast(_,_,_)) {
+ case (ast::expr_cast(_,_,_)) {
add_them = as_prec < outer_prec;
}
case (_) {
@@ -899,7 +901,7 @@ fn print_maybe_parens(ps s, @ast.expr expr, int outer_prec) {
fn escape_str(str st, char to_escape) -> str {
let str out = "";
- auto len = Str.byte_len(st);
+ auto len = _str::byte_len(st);
auto i = 0u;
while (i < len) {
alt (st.(i) as char) {
@@ -909,7 +911,7 @@ fn escape_str(str st, char to_escape) -> str {
case ('\\') {out += "\\\\";}
case (?cur) {
if (cur == to_escape) {out += "\\";}
- Str.push_byte(out, cur as u8);
+ _str::push_byte(out, cur as u8);
}
}
i += 1u;
@@ -917,11 +919,11 @@ fn escape_str(str st, char to_escape) -> str {
ret out;
}
-fn print_mt(ps s, &ast.mt mt) {
+fn print_mt(ps s, &ast::mt mt) {
alt (mt.mut) {
- case (ast.mut) { wrd1(s, "mutable"); }
- case (ast.maybe_mut) { wrd1(s, "mutable?"); }
- case (ast.imm) { /* nothing */ }
+ case (ast::mut) { wrd1(s, "mutable"); }
+ case (ast::maybe_mut) { wrd1(s, "mutable?"); }
+ case (ast::imm) { /* nothing */ }
}
print_type(s, mt.ty);
}
@@ -930,24 +932,24 @@ fn print_string(ps s, str st) {
wrd(s.s, "\""); wrd(s.s, escape_str(st, '"')); wrd(s.s, "\"");
}
-fn print_ty_fn(ps s, ast.proto proto, Option.t[str] id,
- vec[ast.ty_arg] inputs, @ast.ty output) {
- if (proto == ast.proto_fn) {wrd(s.s, "fn");}
+fn print_ty_fn(ps s, ast::proto proto, option::t[str] id,
+ vec[ast::ty_arg] inputs, @ast::ty output) {
+ if (proto == ast::proto_fn) {wrd(s.s, "fn");}
else {wrd(s.s, "iter");}
alt (id) {
- case (Option.some[str](?id)) {space(s.s); wrd(s.s, id);}
+ case (option::some[str](?id)) {space(s.s); wrd(s.s, id);}
case (_) {}
}
popen_h(s);
- fn print_arg(ps s, &ast.ty_arg input) {
- if (input.mode == ast.alias) {wrd(s.s, "&");}
+ fn print_arg(ps s, &ast::ty_arg input) {
+ if (input.mode == ast::alias) {wrd(s.s, "&");}
print_type(s, input.ty);
}
auto f = print_arg;
- commasep[ast.ty_arg](s, inputs, f);
+ commasep[ast::ty_arg](s, inputs, f);
pclose(s);
maybe_print_comment(s, output.span.lo);
- if (output.node != ast.ty_nil) {
+ if (output.node != ast::ty_nil) {
space(s.s);
hbox(s);
wrd1(s, "->");
@@ -956,21 +958,21 @@ fn print_ty_fn(ps s, ast.proto proto, Option.t[str] id,
}
}
-fn next_comment(ps s) -> Option.t[lexer.cmnt] {
+fn next_comment(ps s) -> option::t[lexer::cmnt] {
alt (s.comments) {
- case (Option.some[vec[lexer.cmnt]](?cmnts)) {
- if (s.cur_cmnt < Vec.len[lexer.cmnt](cmnts)) {
- ret Option.some[lexer.cmnt](cmnts.(s.cur_cmnt));
- } else {ret Option.none[lexer.cmnt];}
+ case (option::some[vec[lexer::cmnt]](?cmnts)) {
+ if (s.cur_cmnt < _vec::len[lexer::cmnt](cmnts)) {
+ ret option::some[lexer::cmnt](cmnts.(s.cur_cmnt));
+ } else {ret option::none[lexer::cmnt];}
}
- case (_) {ret Option.none[lexer.cmnt];}
+ case (_) {ret option::none[lexer::cmnt];}
}
}
fn maybe_print_comment(ps s, uint pos) {
while (true) {
alt (next_comment(s)) {
- case (Option.some[lexer.cmnt](?cmnt)) {
+ case (option::some[lexer::cmnt](?cmnt)) {
if (cmnt.pos < pos) {
print_comment(s, cmnt.val);
if (cmnt.space_after) {line(s.s);}
@@ -982,9 +984,9 @@ fn maybe_print_comment(ps s, uint pos) {
}
}
-fn maybe_print_line_comment(ps s, common.span span) -> bool {
+fn maybe_print_line_comment(ps s, common::span span) -> bool {
alt (next_comment(s)) {
- case (Option.some[lexer.cmnt](?cmnt)) {
+ case (option::some[lexer::cmnt](?cmnt)) {
if (span.hi + 4u >= cmnt.pos) {
wrd(s.s, " ");
print_comment(s, cmnt.val);
@@ -1000,7 +1002,7 @@ fn maybe_print_line_comment(ps s, common.span span) -> bool {
fn print_remaining_comments(ps s) {
while (true) {
alt (next_comment(s)) {
- case (Option.some[lexer.cmnt](?cmnt)) {
+ case (option::some[lexer::cmnt](?cmnt)) {
print_comment(s, cmnt.val);
if (cmnt.space_after) {line(s.s);}
s.cur_cmnt += 1u;
@@ -1010,20 +1012,20 @@ fn print_remaining_comments(ps s) {
}
}
-fn print_comment(ps s, lexer.cmnt_ cmnt) {
+fn print_comment(ps s, lexer::cmnt_ cmnt) {
alt (cmnt) {
- case (lexer.cmnt_line(?val)) {
+ case (lexer::cmnt_line(?val)) {
wrd(s.s, "// " + val);
- pp.hardbreak(s.s);
+ pp::hardbreak(s.s);
}
- case (lexer.cmnt_block(?lines)) {
- pp.abox(s.s);
+ case (lexer::cmnt_block(?lines)) {
+ pp::abox(s.s);
wrd(s.s, "/* ");
- pp.abox(s.s);
+ pp::abox(s.s);
auto first = true;
for (str ln in lines) {
if (first) {first = false;}
- else {pp.hardbreak(s.s);}
+ else {pp::hardbreak(s.s);}
wrd(s.s, ln);
}
end(s.s);
diff --git a/src/comp/rustc.rc b/src/comp/rustc.rc
index de11256c184fa..1e619b293f938 100644
--- a/src/comp/rustc.rc
+++ b/src/comp/rustc.rc
@@ -55,11 +55,11 @@ mod util {
mod typestate_ann;
}
-auth front.creader.load_crate = unsafe;
-auth front.creader.get_metadata_section = unsafe;
-auth middle.metadata = unsafe;
-auth middle.trans = unsafe;
-auth lib.llvm = unsafe;
+auth front::creader::load_crate = unsafe;
+auth front::creader::get_metadata_section = unsafe;
+auth middle::metadata = unsafe;
+auth middle::trans = unsafe;
+auth lib::llvm = unsafe;
mod lib {
alt (target_os) {
diff --git a/src/comp/util/common.rs b/src/comp/util/common.rs
index 83223d7507e18..dc5e6d0897e3c 100644
--- a/src/comp/util/common.rs
+++ b/src/comp/util/common.rs
@@ -1,23 +1,23 @@
-import std.Map;
-import std.Map.hashmap;
-import std.UInt;
-import std.Int;
-import std.Vec;
-import std.Option.none;
-import front.ast;
-import util.typestate_ann.ts_ann;
-
-import middle.fold;
-import middle.fold.respan;
-
-import std.IO.stdout;
-import std.IO.str_writer;
-import std.IO.string_writer;
-import pretty.pprust.print_block;
-import pretty.pprust.print_expr;
-import pretty.pprust.print_decl;
-import pretty.pprust.print_fn;
-import pretty.pp.mkstate;
+import std::map;
+import std::map::hashmap;
+import std::_uint;
+import std::_int;
+import std::_vec;
+import std::option::none;
+import front::ast;
+import util::typestate_ann::ts_ann;
+
+import middle::fold;
+import middle::fold::respan;
+
+import std::io::stdout;
+import std::io::str_writer;
+import std::io::string_writer;
+import pretty::pprust::print_block;
+import pretty::pprust::print_expr;
+import pretty::pprust::print_decl;
+import pretty::pprust::print_fn;
+import pretty::pp::mkstate;
type filename = str;
type span = rec(uint lo, uint hi);
@@ -56,150 +56,150 @@ fn ty_mach_to_str(ty_mach tm) -> str {
}
}
-fn new_str_hash[V]() -> std.Map.hashmap[str,V] {
- let std.Map.hashfn[str] hasher = std.Str.hash;
- let std.Map.eqfn[str] eqer = std.Str.eq;
- ret std.Map.mk_hashmap[str,V](hasher, eqer);
+fn new_str_hash[V]() -> std::map::hashmap[str,V] {
+ let std::map::hashfn[str] hasher = std::_str::hash;
+ let std::map::eqfn[str] eqer = std::_str::eq;
+ ret std::map::mk_hashmap[str,V](hasher, eqer);
}
-fn def_eq(&ast.def_id a, &ast.def_id b) -> bool {
+fn def_eq(&ast::def_id a, &ast::def_id b) -> bool {
ret a._0 == b._0 && a._1 == b._1;
}
-fn hash_def(&ast.def_id d) -> uint {
+fn hash_def(&ast::def_id d) -> uint {
auto h = 5381u;
h = ((h << 5u) + h) ^ (d._0 as uint);
h = ((h << 5u) + h) ^ (d._1 as uint);
ret h;
}
-fn new_def_hash[V]() -> std.Map.hashmap[ast.def_id,V] {
- let std.Map.hashfn[ast.def_id] hasher = hash_def;
- let std.Map.eqfn[ast.def_id] eqer = def_eq;
- ret std.Map.mk_hashmap[ast.def_id,V](hasher, eqer);
+fn new_def_hash[V]() -> std::map::hashmap[ast::def_id,V] {
+ let std::map::hashfn[ast::def_id] hasher = hash_def;
+ let std::map::eqfn[ast::def_id] eqer = def_eq;
+ ret std::map::mk_hashmap[ast::def_id,V](hasher, eqer);
}
-fn new_int_hash[V]() -> std.Map.hashmap[int,V] {
+fn new_int_hash[V]() -> std::map::hashmap[int,V] {
fn hash_int(&int x) -> uint { ret x as uint; }
fn eq_int(&int a, &int b) -> bool { ret a == b; }
auto hasher = hash_int;
auto eqer = eq_int;
- ret std.Map.mk_hashmap[int,V](hasher, eqer);
+ ret std::map::mk_hashmap[int,V](hasher, eqer);
}
-fn new_uint_hash[V]() -> std.Map.hashmap[uint,V] {
+fn new_uint_hash[V]() -> std::map::hashmap[uint,V] {
fn hash_uint(&uint x) -> uint { ret x; }
fn eq_uint(&uint a, &uint b) -> bool { ret a == b; }
auto hasher = hash_uint;
auto eqer = eq_uint;
- ret std.Map.mk_hashmap[uint,V](hasher, eqer);
+ ret std::map::mk_hashmap[uint,V](hasher, eqer);
}
fn istr(int i) -> str {
- ret Int.to_str(i, 10u);
+ ret _int::to_str(i, 10u);
}
fn uistr(uint i) -> str {
- ret UInt.to_str(i, 10u);
+ ret _uint::to_str(i, 10u);
}
-fn elt_expr(&ast.elt e) -> @ast.expr { ret e.expr; }
+fn elt_expr(&ast::elt e) -> @ast::expr { ret e.expr; }
-fn elt_exprs(&vec[ast.elt] elts) -> vec[@ast.expr] {
+fn elt_exprs(&vec[ast::elt] elts) -> vec[@ast::expr] {
auto f = elt_expr;
- ret Vec.map[ast.elt, @ast.expr](f, elts);
+ ret _vec::map[ast::elt, @ast::expr](f, elts);
}
-fn field_expr(&ast.field f) -> @ast.expr { ret f.expr; }
+fn field_expr(&ast::field f) -> @ast::expr { ret f.expr; }
-fn field_exprs(vec[ast.field] fields) -> vec [@ast.expr] {
+fn field_exprs(vec[ast::field] fields) -> vec [@ast::expr] {
auto f = field_expr;
- ret Vec.map[ast.field, @ast.expr](f, fields);
+ ret _vec::map[ast::field, @ast::expr](f, fields);
}
-fn plain_ann(&ast.ann old, middle.ty.ctxt tcx) -> ast.ann {
- ret ast.ann_type(ast.ann_tag(old), middle.ty.mk_nil(tcx),
- none[vec[middle.ty.t]], none[@ts_ann]);
+fn plain_ann(&ast::ann old, middle::ty::ctxt tcx) -> ast::ann {
+ ret ast::ann_type(ast::ann_tag(old), middle::ty::mk_nil(tcx),
+ none[vec[middle::ty::t]], none[@ts_ann]);
}
-fn expr_to_str(&@ast.expr e) -> str {
+fn expr_to_str(&@ast::expr e) -> str {
let str_writer s = string_writer();
auto out_ = mkstate(s.get_writer(), 80u);
auto out = @rec(s=out_,
- comments=none[vec[front.lexer.cmnt]],
+ comments=none[vec[front::lexer::cmnt]],
mutable cur_cmnt=0u);
print_expr(out, e);
ret s.get_str();
}
-fn log_expr(&ast.expr e) -> () {
+fn log_expr(&ast::expr e) -> () {
log(expr_to_str(@e));
}
-fn log_expr_err(&ast.expr e) -> () {
+fn log_expr_err(&ast::expr e) -> () {
log_err(expr_to_str(@e));
}
-fn block_to_str(&ast.block b) -> str {
+fn block_to_str(&ast::block b) -> str {
let str_writer s = string_writer();
auto out_ = mkstate(s.get_writer(), 80u);
auto out = @rec(s=out_,
- comments=none[vec[front.lexer.cmnt]],
+ comments=none[vec[front::lexer::cmnt]],
mutable cur_cmnt=0u);
print_block(out, b);
ret s.get_str();
}
-fn log_block(&ast.block b) -> () {
+fn log_block(&ast::block b) -> () {
log(block_to_str(b));
}
-fn log_block_err(&ast.block b) -> () {
+fn log_block_err(&ast::block b) -> () {
log_err(block_to_str(b));
}
-fn log_ann(&ast.ann a) -> () {
+fn log_ann(&ast::ann a) -> () {
alt (a) {
- case (ast.ann_none(_)) {
+ case (ast::ann_none(_)) {
log("ann_none");
}
- case (ast.ann_type(_,_,_,_)) {
+ case (ast::ann_type(_,_,_,_)) {
log("ann_type");
}
}
}
-fn fun_to_str(&ast._fn f, str name, vec[ast.ty_param] params) -> str {
+fn fun_to_str(&ast::_fn f, str name, vec[ast::ty_param] params) -> str {
let str_writer s = string_writer();
auto out_ = mkstate(s.get_writer(), 80u);
auto out = @rec(s=out_,
- comments=none[vec[front.lexer.cmnt]],
+ comments=none[vec[front::lexer::cmnt]],
mutable cur_cmnt=0u);
print_fn(out, f.decl, name, params);
ret s.get_str();
}
-fn log_fn(&ast._fn f, str name, vec[ast.ty_param] params) -> () {
+fn log_fn(&ast::_fn f, str name, vec[ast::ty_param] params) -> () {
log(fun_to_str(f, name, params));
}
-fn log_fn_err(&ast._fn f, str name, vec[ast.ty_param] params) -> () {
+fn log_fn_err(&ast::_fn f, str name, vec[ast::ty_param] params) -> () {
log_err(fun_to_str(f, name, params));
}
-fn stmt_to_str(&ast.stmt st) -> str {
+fn stmt_to_str(&ast::stmt st) -> str {
let str_writer s = string_writer();
auto out_ = mkstate(s.get_writer(), 80u);
auto out = @rec(s=out_,
- comments=none[vec[front.lexer.cmnt]],
+ comments=none[vec[front::lexer::cmnt]],
mutable cur_cmnt=0u);
alt (st.node) {
- case (ast.stmt_decl(?decl,_)) {
+ case (ast::stmt_decl(?decl,_)) {
print_decl(out, decl);
}
- case (ast.stmt_expr(?ex,_)) {
+ case (ast::stmt_expr(?ex,_)) {
print_expr(out, ex);
}
case (_) { /* do nothing */ }
@@ -207,40 +207,40 @@ fn stmt_to_str(&ast.stmt st) -> str {
ret s.get_str();
}
-fn log_stmt(&ast.stmt st) -> () {
+fn log_stmt(&ast::stmt st) -> () {
log(stmt_to_str(st));
}
-fn log_stmt_err(&ast.stmt st) -> () {
+fn log_stmt_err(&ast::stmt st) -> () {
log_err(stmt_to_str(st));
}
-fn decl_lhs(@ast.decl d) -> ast.def_id {
+fn decl_lhs(@ast::decl d) -> ast::def_id {
alt (d.node) {
- case (ast.decl_local(?l)) {
+ case (ast::decl_local(?l)) {
ret l.id;
}
- case (ast.decl_item(?an_item)) {
+ case (ast::decl_item(?an_item)) {
alt (an_item.node) {
- case (ast.item_const(_,_,_,?d,_)) {
+ case (ast::item_const(_,_,_,?d,_)) {
ret d;
}
- case (ast.item_fn(_,_,_,?d,_)) {
+ case (ast::item_fn(_,_,_,?d,_)) {
ret d;
}
- case (ast.item_mod(_,_,?d)) {
+ case (ast::item_mod(_,_,?d)) {
ret d;
}
- case (ast.item_native_mod(_,_,?d)) {
+ case (ast::item_native_mod(_,_,?d)) {
ret d;
}
- case (ast.item_ty(_,_,_,?d,_)) {
+ case (ast::item_ty(_,_,_,?d,_)) {
ret d;
}
- case (ast.item_tag(_,_,_,?d,_)) {
+ case (ast::item_tag(_,_,_,?d,_)) {
ret d;
}
- case (ast.item_obj(_,_,_,?d,_)) {
+ case (ast::item_obj(_,_,_,?d,_)) {
ret d.ctor; /* This doesn't really make sense */
}
}
@@ -248,29 +248,29 @@ fn decl_lhs(@ast.decl d) -> ast.def_id {
}
}
-fn has_nonlocal_exits(&ast.block b) -> bool {
+fn has_nonlocal_exits(&ast::block b) -> bool {
/* overkill, but just passing around a mutable bool doesn't seem
to work in rustboot */
auto has_exits = new_str_hash[()]();
- fn set_break(&flag f, &span sp, &ast.ann a) -> @ast.expr {
+ fn set_break(&flag f, &span sp, &ast::ann a) -> @ast::expr {
f.insert("foo", ());
- ret @respan(sp, ast.expr_break(a));
+ ret @respan(sp, ast::expr_break(a));
}
- fn set_cont(&flag f, &span sp, &ast.ann a) -> @ast.expr {
+ fn set_cont(&flag f, &span sp, &ast::ann a) -> @ast::expr {
f.insert("foo", ());
- ret @respan(sp, ast.expr_cont(a));
+ ret @respan(sp, ast::expr_cont(a));
}
fn check_b(&flag f) -> bool {
ret (f.size() == 0u);
}
- auto fld0 = fold.new_identity_fold[flag]();
+ auto fld0 = fold::new_identity_fold[flag]();
fld0 = @rec(fold_expr_break = bind set_break(_,_,_),
fold_expr_cont = bind set_cont(_,_,_),
keep_going = bind check_b(_) with *fld0);
- fold.fold_block[flag](has_exits, fld0, b);
+ fold::fold_block[flag](has_exits, fld0, b);
ret (has_exits.size() > 0u);
}
diff --git a/src/comp/util/typestate_ann.rs b/src/comp/util/typestate_ann.rs
index 949eaeb2f54b6..249dc5ca61d6a 100644
--- a/src/comp/util/typestate_ann.rs
+++ b/src/comp/util/typestate_ann.rs
@@ -1,21 +1,21 @@
-import front.ast.ident;
-import std.Vec;
-import std.BitV;
+import front::ast::ident;
+import std::_vec;
+import std::bitv;
/*
This says: this expression requires the idents in to be initialized,
and given the precondition, it guarantees that the idents in are
initialized.
*/
-type precond = BitV.t; /* 1 means "this variable must be initialized"
+type precond = bitv::t; /* 1 means "this variable must be initialized"
0 means "don't care about this variable" */
-type postcond = BitV.t; /* 1 means "this variable is initialized"
+type postcond = bitv::t; /* 1 means "this variable is initialized"
0 means "don't know about this variable */
-type prestate = BitV.t; /* 1 means "this variable is definitely initialized"
+type prestate = bitv::t; /* 1 means "this variable is definitely initialized"
0 means "don't know whether this variable is
initialized" */
-type poststate = BitV.t; /* 1 means "this variable is definitely initialized"
+type poststate = bitv::t; /* 1 means "this variable is definitely initialized"
0 means "don't know whether this variable is
initialized" */
@@ -29,7 +29,7 @@ type pre_and_post_state = rec(prestate prestate, poststate poststate);
type ts_ann = rec(pre_and_post conditions, pre_and_post_state states);
fn true_precond(uint num_vars) -> precond {
- be BitV.create(num_vars, false);
+ be bitv::create(num_vars, false);
}
fn true_postcond(uint num_vars) -> postcond {
@@ -45,7 +45,7 @@ fn empty_poststate(uint num_vars) -> poststate {
}
fn false_postcond(uint num_vars) -> postcond {
- be BitV.create(num_vars, true);
+ be bitv::create(num_vars, true);
}
fn empty_pre_post(uint num_vars) -> pre_and_post {
@@ -72,15 +72,15 @@ fn get_post(&pre_and_post p) -> postcond {
}
fn difference(&precond p1, &precond p2) -> bool {
- be BitV.difference(p1, p2);
+ be bitv::difference(p1, p2);
}
fn union(&precond p1, &precond p2) -> bool {
- be BitV.union(p1, p2);
+ be bitv::union(p1, p2);
}
fn intersect(&precond p1, &precond p2) -> bool {
- be BitV.intersect(p1, p2);
+ be bitv::intersect(p1, p2);
}
fn pps_len(&pre_and_post p) -> uint {
@@ -91,62 +91,62 @@ fn pps_len(&pre_and_post p) -> uint {
fn require_and_preserve(uint i, &pre_and_post p) -> () {
// sets the ith bit in p's pre and post
- BitV.set(p.precondition, i, true);
- BitV.set(p.postcondition, i, true);
+ bitv::set(p.precondition, i, true);
+ bitv::set(p.postcondition, i, true);
}
fn set_in_postcond(uint i, &pre_and_post p) -> bool {
// sets the ith bit in p's post
- auto was_set = BitV.get(p.postcondition, i);
- BitV.set(p.postcondition, i, true);
+ auto was_set = bitv::get(p.postcondition, i);
+ bitv::set(p.postcondition, i, true);
ret !was_set;
}
fn set_in_poststate(uint i, &pre_and_post_state s) -> bool {
// sets the ith bit in p's post
- auto was_set = BitV.get(s.poststate, i);
- BitV.set(s.poststate, i, true);
+ auto was_set = bitv::get(s.poststate, i);
+ bitv::set(s.poststate, i, true);
ret !was_set;
}
// Sets all the bits in a's precondition to equal the
// corresponding bit in p's precondition.
fn set_precondition(&ts_ann a, &precond p) -> () {
- BitV.copy(a.conditions.precondition, p);
+ bitv::copy(a.conditions.precondition, p);
}
// Sets all the bits in a's postcondition to equal the
// corresponding bit in p's postcondition.
fn set_postcondition(&ts_ann a, &postcond p) -> () {
- BitV.copy(a.conditions.postcondition, p);
+ bitv::copy(a.conditions.postcondition, p);
}
// Sets all the bits in a's prestate to equal the
// corresponding bit in p's prestate.
fn set_prestate(@ts_ann a, &prestate p) -> bool {
- ret BitV.copy(a.states.prestate, p);
+ ret bitv::copy(a.states.prestate, p);
}
// Sets all the bits in a's postcondition to equal the
// corresponding bit in p's postcondition.
fn set_poststate(@ts_ann a, &poststate p) -> bool {
- ret BitV.copy(a.states.poststate, p);
+ ret bitv::copy(a.states.poststate, p);
}
// Set all the bits in p that are set in new
fn extend_prestate(&prestate p, &poststate new) -> bool {
- ret BitV.union(p, new);
+ ret bitv::union(p, new);
}
// Set all the bits in p that are set in new
fn extend_poststate(&poststate p, &poststate new) -> bool {
- ret BitV.union(p, new);
+ ret bitv::union(p, new);
}
// Clears the given bit in p
fn relax_prestate(uint i, &prestate p) -> bool {
- auto was_set = BitV.get(p, i);
- BitV.set(p, i, false);
+ auto was_set = bitv::get(p, i);
+ bitv::set(p, i, false);
ret was_set;
}
@@ -164,16 +164,16 @@ fn pp_clone(&pre_and_post p) -> pre_and_post {
}
fn clone(prestate p) -> prestate {
- ret BitV.clone(p);
+ ret bitv::clone(p);
}
// returns true if a implies b
// that is, returns true except if for some bits c and d,
// c = 1 and d = 0
-fn implies(BitV.t a, BitV.t b) -> bool {
- auto tmp = BitV.clone(b);
- BitV.difference(tmp, a);
- ret BitV.is_false(tmp);
+fn implies(bitv::t a, bitv::t b) -> bool {
+ auto tmp = bitv::clone(b);
+ bitv::difference(tmp, a);
+ ret bitv::is_false(tmp);
}
//
diff --git a/src/lib/GenericOS.rs b/src/lib/GenericOS.rs
deleted file mode 100644
index 567843f28c575..0000000000000
--- a/src/lib/GenericOS.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-fn getenv(str n) -> Option.t[str] {
- auto s = OS.libc.getenv(Str.buf(n));
- if ((s as int) == 0) {
- ret Option.none[str];
- } else {
- ret Option.some[str](Str.str_from_cstr(s));
- }
-}
-
diff --git a/src/lib/Int.rs b/src/lib/_int.rs
similarity index 93%
rename from src/lib/Int.rs
rename to src/lib/_int.rs
index 59fb507f7fb1c..321602ec1d8cd 100644
--- a/src/lib/Int.rs
+++ b/src/lib/_int.rs
@@ -29,9 +29,9 @@ fn to_str(int n, uint radix) -> str
{
assert (0u < radix && radix <= 16u);
if (n < 0) {
- ret "-" + UInt.to_str((-n) as uint, radix);
+ ret "-" + _uint::to_str((-n) as uint, radix);
} else {
- ret UInt.to_str(n as uint, radix);
+ ret _uint::to_str(n as uint, radix);
}
}
diff --git a/src/lib/Str.rs b/src/lib/_str.rs
similarity index 81%
rename from src/lib/Str.rs
rename to src/lib/_str.rs
index 6e39b3599f446..36b2376d4dbed 100644
--- a/src/lib/Str.rs
+++ b/src/lib/_str.rs
@@ -1,6 +1,6 @@
-import rustrt.sbuf;
+import rustrt::sbuf;
-import Vec.rustrt.vbuf;
+import _vec::rustrt::vbuf;
native "rust" mod rustrt {
type sbuf;
@@ -84,7 +84,7 @@ const uint tag_six_b = 0xfc_u;
fn is_utf8(vec[u8] v) -> bool {
auto i = 0u;
- auto total = Vec.len[u8](v);
+ auto total = _vec::len[u8](v);
while (i < total) {
auto chsize = utf8_char_width(v.(i));
if (chsize == 0u) {ret false;}
@@ -111,7 +111,7 @@ fn is_ascii(str s) -> bool {
}
fn alloc(uint n_bytes) -> str {
- ret rustrt.str_alloc(n_bytes);
+ ret rustrt::str_alloc(n_bytes);
}
// Returns the number of bytes (a.k.a. UTF-8 code units) in s.
@@ -120,67 +120,67 @@ fn alloc(uint n_bytes) -> str {
// http://icu-project.org/apiref/icu4c/classBreakIterator.html for a
// way to implement those.
fn byte_len(str s) -> uint {
- ret rustrt.str_byte_len(s);
+ ret rustrt::str_byte_len(s);
}
fn buf(str s) -> sbuf {
- ret rustrt.str_buf(s);
+ ret rustrt::str_buf(s);
}
fn bytes(str s) -> vec[u8] {
- ret rustrt.str_vec(s);
+ ret rustrt::str_vec(s);
}
fn from_bytes(vec[u8] v) : is_utf8(v) -> str {
- ret rustrt.str_from_vec(v);
+ ret rustrt::str_from_vec(v);
}
// FIXME temp thing
fn unsafe_from_bytes(vec[mutable? u8] v) -> str {
- ret rustrt.str_from_vec(v);
+ ret rustrt::str_from_vec(v);
}
fn unsafe_from_byte(u8 u) -> str {
- ret rustrt.str_from_vec(vec(u));
+ ret rustrt::str_from_vec(vec(u));
}
fn str_from_cstr(sbuf cstr) -> str {
- ret rustrt.str_from_cstr(cstr);
+ ret rustrt::str_from_cstr(cstr);
}
fn str_from_buf(sbuf buf, uint len) -> str {
- ret rustrt.str_from_buf(buf, len);
+ ret rustrt::str_from_buf(buf, len);
}
fn push_utf8_bytes(&mutable str s, char ch) {
auto code = ch as uint;
if (code < max_one_b) {
- s = rustrt.str_push_byte(s, code);
+ s = rustrt::str_push_byte(s, code);
} else if (code < max_two_b) {
- s = rustrt.str_push_byte(s, ((code >> 6u) & 0x1f_u) | tag_two_b);
- s = rustrt.str_push_byte(s, (code & 0x3f_u) | tag_cont);
+ s = rustrt::str_push_byte(s, ((code >> 6u) & 0x1f_u) | tag_two_b);
+ s = rustrt::str_push_byte(s, (code & 0x3f_u) | tag_cont);
} else if (code < max_three_b) {
- s = rustrt.str_push_byte(s, ((code >> 12u) & 0x0f_u) | tag_three_b);
- s = rustrt.str_push_byte(s, ((code >> 6u) & 0x3f_u) | tag_cont);
- s = rustrt.str_push_byte(s, (code & 0x3f_u) | tag_cont);
+ s = rustrt::str_push_byte(s, ((code >> 12u) & 0x0f_u) | tag_three_b);
+ s = rustrt::str_push_byte(s, ((code >> 6u) & 0x3f_u) | tag_cont);
+ s = rustrt::str_push_byte(s, (code & 0x3f_u) | tag_cont);
} else if (code < max_four_b) {
- s = rustrt.str_push_byte(s, ((code >> 18u) & 0x07_u) | tag_four_b);
- s = rustrt.str_push_byte(s, ((code >> 12u) & 0x3f_u) | tag_cont);
- s = rustrt.str_push_byte(s, ((code >> 6u) & 0x3f_u) | tag_cont);
- s = rustrt.str_push_byte(s, (code & 0x3f_u) | tag_cont);
+ s = rustrt::str_push_byte(s, ((code >> 18u) & 0x07_u) | tag_four_b);
+ s = rustrt::str_push_byte(s, ((code >> 12u) & 0x3f_u) | tag_cont);
+ s = rustrt::str_push_byte(s, ((code >> 6u) & 0x3f_u) | tag_cont);
+ s = rustrt::str_push_byte(s, (code & 0x3f_u) | tag_cont);
} else if (code < max_five_b) {
- s = rustrt.str_push_byte(s, ((code >> 24u) & 0x03_u) | tag_five_b);
- s = rustrt.str_push_byte(s, ((code >> 18u) & 0x3f_u) | tag_cont);
- s = rustrt.str_push_byte(s, ((code >> 12u) & 0x3f_u) | tag_cont);
- s = rustrt.str_push_byte(s, ((code >> 6u) & 0x3f_u) | tag_cont);
- s = rustrt.str_push_byte(s, (code & 0x3f_u) | tag_cont);
+ s = rustrt::str_push_byte(s, ((code >> 24u) & 0x03_u) | tag_five_b);
+ s = rustrt::str_push_byte(s, ((code >> 18u) & 0x3f_u) | tag_cont);
+ s = rustrt::str_push_byte(s, ((code >> 12u) & 0x3f_u) | tag_cont);
+ s = rustrt::str_push_byte(s, ((code >> 6u) & 0x3f_u) | tag_cont);
+ s = rustrt::str_push_byte(s, (code & 0x3f_u) | tag_cont);
} else {
- s = rustrt.str_push_byte(s, ((code >> 30u) & 0x01_u) | tag_six_b);
- s = rustrt.str_push_byte(s, ((code >> 24u) & 0x3f_u) | tag_cont);
- s = rustrt.str_push_byte(s, ((code >> 18u) & 0x3f_u) | tag_cont);
- s = rustrt.str_push_byte(s, ((code >> 12u) & 0x3f_u) | tag_cont);
- s = rustrt.str_push_byte(s, ((code >> 6u) & 0x3f_u) | tag_cont);
- s = rustrt.str_push_byte(s, (code & 0x3f_u) | tag_cont);
+ s = rustrt::str_push_byte(s, ((code >> 30u) & 0x01_u) | tag_six_b);
+ s = rustrt::str_push_byte(s, ((code >> 24u) & 0x3f_u) | tag_cont);
+ s = rustrt::str_push_byte(s, ((code >> 18u) & 0x3f_u) | tag_cont);
+ s = rustrt::str_push_byte(s, ((code >> 12u) & 0x3f_u) | tag_cont);
+ s = rustrt::str_push_byte(s, ((code >> 6u) & 0x3f_u) | tag_cont);
+ s = rustrt::str_push_byte(s, (code & 0x3f_u) | tag_cont);
}
}
@@ -253,7 +253,7 @@ fn to_chars(str s) -> vec[char] {
auto len = byte_len(s);
while (i < len) {
auto cur = char_range_at(s, i);
- Vec.push[char](buf, cur._0);
+ _vec::push[char](buf, cur._0);
i = cur._1;
}
ret buf;
@@ -287,8 +287,8 @@ fn unshift_char(&mutable str s, char ch) {
}
fn refcount(str s) -> uint {
- auto r = rustrt.refcount[u8](s);
- if (r == Dbg.const_refcount) {
+ auto r = rustrt::refcount[u8](s);
+ if (r == dbg::const_refcount) {
ret r;
} else {
// -1 because calling this function incremented the refcount.
@@ -311,7 +311,7 @@ fn index(str s, u8 c) -> int {
}
fn rindex(str s, u8 c) -> int {
- let int n = Str.byte_len(s) as int;
+ let int n = _str::byte_len(s) as int;
while (n >= 0) {
if (s.(n) == c) {
ret n;
@@ -387,8 +387,8 @@ fn substr(str s, uint begin, uint len) -> str {
fn slice(str s, uint begin, uint end) -> str {
// FIXME: Typestate precondition
assert (begin <= end);
- assert (end <= Str.byte_len(s));
- ret rustrt.str_slice(s, begin, end);
+ assert (end <= _str::byte_len(s));
+ ret rustrt::str_slice(s, begin, end);
}
fn shift_byte(&mutable str s) -> u8 {
@@ -408,7 +408,7 @@ fn pop_byte(&mutable str s) -> u8 {
}
fn push_byte(&mutable str s, u8 b) {
- s = rustrt.str_push_byte(s, b as uint);
+ s = rustrt::str_push_byte(s, b as uint);
}
fn unshift_byte(&mutable str s, u8 b) {
@@ -432,7 +432,7 @@ fn split(str s, u8 sep) -> vec[str] {
ends_with_sep = false;
}
}
- if (Str.byte_len(accum) != 0u ||
+ if (_str::byte_len(accum) != 0u ||
ends_with_sep) {
v += vec(accum);
}
diff --git a/src/lib/Task.rs b/src/lib/_task.rs
similarity index 92%
rename from src/lib/Task.rs
rename to src/lib/_task.rs
index 8eece16b50827..b6b754f0cb2d6 100644
--- a/src/lib/Task.rs
+++ b/src/lib/_task.rs
@@ -8,7 +8,7 @@ native "rust" mod rustrt {
* arg: time_in_us maximum number of microseconds to yield control for
*/
fn sleep(uint time_in_us) {
- ret rustrt.task_sleep(time_in_us);
+ ret rustrt::task_sleep(time_in_us);
}
// Local Variables:
diff --git a/src/lib/U8.rs b/src/lib/_u8.rs
similarity index 100%
rename from src/lib/U8.rs
rename to src/lib/_u8.rs
diff --git a/src/lib/UInt.rs b/src/lib/_uint.rs
similarity index 89%
rename from src/lib/UInt.rs
rename to src/lib/_uint.rs
index eea5232569405..a68901cc06d75 100644
--- a/src/lib/UInt.rs
+++ b/src/lib/_uint.rs
@@ -23,7 +23,7 @@ iter range(uint lo, uint hi) -> uint {
fn next_power_of_two(uint n) -> uint {
// FIXME change |* uint(4)| below to |* uint(8) / uint(2)| and watch the
// world explode.
- let uint halfbits = Sys.rustrt.size_of[uint]() * 4u;
+ let uint halfbits = sys::rustrt::size_of[uint]() * 4u;
let uint tmp = n - 1u;
let uint shift = 1u;
while (shift <= halfbits) {
@@ -34,12 +34,12 @@ fn next_power_of_two(uint n) -> uint {
}
fn parse_buf(vec[u8] buf, uint radix) -> uint {
- if (Vec.len[u8](buf) == 0u) {
+ if (_vec::len[u8](buf) == 0u) {
log_err "parse_buf(): buf is empty";
fail;
}
- auto i = Vec.len[u8](buf) - 1u;
+ auto i = _vec::len[u8](buf) - 1u;
auto power = 1u;
auto n = 0u;
while (true) {
@@ -83,15 +83,15 @@ fn to_str(uint num, uint radix) -> str
let str s = "";
while (n != 0u) {
- s += Str.unsafe_from_byte(digit(n % radix) as u8);
+ s += _str::unsafe_from_byte(digit(n % radix) as u8);
n /= radix;
}
let str s1 = "";
- let uint len = Str.byte_len(s);
+ let uint len = _str::byte_len(s);
while (len != 0u) {
len -= 1u;
- s1 += Str.unsafe_from_byte(s.(len));
+ s1 += _str::unsafe_from_byte(s.(len));
}
ret s1;
diff --git a/src/lib/Vec.rs b/src/lib/_vec.rs
similarity index 87%
rename from src/lib/Vec.rs
rename to src/lib/_vec.rs
index 28b5d018d54c3..0988864a160dc 100644
--- a/src/lib/Vec.rs
+++ b/src/lib/_vec.rs
@@ -1,8 +1,8 @@
-import Option.none;
-import Option.some;
-import Util.orb;
+import option::none;
+import option::some;
+import util::orb;
-type vbuf = rustrt.vbuf;
+type vbuf = rustrt::vbuf;
type operator2[T,U,V] = fn(&T, &U) -> V;
@@ -38,16 +38,16 @@ native "rust" mod rustrt {
}
fn alloc[T](uint n_elts) -> vec[T] {
- ret rustrt.vec_alloc[vec[T], T](n_elts);
+ ret rustrt::vec_alloc[vec[T], T](n_elts);
}
fn alloc_mut[T](uint n_elts) -> vec[mutable T] {
- ret rustrt.vec_alloc_mut[vec[mutable T], T](n_elts);
+ ret rustrt::vec_alloc_mut[vec[mutable T], T](n_elts);
}
fn refcount[T](array[T] v) -> uint {
- auto r = rustrt.refcount[T](v);
- if (r == Dbg.const_refcount) {
+ auto r = rustrt::refcount[T](v);
+ if (r == dbg::const_refcount) {
ret r;
} else {
// -1 because calling this function incremented the refcount.
@@ -56,7 +56,7 @@ fn refcount[T](array[T] v) -> uint {
}
fn vec_from_vbuf[T](vbuf v, uint n_elts) -> vec[T] {
- ret rustrt.vec_from_vbuf[T](v, n_elts);
+ ret rustrt::vec_from_vbuf[T](v, n_elts);
}
// FIXME: Remove me; this is a botch to get around rustboot's bad typechecker.
@@ -119,28 +119,28 @@ fn init_elt_mut[T](&T t, uint n_elts) -> vec[mutable T] {
}
fn buf[T](array[T] v) -> vbuf {
- ret rustrt.vec_buf[T](v, 0u);
+ ret rustrt::vec_buf[T](v, 0u);
}
fn len[T](array[T] v) -> uint {
- ret rustrt.vec_len[T](v);
+ ret rustrt::vec_len[T](v);
}
fn len_set[T](array[T] v, uint n) {
- rustrt.vec_len_set[T](v, n);
+ rustrt::vec_len_set[T](v, n);
}
fn buf_off[T](array[T] v, uint offset) -> vbuf {
assert (offset < len[T](v));
- ret rustrt.vec_buf[T](v, offset);
+ ret rustrt::vec_buf[T](v, offset);
}
fn print_debug_info[T](array[T] v) {
- rustrt.vec_print_debug_info[T](v);
+ rustrt::vec_print_debug_info[T](v);
}
// Returns the last element of v.
-fn last[T](array[T] v) -> Option.t[T] {
+fn last[T](array[T] v) -> option::t[T] {
auto l = len[T](v);
if (l == 0u) {
ret none[T];
@@ -199,14 +199,14 @@ fn grow[T](&array[T] v, uint n, &T initval) {
}
fn grow_set[T](&vec[mutable T] v, uint index, &T initval, &T val) {
- auto length = Vec.len(v);
+ auto length = _vec::len(v);
if (index >= length) {
grow(v, index - length + 1u, initval);
}
v.(index) = val;
}
-fn map[T, U](&Option.operator[T,U] f, &array[T] v) -> vec[U] {
+fn map[T, U](&option::operator[T,U] f, &array[T] v) -> vec[U] {
let vec[U] u = alloc[U](len[T](v));
for (T ve in v) {
u += vec(f(ve));
@@ -230,7 +230,7 @@ fn map2[T,U,V](&operator2[T,U,V] f, &array[T] v0, &array[U] v1) -> vec[V] {
ret u;
}
-fn find[T](fn (&T) -> bool f, &array[T] v) -> Option.t[T] {
+fn find[T](fn (&T) -> bool f, &array[T] v) -> option::t[T] {
for (T elt in v) {
if (f(elt)) {
ret some[T](elt);
@@ -270,24 +270,24 @@ fn unzip[T, U](&vec[tup(T, U)] v) -> tup(vec[T], vec[U]) {
fn or(&vec[bool] v) -> bool {
auto f = orb;
- ret Vec.foldl[bool, bool](f, false, v);
+ ret _vec::foldl[bool, bool](f, false, v);
}
fn clone[T](&vec[T] v) -> vec[T] {
ret slice[T](v, 0u, len[T](v));
}
-fn plus_option[T](&vec[T] v, &Option.t[T] o) -> () {
+fn plus_option[T](&vec[T] v, &option::t[T] o) -> () {
alt (o) {
case (none[T]) {}
case (some[T](?x)) { v += vec(x); }
}
}
-fn cat_options[T](&vec[Option.t[T]] v) -> vec[T] {
+fn cat_options[T](&vec[option::t[T]] v) -> vec[T] {
let vec[T] res = vec();
- for (Option.t[T] o in v) {
+ for (option::t[T] o in v) {
alt (o) {
case (none[T]) { }
case (some[T](?t)) {
diff --git a/src/lib/BitV.rs b/src/lib/bitv.rs
similarity index 85%
rename from src/lib/BitV.rs
rename to src/lib/bitv.rs
index b0a4c9ea7f7be..1b4528a44a99c 100644
--- a/src/lib/BitV.rs
+++ b/src/lib/bitv.rs
@@ -21,19 +21,19 @@ fn create(uint nbits, bool init) -> t {
elt = 0u;
}
- auto storage = Vec.init_elt_mut[uint](elt, nbits / uint_bits() + 1u);
+ auto storage = _vec::init_elt_mut[uint](elt, nbits / uint_bits() + 1u);
ret rec(storage = storage, nbits = nbits);
}
fn process(&fn(uint, uint) -> uint op, &t v0, &t v1) -> bool {
- auto len = Vec.len(v1.storage);
+ auto len = _vec::len(v1.storage);
- assert (Vec.len(v0.storage) == len);
+ assert (_vec::len(v0.storage) == len);
assert (v0.nbits == v1.nbits);
auto changed = false;
- for each (uint i in UInt.range(0u, len)) {
+ for each (uint i in _uint::range(0u, len)) {
auto w0 = v0.storage.(i);
auto w1 = v1.storage.(i);
@@ -75,9 +75,9 @@ fn copy(&t v0, t v1) -> bool {
}
fn clone(t v) -> t {
- auto storage = Vec.init_elt_mut[uint](0u, v.nbits / uint_bits() + 1u);
- auto len = Vec.len(v.storage);
- for each (uint i in UInt.range(0u, len)) {
+ auto storage = _vec::init_elt_mut[uint](0u, v.nbits / uint_bits() + 1u);
+ auto len = _vec::len(v.storage);
+ for each (uint i in _uint::range(0u, len)) {
storage.(i) = v.storage.(i);
}
ret rec(storage = storage, nbits = v.nbits);
@@ -97,7 +97,7 @@ fn get(&t v, uint i) -> bool {
fn equal(&t v0, &t v1) -> bool {
// FIXME: when we can break or return from inside an iterator loop,
// we can eliminate this painful while-loop
- auto len = Vec.len(v1.storage);
+ auto len = _vec::len(v1.storage);
auto i = 0u;
while (i < len) {
if (v0.storage.(i) != v1.storage.(i)) {
@@ -109,13 +109,13 @@ fn equal(&t v0, &t v1) -> bool {
}
fn clear(&t v) {
- for each (uint i in UInt.range(0u, Vec.len(v.storage))) {
+ for each (uint i in _uint::range(0u, _vec::len(v.storage))) {
v.storage.(i) = 0u;
}
}
fn invert(&t v) {
- for each (uint i in UInt.range(0u, Vec.len(v.storage))) {
+ for each (uint i in _uint::range(0u, _vec::len(v.storage))) {
v.storage.(i) = ~v.storage.(i);
}
}
@@ -176,13 +176,13 @@ fn init_to_vec(t v, uint i) -> uint {
fn to_vec(&t v) -> vec[uint] {
auto sub = bind init_to_vec(v, _);
- ret Vec.init_fn[uint](sub, v.nbits);
+ ret _vec::init_fn[uint](sub, v.nbits);
}
fn to_str(&t v) -> str {
auto res = "";
- for (uint i in BitV.to_vec(v)) {
+ for (uint i in bitv::to_vec(v)) {
if (i == 1u) {
res += "1";
}
@@ -196,7 +196,7 @@ fn to_str(&t v) -> str {
// FIXME: can we just use structural equality on to_vec?
fn eq_vec(&t v0, &vec[uint] v1) -> bool {
- assert (v0.nbits == Vec.len[uint](v1));
+ assert (v0.nbits == _vec::len[uint](v1));
auto len = v0.nbits;
auto i = 0u;
while (i < len) {
diff --git a/src/lib/Box.rs b/src/lib/box.rs
similarity index 53%
rename from src/lib/Box.rs
rename to src/lib/box.rs
index 2d94c680bf8be..4429fd6a0b0d1 100644
--- a/src/lib/Box.rs
+++ b/src/lib/box.rs
@@ -4,5 +4,5 @@ native "rust" mod rustrt {
fn rust_ptr_eq[T](@T a, @T b) -> int;
}
-fn ptr_eq[T](@T a, @T b) -> bool { ret rustrt.rust_ptr_eq[T](a, b) != 0; }
+fn ptr_eq[T](@T a, @T b) -> bool { ret rustrt::rust_ptr_eq[T](a, b) != 0; }
diff --git a/src/lib/Dbg.rs b/src/lib/dbg.rs
similarity index 82%
rename from src/lib/Dbg.rs
rename to src/lib/dbg.rs
index f155d1198f8a7..be36756256747 100644
--- a/src/lib/Dbg.rs
+++ b/src/lib/dbg.rs
@@ -20,23 +20,23 @@ native "rust" mod rustrt {
}
fn debug_vec[T](vec[T] v) {
- Vec.print_debug_info[T](v);
+ _vec::print_debug_info[T](v);
}
fn debug_tydesc[T]() {
- rustrt.debug_tydesc[T]();
+ rustrt::debug_tydesc[T]();
}
fn debug_opaque[T](&T x) {
- rustrt.debug_opaque[T](x);
+ rustrt::debug_opaque[T](x);
}
fn debug_box[T](@T x) {
- rustrt.debug_box[T](x);
+ rustrt::debug_box[T](x);
}
fn debug_tag[T](&T x) {
- rustrt.debug_tag[T](x);
+ rustrt::debug_tag[T](x);
}
/**
@@ -49,19 +49,19 @@ fn debug_tag[T](&T x) {
* the front of any obj's data tuple.x
*/
fn debug_obj[T](&T x, uint nmethods, uint nbytes) {
- rustrt.debug_obj[T](x, nmethods, nbytes);
+ rustrt::debug_obj[T](x, nmethods, nbytes);
}
fn debug_fn[T](&T x) {
- rustrt.debug_fn[T](x);
+ rustrt::debug_fn[T](x);
}
fn ptr_cast[T, U](@T x) -> @U {
- ret rustrt.debug_ptrcast[T, U](x);
+ ret rustrt::debug_ptrcast[T, U](x);
}
fn trap(str s) {
- rustrt.debug_trap(s);
+ rustrt::debug_trap(s);
}
// Local Variables:
diff --git a/src/lib/Deque.rs b/src/lib/deque.rs
similarity index 75%
rename from src/lib/Deque.rs
rename to src/lib/deque.rs
index a38e4fec44698..c0ded5bf54677 100644
--- a/src/lib/Deque.rs
+++ b/src/lib/deque.rs
@@ -19,7 +19,7 @@ type t[T] = obj {
fn create[T]() -> t[T] {
- type cell[T] = Option.t[T];
+ type cell[T] = option::t[T];
let uint initial_capacity = 32u; // 2^5
@@ -28,25 +28,25 @@ fn create[T]() -> t[T] {
* elsewhere.
*/
fn grow[T](uint nelts, uint lo, vec[cell[T]] elts) -> vec[cell[T]] {
- assert (nelts == Vec.len[cell[T]](elts));
+ assert (nelts == _vec::len[cell[T]](elts));
fn fill[T](uint i, uint nelts, uint lo,
vec[cell[T]] old) -> cell[T] {
if (i < nelts) {
ret old.((lo + i) % nelts);
} else {
- ret Option.none[T];
+ ret option::none[T];
}
}
- let uint nalloc = UInt.next_power_of_two(nelts + 1u);
- let Vec.init_op[cell[T]] copy_op = bind fill[T](_, nelts, lo, elts);
- ret Vec.init_fn[cell[T]](copy_op, nalloc);
+ let uint nalloc = _uint::next_power_of_two(nelts + 1u);
+ let _vec::init_op[cell[T]] copy_op = bind fill[T](_, nelts, lo, elts);
+ ret _vec::init_fn[cell[T]](copy_op, nalloc);
}
fn get[T](vec[cell[T]] elts, uint i) -> T {
alt (elts.(i)) {
- case (Option.some[T](?t)) { ret t; }
+ case (option::some[T](?t)) { ret t; }
case (_) { fail; }
}
fail; // FIXME: remove me when exhaustiveness checking works
@@ -63,18 +63,18 @@ fn create[T]() -> t[T] {
let uint oldlo = lo;
if (lo == 0u) {
- lo = Vec.len[cell[T]](elts) - 1u;
+ lo = _vec::len[cell[T]](elts) - 1u;
} else {
lo -= 1u;
}
if (lo == hi) {
elts = grow[T](nelts, oldlo, elts);
- lo = Vec.len[cell[T]](elts) - 1u;
+ lo = _vec::len[cell[T]](elts) - 1u;
hi = nelts;
}
- elts.(lo) = Option.some[T](t);
+ elts.(lo) = option::some[T](t);
nelts += 1u;
}
@@ -85,8 +85,8 @@ fn create[T]() -> t[T] {
hi = nelts;
}
- elts.(hi) = Option.some[T](t);
- hi = (hi + 1u) % Vec.len[cell[T]](elts);
+ elts.(hi) = option::some[T](t);
+ hi = (hi + 1u) % _vec::len[cell[T]](elts);
nelts += 1u;
}
@@ -96,21 +96,21 @@ fn create[T]() -> t[T] {
*/
fn pop_front() -> T {
let T t = get[T](elts, lo);
- elts.(lo) = Option.none[T];
- lo = (lo + 1u) % Vec.len[cell[T]](elts);
+ elts.(lo) = option::none[T];
+ lo = (lo + 1u) % _vec::len[cell[T]](elts);
nelts -= 1u;
ret t;
}
fn pop_back() -> T {
if (hi == 0u) {
- hi = Vec.len[cell[T]](elts) - 1u;
+ hi = _vec::len[cell[T]](elts) - 1u;
} else {
hi -= 1u;
}
let T t = get[T](elts, hi);
- elts.(hi) = Option.none[T];
+ elts.(hi) = option::none[T];
nelts -= 1u;
ret t;
}
@@ -124,12 +124,12 @@ fn create[T]() -> t[T] {
}
fn get(int i) -> T {
- let uint idx = (lo + (i as uint)) % Vec.len[cell[T]](elts);
+ let uint idx = (lo + (i as uint)) % _vec::len[cell[T]](elts);
ret get[T](elts, idx);
}
}
- let vec[cell[T]] v = Vec.init_elt[cell[T]](Option.none[T],
+ let vec[cell[T]] v = _vec::init_elt[cell[T]](option::none[T],
initial_capacity);
ret deque[T](0u, 0u, 0u, v);
diff --git a/src/lib/EBML.rs b/src/lib/ebml.rs
similarity index 84%
rename from src/lib/EBML.rs
rename to src/lib/ebml.rs
index 9b17bf06a6828..0efb05b83c3f7 100644
--- a/src/lib/EBML.rs
+++ b/src/lib/ebml.rs
@@ -1,9 +1,9 @@
-// Simple Extensible Binary Markup Language (EBML) reader and writer on a
+// Simple Extensible Binary Markup Language (ebml) reader and writer on a
// cursor model. See the specification here:
// http://www.matroska.org/technical/specs/rfc/index.html
-import Option.none;
-import Option.some;
+import option::none;
+import option::some;
type ebml_tag = rec(uint id, uint size);
type ebml_state = rec(ebml_tag ebml_tag, uint tag_pos, uint data_pos);
@@ -11,7 +11,7 @@ type ebml_state = rec(ebml_tag ebml_tag, uint tag_pos, uint data_pos);
// TODO: When we have module renaming, make "reader" and "writer" separate
// modules within this file.
-// EBML reading
+// ebml reading
type doc = rec(vec[u8] data,
uint start,
@@ -38,7 +38,7 @@ fn vint_at(vec[u8] data, uint start) -> tup(uint, uint) {
}
fn new_doc(vec[u8] data) -> doc {
- ret rec(data=data, start=0u, end=Vec.len[u8](data));
+ ret rec(data=data, start=0u, end=_vec::len[u8](data));
}
fn doc_at(vec[u8] data, uint start) -> doc {
@@ -48,7 +48,7 @@ fn doc_at(vec[u8] data, uint start) -> doc {
ret rec(data=data, start=elt_size._1, end=end);
}
-fn maybe_get_doc(doc d, uint tg) -> Option.t[doc] {
+fn maybe_get_doc(doc d, uint tg) -> option::t[doc] {
auto pos = d.start;
while (pos < d.end) {
auto elt_tag = vint_at(d.data, pos);
@@ -65,7 +65,7 @@ fn get_doc(doc d, uint tg) -> doc {
alt (maybe_get_doc(d, tg)) {
case (some[doc](?d)) {ret d;}
case (none[doc]) {
- log_err "failed to find block with tag " + UInt.to_str(tg, 10u);
+ log_err "failed to find block with tag " + _uint::to_str(tg, 10u);
fail;
}
}
@@ -94,7 +94,7 @@ iter tagged_docs(doc d, uint tg) -> doc {
}
fn doc_data(doc d) -> vec[u8] {
- ret Vec.slice[u8](d.data, d.start, d.end);
+ ret _vec::slice[u8](d.data, d.start, d.end);
}
fn be_uint_from_bytes(vec[u8] data, uint start, uint size) -> uint {
@@ -114,11 +114,11 @@ fn doc_as_uint(doc d) -> uint {
ret be_uint_from_bytes(d.data, d.start, d.end - d.start);
}
-// EBML writing
+// ebml writing
-type writer = rec(IO.buf_writer writer, mutable vec[uint] size_positions);
+type writer = rec(io::buf_writer writer, mutable vec[uint] size_positions);
-fn write_sized_vint(&IO.buf_writer w, uint n, uint size) {
+fn write_sized_vint(&io::buf_writer w, uint n, uint size) {
let vec[u8] buf;
alt (size) {
case (1u) {
@@ -148,7 +148,7 @@ fn write_sized_vint(&IO.buf_writer w, uint n, uint size) {
w.write(buf);
}
-fn write_vint(&IO.buf_writer w, uint n) {
+fn write_vint(&io::buf_writer w, uint n) {
if (n < 0x7fu) { write_sized_vint(w, n, 1u); ret; }
if (n < 0x4000u) { write_sized_vint(w, n, 2u); ret; }
if (n < 0x200000u) { write_sized_vint(w, n, 3u); ret; }
@@ -157,15 +157,15 @@ fn write_vint(&IO.buf_writer w, uint n) {
fail;
}
-fn create_writer(&IO.buf_writer w) -> writer {
+fn create_writer(&io::buf_writer w) -> writer {
let vec[uint] size_positions = vec();
ret rec(writer=w, mutable size_positions=size_positions);
}
-// TODO: Provide a function to write the standard EBML header.
+// TODO: Provide a function to write the standard ebml header.
fn start_tag(&writer w, uint tag_id) {
- // Write the tag ID.
+ // Write the tag ID:
write_vint(w.writer, tag_id);
// Write a placeholder four-byte size.
@@ -175,11 +175,11 @@ fn start_tag(&writer w, uint tag_id) {
}
fn end_tag(&writer w) {
- auto last_size_pos = Vec.pop[uint](w.size_positions);
+ auto last_size_pos = _vec::pop[uint](w.size_positions);
auto cur_pos = w.writer.tell();
- w.writer.seek(last_size_pos as int, IO.seek_set);
+ w.writer.seek(last_size_pos as int, io::seek_set);
write_sized_vint(w.writer, cur_pos - last_size_pos - 4u, 4u);
- w.writer.seek(cur_pos as int, IO.seek_set);
+ w.writer.seek(cur_pos as int, io::seek_set);
}
// TODO: optionally perform "relaxations" on end_tag to more efficiently
diff --git a/src/lib/ExtFmt.rs b/src/lib/extfmt.rs
similarity index 88%
rename from src/lib/ExtFmt.rs
rename to src/lib/extfmt.rs
index 0510a2a87ec3d..c5691fe9b915c 100644
--- a/src/lib/ExtFmt.rs
+++ b/src/lib/extfmt.rs
@@ -13,8 +13,8 @@
* combinations at the moment.
*/
-import Option.none;
-import Option.some;
+import option::none;
+import option::some;
/*
* We have a CT (compile-time) module that parses format strings into a
@@ -66,7 +66,7 @@ mod CT {
}
// A formatted conversion from an expression to a string
- type conv = rec(Option.t[int] param,
+ type conv = rec(option::t[int] param,
vec[flag] flags,
count width,
count precision,
@@ -80,11 +80,11 @@ mod CT {
fn parse_fmt_string(str s) -> vec[piece] {
let vec[piece] pieces = vec();
- auto lim = Str.byte_len(s);
+ auto lim = _str::byte_len(s);
auto buf = "";
fn flush_buf(str buf, &vec[piece] pieces) -> str {
- if (Str.byte_len(buf) > 0u) {
+ if (_str::byte_len(buf) > 0u) {
auto piece = piece_string(buf);
pieces += vec(piece);
}
@@ -93,15 +93,15 @@ mod CT {
auto i = 0u;
while (i < lim) {
- auto curr = Str.substr(s, i, 1u);
- if (Str.eq(curr, "%")) {
+ auto curr = _str::substr(s, i, 1u);
+ if (_str::eq(curr, "%")) {
i += 1u;
if (i >= lim) {
log_err "unterminated conversion at end of string";
fail;
}
- auto curr2 = Str.substr(s, i, 1u);
- if (Str.eq(curr2, "%")) {
+ auto curr2 = _str::substr(s, i, 1u);
+ if (_str::eq(curr2, "%")) {
i += 1u;
} else {
buf = flush_buf(buf, pieces);
@@ -118,14 +118,14 @@ mod CT {
ret pieces;
}
- fn peek_num(str s, uint i, uint lim) -> Option.t[tup(uint, uint)] {
+ fn peek_num(str s, uint i, uint lim) -> option::t[tup(uint, uint)] {
if (i >= lim) {
ret none[tup(uint, uint)];
}
auto c = s.(i);
if (!('0' as u8 <= c && c <= '9' as u8)) {
- ret Option.none[tup(uint, uint)];
+ ret option::none[tup(uint, uint)];
}
auto n = (c - ('0' as u8)) as uint;
@@ -156,7 +156,7 @@ mod CT {
ty._1);
}
- fn parse_parameter(str s, uint i, uint lim) -> tup(Option.t[int], uint) {
+ fn parse_parameter(str s, uint i, uint lim) -> tup(option::t[int], uint) {
if (i >= lim) {
ret tup(none[int], i);
}
@@ -270,27 +270,27 @@ mod CT {
}
auto t;
- auto tstr = Str.substr(s, i, 1u);
- if (Str.eq(tstr, "b")) {
+ auto tstr = _str::substr(s, i, 1u);
+ if (_str::eq(tstr, "b")) {
t = ty_bool;
- } else if (Str.eq(tstr, "s")) {
+ } else if (_str::eq(tstr, "s")) {
t = ty_str;
- } else if (Str.eq(tstr, "c")) {
+ } else if (_str::eq(tstr, "c")) {
t = ty_char;
- } else if (Str.eq(tstr, "d")
- || Str.eq(tstr, "i")) {
+ } else if (_str::eq(tstr, "d")
+ || _str::eq(tstr, "i")) {
// TODO: Do we really want two signed types here?
// How important is it to be printf compatible?
t = ty_int(signed);
- } else if (Str.eq(tstr, "u")) {
+ } else if (_str::eq(tstr, "u")) {
t = ty_int(unsigned);
- } else if (Str.eq(tstr, "x")) {
+ } else if (_str::eq(tstr, "x")) {
t = ty_hex(case_lower);
- } else if (Str.eq(tstr, "X")) {
+ } else if (_str::eq(tstr, "X")) {
t = ty_hex(case_upper);
- } else if (Str.eq(tstr, "t")) {
+ } else if (_str::eq(tstr, "t")) {
t = ty_bits;
- } else if (Str.eq(tstr, "o")) {
+ } else if (_str::eq(tstr, "o")) {
t = ty_octal;
} else {
log_err "unknown type in conversion";
@@ -315,7 +315,7 @@ mod RT {
flag_alternate;
// FIXME: This is a hack to avoid creating 0-length vec exprs,
// which have some difficulty typechecking currently. See
- // comments in front.extfmt.make_flags
+ // comments in front::extfmt::make_flags
flag_none;
}
@@ -364,7 +364,7 @@ mod RT {
res = uint_to_str_prec(u, 16u, prec);
}
case (ty_hex_upper) {
- res = Str.to_upper(uint_to_str_prec(u, 16u, prec));
+ res = _str::to_upper(uint_to_str_prec(u, 16u, prec));
}
case (ty_bits) {
res = uint_to_str_prec(u, 2u, prec);
@@ -383,13 +383,13 @@ mod RT {
} else {
s = "false";
}
- // Run the boolean conversion through the string conversion logic,
+ // run the boolean conversion through the string conversion logic,
// giving it the same rules for precision, etc.
ret conv_str(cv, s);
}
fn conv_char(&conv cv, char c) -> str {
- ret pad(cv, Str.from_char(c), pad_nozero);
+ ret pad(cv, _str::from_char(c), pad_nozero);
}
fn conv_str(&conv cv, str s) -> str {
@@ -399,9 +399,9 @@ mod RT {
}
case (count_is(?max)) {
// For strings, precision is the maximum characters displayed
- if (max as uint < Str.char_len(s)) {
+ if (max as uint < _str::char_len(s)) {
// FIXME: substr works on bytes, not chars!
- unpadded = Str.substr(s, 0u, max as uint);
+ unpadded = _str::substr(s, 0u, max as uint);
}
}
}
@@ -420,15 +420,15 @@ mod RT {
// Convert a uint to string with a minimum number of digits. If precision
// is 0 and num is 0 then the result is the empty string. Could move this
- // to UInt. but it doesn't seem all that useful.
+ // to _uint: but it doesn't seem all that useful.
fn uint_to_str_prec(uint num, uint radix, uint prec) -> str {
auto s;
if (prec == 0u && num == 0u) {
s = "";
} else {
- s = UInt.to_str(num, radix);
- auto len = Str.char_len(s);
+ s = _uint::to_str(num, radix);
+ auto len = _str::char_len(s);
if (len < prec) {
auto diff = prec - len;
auto pad = str_init_elt('0', diff);
@@ -450,12 +450,12 @@ mod RT {
}
}
- // FIXME: This might be useful in Str. but needs to be utf8 safe first
+ // FIXME: This might be useful in _str: but needs to be utf8 safe first
fn str_init_elt(char c, uint n_elts) -> str {
- auto svec = Vec.init_elt[u8](c as u8, n_elts);
+ auto svec = _vec::init_elt[u8](c as u8, n_elts);
// FIXME: Using unsafe_from_bytes because rustboot
// can't figure out the is_utf8 predicate on from_bytes?
- ret Str.unsafe_from_bytes(svec);
+ ret _str::unsafe_from_bytes(svec);
}
tag pad_mode {
@@ -476,7 +476,7 @@ mod RT {
}
}
- auto strlen = Str.char_len(s);
+ auto strlen = _str::char_len(s);
if (uwidth <= strlen) {
ret s;
}
@@ -532,16 +532,16 @@ mod RT {
// instead.
if (signed
&& zero_padding
- && Str.byte_len(s) > 0u) {
+ && _str::byte_len(s) > 0u) {
auto head = s.(0);
if (head == '+' as u8
|| head == '-' as u8
|| head == ' ' as u8) {
- auto headstr = Str.unsafe_from_bytes(vec(head));
- auto bytelen = Str.byte_len(s);
- auto numpart = Str.substr(s, 1u, bytelen - 1u);
+ auto headstr = _str::unsafe_from_bytes(vec(head));
+ auto bytelen = _str::byte_len(s);
+ auto numpart = _str::substr(s, 1u, bytelen - 1u);
ret headstr + padstr + numpart;
}
}
diff --git a/src/lib/FS.rs b/src/lib/fs.rs
similarity index 54%
rename from src/lib/FS.rs
rename to src/lib/fs.rs
index 69edf247a3ec0..a897576944b59 100644
--- a/src/lib/FS.rs
+++ b/src/lib/fs.rs
@@ -3,43 +3,43 @@ native "rust" mod rustrt {
}
fn path_sep() -> str {
- ret Str.from_char(OS_FS.path_sep);
+ ret _str::from_char(os_fs::path_sep);
}
type path = str;
fn dirname(path p) -> path {
- let int i = Str.rindex(p, OS_FS.path_sep as u8);
+ let int i = _str::rindex(p, os_fs::path_sep as u8);
if (i == -1) {
- i = Str.rindex(p, OS_FS.alt_path_sep as u8);
+ i = _str::rindex(p, os_fs::alt_path_sep as u8);
if (i == -1) {
ret p;
}
}
- ret Str.substr(p, 0u, i as uint);
+ ret _str::substr(p, 0u, i as uint);
}
fn connect(path pre, path post) -> path {
- auto len = Str.byte_len(pre);
- if (pre.(len - 1u) == (OS_FS.path_sep as u8)) { // Trailing '/'?
+ auto len = _str::byte_len(pre);
+ if (pre.(len - 1u) == (os_fs::path_sep as u8)) { // Trailing '/'?
ret pre + post;
}
ret pre + path_sep() + post;
}
fn file_is_dir(path p) -> bool {
- ret rustrt.rust_file_is_dir(p) != 0;
+ ret rustrt::rust_file_is_dir(p) != 0;
}
fn list_dir(path p) -> vec[str] {
- auto pl = Str.byte_len(p);
- if (pl == 0u || p.(pl - 1u) as char != OS_FS.path_sep) {
+ auto pl = _str::byte_len(p);
+ if (pl == 0u || p.(pl - 1u) as char != os_fs::path_sep) {
p += path_sep();
}
let vec[str] full_paths = vec();
- for (str filename in OS_FS.list_dir(p)) {
- if (!Str.eq(filename, ".")) {if (!Str.eq(filename, "..")) {
- Vec.push[str](full_paths, p + filename);
+ for (str filename in os_fs::list_dir(p)) {
+ if (!_str::eq(filename, ".")) {if (!_str::eq(filename, "..")) {
+ _vec::push[str](full_paths, p + filename);
}}
}
ret full_paths;
diff --git a/src/lib/generic_os.rs b/src/lib/generic_os.rs
new file mode 100644
index 0000000000000..6b2795af93e90
--- /dev/null
+++ b/src/lib/generic_os.rs
@@ -0,0 +1,9 @@
+fn getenv(str n) -> option::t[str] {
+ auto s = os::libc::getenv(_str::buf(n));
+ if ((s as int) == 0) {
+ ret option::none[str];
+ } else {
+ ret option::some[str](_str::str_from_cstr(s));
+ }
+}
+
diff --git a/src/lib/GetOpts.rs b/src/lib/getopts.rs
similarity index 70%
rename from src/lib/GetOpts.rs
rename to src/lib/getopts.rs
index 0cacf3ffc6533..c1bcaae30c543 100644
--- a/src/lib/GetOpts.rs
+++ b/src/lib/getopts.rs
@@ -7,8 +7,8 @@
* argument values out of the match object.
*/
-import Option.some;
-import Option.none;
+import option::some;
+import option::none;
tag name { long(str); short(char); }
tag hasarg { yes; no; maybe; }
@@ -17,7 +17,7 @@ tag occur { req; optional; multi; }
type opt = rec(name name, hasarg hasarg, occur occur);
fn mkname(str nm) -> name {
- if (Str.char_len(nm) == 1u) { ret short(Str.char_at(nm, 0u)); }
+ if (_str::char_len(nm) == 1u) { ret short(_str::char_at(nm, 0u)); }
else { ret long(nm); }
}
fn reqopt(str name) -> opt {
@@ -41,11 +41,11 @@ tag optval {
type match = rec(vec[opt] opts, vec[mutable vec[optval]] vals, vec[str] free);
fn is_arg(str arg) -> bool {
- ret Str.byte_len(arg) > 1u && arg.(0) == '-' as u8;
+ ret _str::byte_len(arg) > 1u && arg.(0) == '-' as u8;
}
fn name_str(name nm) -> str {
alt (nm) {
- case (short(?ch)) {ret Str.from_char(ch);}
+ case (short(?ch)) {ret _str::from_char(ch);}
case (long(?s)) {ret s;}
}
}
@@ -55,16 +55,16 @@ fn name_eq(name a, name b) -> bool {
alt (a) {
case (long(?a)) {
alt (b) {
- case (long(?b)) { ret Str.eq(a, b); }
+ case (long(?b)) { ret _str::eq(a, b); }
case (_) { ret false; }
}
}
case (_) { if (a == b) { ret true; } else {ret false; } }
}
}
-fn find_opt(vec[opt] opts, name nm) -> Option.t[uint] {
+fn find_opt(vec[opt] opts, name nm) -> option::t[uint] {
auto i = 0u;
- auto l = Vec.len[opt](opts);
+ auto l = _vec::len[opt](opts);
while (i < l) {
if (name_eq(opts.(i).name, nm)) { ret some[uint](i); }
i += 1u;
@@ -91,7 +91,7 @@ fn fail_str(fail_ f) -> str {
ret "Required option '" + nm + "' missing.";
}
case (option_duplicated(?nm)) {
- ret "Option '" + nm + "' given more than once.";
+ ret "option '" + nm + "' given more than once.";
}
}
}
@@ -102,41 +102,41 @@ tag result {
}
fn getopts(vec[str] args, vec[opt] opts) -> result {
- auto n_opts = Vec.len[opt](opts);
- fn empty_(uint x) -> vec[optval]{ret Vec.empty[optval]();}
+ auto n_opts = _vec::len[opt](opts);
+ fn empty_(uint x) -> vec[optval]{ret _vec::empty[optval]();}
auto f = empty_;
- auto vals = Vec.init_fn_mut[vec[optval]](f, n_opts);
+ auto vals = _vec::init_fn_mut[vec[optval]](f, n_opts);
let vec[str] free = vec();
- auto l = Vec.len[str](args);
+ auto l = _vec::len[str](args);
auto i = 0u;
while (i < l) {
auto cur = args.(i);
- auto curlen = Str.byte_len(cur);
+ auto curlen = _str::byte_len(cur);
if (!is_arg(cur)) {
- Vec.push[str](free, cur);
- } else if (Str.eq(cur, "--")) {
- free += Vec.slice[str](args, i + 1u, l);
+ _vec::push[str](free, cur);
+ } else if (_str::eq(cur, "--")) {
+ free += _vec::slice[str](args, i + 1u, l);
break;
} else {
auto names;
- auto i_arg = Option.none[str];
+ auto i_arg = option::none[str];
if (cur.(1) == '-' as u8) {
- auto tail = Str.slice(cur, 2u, curlen);
- auto eq = Str.index(tail, '=' as u8);
+ auto tail = _str::slice(cur, 2u, curlen);
+ auto eq = _str::index(tail, '=' as u8);
if (eq == -1) {
names = vec(long(tail));
} else {
- names = vec(long(Str.slice(tail, 0u, eq as uint)));
- i_arg = Option.some[str]
- (Str.slice(tail, (eq as uint) + 1u, curlen - 2u));
+ names = vec(long(_str::slice(tail, 0u, eq as uint)));
+ i_arg = option::some[str]
+ (_str::slice(tail, (eq as uint) + 1u, curlen - 2u));
}
} else {
auto j = 1u;
names = vec();
while (j < curlen) {
- auto range = Str.char_range_at(cur, j);
- Vec.push[name](names, short(range._0));
+ auto range = _str::char_range_at(cur, j);
+ _vec::push[name](names, short(range._0));
j = range._1;
}
}
@@ -152,29 +152,29 @@ fn getopts(vec[str] args, vec[opt] opts) -> result {
}
alt (opts.(optid).hasarg) {
case (no) {
- Vec.push[optval](vals.(optid), given);
+ _vec::push[optval](vals.(optid), given);
}
case (maybe) {
- if (!Option.is_none[str](i_arg)) {
- Vec.push[optval](vals.(optid),
- val(Option.get[str](i_arg)));
- } else if (name_pos < Vec.len[name](names) ||
+ if (!option::is_none[str](i_arg)) {
+ _vec::push[optval](vals.(optid),
+ val(option::get[str](i_arg)));
+ } else if (name_pos < _vec::len[name](names) ||
i + 1u == l || is_arg(args.(i + 1u))) {
- Vec.push[optval](vals.(optid), given);
+ _vec::push[optval](vals.(optid), given);
} else {
i += 1u;
- Vec.push[optval](vals.(optid), val(args.(i)));
+ _vec::push[optval](vals.(optid), val(args.(i)));
}
}
case (yes) {
- if (!Option.is_none[str](i_arg)) {
- Vec.push[optval](vals.(optid),
- val(Option.get[str](i_arg)));
+ if (!option::is_none[str](i_arg)) {
+ _vec::push[optval](vals.(optid),
+ val(option::get[str](i_arg)));
} else if (i + 1u == l) {
ret failure(argument_missing(name_str(nm)));
} else {
i += 1u;
- Vec.push[optval](vals.(optid), val(args.(i)));
+ _vec::push[optval](vals.(optid), val(args.(i)));
}
}
}
@@ -185,7 +185,7 @@ fn getopts(vec[str] args, vec[opt] opts) -> result {
i = 0u;
while (i < n_opts) {
- auto n = Vec.len[optval](vals.(i));
+ auto n = _vec::len[optval](vals.(i));
auto occ = opts.(i).occur;
if (occ == req) {if (n == 0u) {
ret failure(option_missing(name_str(opts.(i).name)));
@@ -212,7 +212,7 @@ fn opt_val(match m, str nm) -> optval {
ret opt_vals(m, nm).(0);
}
fn opt_present(match m, str nm) -> bool {
- ret Vec.len[optval](opt_vals(m, nm)) > 0u;
+ ret _vec::len[optval](opt_vals(m, nm)) > 0u;
}
fn opt_str(match m, str nm) -> str {
alt (opt_val(m, nm)) {
@@ -224,15 +224,15 @@ fn opt_strs(match m, str nm) -> vec[str] {
let vec[str] acc = vec();
for (optval v in opt_vals(m, nm)) {
alt (v) {
- case (val(?s)) { Vec.push[str](acc, s); }
+ case (val(?s)) { _vec::push[str](acc, s); }
case (_) {}
}
}
ret acc;
}
-fn opt_maybe_str(match m, str nm) -> Option.t[str] {
+fn opt_maybe_str(match m, str nm) -> option::t[str] {
auto vals = opt_vals(m, nm);
- if (Vec.len[optval](vals) == 0u) { ret none[str]; }
+ if (_vec::len[optval](vals) == 0u) { ret none[str]; }
alt (vals.(0)) {
case (val(?s)) { ret some[str](s); }
case (_) { ret none[str]; }
diff --git a/src/lib/IO.rs b/src/lib/io.rs
similarity index 78%
rename from src/lib/IO.rs
rename to src/lib/io.rs
index c0ae2c2f459bd..c996584f8f058 100644
--- a/src/lib/IO.rs
+++ b/src/lib/io.rs
@@ -1,8 +1,8 @@
-import OS.libc;
+import os::libc;
native "rust" mod rustrt {
- fn rust_get_stdin() -> OS.libc.FILE;
- fn rust_get_stdout() -> OS.libc.FILE;
+ fn rust_get_stdin() -> os::libc::FILE;
+ fn rust_get_stdout() -> os::libc::FILE;
}
// Reading
@@ -55,30 +55,30 @@ fn convert_whence(seek_style whence) -> int {
}
}
-state obj FILE_buf_reader(OS.libc.FILE f, bool must_close) {
+state obj FILE_buf_reader(os::libc::FILE f, bool must_close) {
fn read(uint len) -> vec[u8] {
- auto buf = Vec.alloc[u8](len);
- auto read = OS.libc.fread(Vec.buf[u8](buf), 1u, len, f);
- Vec.len_set[u8](buf, read);
+ auto buf = _vec::alloc[u8](len);
+ auto read = os::libc::fread(_vec::buf[u8](buf), 1u, len, f);
+ _vec::len_set[u8](buf, read);
ret buf;
}
fn read_byte() -> int {
- ret OS.libc.fgetc(f);
+ ret os::libc::fgetc(f);
}
fn unread_byte(int byte) {
- OS.libc.ungetc(byte, f);
+ os::libc::ungetc(byte, f);
}
fn eof() -> bool {
- ret OS.libc.feof(f) != 0;
+ ret os::libc::feof(f) != 0;
}
fn seek(int offset, seek_style whence) {
- assert (OS.libc.fseek(f, offset, convert_whence(whence)) == 0);
+ assert (os::libc::fseek(f, offset, convert_whence(whence)) == 0);
}
fn tell() -> uint {
- ret OS.libc.ftell(f) as uint;
+ ret os::libc::ftell(f) as uint;
}
drop {
- if (must_close) { OS.libc.fclose(f); }
+ if (must_close) { os::libc::fclose(f); }
}
}
@@ -100,7 +100,7 @@ state obj new_reader(buf_reader rdr) {
auto c0 = rdr.read_byte();
if (c0 == -1) {ret -1 as char;} // FIXME will this stay valid?
auto b0 = c0 as u8;
- auto w = Str.utf8_char_width(b0);
+ auto w = _str::utf8_char_width(b0);
assert (w > 0u);
if (w == 1u) {ret b0 as char;}
auto val = 0u;
@@ -112,7 +112,7 @@ state obj new_reader(buf_reader rdr) {
val <<= 6u;
val += (next & 0x3f) as uint;
}
- // See Str.char_at
+ // See _str::char_at
val += ((b0 << ((w + 1u) as u8)) as uint) << ((w - 1u) * 6u - w - 1u);
ret val as char;
}
@@ -126,9 +126,9 @@ state obj new_reader(buf_reader rdr) {
while (go_on) {
auto ch = rdr.read_byte();
if (ch == -1 || ch == 10) {go_on = false;}
- else {Vec.push[u8](buf, ch as u8);}
+ else {_vec::push[u8](buf, ch as u8);}
}
- ret Str.unsafe_from_bytes(buf);
+ ret _str::unsafe_from_bytes(buf);
}
fn read_c_str() -> str {
let vec[u8] buf = vec();
@@ -136,9 +136,9 @@ state obj new_reader(buf_reader rdr) {
while (go_on) {
auto ch = rdr.read_byte();
if (ch < 1) {go_on = false;}
- else {Vec.push[u8](buf, ch as u8);}
+ else {_vec::push[u8](buf, ch as u8);}
}
- ret Str.unsafe_from_bytes(buf);
+ ret _str::unsafe_from_bytes(buf);
}
// FIXME deal with eof?
fn read_le_uint(uint size) -> uint {
@@ -164,7 +164,7 @@ state obj new_reader(buf_reader rdr) {
// FIXME deal with eof?
fn read_be_uint(uint size) -> uint {
auto val = 0u;
- auto sz = size; // FIXME: trans.ml bug workaround
+ auto sz = size; // FIXME: trans::ml bug workaround
while (sz > 0u) {
sz -= 1u;
val += (rdr.read_byte() as uint) << (sz * 8u);
@@ -187,11 +187,11 @@ state obj new_reader(buf_reader rdr) {
}
fn stdin() -> reader {
- ret new_reader(FILE_buf_reader(rustrt.rust_get_stdin(), false));
+ ret new_reader(FILE_buf_reader(rustrt::rust_get_stdin(), false));
}
fn file_reader(str path) -> reader {
- auto f = OS.libc.fopen(Str.buf(path), Str.buf("r"));
+ auto f = os::libc::fopen(_str::buf(path), _str::buf("r"));
if (f as uint == 0u) {
log_err "error opening " + path;
fail;
@@ -212,17 +212,17 @@ type byte_buf = @rec(vec[u8] buf, mutable uint pos);
state obj byte_buf_reader(byte_buf bbuf) {
fn read(uint len) -> vec[u8] {
- auto rest = Vec.len[u8](bbuf.buf) - bbuf.pos;
+ auto rest = _vec::len[u8](bbuf.buf) - bbuf.pos;
auto to_read = len;
if (rest < to_read) {
to_read = rest;
}
- auto range = Vec.slice[u8](bbuf.buf, bbuf.pos, bbuf.pos + to_read);
+ auto range = _vec::slice[u8](bbuf.buf, bbuf.pos, bbuf.pos + to_read);
bbuf.pos += to_read;
ret range;
}
fn read_byte() -> int {
- if (bbuf.pos == Vec.len[u8](bbuf.buf)) {ret -1;}
+ if (bbuf.pos == _vec::len[u8](bbuf.buf)) {ret -1;}
auto b = bbuf.buf.(bbuf.pos);
bbuf.pos += 1u;
ret b as int;
@@ -234,12 +234,12 @@ state obj byte_buf_reader(byte_buf bbuf) {
}
fn eof() -> bool {
- ret bbuf.pos == Vec.len[u8](bbuf.buf);
+ ret bbuf.pos == _vec::len[u8](bbuf.buf);
}
fn seek(int offset, seek_style whence) {
auto pos = bbuf.pos;
- auto len = Vec.len[u8](bbuf.buf);
+ auto len = _vec::len[u8](bbuf.buf);
bbuf.pos = seek_in_buf(offset, pos, len, whence);
}
@@ -268,40 +268,40 @@ type buf_writer = state obj {
fn tell() -> uint; // FIXME: eventually u64
};
-state obj FILE_writer(OS.libc.FILE f, bool must_close) {
+state obj FILE_writer(os::libc::FILE f, bool must_close) {
fn write(vec[u8] v) {
- auto len = Vec.len[u8](v);
- auto vbuf = Vec.buf[u8](v);
- auto nout = OS.libc.fwrite(vbuf, len, 1u, f);
+ auto len = _vec::len[u8](v);
+ auto vbuf = _vec::buf[u8](v);
+ auto nout = os::libc::fwrite(vbuf, len, 1u, f);
if (nout < 1u) {
log_err "error dumping buffer";
}
}
fn seek(int offset, seek_style whence) {
- assert (OS.libc.fseek(f, offset, convert_whence(whence)) == 0);
+ assert (os::libc::fseek(f, offset, convert_whence(whence)) == 0);
}
fn tell() -> uint {
- ret OS.libc.ftell(f) as uint;
+ ret os::libc::ftell(f) as uint;
}
drop {
- if (must_close) {OS.libc.fclose(f);}
+ if (must_close) {os::libc::fclose(f);}
}
}
state obj fd_buf_writer(int fd, bool must_close) {
fn write(vec[u8] v) {
- auto len = Vec.len[u8](v);
+ auto len = _vec::len[u8](v);
auto count = 0u;
auto vbuf;
while (count < len) {
- vbuf = Vec.buf_off[u8](v, count);
- auto nout = OS.libc.write(fd, vbuf, len);
+ vbuf = _vec::buf_off[u8](v, count);
+ auto nout = os::libc::write(fd, vbuf, len);
if (nout < 0) {
log_err "error dumping buffer";
- log_err Sys.rustrt.last_os_error();
+ log_err sys::rustrt::last_os_error();
fail;
}
count += nout as uint;
@@ -319,32 +319,32 @@ state obj fd_buf_writer(int fd, bool must_close) {
}
drop {
- if (must_close) {OS.libc.close(fd);}
+ if (must_close) {os::libc::close(fd);}
}
}
fn file_buf_writer(str path, vec[fileflag] flags) -> buf_writer {
let int fflags =
- OS.libc_constants.O_WRONLY() |
- OS.libc_constants.O_BINARY();
+ os::libc_constants::O_WRONLY() |
+ os::libc_constants::O_BINARY();
for (fileflag f in flags) {
alt (f) {
- case (append) { fflags |= OS.libc_constants.O_APPEND(); }
- case (create) { fflags |= OS.libc_constants.O_CREAT(); }
- case (truncate) { fflags |= OS.libc_constants.O_TRUNC(); }
+ case (append) { fflags |= os::libc_constants::O_APPEND(); }
+ case (create) { fflags |= os::libc_constants::O_CREAT(); }
+ case (truncate) { fflags |= os::libc_constants::O_TRUNC(); }
case (none) {}
}
}
- auto fd = OS.libc.open(Str.buf(path),
+ auto fd = os::libc::open(_str::buf(path),
fflags,
- OS.libc_constants.S_IRUSR() |
- OS.libc_constants.S_IWUSR());
+ os::libc_constants::S_IRUSR() |
+ os::libc_constants::S_IWUSR());
if (fd < 0) {
log_err "error opening file for writing";
- log_err Sys.rustrt.last_os_error();
+ log_err sys::rustrt::last_os_error();
fail;
}
ret fd_buf_writer(fd, true);
@@ -390,17 +390,17 @@ state obj new_writer(buf_writer out) {
ret out;
}
fn write_str(str s) {
- out.write(Str.bytes(s));
+ out.write(_str::bytes(s));
}
fn write_char(char ch) {
// FIXME needlessly consy
- out.write(Str.bytes(Str.from_char(ch)));
+ out.write(_str::bytes(_str::from_char(ch)));
}
fn write_int(int n) {
- out.write(Str.bytes(Int.to_str(n, 10u)));
+ out.write(_str::bytes(_int::to_str(n, 10u)));
}
fn write_uint(uint n) {
- out.write(Str.bytes(UInt.to_str(n, 10u)));
+ out.write(_str::bytes(_uint::to_str(n, 10u)));
}
fn write_bytes(vec[u8] bytes) {
out.write(bytes);
@@ -427,7 +427,7 @@ fn file_writer(str path, vec[fileflag] flags) -> writer {
// FIXME: fileflags
fn buffered_file_buf_writer(str path) -> buf_writer {
- auto f = OS.libc.fopen(Str.buf(path), Str.buf("w"));
+ auto f = os::libc::fopen(_str::buf(path), _str::buf("w"));
if (f as uint == 0u) {
log_err "error opening " + path;
fail;
@@ -451,21 +451,21 @@ type mutable_byte_buf = @rec(mutable vec[mutable u8] buf, mutable uint pos);
state obj byte_buf_writer(mutable_byte_buf buf) {
fn write(vec[u8] v) {
// Fast path.
- if (buf.pos == Vec.len(buf.buf)) {
+ if (buf.pos == _vec::len(buf.buf)) {
// FIXME: Fix our type system. There's no reason you shouldn't be
// able to add a mutable vector to an immutable one.
- auto mv = Vec.rustrt.unsafe_vec_to_mut[u8](v);
+ auto mv = _vec::rustrt::unsafe_vec_to_mut[u8](v);
buf.buf += mv;
- buf.pos += Vec.len[u8](v);
+ buf.pos += _vec::len[u8](v);
ret;
}
- // FIXME: Optimize. These should be unique pointers.
- auto vlen = Vec.len[u8](v);
+ // FIXME: Optimize: These should be unique pointers.
+ auto vlen = _vec::len[u8](v);
auto vpos = 0u;
while (vpos < vlen) {
auto b = v.(vpos);
- if (buf.pos == Vec.len(buf.buf)) {
+ if (buf.pos == _vec::len(buf.buf)) {
buf.buf += vec(mutable b);
} else {
buf.buf.(buf.pos) = b;
@@ -477,7 +477,7 @@ state obj byte_buf_writer(mutable_byte_buf buf) {
fn seek(int offset, seek_style whence) {
auto pos = buf.pos;
- auto len = Vec.len(buf.buf);
+ auto len = _vec::len(buf.buf);
buf.pos = seek_in_buf(offset, pos, len, whence);
}
@@ -487,12 +487,12 @@ state obj byte_buf_writer(mutable_byte_buf buf) {
fn string_writer() -> str_writer {
// FIXME: yikes, this is bad. Needs fixing of mutable syntax.
let vec[mutable u8] b = vec(mutable 0u8);
- Vec.pop(b);
+ _vec::pop(b);
let mutable_byte_buf buf = @rec(mutable buf = b, mutable pos = 0u);
state obj str_writer_wrap(writer wr, mutable_byte_buf buf) {
fn get_writer() -> writer {ret wr;}
- fn get_str() -> str {ret Str.unsafe_from_bytes(buf.buf);}
+ fn get_str() -> str {ret _str::unsafe_from_bytes(buf.buf);}
}
ret str_writer_wrap(new_writer(byte_buf_writer(buf)), buf);
}
diff --git a/src/lib/linux_OS.rs b/src/lib/linux_os.rs
similarity index 89%
rename from src/lib/linux_OS.rs
rename to src/lib/linux_os.rs
index 02c9183bded9c..3b074e411fd54 100644
--- a/src/lib/linux_OS.rs
+++ b/src/lib/linux_os.rs
@@ -1,10 +1,10 @@
-import Str.sbuf;
-import Vec.vbuf;
+import _str::sbuf;
+import _vec::vbuf;
// FIXME Somehow merge stuff duplicated here and macosx_os.rs. Made difficult
// by https://github.com/graydon/rust/issues#issue/268
-native mod libc = "libc.so.6" {
+native mod libc = "libc::so.6" {
fn open(sbuf s, int flags, uint mode) -> int;
fn read(int fd, vbuf buf, uint count) -> int;
@@ -66,17 +66,17 @@ fn dylib_filename(str base) -> str {
fn pipe() -> tup(int, int) {
let vec[mutable int] fds = vec(mutable 0, 0);
- assert (OS.libc.pipe(Vec.buf(fds)) == 0);
+ assert (os::libc::pipe(_vec::buf(fds)) == 0);
ret tup(fds.(0), fds.(1));
}
-fn fd_FILE(int fd) -> libc.FILE {
- ret libc.fdopen(fd, Str.buf("r"));
+fn fd_FILE(int fd) -> libc::FILE {
+ ret libc::fdopen(fd, _str::buf("r"));
}
fn waitpid(int pid) -> int {
let vec[mutable int] status = vec(mutable 0);
- assert (OS.libc.waitpid(pid, Vec.buf(status), 0) != -1);
+ assert (os::libc::waitpid(pid, _vec::buf(status), 0) != -1);
ret status.(0);
}
diff --git a/src/lib/List.rs b/src/lib/list.rs
similarity index 94%
rename from src/lib/List.rs
rename to src/lib/list.rs
index 6d7748f0e387f..86d6c21dacca4 100644
--- a/src/lib/List.rs
+++ b/src/lib/list.rs
@@ -1,5 +1,5 @@
-import Option.some;
-import Option.none;
+import option::some;
+import option::none;
// FIXME: It would probably be more appealing to define this as
// type list[T] = rec(T hd, option[@list[T]] tl), but at the moment
@@ -27,7 +27,7 @@ fn foldl[T,U](&list[T] ls, &U u, fn(&T t, &U u) -> U f) -> U {
}
fn find[T,U](&list[T] ls,
- (fn(&T) -> Option.t[U]) f) -> Option.t[U] {
+ (fn(&T) -> option::t[U]) f) -> option::t[U] {
alt(ls) {
case (cons[T](?hd, ?tl)) {
alt (f(hd)) {
diff --git a/src/lib/macos_OS.rs b/src/lib/macos_os.rs
similarity index 88%
rename from src/lib/macos_OS.rs
rename to src/lib/macos_os.rs
index 2cd6894fb86c7..2ad893198533d 100644
--- a/src/lib/macos_OS.rs
+++ b/src/lib/macos_os.rs
@@ -1,7 +1,7 @@
-import Str.sbuf;
-import Vec.vbuf;
+import _str::sbuf;
+import _vec::vbuf;
-native mod libc = "libc.dylib" {
+native mod libc = "libc::dylib" {
fn open(sbuf s, int flags, uint mode) -> int;
fn read(int fd, vbuf buf, uint count) -> int;
@@ -63,17 +63,17 @@ fn dylib_filename(str base) -> str {
fn pipe() -> tup(int, int) {
let vec[mutable int] fds = vec(mutable 0, 0);
- assert (OS.libc.pipe(Vec.buf(fds)) == 0);
+ assert (os::libc::pipe(_vec::buf(fds)) == 0);
ret tup(fds.(0), fds.(1));
}
-fn fd_FILE(int fd) -> libc.FILE {
- ret libc.fdopen(fd, Str.buf("r"));
+fn fd_FILE(int fd) -> libc::FILE {
+ ret libc::fdopen(fd, _str::buf("r"));
}
fn waitpid(int pid) -> int {
let vec[mutable int] status = vec(mutable 0);
- assert (OS.libc.waitpid(pid, Vec.buf(status), 0) != -1);
+ assert (os::libc::waitpid(pid, _vec::buf(status), 0) != -1);
ret status.(0);
}
diff --git a/src/lib/Map.rs b/src/lib/map.rs
similarity index 88%
rename from src/lib/Map.rs
rename to src/lib/map.rs
index 6f1ad6d70299d..5483dccf3420a 100644
--- a/src/lib/Map.rs
+++ b/src/lib/map.rs
@@ -11,8 +11,8 @@ state type hashmap[K, V] = state obj {
fn insert(&K key, &V val) -> bool;
fn contains_key(&K key) -> bool;
fn get(&K key) -> V;
- fn find(&K key) -> Option.t[V];
- fn remove(&K key) -> Option.t[V];
+ fn find(&K key) -> option::t[V];
+ fn remove(&K key) -> option::t[V];
fn rehash();
iter items() -> @tup(K,V);
};
@@ -20,7 +20,7 @@ state type hashmap[K, V] = state obj {
fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
let uint initial_capacity = 32u; // 2^5
- let Util.rational load_factor = rec(num=3, den=4);
+ let util::rational load_factor = rec(num=3, den=4);
tag bucket[K, V] {
nil;
@@ -29,7 +29,7 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
}
fn make_buckets[K, V](uint nbkts) -> vec[mutable bucket[K, V]] {
- ret Vec.init_elt_mut[bucket[K, V]](nil[K, V], nbkts);
+ ret _vec::init_elt_mut[bucket[K, V]](nil[K, V], nbkts);
}
// Derive two hash functions from the one given by taking the upper
@@ -96,7 +96,7 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
vec[mutable bucket[K, V]] bkts,
uint nbkts,
&K key)
- -> Option.t[V]
+ -> option::t[V]
{
let uint i = 0u;
let uint h = hasher(key);
@@ -105,17 +105,17 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
alt (bkts.(j)) {
case (some[K, V](?k, ?v)) {
if (eqer(key, k)) {
- ret Option.some[V](v);
+ ret option::some[V](v);
}
}
case (nil[K, V]) {
- ret Option.none[V];
+ ret option::none[V];
}
case (deleted[K, V]) { }
}
i += 1u;
}
- ret Option.none[V];
+ ret option::none[V];
}
@@ -140,15 +140,15 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
mutable vec[mutable bucket[K, V]] bkts,
mutable uint nbkts,
mutable uint nelts,
- Util.rational lf)
+ util::rational lf)
{
fn size() -> uint { ret nelts; }
fn insert(&K key, &V val) -> bool {
- let Util.rational load = rec(num=(nelts + 1u) as int,
+ let util::rational load = rec(num=(nelts + 1u) as int,
den=nbkts as int);
- if (!Util.rational_leq(load, lf)) {
- let uint nnewbkts = UInt.next_power_of_two(nbkts + 1u);
+ if (!util::rational_leq(load, lf)) {
+ let uint nnewbkts = _uint::next_power_of_two(nbkts + 1u);
let vec[mutable bucket[K, V]] newbkts =
make_buckets[K, V](nnewbkts);
rehash[K, V](hasher, eqer, bkts, nbkts,
@@ -167,7 +167,7 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
fn contains_key(&K key) -> bool {
alt (find_common[K, V](hasher, eqer, bkts, nbkts, key)) {
- case (Option.some[V](_)) { ret true; }
+ case (option::some[V](_)) { ret true; }
case (_) { ret false; }
}
fail; // FIXME: remove me when exhaustiveness checking works
@@ -175,19 +175,19 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
fn get(&K key) -> V {
alt (find_common[K, V](hasher, eqer, bkts, nbkts, key)) {
- case (Option.some[V](?val)) { ret val; }
+ case (option::some[V](?val)) { ret val; }
case (_) { fail; }
}
fail; // FIXME: remove me when exhaustiveness checking works
}
- fn find(&K key) -> Option.t[V] {
+ fn find(&K key) -> option::t[V] {
// FIXME: should be 'be' but parametric tail-calls don't
// work at the moment.
ret find_common[K, V](hasher, eqer, bkts, nbkts, key);
}
- fn remove(&K key) -> Option.t[V] {
+ fn remove(&K key) -> option::t[V] {
let uint i = 0u;
let uint h = hasher(key);
while (i < nbkts) {
@@ -197,17 +197,17 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
if (eqer(key, k)) {
bkts.(j) = deleted[K, V];
nelts -= 1u;
- ret Option.some[V](v);
+ ret option::some[V](v);
}
}
case (deleted[K, V]) { }
case (nil[K, V]) {
- ret Option.none[V];
+ ret option::none[V];
}
}
i += 1u;
}
- ret Option.none[V];
+ ret option::none[V];
}
fn rehash() {
diff --git a/src/lib/Option.rs b/src/lib/option.rs
similarity index 95%
rename from src/lib/Option.rs
rename to src/lib/option.rs
index 3fb9aa3b61357..78ed2fb3614ef 100644
--- a/src/lib/Option.rs
+++ b/src/lib/option.rs
@@ -1,4 +1,4 @@
-// lib/Option.rs
+// lib/option::rs
tag t[T] {
none;
@@ -39,7 +39,7 @@ fn is_none[T](&t[T] opt) -> bool {
}
fn from_maybe[T](&T def, &t[T] opt) -> T {
- auto f = bind Util.id[T](_);
+ auto f = bind util::id[T](_);
ret maybe[T, T](def, f, opt);
}
diff --git a/src/lib/posix_FS.rs b/src/lib/posix_fs.rs
similarity index 66%
rename from src/lib/posix_FS.rs
rename to src/lib/posix_fs.rs
index b1f01a66414c4..1244dd1bd98d1 100644
--- a/src/lib/posix_FS.rs
+++ b/src/lib/posix_fs.rs
@@ -1,21 +1,21 @@
native "rust" mod rustrt {
- fn rust_dirent_filename(OS.libc.dirent ent) -> str;
+ fn rust_dirent_filename(os::libc::dirent ent) -> str;
}
fn list_dir(str path) -> vec[str] {
// TODO ensure this is always closed
- auto dir = OS.libc.opendir(Str.buf(path));
+ auto dir = os::libc::opendir(_str::buf(path));
assert (dir as uint != 0u);
let vec[str] result = vec();
while (true) {
- auto ent = OS.libc.readdir(dir);
+ auto ent = os::libc::readdir(dir);
if (ent as int == 0) {
- OS.libc.closedir(dir);
+ os::libc::closedir(dir);
ret result;
}
- Vec.push[str](result, rustrt.rust_dirent_filename(ent));
+ _vec::push[str](result, rustrt::rust_dirent_filename(ent));
}
- OS.libc.closedir(dir);
+ os::libc::closedir(dir);
ret result;
}
diff --git a/src/lib/Rand.rs b/src/lib/rand.rs
similarity index 79%
rename from src/lib/Rand.rs
rename to src/lib/rand.rs
index 06eb2f06fd7cb..da8f552ff53e2 100644
--- a/src/lib/Rand.rs
+++ b/src/lib/rand.rs
@@ -12,16 +12,16 @@ native "rust" mod rustrt {
type rng = obj { fn next() -> u32; };
fn mk_rng() -> rng {
- obj rt_rng(rustrt.rctx c) {
+ obj rt_rng(rustrt::rctx c) {
fn next() -> u32 {
- ret rustrt.rand_next(c);
+ ret rustrt::rand_next(c);
}
drop {
- rustrt.rand_free(c);
+ rustrt::rand_free(c);
}
}
- ret rt_rng(rustrt.rand_new());
+ ret rt_rng(rustrt::rand_new());
}
// Local Variables:
diff --git a/src/lib/Run_Program.rs b/src/lib/run_program.rs
similarity index 57%
rename from src/lib/Run_Program.rs
rename to src/lib/run_program.rs
index 30c0ee9c9a2fc..abcf1472067ef 100644
--- a/src/lib/Run_Program.rs
+++ b/src/lib/run_program.rs
@@ -1,74 +1,74 @@
-import Str.sbuf;
-import Vec.vbuf;
+import _str::sbuf;
+import _vec::vbuf;
native "rust" mod rustrt {
fn rust_run_program(vbuf argv, int in_fd, int out_fd, int err_fd) -> int;
}
fn argvec(str prog, vec[str] args) -> vec[sbuf] {
- auto argptrs = vec(Str.buf(prog));
+ auto argptrs = vec(_str::buf(prog));
for (str arg in args) {
- Vec.push[sbuf](argptrs, Str.buf(arg));
+ _vec::push[sbuf](argptrs, _str::buf(arg));
}
- Vec.push[sbuf](argptrs, 0 as sbuf);
+ _vec::push[sbuf](argptrs, 0 as sbuf);
ret argptrs;
}
fn run_program(str prog, vec[str] args) -> int {
- auto pid = rustrt.rust_run_program(Vec.buf[sbuf](argvec(prog, args)),
+ auto pid = rustrt::rust_run_program(_vec::buf[sbuf](argvec(prog, args)),
0, 0, 0);
- ret OS.waitpid(pid);
+ ret os::waitpid(pid);
}
type program =
state obj {
fn get_id() -> int;
- fn input() -> IO.writer;
- fn output() -> IO.reader;
+ fn input() -> io::writer;
+ fn output() -> io::reader;
fn close_input();
fn finish() -> int;
};
fn start_program(str prog, vec[str] args) -> @program {
- auto pipe_input = OS.pipe();
- auto pipe_output = OS.pipe();
- auto pid = rustrt.rust_run_program
- (Vec.buf[sbuf](argvec(prog, args)),
+ auto pipe_input = os::pipe();
+ auto pipe_output = os::pipe();
+ auto pid = rustrt::rust_run_program
+ (_vec::buf[sbuf](argvec(prog, args)),
pipe_input._0, pipe_output._1, 0);
if (pid == -1) {fail;}
- OS.libc.close(pipe_input._0);
- OS.libc.close(pipe_output._1);
+ os::libc::close(pipe_input._0);
+ os::libc::close(pipe_output._1);
state obj new_program(int pid,
int in_fd,
- OS.libc.FILE out_file,
+ os::libc::FILE out_file,
mutable bool finished) {
fn get_id() -> int {ret pid;}
- fn input() -> IO.writer {
- ret IO.new_writer(IO.fd_buf_writer(in_fd, false));
+ fn input() -> io::writer {
+ ret io::new_writer(io::fd_buf_writer(in_fd, false));
}
- fn output() -> IO.reader {
- ret IO.new_reader(IO.FILE_buf_reader(out_file, false));
+ fn output() -> io::reader {
+ ret io::new_reader(io::FILE_buf_reader(out_file, false));
}
fn close_input() {
- OS.libc.close(in_fd);
+ os::libc::close(in_fd);
}
fn finish() -> int {
if (finished) {ret 0;}
finished = true;
- OS.libc.close(in_fd);
- ret OS.waitpid(pid);
+ os::libc::close(in_fd);
+ ret os::waitpid(pid);
}
drop {
if (!finished) {
- OS.libc.close(in_fd);
- OS.waitpid(pid);
+ os::libc::close(in_fd);
+ os::waitpid(pid);
}
- OS.libc.fclose(out_file);
+ os::libc::fclose(out_file);
}
}
ret @new_program(pid, pipe_input._1,
- OS.fd_FILE(pipe_output._0),
+ os::fd_FILE(pipe_output._0),
false);
}
@@ -80,7 +80,7 @@ fn program_output(str prog, vec[str] args)
auto buf = "";
while (!out.eof()) {
auto bytes = out.read_bytes(4096u);
- buf += Str.unsafe_from_bytes(bytes);
+ buf += _str::unsafe_from_bytes(bytes);
}
ret rec(status=pr.finish(), out=buf);
}
diff --git a/src/lib/SHA1.rs b/src/lib/sha1.rs
similarity index 94%
rename from src/lib/SHA1.rs
rename to src/lib/sha1.rs
index 6aec814c8b880..96535d121f945 100644
--- a/src/lib/SHA1.rs
+++ b/src/lib/sha1.rs
@@ -74,8 +74,8 @@ fn mk_sha1() -> sha1 {
fn process_msg_block(&sha1state st) {
// FIXME: Make precondition
- assert (Vec.len(st.h) == digest_buf_len);
- assert (Vec.len(st.work_buf) == work_buf_len);
+ assert (_vec::len(st.h) == digest_buf_len);
+ assert (_vec::len(st.work_buf) == work_buf_len);
let int t; // Loop counter
auto w = st.work_buf;
@@ -196,7 +196,7 @@ fn mk_sha1() -> sha1 {
*/
fn pad_msg(&sha1state st) {
// FIXME: Should be a precondition
- assert (Vec.len(st.msg_block) == msg_block_len);
+ assert (_vec::len(st.msg_block) == msg_block_len);
/*
* Check to see if the current message block is too small to hold
@@ -240,7 +240,7 @@ fn mk_sha1() -> sha1 {
fn reset() {
// FIXME: Should be typestate precondition
- assert (Vec.len(st.h) == digest_buf_len);
+ assert (_vec::len(st.h) == digest_buf_len);
st.len_low = 0u32;
st.len_high = 0u32;
@@ -260,7 +260,7 @@ fn mk_sha1() -> sha1 {
}
fn input_str(&str msg) {
- add_input(st, Str.bytes(msg));
+ add_input(st, _str::bytes(msg));
}
fn result() -> vec[u8] {
@@ -271,19 +271,19 @@ fn mk_sha1() -> sha1 {
auto r = mk_result(st);
auto s = "";
for (u8 b in r) {
- s += UInt.to_str(b as uint, 16u);
+ s += _uint::to_str(b as uint, 16u);
}
ret s;
}
}
- auto st = rec(h = Vec.init_elt_mut[u32](0u32, digest_buf_len),
+ auto st = rec(h = _vec::init_elt_mut[u32](0u32, digest_buf_len),
mutable len_low = 0u32,
mutable len_high = 0u32,
- msg_block = Vec.init_elt_mut[u8](0u8, msg_block_len),
+ msg_block = _vec::init_elt_mut[u8](0u8, msg_block_len),
mutable msg_block_idx = 0u,
mutable computed = false,
- work_buf = Vec.init_elt_mut[u32](0u32, work_buf_len));
+ work_buf = _vec::init_elt_mut[u32](0u32, work_buf_len));
auto sh = sha1(st);
sh.reset();
ret sh;
diff --git a/src/lib/Sort.rs b/src/lib/sort.rs
similarity index 98%
rename from src/lib/Sort.rs
rename to src/lib/sort.rs
index 7ecaaaba0cf63..3b3c64036be2e 100644
--- a/src/lib/Sort.rs
+++ b/src/lib/sort.rs
@@ -1,5 +1,5 @@
-import Vec.len;
-import Vec.slice;
+import _vec::len;
+import _vec::slice;
type lteq[T] = fn(&T a, &T b) -> bool;
diff --git a/src/lib/std.rc b/src/lib/std.rc
index a317b1148f741..5c0ea313ad43d 100644
--- a/src/lib/std.rc
+++ b/src/lib/std.rc
@@ -6,76 +6,76 @@ meta (name = "std",
// Built-in types support modules.
-mod Int;
-mod UInt;
-mod U8;
-mod Vec;
-mod Str;
+mod _int;
+mod _uint;
+mod _u8;
+mod _vec;
+mod _str;
-// General IO and system-services modules.
+// General io and system-services modules.
-mod IO;
-mod Sys;
-mod Task;
+mod io;
+mod sys;
+mod _task;
// Utility modules.
-mod Option;
-mod Util;
+mod option;
+mod util;
// Authorize various rule-bendings.
-auth IO = unsafe;
-auth FS = unsafe;
-auth OS_FS = unsafe;
-auth Run = unsafe;
-auth Str = unsafe;
-auth Vec = unsafe;
-auth Task = unsafe;
+auth io = unsafe;
+auth fs = unsafe;
+auth os_fs = unsafe;
+auth run = unsafe;
+auth _str = unsafe;
+auth _vec = unsafe;
+auth _task = unsafe;
-auth Dbg = unsafe;
+auth dbg = unsafe;
-auth UInt.next_power_of_two = unsafe;
-auth Map.mk_hashmap = unsafe;
-auth Rand.mk_rng = unsafe;
+auth _uint::next_power_of_two = unsafe;
+auth map::mk_hashmap = unsafe;
+auth rand::mk_rng = unsafe;
-// Target-OS module.
+// Target-os module.
-// TODO: Have each OS module re-export everything from GenericOS.
-mod GenericOS;
+// TODO: Have each os module re-export everything from genericos.
+mod generic_os;
alt (target_os) {
case ("win32") {
- mod OS = "win32_OS.rs";
- mod OS_FS = "win32_FS.rs";
+ mod os = "win32_os.rs";
+ mod os_fs = "win32_fs.rs";
} case ("macos") {
- mod OS = "macos_OS.rs";
- mod OS_FS = "posix_FS.rs";
+ mod os = "macos_os.rs";
+ mod os_fs = "posix_fs.rs";
} else {
- mod OS = "linux_OS.rs";
- mod OS_FS = "posix_FS.rs";
+ mod os = "linux_os.rs";
+ mod os_fs = "posix_fs.rs";
}
}
-mod Run = "Run_Program.rs";
-mod FS;
+mod run = "run_program.rs";
+mod fs;
// FIXME: parametric
-mod Map;
-mod Deque;
-mod List;
-mod Rand;
-mod Dbg;
-mod BitV;
-mod Sort;
-mod SHA1;
-mod EBML;
-mod UFind;
-mod ExtFmt;
-mod Box;
-mod GetOpts;
-mod Term;
-mod Time;
+mod map;
+mod deque;
+mod list;
+mod rand;
+mod dbg;
+mod bitv;
+mod sort;
+mod sha1;
+mod ebml;
+mod ufind;
+mod extfmt;
+mod box;
+mod getopts;
+mod term;
+mod time;
// Local Variables:
// mode: rust;
diff --git a/src/lib/Sys.rs b/src/lib/sys.rs
similarity index 100%
rename from src/lib/Sys.rs
rename to src/lib/sys.rs
diff --git a/src/lib/Term.rs b/src/lib/term.rs
similarity index 79%
rename from src/lib/Term.rs
rename to src/lib/term.rs
index b07dcc0c3dddb..6fd54a2d4e6f5 100644
--- a/src/lib/Term.rs
+++ b/src/lib/term.rs
@@ -21,20 +21,20 @@ const u8 color_bright_magenta = 13u8;
const u8 color_bright_cyan = 14u8;
const u8 color_bright_white = 15u8;
-fn esc(IO.buf_writer writer) {
+fn esc(io::buf_writer writer) {
writer.write(vec(0x1bu8, '[' as u8));
}
-fn reset(IO.buf_writer writer) {
+fn reset(io::buf_writer writer) {
esc(writer);
writer.write(vec('0' as u8, 'm' as u8));
}
fn color_supported() -> bool {
- ret GenericOS.getenv("TERM") == Option.some[str]("xterm-color");
+ ret generic_os::getenv("TERM") == option::some[str]("xterm-color");
}
-fn set_color(IO.buf_writer writer, u8 first_char, u8 color) {
+fn set_color(io::buf_writer writer, u8 first_char, u8 color) {
assert (color < 16u8);
esc(writer);
@@ -45,11 +45,11 @@ fn set_color(IO.buf_writer writer, u8 first_char, u8 color) {
writer.write(vec(first_char, ('0' as u8) + color, 'm' as u8));
}
-fn fg(IO.buf_writer writer, u8 color) {
+fn fg(io::buf_writer writer, u8 color) {
ret set_color(writer, '3' as u8, color);
}
-fn bg(IO.buf_writer writer, u8 color) {
+fn bg(io::buf_writer writer, u8 color) {
ret set_color(writer, '4' as u8, color);
}
diff --git a/src/lib/Time.rs b/src/lib/time.rs
similarity index 83%
rename from src/lib/Time.rs
rename to src/lib/time.rs
index 70a12a6fec45f..645d19ac2739e 100644
--- a/src/lib/Time.rs
+++ b/src/lib/time.rs
@@ -6,7 +6,7 @@ type timeval = rec(u32 sec, u32 usec);
fn get_time() -> timeval {
let timeval res = rec(sec=0u32, usec=0u32);
- rustrt.get_time(res.sec, res.usec);
+ rustrt::get_time(res.sec, res.usec);
ret res;
}
diff --git a/src/lib/UFind.rs b/src/lib/ufind.rs
similarity index 82%
rename from src/lib/UFind.rs
rename to src/lib/ufind.rs
index 0bb06d7cfb89c..faa77305b9eda 100644
--- a/src/lib/UFind.rs
+++ b/src/lib/ufind.rs
@@ -1,19 +1,19 @@
-import Option.none;
-import Option.some;
+import option::none;
+import option::some;
// A very naive implementation of union-find with unsigned integer nodes.
-type node = Option.t[uint];
+type node = option::t[uint];
type ufind = rec(mutable vec[mutable node] nodes);
fn make() -> ufind {
let vec[mutable node] v = vec(mutable none[uint]);
- Vec.pop(v); // FIXME: botch
+ _vec::pop(v); // FIXME: botch
ret rec(mutable nodes=v);
}
fn make_set(&ufind ufnd) -> uint {
- auto idx = Vec.len(ufnd.nodes);
+ auto idx = _vec::len(ufnd.nodes);
ufnd.nodes += vec(mutable none[uint]);
ret idx;
}
diff --git a/src/lib/Util.rs b/src/lib/util.rs
similarity index 89%
rename from src/lib/Util.rs
rename to src/lib/util.rs
index a385aafda6473..b8d8ed6587d79 100644
--- a/src/lib/Util.rs
+++ b/src/lib/util.rs
@@ -4,10 +4,10 @@ fn id[T](&T x) -> T {
/* FIXME (issue #141): See test/run-pass/constrained-type.rs. Uncomment
* the constraint once fixed. */
-type rational = rec(int num, int den); // : Int.positive(*.den);
+type rational = rec(int num, int den); // : _int::positive(*.den);
fn rational_leq(&rational x, &rational y) -> bool {
- // NB: Uses the fact that rationals have positive denominators WLOG.
+ // NB: Uses the fact that rationals have positive denominators WLOG:
ret x.num * y.den <= y.num * x.den;
}
diff --git a/src/lib/win32_FS.rs b/src/lib/win32_fs.rs
similarity index 94%
rename from src/lib/win32_FS.rs
rename to src/lib/win32_fs.rs
index 94599e3c3dfa6..3e2c4f67bc2a8 100644
--- a/src/lib/win32_FS.rs
+++ b/src/lib/win32_fs.rs
@@ -4,7 +4,7 @@ native "rust" mod rustrt {
}
fn list_dir(str path) -> vec[str] {
- ret rustrt.rust_list_files(path+"*");
+ ret rustrt::rust_list_files(path+"*");
}
/* FIXME: win32 path handling actually accepts '/' or '\' and has subtly
diff --git a/src/lib/win32_OS.rs b/src/lib/win32_os.rs
similarity index 87%
rename from src/lib/win32_OS.rs
rename to src/lib/win32_os.rs
index 7330102e13df8..e9555249ed4ab 100644
--- a/src/lib/win32_OS.rs
+++ b/src/lib/win32_os.rs
@@ -1,5 +1,5 @@
-import Str.sbuf;
-import Vec.vbuf;
+import _str::sbuf;
+import _vec::vbuf;
native mod libc = "msvcrt.dll" {
fn open(sbuf s, int flags, uint mode) -> int = "_open";
@@ -53,13 +53,13 @@ fn dylib_filename(str base) -> str {
fn pipe() -> tup(int, int) {
let vec[mutable int] fds = vec(mutable 0, 0);
- assert (OS.libc._pipe(Vec.buf(fds), 1024u,
- libc_constants.O_BINARY()) == 0);
+ assert (os::libc::_pipe(_vec::buf(fds), 1024u,
+ libc_constants::O_BINARY()) == 0);
ret tup(fds.(0), fds.(1));
}
-fn fd_FILE(int fd) -> libc.FILE {
- ret libc._fdopen(fd, Str.buf("r"));
+fn fd_FILE(int fd) -> libc::FILE {
+ ret libc::_fdopen(fd, _str::buf("r"));
}
native "rust" mod rustrt {
@@ -67,7 +67,7 @@ native "rust" mod rustrt {
}
fn waitpid(int pid) -> int {
- ret rustrt.rust_process_wait(pid);
+ ret rustrt::rust_process_wait(pid);
}
// Local Variables:
diff --git a/src/test/bench/99-bottles/99bob-iter.rs b/src/test/bench/99-bottles/99bob-iter.rs
index e8cc4b4bb911b..5aa3dc2f54455 100644
--- a/src/test/bench/99-bottles/99bob-iter.rs
+++ b/src/test/bench/99-bottles/99bob-iter.rs
@@ -1,10 +1,10 @@
-/* -*- mode:rust;indent-tabs-mode:nil -*-
+/* -*- mode::rust;indent-tabs-mode::nil -*-
* Implementation of 99 Bottles of Beer
* http://99-bottles-of-beer.net/
*/
use std;
-import std.Int;
-import std.Str;
+import std::_int;
+import std::_str;
fn b1() -> str {
ret "# of beer on the wall, # of beer.";
@@ -32,15 +32,15 @@ case (1) {
ns = "1 bottle";
}
case (_) {
- ns = Int.to_str(n, 10u) + " bottles";
+ ns = _int::to_str(n, 10u) + " bottles";
}
}
- while (i < Str.byte_len(t)) {
+ while (i < _str::byte_len(t)) {
if (t.(i) == ('#' as u8)) {
b += ns;
}
else {
- Str.push_byte(b, t.(i));
+ _str::push_byte(b, t.(i));
}
i += 1u;
}
diff --git a/src/test/bench/99-bottles/99bob-pattern.rs b/src/test/bench/99-bottles/99bob-pattern.rs
index fc9ddddb35df4..311fca460c8c5 100644
--- a/src/test/bench/99-bottles/99bob-pattern.rs
+++ b/src/test/bench/99-bottles/99bob-pattern.rs
@@ -1,10 +1,10 @@
-/* -*- mode:rust;indent-tabs-mode:nil -*-
+/* -*- mode::rust;indent-tabs-mode::nil -*-
* Implementation of 99 Bottles of Beer
* http://99-bottles-of-beer.net/
*/
use std;
-import std.Int;
-import std.Str;
+import std::_int;
+import std::_str;
tag bottle { none; dual; single; multiple(int);}
@@ -25,8 +25,8 @@ fn show(bottle b) {
log "Take one down and pass it around, 1 bottle of beer on the wall.";
}
case (multiple(?n)) {
- let str nb = Int.to_str(n, 10u);
- let str mb = Int.to_str(n - 1, 10u);
+ let str nb = _int::to_str(n, 10u);
+ let str mb = _int::to_str(n - 1, 10u);
log nb + " bottles of beer on the wall, " + nb + " bottles of beer,";
log "Take one down and pass it around, "
+ mb + " bottles of beer on the wall.";
diff --git a/src/test/bench/99-bottles/99bob-simple.rs b/src/test/bench/99-bottles/99bob-simple.rs
index 5c0f082405904..569b076a5ec67 100644
--- a/src/test/bench/99-bottles/99bob-simple.rs
+++ b/src/test/bench/99-bottles/99bob-simple.rs
@@ -1,10 +1,10 @@
-/* -*- mode:rust;indent-tabs-mode:nil -*-
+/* -*- mode::rust;indent-tabs-mode::nil -*-
* Implementation of 99 Bottles of Beer
* http://99-bottles-of-beer.net/
*/
use std;
-import std.Int;
-import std.Str;
+import std::_int;
+import std::_str;
fn b1() -> str {
ret "# of beer on the wall, # of beer.";
@@ -31,15 +31,15 @@ case (1) {
ns = "1 bottle";
}
case (_) {
- ns = Int.to_str(n, 10u) + " bottles";
+ ns = _int::to_str(n, 10u) + " bottles";
}
}
- while (i < Str.byte_len(t)) {
+ while (i < _str::byte_len(t)) {
if (t.(i) == ('#' as u8)) {
b += ns;
}
else {
- Str.push_byte(b, t.(i));
+ _str::push_byte(b, t.(i));
}
i += 1u;
}
diff --git a/src/test/bench/99-bottles/99bob-tail.rs b/src/test/bench/99-bottles/99bob-tail.rs
index 985d9b4b70933..202b653b78f79 100644
--- a/src/test/bench/99-bottles/99bob-tail.rs
+++ b/src/test/bench/99-bottles/99bob-tail.rs
@@ -1,15 +1,15 @@
-/* -*- mode:rust;indent-tabs-mode:nil -*-
+/* -*- mode::rust;indent-tabs-mode::nil -*-
* Implementation of 99 Bottles of Beer
* http://99-bottles-of-beer.net/
*/
use std;
-import std.Int;
-import std.Str;
+import std::_int;
+import std::_str;
fn main() {
fn multiple(int n) {
- let str nb = Int.to_str(n, 10u);
- let str mb = Int.to_str(n - 1, 10u);
+ let str nb = _int::to_str(n, 10u);
+ let str mb = _int::to_str(n - 1, 10u);
log nb + " bottles of beer on the wall, " + nb + " bottles of beer,";
log "Take one down and pass it around, "
+ mb + " bottles of beer on the wall.";
diff --git a/src/test/bench/shootout/binarytrees.rs b/src/test/bench/shootout/binarytrees.rs
index aa81aaac31df9..735ac2d506e7f 100644
--- a/src/test/bench/shootout/binarytrees.rs
+++ b/src/test/bench/shootout/binarytrees.rs
@@ -1,6 +1,6 @@
use std;
-import std.Int;
+import std::_int;
tag tree {
nil;
@@ -49,7 +49,7 @@ fn main() {
auto depth = min_depth;
while (depth <= max_depth) {
- auto iterations = Int.pow(2, (max_depth - depth + min_depth) as uint);
+ auto iterations = _int::pow(2, (max_depth - depth + min_depth) as uint);
auto chk = 0;
auto i = 1;
diff --git a/src/test/bench/shootout/fannkuchredux.rs b/src/test/bench/shootout/fannkuchredux.rs
index 5af56a474c96d..0d24d33820290 100644
--- a/src/test/bench/shootout/fannkuchredux.rs
+++ b/src/test/bench/shootout/fannkuchredux.rs
@@ -2,8 +2,8 @@
use std;
-import std.Int;
-import std.Vec;
+import std::_int;
+import std::_vec;
fn fannkuch(int n) -> int {
@@ -12,9 +12,9 @@ fn fannkuch(int n) -> int {
}
auto perm1init_ = perm1init; // Rustboot workaround
- auto perm = Vec.init_elt(0, n as uint);
- auto perm1 = Vec.init_fn(perm1init_, n as uint);
- auto count = Vec.init_elt(0, n as uint);
+ auto perm = _vec::init_elt(0, n as uint);
+ auto perm1 = _vec::init_fn(perm1init_, n as uint);
+ auto count = _vec::init_elt(0, n as uint);
auto f = 0;
auto i = 0;
diff --git a/src/test/bench/shootout/fasta.rs b/src/test/bench/shootout/fasta.rs
index 3543c29875430..ec962e38a4810 100644
--- a/src/test/bench/shootout/fasta.rs
+++ b/src/test/bench/shootout/fasta.rs
@@ -7,10 +7,10 @@
* http://shootout.alioth.debian.org/
*/
use std;
-import std.Vec;
-import std.Str;
-import std.UInt;
-import std.Int;
+import std::_vec;
+import std::_str;
+import std::_uint;
+import std::_int;
fn LINE_LENGTH() -> uint {
ret 60u;
@@ -54,21 +54,21 @@ fn select_random(u32 r, vec[aminoacids] genelist) -> char {
ret v.(hi)._0;
}
}
- ret bisect(genelist, 0u, Vec.len[aminoacids](genelist) - 1u, r);
+ ret bisect(genelist, 0u, _vec::len[aminoacids](genelist) - 1u, r);
}
fn make_random_fasta(str id, str desc, vec[aminoacids] genelist, int n) {
log(">" + id + " " + desc);
- auto rng = myrandom(std.Rand.mk_rng().next());
+ auto rng = myrandom(std::rand::mk_rng().next());
let str op = "";
- for each (uint i in UInt.range(0u, n as uint)) {
- Str.push_byte(op, select_random(rng.next(100u32), genelist) as u8);
- if (Str.byte_len(op) >= LINE_LENGTH()) {
+ for each (uint i in _uint::range(0u, n as uint)) {
+ _str::push_byte(op, select_random(rng.next(100u32), genelist) as u8);
+ if (_str::byte_len(op) >= LINE_LENGTH()) {
log(op);
op = "";
}
}
- if (Str.byte_len(op) > 0u) {
+ if (_str::byte_len(op) > 0u) {
log(op);
}
}
@@ -76,16 +76,16 @@ fn make_random_fasta(str id, str desc, vec[aminoacids] genelist, int n) {
fn make_repeat_fasta(str id, str desc, str s, int n) {
log(">" + id + " " + desc);
let str op = "";
- let uint sl = Str.byte_len(s);
- for each (uint i in UInt.range(0u, n as uint)) {
+ let uint sl = _str::byte_len(s);
+ for each (uint i in _uint::range(0u, n as uint)) {
- Str.push_byte(op, s.(i % sl));
- if (Str.byte_len(op) >= LINE_LENGTH()) {
+ _str::push_byte(op, s.(i % sl));
+ if (_str::byte_len(op) >= LINE_LENGTH()) {
log(op);
op = "";
}
}
- if (Str.byte_len(op) > 0u) {
+ if (_str::byte_len(op) > 0u) {
log(op);
}
}
diff --git a/src/test/bench/shootout/nbody.rs b/src/test/bench/shootout/nbody.rs
index f2041c0e33ddd..b665e7609db4c 100644
--- a/src/test/bench/shootout/nbody.rs
+++ b/src/test/bench/shootout/nbody.rs
@@ -19,33 +19,33 @@ fn main() {
// 50000000
);
- let vec[Body.props] bodies = NBodySystem.MakeNBodySystem();
+ let vec[Body::props] bodies = NBodySystem::MakeNBodySystem();
for (int n in inputs) {
- log NBodySystem.energy(bodies);
+ log NBodySystem::energy(bodies);
let int i = 0;
while (i < n) {
- NBodySystem.advance(bodies, 0.01);
+ NBodySystem::advance(bodies, 0.01);
i += 1;
}
- log NBodySystem.energy(bodies);
+ log NBodySystem::energy(bodies);
}
}
-// Body.props is a record of floats, so
-// vec[Body.props] is a vector of records of floats
+// Body::props is a record of floats, so
+// vec[Body::props] is a vector of records of floats
mod NBodySystem {
- fn MakeNBodySystem() -> vec[Body.props] {
- let vec[Body.props] bodies = vec(
- // these each return a Body.props
- Body.sun(),
- Body.jupiter(),
- Body.saturn(),
- Body.uranus(),
- Body.neptune());
+ fn MakeNBodySystem() -> vec[Body::props] {
+ let vec[Body::props] bodies = vec(
+ // these each return a Body::props
+ Body::sun(),
+ Body::jupiter(),
+ Body::saturn(),
+ Body::uranus(),
+ Body::neptune());
let float px = 0.0;
let float py = 0.0;
@@ -61,12 +61,12 @@ mod NBodySystem {
}
// side-effecting
- Body.offsetMomentum(bodies.(0), px, py, pz);
+ Body::offsetMomentum(bodies.(0), px, py, pz);
ret bodies;
}
- fn advance(vec[Body.props] bodies, float dt) -> () {
+ fn advance(vec[Body::props] bodies, float dt) -> () {
let int i = 0;
while (i < 5) {
@@ -86,14 +86,14 @@ mod NBodySystem {
}
}
- fn advance_one(&Body.props bi, &Body.props bj, float dt) {
+ fn advance_one(&Body::props bi, &Body::props bj, float dt) {
let float dx = bi.x - bj.x;
let float dy = bi.y - bj.y;
let float dz = bi.z - bj.z;
let float dSquared = dx * dx + dy * dy + dz * dz;
- let float distance = llvm.sqrt(dSquared);
+ let float distance = llvm::sqrt(dSquared);
let float mag = dt / (dSquared * distance);
bi.vx -= dx * bj.mass * mag;
@@ -105,13 +105,13 @@ mod NBodySystem {
bj.vz += dz * bi.mass * mag;
}
- fn move(&Body.props b, float dt) {
+ fn move(&Body::props b, float dt) {
b.x += dt * b.vx;
b.y += dt * b.vy;
b.z += dt * b.vz;
}
- fn energy(vec[Body.props] bodies) -> float {
+ fn energy(vec[Body::props] bodies) -> float {
let float dx;
let float dy;
let float dz;
@@ -131,7 +131,7 @@ mod NBodySystem {
dy = bodies.(i).y - bodies.(j).y;
dz = bodies.(i).z - bodies.(j).z;
- distance = llvm.sqrt(dx*dx + dy*dy + dz*dz);
+ distance = llvm::sqrt(dx*dx + dy*dy + dz*dz);
e -= (bodies.(i).mass * bodies.(j).mass) / distance;
j += 1;
@@ -158,7 +158,7 @@ mod Body {
mutable float vz,
float mass);
- fn jupiter() -> Body.props {
+ fn jupiter() -> Body::props {
ret rec(
mutable x = 4.84143144246472090e+00,
mutable y = -1.16032004402742839e+00,
@@ -170,7 +170,7 @@ mod Body {
);
}
- fn saturn() -> Body.props {
+ fn saturn() -> Body::props {
ret rec(
mutable x = 8.34336671824457987e+00,
mutable y = 4.12479856412430479e+00,
@@ -182,7 +182,7 @@ mod Body {
);
}
- fn uranus() -> Body.props {
+ fn uranus() -> Body::props {
ret rec(
mutable x = 1.28943695621391310e+01,
mutable y = -1.51111514016986312e+01,
@@ -194,7 +194,7 @@ mod Body {
);
}
- fn neptune() -> Body.props {
+ fn neptune() -> Body::props {
ret rec(
mutable x = 1.53796971148509165e+01,
mutable y = -2.59193146099879641e+01,
@@ -206,7 +206,7 @@ mod Body {
);
}
- fn sun() -> Body.props {
+ fn sun() -> Body::props {
ret rec(
mutable x = 0.0,
mutable y = 0.0,
@@ -218,7 +218,7 @@ mod Body {
);
}
- fn offsetMomentum(&Body.props props,
+ fn offsetMomentum(&Body::props props,
float px,
float py,
float pz) -> () {
diff --git a/src/test/compile-fail/bad-expr-path.rs b/src/test/compile-fail/bad-expr-path.rs
index 01e27c5a15a49..e8388c5570701 100644
--- a/src/test/compile-fail/bad-expr-path.rs
+++ b/src/test/compile-fail/bad-expr-path.rs
@@ -5,5 +5,5 @@ mod m1 {
}
fn main(vec[str] args) {
- log m1.a;
+ log m1::a;
}
diff --git a/src/test/compile-fail/bad-expr-path2.rs b/src/test/compile-fail/bad-expr-path2.rs
index a2f58f8ede1ac..607c917387b75 100644
--- a/src/test/compile-fail/bad-expr-path2.rs
+++ b/src/test/compile-fail/bad-expr-path2.rs
@@ -1,4 +1,4 @@
-// error-pattern: can't refer to a module as a first-class value
+// error-pattern: is a module, not a
mod m1 {
mod a {
@@ -6,5 +6,5 @@ mod m1 {
}
fn main(vec[str] args) {
- log m1.a;
+ log m1::a;
}
diff --git a/src/test/compile-fail/export-boot.rs b/src/test/compile-fail/export-boot.rs
index 892f544fcc43f..75b9de2886b9b 100644
--- a/src/test/compile-fail/export-boot.rs
+++ b/src/test/compile-fail/export-boot.rs
@@ -17,5 +17,5 @@ mod foo {
}
fn main() {
- foo.z(10);
+ foo::z(10);
}
diff --git a/src/test/compile-fail/export-fully-qualified.rs b/src/test/compile-fail/export-fully-qualified.rs
index 1f62b0a81788b..2c64a48d99ccd 100644
--- a/src/test/compile-fail/export-fully-qualified.rs
+++ b/src/test/compile-fail/export-fully-qualified.rs
@@ -10,7 +10,7 @@ mod foo {
export bar;
fn bar() {
- foo.baz();
+ foo::baz();
}
fn baz() {
diff --git a/src/test/compile-fail/export-import.rs b/src/test/compile-fail/export-import.rs
index 851250876e0a1..1ef963f852a2d 100644
--- a/src/test/compile-fail/export-import.rs
+++ b/src/test/compile-fail/export-import.rs
@@ -2,7 +2,7 @@
// xfail-stage0
// error-pattern: unresolved import
-import m.unexported;
+import m::unexported;
mod m {
export exported;
diff --git a/src/test/compile-fail/export-no-tag-variants.rs b/src/test/compile-fail/export-no-tag-variants.rs
index 697998029d399..7676191c8ea56 100644
--- a/src/test/compile-fail/export-no-tag-variants.rs
+++ b/src/test/compile-fail/export-no-tag-variants.rs
@@ -13,5 +13,5 @@ mod foo {
}
fn main() {
- auto x = foo.t1;
+ auto x = foo::t1;
}
diff --git a/src/test/compile-fail/export-tag-variant.rs b/src/test/compile-fail/export-tag-variant.rs
index c37dac2ecd3fb..5af6b07cf1ead 100644
--- a/src/test/compile-fail/export-tag-variant.rs
+++ b/src/test/compile-fail/export-tag-variant.rs
@@ -13,5 +13,5 @@ mod foo {
}
fn main() {
- auto z = foo.y1;
+ auto z = foo::y1;
}
diff --git a/src/test/compile-fail/export.rs b/src/test/compile-fail/export.rs
index d54e515c6a5d2..8df742f4df2b2 100644
--- a/src/test/compile-fail/export.rs
+++ b/src/test/compile-fail/export.rs
@@ -11,5 +11,5 @@ mod foo {
}
fn main() {
- foo.z(10);
+ foo::z(10);
}
diff --git a/src/test/compile-fail/export2.rs b/src/test/compile-fail/export2.rs
index 18e84ddc035e8..720a21d8df51b 100644
--- a/src/test/compile-fail/export2.rs
+++ b/src/test/compile-fail/export2.rs
@@ -5,7 +5,7 @@ mod foo {
export x;
fn x() {
- bar.x();
+ bar::x();
}
}
@@ -21,5 +21,5 @@ mod bar {
}
fn main() {
- foo.x();
+ foo::x();
}
diff --git a/src/test/compile-fail/import-loop-2.rs b/src/test/compile-fail/import-loop-2.rs
index 474634b520ce8..2413ae1f90afa 100644
--- a/src/test/compile-fail/import-loop-2.rs
+++ b/src/test/compile-fail/import-loop-2.rs
@@ -1,11 +1,11 @@
// error-pattern:cyclic import
mod a {
- import b.x;
+ import b::x;
}
mod b {
- import a.x;
+ import a::x;
fn main() {
auto y = x;
diff --git a/src/test/compile-fail/import.rs b/src/test/compile-fail/import.rs
index bf132a02e8d90..7fe01bf498055 100644
--- a/src/test/compile-fail/import.rs
+++ b/src/test/compile-fail/import.rs
@@ -1,8 +1,8 @@
// xfail-boot
// xfail-stage0
// error-pattern: unresolved import: baz
-import zed.bar;
-import zed.baz;
+import zed::bar;
+import zed::baz;
mod zed {
fn bar() {
log "bar";
diff --git a/src/test/compile-fail/import2.rs b/src/test/compile-fail/import2.rs
index 5a5361938d328..beb704ca3e74e 100644
--- a/src/test/compile-fail/import2.rs
+++ b/src/test/compile-fail/import2.rs
@@ -1,6 +1,6 @@
// xfail-boot
// error-pattern: unresolved name
-import baz.zed.bar;
+import baz::zed::bar;
mod baz {
}
mod zed {
diff --git a/src/test/compile-fail/import3.rs b/src/test/compile-fail/import3.rs
index eede762610ca6..ba7a178c37d17 100644
--- a/src/test/compile-fail/import3.rs
+++ b/src/test/compile-fail/import3.rs
@@ -1,6 +1,6 @@
// xfail-boot
// error-pattern: main is not a module or crate
-import main.bar;
+import main::bar;
fn main(vec[str] args) {
log "foo";
diff --git a/src/test/compile-fail/import4.rs b/src/test/compile-fail/import4.rs
index bbef8d53eae84..3df84c10fb4eb 100644
--- a/src/test/compile-fail/import4.rs
+++ b/src/test/compile-fail/import4.rs
@@ -1,8 +1,8 @@
// xfail-boot
// error-pattern: cyclic import
-import zed.bar;
-import bar.zed;
+import zed::bar;
+import bar::zed;
fn main(vec[str] args) {
log "loop";
diff --git a/src/test/run-pass/alt-join.rs b/src/test/run-pass/alt-join.rs
index 8f45e6ff5ac09..a785f91d3b449 100644
--- a/src/test/run-pass/alt-join.rs
+++ b/src/test/run-pass/alt-join.rs
@@ -1,10 +1,10 @@
use std;
-import std.Option;
-import std.Option.t;
-import std.Option.none;
-import std.Option.some;
+import std::option;
+import std::option::t;
+import std::option::none;
+import std::option::some;
-fn foo[T](&Option.t[T] y) {
+fn foo[T](&option::t[T] y) {
let int x;
let vec[int] res = vec();
diff --git a/src/test/run-pass/alt-path.rs b/src/test/run-pass/alt-path.rs
index ad55713b0852a..205500e1c9229 100644
--- a/src/test/run-pass/alt-path.rs
+++ b/src/test/run-pass/alt-path.rs
@@ -4,9 +4,9 @@ mod m1 {
foo2;
}
}
-fn bar(m1.foo x) {
+fn bar(m1::foo x) {
alt(x) {
- case (m1.foo1) {
+ case (m1::foo1) {
}
}
}
diff --git a/src/test/run-pass/alt-pattern-drop.rs b/src/test/run-pass/alt-pattern-drop.rs
index 76e7c3aa18d79..a59248ebfa8eb 100644
--- a/src/test/run-pass/alt-pattern-drop.rs
+++ b/src/test/run-pass/alt-pattern-drop.rs
@@ -1,9 +1,9 @@
// -*- rust -*-
use std;
-import std.Str;
+import std::_str;
-// FIXME: import std.Dbg.const_refcount. Currently
+// FIXME: import std::dbg.const_refcount. Currently
// cross-crate const references don't work.
const uint const_refcount = 0x7bad_face_u;
@@ -20,13 +20,13 @@ fn foo(str s) {
case (_) { log "?"; fail; }
}
- log Str.refcount(s);
- assert (Str.refcount(s) == const_refcount);
+ log _str::refcount(s);
+ assert (_str::refcount(s) == const_refcount);
}
fn main() {
let str s = "hi"; // ref up
foo(s); // ref up then down
- log Str.refcount(s);
- assert (Str.refcount(s) == const_refcount);
+ log _str::refcount(s);
+ assert (_str::refcount(s) == const_refcount);
}
diff --git a/src/test/run-pass/export-abstract-tag.rs b/src/test/run-pass/export-abstract-tag.rs
index b192b698ea81f..7e488631051a0 100644
--- a/src/test/run-pass/export-abstract-tag.rs
+++ b/src/test/run-pass/export-abstract-tag.rs
@@ -15,5 +15,5 @@ mod foo {
}
fn main() {
- let foo.t v = foo.f();
+ let foo::t v = foo::f();
}
diff --git a/src/test/run-pass/export-non-interference2.rs b/src/test/run-pass/export-non-interference2.rs
index e5b324e4aa746..533df528043c8 100644
--- a/src/test/run-pass/export-non-interference2.rs
+++ b/src/test/run-pass/export-non-interference2.rs
@@ -14,5 +14,5 @@ mod foo {
}
fn main() {
- foo.bar.y();
+ foo::bar::y();
}
diff --git a/src/test/run-pass/export-non-interference3.rs b/src/test/run-pass/export-non-interference3.rs
index c52b13f7ec7ae..7b936b63e1150 100644
--- a/src/test/run-pass/export-non-interference3.rs
+++ b/src/test/run-pass/export-non-interference3.rs
@@ -2,7 +2,7 @@ mod foo {
export x;
fn x() {
- bar.x();
+ bar::x();
}
}
@@ -15,5 +15,5 @@ mod bar {
}
fn main() {
- foo.x();
+ foo::x();
}
diff --git a/src/test/run-pass/export-tag-variant.rs b/src/test/run-pass/export-tag-variant.rs
index e99bc0410bbc5..309261a50d5eb 100644
--- a/src/test/run-pass/export-tag-variant.rs
+++ b/src/test/run-pass/export-tag-variant.rs
@@ -8,5 +8,5 @@ mod foo {
}
fn main() {
- auto v = foo.t1;
+ auto v = foo::t1;
}
diff --git a/src/test/run-pass/export-unexported-dep.rs b/src/test/run-pass/export-unexported-dep.rs
index 94ef5241edbe0..dcb88af2f73d4 100644
--- a/src/test/run-pass/export-unexported-dep.rs
+++ b/src/test/run-pass/export-unexported-dep.rs
@@ -20,5 +20,5 @@ mod foo {
}
fn main() {
- foo.g(foo.f());
+ foo::g(foo::f());
}
\ No newline at end of file
diff --git a/src/test/run-pass/generic-fn-twice.rs b/src/test/run-pass/generic-fn-twice.rs
index 0c6257f887411..49dc3ed789de7 100644
--- a/src/test/run-pass/generic-fn-twice.rs
+++ b/src/test/run-pass/generic-fn-twice.rs
@@ -5,6 +5,6 @@ mod foomod {
}
fn main() {
- foomod.foo[int]();
- foomod.foo[int]();
+ foomod::foo[int]();
+ foomod::foo[int]();
}
diff --git a/src/test/run-pass/import.rs b/src/test/run-pass/import.rs
index 76de0d1870711..2bccd392a33a2 100644
--- a/src/test/run-pass/import.rs
+++ b/src/test/run-pass/import.rs
@@ -5,8 +5,8 @@ mod foo {
}
mod bar {
- import foo.x;
- import z = foo.x;
+ import foo::x;
+ import z = foo::x;
fn main() {
x(10);
z(10);
diff --git a/src/test/run-pass/import2.rs b/src/test/run-pass/import2.rs
index 31b49aeab1847..2531b857ae170 100644
--- a/src/test/run-pass/import2.rs
+++ b/src/test/run-pass/import2.rs
@@ -1,4 +1,4 @@
-import zed.bar;
+import zed::bar;
mod zed {
fn bar() {
log "bar";
diff --git a/src/test/run-pass/import3.rs b/src/test/run-pass/import3.rs
index 559c6ee9ea97c..282c4d232d438 100644
--- a/src/test/run-pass/import3.rs
+++ b/src/test/run-pass/import3.rs
@@ -1,5 +1,5 @@
-import zed.bar;
-import baz.zed;
+import zed::bar;
+import baz::zed;
mod baz {
mod zed {
fn bar() {
diff --git a/src/test/run-pass/import4.rs b/src/test/run-pass/import4.rs
index 5b0cb9f331ff0..2c4170a397ea7 100644
--- a/src/test/run-pass/import4.rs
+++ b/src/test/run-pass/import4.rs
@@ -1,4 +1,4 @@
-import zed.bar;
+import zed::bar;
mod zed {
fn bar() {
log "bar";
diff --git a/src/test/run-pass/import5.rs b/src/test/run-pass/import5.rs
index 5e07e708d3351..077cc14cd970e 100644
--- a/src/test/run-pass/import5.rs
+++ b/src/test/run-pass/import5.rs
@@ -1,6 +1,6 @@
-import foo.bar;
+import foo::bar;
mod foo {
- import zed.bar;
+ import zed::bar;
mod zed {
fn bar() {
log "foo";
diff --git a/src/test/run-pass/import6.rs b/src/test/run-pass/import6.rs
index 5e3a9d7429a20..c8268d99c25b3 100644
--- a/src/test/run-pass/import6.rs
+++ b/src/test/run-pass/import6.rs
@@ -1,5 +1,5 @@
-import bar.baz;
-import foo.zed;
+import bar::baz;
+import foo::zed;
mod foo {
mod zed {
fn baz() {
@@ -8,7 +8,7 @@ mod foo {
}
}
mod bar {
- import zed.baz;
+ import zed::baz;
}
fn main(vec[str] args) {
baz();
diff --git a/src/test/run-pass/import7.rs b/src/test/run-pass/import7.rs
index 29915fb1f2fc7..6b11762efdeb0 100644
--- a/src/test/run-pass/import7.rs
+++ b/src/test/run-pass/import7.rs
@@ -1,5 +1,5 @@
-import bar.baz;
-import foo.zed;
+import bar::baz;
+import foo::zed;
mod foo {
mod zed {
fn baz() {
@@ -8,7 +8,7 @@ mod foo {
}
}
mod bar {
- import zed.baz;
+ import zed::baz;
mod foo {
mod zed {
}
diff --git a/src/test/run-pass/import8.rs b/src/test/run-pass/import8.rs
index 5031e98475b3d..753d6da0acf28 100644
--- a/src/test/run-pass/import8.rs
+++ b/src/test/run-pass/import8.rs
@@ -1,5 +1,5 @@
-import foo.x;
-import z = foo.x;
+import foo::x;
+import z = foo::x;
mod foo {
fn x(int y) {
diff --git a/src/test/run-pass/inner-module.rs b/src/test/run-pass/inner-module.rs
index f5066b6e038cc..03f32bc4cd6c2 100644
--- a/src/test/run-pass/inner-module.rs
+++ b/src/test/run-pass/inner-module.rs
@@ -7,11 +7,11 @@ mod inner {
}
}
fn hello() {
- inner2.hello();
+ inner2::hello();
}
}
fn main() {
- inner.hello();
- inner.inner2.hello();
+ inner::hello();
+ inner::inner2::hello();
}
diff --git a/src/test/run-pass/lib-bitv.rs b/src/test/run-pass/lib-bitv.rs
index b047f47a5cb3d..506d5b2ad1d0a 100644
--- a/src/test/run-pass/lib-bitv.rs
+++ b/src/test/run-pass/lib-bitv.rs
@@ -1,132 +1,132 @@
use std;
-import std.Vec;
-import std.BitV;
+import std::_vec;
+import std::bitv;
fn test_0_elements() {
auto act;
auto exp;
- act = BitV.create(0u, false);
- exp = Vec.init_elt[uint](0u, 0u);
+ act = bitv::create(0u, false);
+ exp = _vec::init_elt[uint](0u, 0u);
// FIXME: why can't I write vec[uint]()?
- assert (BitV.eq_vec(act, exp));
+ assert (bitv::eq_vec(act, exp));
}
fn test_1_element() {
auto act;
- act = BitV.create(1u, false);
- assert (BitV.eq_vec(act, vec(0u)));
+ act = bitv::create(1u, false);
+ assert (bitv::eq_vec(act, vec(0u)));
- act = BitV.create(1u, true);
- assert (BitV.eq_vec(act, vec(1u)));
+ act = bitv::create(1u, true);
+ assert (bitv::eq_vec(act, vec(1u)));
}
fn test_10_elements() {
auto act;
// all 0
- act = BitV.create(10u, false);
- assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
+ act = bitv::create(10u, false);
+ assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
// all 1
- act = BitV.create(10u, true);
- assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u)));
+ act = bitv::create(10u, true);
+ assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u)));
// mixed
- act = BitV.create(10u, false);
- BitV.set(act, 0u, true);
- BitV.set(act, 1u, true);
- BitV.set(act, 2u, true);
- BitV.set(act, 3u, true);
- BitV.set(act, 4u, true);
- assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u)));
+ act = bitv::create(10u, false);
+ bitv::set(act, 0u, true);
+ bitv::set(act, 1u, true);
+ bitv::set(act, 2u, true);
+ bitv::set(act, 3u, true);
+ bitv::set(act, 4u, true);
+ assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u)));
// mixed
- act = BitV.create(10u, false);
- BitV.set(act, 5u, true);
- BitV.set(act, 6u, true);
- BitV.set(act, 7u, true);
- BitV.set(act, 8u, true);
- BitV.set(act, 9u, true);
- assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u)));
+ act = bitv::create(10u, false);
+ bitv::set(act, 5u, true);
+ bitv::set(act, 6u, true);
+ bitv::set(act, 7u, true);
+ bitv::set(act, 8u, true);
+ bitv::set(act, 9u, true);
+ assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u)));
// mixed
- act = BitV.create(10u, false);
- BitV.set(act, 0u, true);
- BitV.set(act, 3u, true);
- BitV.set(act, 6u, true);
- BitV.set(act, 9u, true);
- assert (BitV.eq_vec(act, vec(1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u)));
+ act = bitv::create(10u, false);
+ bitv::set(act, 0u, true);
+ bitv::set(act, 3u, true);
+ bitv::set(act, 6u, true);
+ bitv::set(act, 9u, true);
+ assert (bitv::eq_vec(act, vec(1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u)));
}
fn test_31_elements() {
auto act;
// all 0
- act = BitV.create(31u, false);
- assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ act = bitv::create(31u, false);
+ assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u)));
// all 1
- act = BitV.create(31u, true);
- assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+ act = bitv::create(31u, true);
+ assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u)));
// mixed
- act = BitV.create(31u, false);
- BitV.set(act, 0u, true);
- BitV.set(act, 1u, true);
- BitV.set(act, 2u, true);
- BitV.set(act, 3u, true);
- BitV.set(act, 4u, true);
- BitV.set(act, 5u, true);
- BitV.set(act, 6u, true);
- BitV.set(act, 7u, true);
- assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+ act = bitv::create(31u, false);
+ bitv::set(act, 0u, true);
+ bitv::set(act, 1u, true);
+ bitv::set(act, 2u, true);
+ bitv::set(act, 3u, true);
+ bitv::set(act, 4u, true);
+ bitv::set(act, 5u, true);
+ bitv::set(act, 6u, true);
+ bitv::set(act, 7u, true);
+ assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u)));
// mixed
- act = BitV.create(31u, false);
- BitV.set(act, 16u, true);
- BitV.set(act, 17u, true);
- BitV.set(act, 18u, true);
- BitV.set(act, 19u, true);
- BitV.set(act, 20u, true);
- BitV.set(act, 21u, true);
- BitV.set(act, 22u, true);
- BitV.set(act, 23u, true);
- assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ act = bitv::create(31u, false);
+ bitv::set(act, 16u, true);
+ bitv::set(act, 17u, true);
+ bitv::set(act, 18u, true);
+ bitv::set(act, 19u, true);
+ bitv::set(act, 20u, true);
+ bitv::set(act, 21u, true);
+ bitv::set(act, 22u, true);
+ bitv::set(act, 23u, true);
+ assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
0u, 0u, 0u, 0u, 0u, 0u, 0u)));
// mixed
- act = BitV.create(31u, false);
- BitV.set(act, 24u, true);
- BitV.set(act, 25u, true);
- BitV.set(act, 26u, true);
- BitV.set(act, 27u, true);
- BitV.set(act, 28u, true);
- BitV.set(act, 29u, true);
- BitV.set(act, 30u, true);
- assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ act = bitv::create(31u, false);
+ bitv::set(act, 24u, true);
+ bitv::set(act, 25u, true);
+ bitv::set(act, 26u, true);
+ bitv::set(act, 27u, true);
+ bitv::set(act, 28u, true);
+ bitv::set(act, 29u, true);
+ bitv::set(act, 30u, true);
+ assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
1u, 1u, 1u, 1u, 1u, 1u, 1u)));
// mixed
- act = BitV.create(31u, false);
- BitV.set(act, 3u, true);
- BitV.set(act, 17u, true);
- BitV.set(act, 30u, true);
- assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
+ act = bitv::create(31u, false);
+ bitv::set(act, 3u, true);
+ bitv::set(act, 17u, true);
+ bitv::set(act, 30u, true);
+ assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 1u)));
@@ -136,71 +136,71 @@ fn test_32_elements() {
auto act;
// all 0
- act = BitV.create(32u, false);
- assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ act = bitv::create(32u, false);
+ assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
// all 1
- act = BitV.create(32u, true);
- assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+ act = bitv::create(32u, true);
+ assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u)));
// mixed
- act = BitV.create(32u, false);
- BitV.set(act, 0u, true);
- BitV.set(act, 1u, true);
- BitV.set(act, 2u, true);
- BitV.set(act, 3u, true);
- BitV.set(act, 4u, true);
- BitV.set(act, 5u, true);
- BitV.set(act, 6u, true);
- BitV.set(act, 7u, true);
- assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+ act = bitv::create(32u, false);
+ bitv::set(act, 0u, true);
+ bitv::set(act, 1u, true);
+ bitv::set(act, 2u, true);
+ bitv::set(act, 3u, true);
+ bitv::set(act, 4u, true);
+ bitv::set(act, 5u, true);
+ bitv::set(act, 6u, true);
+ bitv::set(act, 7u, true);
+ assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
// mixed
- act = BitV.create(32u, false);
- BitV.set(act, 16u, true);
- BitV.set(act, 17u, true);
- BitV.set(act, 18u, true);
- BitV.set(act, 19u, true);
- BitV.set(act, 20u, true);
- BitV.set(act, 21u, true);
- BitV.set(act, 22u, true);
- BitV.set(act, 23u, true);
- assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ act = bitv::create(32u, false);
+ bitv::set(act, 16u, true);
+ bitv::set(act, 17u, true);
+ bitv::set(act, 18u, true);
+ bitv::set(act, 19u, true);
+ bitv::set(act, 20u, true);
+ bitv::set(act, 21u, true);
+ bitv::set(act, 22u, true);
+ bitv::set(act, 23u, true);
+ assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
// mixed
- act = BitV.create(32u, false);
- BitV.set(act, 24u, true);
- BitV.set(act, 25u, true);
- BitV.set(act, 26u, true);
- BitV.set(act, 27u, true);
- BitV.set(act, 28u, true);
- BitV.set(act, 29u, true);
- BitV.set(act, 30u, true);
- BitV.set(act, 31u, true);
- assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ act = bitv::create(32u, false);
+ bitv::set(act, 24u, true);
+ bitv::set(act, 25u, true);
+ bitv::set(act, 26u, true);
+ bitv::set(act, 27u, true);
+ bitv::set(act, 28u, true);
+ bitv::set(act, 29u, true);
+ bitv::set(act, 30u, true);
+ bitv::set(act, 31u, true);
+ assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u)));
// mixed
- act = BitV.create(32u, false);
- BitV.set(act, 3u, true);
- BitV.set(act, 17u, true);
- BitV.set(act, 30u, true);
- BitV.set(act, 31u, true);
- assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
+ act = bitv::create(32u, false);
+ bitv::set(act, 3u, true);
+ bitv::set(act, 17u, true);
+ bitv::set(act, 30u, true);
+ bitv::set(act, 31u, true);
+ assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u)));
@@ -210,77 +210,77 @@ fn test_33_elements() {
auto act;
// all 0
- act = BitV.create(33u, false);
- assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ act = bitv::create(33u, false);
+ assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u)));
// all 1
- act = BitV.create(33u, true);
- assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+ act = bitv::create(33u, true);
+ assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u)));
// mixed
- act = BitV.create(33u, false);
- BitV.set(act, 0u, true);
- BitV.set(act, 1u, true);
- BitV.set(act, 2u, true);
- BitV.set(act, 3u, true);
- BitV.set(act, 4u, true);
- BitV.set(act, 5u, true);
- BitV.set(act, 6u, true);
- BitV.set(act, 7u, true);
- assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+ act = bitv::create(33u, false);
+ bitv::set(act, 0u, true);
+ bitv::set(act, 1u, true);
+ bitv::set(act, 2u, true);
+ bitv::set(act, 3u, true);
+ bitv::set(act, 4u, true);
+ bitv::set(act, 5u, true);
+ bitv::set(act, 6u, true);
+ bitv::set(act, 7u, true);
+ assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u)));
// mixed
- act = BitV.create(33u, false);
- BitV.set(act, 16u, true);
- BitV.set(act, 17u, true);
- BitV.set(act, 18u, true);
- BitV.set(act, 19u, true);
- BitV.set(act, 20u, true);
- BitV.set(act, 21u, true);
- BitV.set(act, 22u, true);
- BitV.set(act, 23u, true);
- assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ act = bitv::create(33u, false);
+ bitv::set(act, 16u, true);
+ bitv::set(act, 17u, true);
+ bitv::set(act, 18u, true);
+ bitv::set(act, 19u, true);
+ bitv::set(act, 20u, true);
+ bitv::set(act, 21u, true);
+ bitv::set(act, 22u, true);
+ bitv::set(act, 23u, true);
+ assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u)));
// mixed
- act = BitV.create(33u, false);
- BitV.set(act, 24u, true);
- BitV.set(act, 25u, true);
- BitV.set(act, 26u, true);
- BitV.set(act, 27u, true);
- BitV.set(act, 28u, true);
- BitV.set(act, 29u, true);
- BitV.set(act, 30u, true);
- BitV.set(act, 31u, true);
- assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ act = bitv::create(33u, false);
+ bitv::set(act, 24u, true);
+ bitv::set(act, 25u, true);
+ bitv::set(act, 26u, true);
+ bitv::set(act, 27u, true);
+ bitv::set(act, 28u, true);
+ bitv::set(act, 29u, true);
+ bitv::set(act, 30u, true);
+ bitv::set(act, 31u, true);
+ assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
0u)));
// mixed
- act = BitV.create(33u, false);
- BitV.set(act, 3u, true);
- BitV.set(act, 17u, true);
- BitV.set(act, 30u, true);
- BitV.set(act, 31u, true);
- BitV.set(act, 32u, true);
- assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
+ act = bitv::create(33u, false);
+ bitv::set(act, 3u, true);
+ bitv::set(act, 17u, true);
+ bitv::set(act, 30u, true);
+ bitv::set(act, 31u, true);
+ bitv::set(act, 32u, true);
+ assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
diff --git a/src/test/run-pass/lib-box.rs b/src/test/run-pass/lib-box.rs
index 62807251bd160..e0e10f5a865e6 100644
--- a/src/test/run-pass/lib-box.rs
+++ b/src/test/run-pass/lib-box.rs
@@ -1,12 +1,12 @@
use std;
-import std.Box;
+import std::box;
fn main() {
auto x = @3;
auto y = @3;
- assert (Box.ptr_eq[int](x, x));
- assert (Box.ptr_eq[int](y, y));
- assert (!Box.ptr_eq[int](x, y));
- assert (!Box.ptr_eq[int](y, x));
+ assert (box::ptr_eq[int](x, x));
+ assert (box::ptr_eq[int](y, y));
+ assert (!box::ptr_eq[int](x, y));
+ assert (!box::ptr_eq[int](y, x));
}
diff --git a/src/test/run-pass/lib-deque.rs b/src/test/run-pass/lib-deque.rs
index 9de238dc8f752..186697fb92791 100644
--- a/src/test/run-pass/lib-deque.rs
+++ b/src/test/run-pass/lib-deque.rs
@@ -1,10 +1,10 @@
// -*- rust -*-
use std;
-import std.Deque;
+import std::deque;
fn test_simple() {
- let Deque.t[int] d = Deque.create[int]();
+ let deque::t[int] d = deque::create[int]();
assert (d.size() == 0u);
d.add_front(17);
d.add_front(42);
@@ -57,7 +57,7 @@ fn test_simple() {
}
fn test_boxes(@int a, @int b, @int c, @int d) {
- let Deque.t[@int] deq = Deque.create[@int]();
+ let deque::t[@int] deq = deque::create[@int]();
assert (deq.size() == 0u);
deq.add_front(a);
deq.add_front(b);
@@ -93,7 +93,7 @@ fn test_boxes(@int a, @int b, @int c, @int d) {
type eqfn[T] = fn(&T a, &T b) -> bool;
fn test_parameterized[T](eqfn[T] e, &T a, &T b, &T c, &T d) {
- let Deque.t[T] deq = Deque.create[T]();
+ let deque::t[T] deq = deque::create[T]();
assert (deq.size() == 0u);
deq.add_front(a);
deq.add_front(b);
diff --git a/src/test/run-pass/lib-int.rs b/src/test/run-pass/lib-int.rs
index a5a9a2a10ce03..20d70ccf756cc 100644
--- a/src/test/run-pass/lib-int.rs
+++ b/src/test/run-pass/lib-int.rs
@@ -1,25 +1,25 @@
use std;
-import std.Int;
-import std.Str.eq;
+import std::_int;
+import std::_str::eq;
fn test_to_str() {
- assert (eq(Int.to_str(0, 10u), "0"));
- assert (eq(Int.to_str(1, 10u), "1"));
- assert (eq(Int.to_str(-1, 10u), "-1"));
- assert (eq(Int.to_str(255, 16u), "ff"));
- assert (eq(Int.to_str(100, 10u), "100"));
+ assert (eq(_int::to_str(0, 10u), "0"));
+ assert (eq(_int::to_str(1, 10u), "1"));
+ assert (eq(_int::to_str(-1, 10u), "-1"));
+ assert (eq(_int::to_str(255, 16u), "ff"));
+ assert (eq(_int::to_str(100, 10u), "100"));
}
fn test_pow() {
- assert (Int.pow(0, 0u) == 1);
- assert (Int.pow(0, 1u) == 0);
- assert (Int.pow(0, 2u) == 0);
- assert (Int.pow(-1, 0u) == -1);
- assert (Int.pow(1, 0u) == 1);
- assert (Int.pow(-3, 2u) == 9);
- assert (Int.pow(-3, 3u) == -27);
- assert (Int.pow(4, 9u) == 262144);
+ assert (_int::pow(0, 0u) == 1);
+ assert (_int::pow(0, 1u) == 0);
+ assert (_int::pow(0, 2u) == 0);
+ assert (_int::pow(-1, 0u) == -1);
+ assert (_int::pow(1, 0u) == 1);
+ assert (_int::pow(-3, 2u) == 9);
+ assert (_int::pow(-3, 3u) == -27);
+ assert (_int::pow(4, 9u) == 262144);
}
fn main() {
diff --git a/src/test/run-pass/lib-io.rs b/src/test/run-pass/lib-io.rs
index e124cde3b22f9..53c1391214bb3 100644
--- a/src/test/run-pass/lib-io.rs
+++ b/src/test/run-pass/lib-io.rs
@@ -5,8 +5,8 @@
// -*- rust -*-
use std;
-import std.IO;
-import std.Str;
+import std::io;
+import std::_str;
fn test_simple(str tmpfilebase) {
let str tmpfile = tmpfilebase + ".tmp";
@@ -15,14 +15,14 @@ fn test_simple(str tmpfilebase) {
log frood;
{
- let IO.writer out = IO.file_writer(tmpfile, vec(IO.create));
+ let io::writer out = io::file_writer(tmpfile, vec(io::create));
out.write_str(frood);
}
- let IO.reader inp = IO.file_reader(tmpfile);
+ let io::reader inp = io::file_reader(tmpfile);
let str frood2 = inp.read_c_str();
log frood2;
- assert (Str.eq(frood, frood2));
+ assert (_str::eq(frood, frood2));
}
fn main(vec[str] argv) {
diff --git a/src/test/run-pass/lib-map.rs b/src/test/run-pass/lib-map.rs
index 1f9560558d965..402ef10814996 100644
--- a/src/test/run-pass/lib-map.rs
+++ b/src/test/run-pass/lib-map.rs
@@ -1,32 +1,32 @@
// -*- rust -*-
use std;
-import std.Map;
-import std.Str;
-import std.UInt;
-import std.Util;
+import std::map;
+import std::_str;
+import std::_uint;
+import std::util;
fn test_simple() {
log "*** starting test_simple";
fn eq_uint(&uint x, &uint y) -> bool { ret x == y; }
fn hash_uint(&uint u) -> uint {
- // FIXME: can't use std.Util.id since we'd be capturing a type param,
+ // FIXME: can't use std::util::id since we'd be capturing a type param,
// and presently we can't close items over type params.
ret u;
}
- let Map.hashfn[uint] hasher_uint = hash_uint;
- let Map.eqfn[uint] eqer_uint = eq_uint;
+ let map::hashfn[uint] hasher_uint = hash_uint;
+ let map::eqfn[uint] eqer_uint = eq_uint;
- let Map.hashfn[str] hasher_str = Str.hash;
- let Map.eqfn[str] eqer_str = Str.eq;
+ let map::hashfn[str] hasher_str = _str::hash;
+ let map::eqfn[str] eqer_str = _str::eq;
log "uint -> uint";
- let Map.hashmap[uint, uint] hm_uu = Map.mk_hashmap[uint, uint](hasher_uint,
- eqer_uint);
+ let map::hashmap[uint, uint] hm_uu =
+ map::mk_hashmap[uint, uint](hasher_uint, eqer_uint);
assert (hm_uu.insert(10u, 12u));
assert (hm_uu.insert(11u, 13u));
@@ -49,7 +49,7 @@ fn test_simple() {
log "str -> uint";
- let Map.hashmap[str, uint] hm_su = Map.mk_hashmap[str, uint](hasher_str,
+ let map::hashmap[str, uint] hm_su = map::mk_hashmap[str, uint](hasher_str,
eqer_str);
assert (hm_su.insert("ten", 12u));
assert (hm_su.insert(eleven, 13u));
@@ -70,42 +70,42 @@ fn test_simple() {
log "uint -> str";
- let Map.hashmap[uint, str] hm_us = Map.mk_hashmap[uint, str](hasher_uint,
+ let map::hashmap[uint, str] hm_us = map::mk_hashmap[uint, str](hasher_uint,
eqer_uint);
assert (hm_us.insert(10u, "twelve"));
assert (hm_us.insert(11u, "thirteen"));
assert (hm_us.insert(12u, "fourteen"));
- assert (Str.eq(hm_us.get(11u), "thirteen"));
- assert (Str.eq(hm_us.get(12u), "fourteen"));
- assert (Str.eq(hm_us.get(10u), "twelve"));
+ assert (_str::eq(hm_us.get(11u), "thirteen"));
+ assert (_str::eq(hm_us.get(12u), "fourteen"));
+ assert (_str::eq(hm_us.get(10u), "twelve"));
assert (!hm_us.insert(12u, "fourteen"));
- assert (Str.eq(hm_us.get(12u), "fourteen"));
+ assert (_str::eq(hm_us.get(12u), "fourteen"));
assert (!hm_us.insert(12u, "twelve"));
- assert (Str.eq(hm_us.get(12u), "twelve"));
+ assert (_str::eq(hm_us.get(12u), "twelve"));
log "str -> str";
- let Map.hashmap[str, str] hm_ss = Map.mk_hashmap[str, str](hasher_str,
+ let map::hashmap[str, str] hm_ss = map::mk_hashmap[str, str](hasher_str,
eqer_str);
assert (hm_ss.insert(ten, "twelve"));
assert (hm_ss.insert(eleven, "thirteen"));
assert (hm_ss.insert(twelve, "fourteen"));
- assert (Str.eq(hm_ss.get("eleven"), "thirteen"));
- assert (Str.eq(hm_ss.get("twelve"), "fourteen"));
- assert (Str.eq(hm_ss.get("ten"), "twelve"));
+ assert (_str::eq(hm_ss.get("eleven"), "thirteen"));
+ assert (_str::eq(hm_ss.get("twelve"), "fourteen"));
+ assert (_str::eq(hm_ss.get("ten"), "twelve"));
assert (!hm_ss.insert("twelve", "fourteen"));
- assert (Str.eq(hm_ss.get("twelve"), "fourteen"));
+ assert (_str::eq(hm_ss.get("twelve"), "fourteen"));
assert (!hm_ss.insert("twelve", "twelve"));
- assert (Str.eq(hm_ss.get("twelve"), "twelve"));
+ assert (_str::eq(hm_ss.get("twelve"), "twelve"));
log "*** finished test_simple";
}
@@ -120,7 +120,7 @@ fn test_growth() {
fn eq_uint(&uint x, &uint y) -> bool { ret x == y; }
fn hash_uint(&uint u) -> uint {
- // FIXME: can't use std.Util.id since we'd be capturing a type param,
+ // FIXME: can't use std::util::id since we'd be capturing a type param,
// and presently we can't close items over type params.
ret u;
}
@@ -128,16 +128,16 @@ fn test_growth() {
log "uint -> uint";
- let Map.hashfn[uint] hasher_uint = hash_uint;
- let Map.eqfn[uint] eqer_uint = eq_uint;
- let Map.hashmap[uint, uint] hm_uu = Map.mk_hashmap[uint, uint](hasher_uint,
- eqer_uint);
+ let map::hashfn[uint] hasher_uint = hash_uint;
+ let map::eqfn[uint] eqer_uint = eq_uint;
+ let map::hashmap[uint, uint] hm_uu =
+ map::mk_hashmap[uint, uint](hasher_uint, eqer_uint);
let uint i = 0u;
while (i < num_to_insert) {
assert (hm_uu.insert(i, i * i));
- log "inserting " + UInt.to_str(i, 10u)
- + " -> " + UInt.to_str(i * i, 10u);
+ log "inserting " + _uint::to_str(i, 10u)
+ + " -> " + _uint::to_str(i * i, 10u);
i += 1u;
}
@@ -145,8 +145,8 @@ fn test_growth() {
i = 0u;
while (i < num_to_insert) {
- log "get(" + UInt.to_str(i, 10u) + ") = "
- + UInt.to_str(hm_uu.get(i), 10u);
+ log "get(" + _uint::to_str(i, 10u) + ") = "
+ + _uint::to_str(hm_uu.get(i), 10u);
assert (hm_uu.get(i) == i * i);
i += 1u;
}
@@ -160,8 +160,8 @@ fn test_growth() {
i = 0u;
while (i < num_to_insert) {
- log "get(" + UInt.to_str(i, 10u) + ") = "
- + UInt.to_str(hm_uu.get(i), 10u);
+ log "get(" + _uint::to_str(i, 10u) + ") = "
+ + _uint::to_str(hm_uu.get(i), 10u);
assert (hm_uu.get(i) == i * i);
i += 1u;
}
@@ -169,16 +169,16 @@ fn test_growth() {
log "str -> str";
- let Map.hashfn[str] hasher_str = Str.hash;
- let Map.eqfn[str] eqer_str = Str.eq;
- let Map.hashmap[str, str] hm_ss = Map.mk_hashmap[str, str](hasher_str,
+ let map::hashfn[str] hasher_str = _str::hash;
+ let map::eqfn[str] eqer_str = _str::eq;
+ let map::hashmap[str, str] hm_ss = map::mk_hashmap[str, str](hasher_str,
eqer_str);
i = 0u;
while (i < num_to_insert) {
- assert (hm_ss.insert(UInt.to_str(i, 2u), UInt.to_str(i * i, 2u)));
- log "inserting \"" + UInt.to_str(i, 2u)
- + "\" -> \"" + UInt.to_str(i * i, 2u) + "\"";
+ assert (hm_ss.insert(_uint::to_str(i, 2u), _uint::to_str(i * i, 2u)));
+ log "inserting \"" + _uint::to_str(i, 2u)
+ + "\" -> \"" + _uint::to_str(i * i, 2u) + "\"";
i += 1u;
}
@@ -187,20 +187,20 @@ fn test_growth() {
i = 0u;
while (i < num_to_insert) {
log "get(\""
- + UInt.to_str(i, 2u)
+ + _uint::to_str(i, 2u)
+ "\") = \""
- + hm_ss.get(UInt.to_str(i, 2u)) + "\"";
+ + hm_ss.get(_uint::to_str(i, 2u)) + "\"";
- assert (Str.eq(hm_ss.get(UInt.to_str(i, 2u)),
- UInt.to_str(i * i, 2u)));
+ assert (_str::eq(hm_ss.get(_uint::to_str(i, 2u)),
+ _uint::to_str(i * i, 2u)));
i += 1u;
}
- assert (hm_ss.insert(UInt.to_str(num_to_insert, 2u),
- UInt.to_str(17u, 2u)));
+ assert (hm_ss.insert(_uint::to_str(num_to_insert, 2u),
+ _uint::to_str(17u, 2u)));
- assert (Str.eq(hm_ss.get(UInt.to_str(num_to_insert, 2u)),
- UInt.to_str(17u, 2u)));
+ assert (_str::eq(hm_ss.get(_uint::to_str(num_to_insert, 2u)),
+ _uint::to_str(17u, 2u)));
log "-----";
@@ -208,10 +208,10 @@ fn test_growth() {
i = 0u;
while (i < num_to_insert) {
- log "get(\"" + UInt.to_str(i, 2u) + "\") = \""
- + hm_ss.get(UInt.to_str(i, 2u)) + "\"";
- assert (Str.eq(hm_ss.get(UInt.to_str(i, 2u)),
- UInt.to_str(i * i, 2u)));
+ log "get(\"" + _uint::to_str(i, 2u) + "\") = \""
+ + hm_ss.get(_uint::to_str(i, 2u)) + "\"";
+ assert (_str::eq(hm_ss.get(_uint::to_str(i, 2u)),
+ _uint::to_str(i * i, 2u)));
i += 1u;
}
@@ -234,15 +234,15 @@ fn test_removal() {
assert (hash(2u) == hash(3u));
assert (hash(0u) != hash(2u));
- let Map.hashfn[uint] hasher = hash;
- let Map.eqfn[uint] eqer = eq;
- let Map.hashmap[uint, uint] hm = Map.mk_hashmap[uint, uint](hasher, eqer);
+ let map::hashfn[uint] hasher = hash;
+ let map::eqfn[uint] eqer = eq;
+ let map::hashmap[uint, uint] hm = map::mk_hashmap[uint, uint](hasher, eqer);
let uint i = 0u;
while (i < num_to_insert) {
assert (hm.insert(i, i * i));
- log "inserting " + UInt.to_str(i, 10u)
- + " -> " + UInt.to_str(i * i, 10u);
+ log "inserting " + _uint::to_str(i, 10u)
+ + " -> " + _uint::to_str(i * i, 10u);
i += 1u;
}
@@ -279,8 +279,8 @@ fn test_removal() {
i = 1u;
while (i < num_to_insert) {
- log "get(" + UInt.to_str(i, 10u) + ") = "
- + UInt.to_str(hm.get(i), 10u);
+ log "get(" + _uint::to_str(i, 10u) + ") = "
+ + _uint::to_str(hm.get(i), 10u);
assert (hm.get(i) == i * i);
i += 2u;
}
@@ -294,8 +294,8 @@ fn test_removal() {
i = 1u;
while (i < num_to_insert) {
- log "get(" + UInt.to_str(i, 10u) + ") = "
- + UInt.to_str(hm.get(i), 10u);
+ log "get(" + _uint::to_str(i, 10u) + ") = "
+ + _uint::to_str(hm.get(i), 10u);
assert (hm.get(i) == i * i);
i += 2u;
}
@@ -305,8 +305,8 @@ fn test_removal() {
i = 0u;
while (i < num_to_insert) {
assert (hm.insert(i, i * i));
- log "inserting " + UInt.to_str(i, 10u)
- + " -> " + UInt.to_str(i * i, 10u);
+ log "inserting " + _uint::to_str(i, 10u)
+ + " -> " + _uint::to_str(i * i, 10u);
i += 2u;
}
@@ -316,8 +316,8 @@ fn test_removal() {
i = 0u;
while (i < num_to_insert) {
- log "get(" + UInt.to_str(i, 10u) + ") = "
- + UInt.to_str(hm.get(i), 10u);
+ log "get(" + _uint::to_str(i, 10u) + ") = "
+ + _uint::to_str(hm.get(i), 10u);
assert (hm.get(i) == i * i);
i += 1u;
}
@@ -333,8 +333,8 @@ fn test_removal() {
i = 0u;
while (i < num_to_insert) {
- log "get(" + UInt.to_str(i, 10u) + ") = "
- + UInt.to_str(hm.get(i), 10u);
+ log "get(" + _uint::to_str(i, 10u) + ") = "
+ + _uint::to_str(hm.get(i), 10u);
assert (hm.get(i) == i * i);
i += 1u;
}
diff --git a/src/test/run-pass/lib-option.rs b/src/test/run-pass/lib-option.rs
index 417ab482764fc..cf004f1dbe538 100644
--- a/src/test/run-pass/lib-option.rs
+++ b/src/test/run-pass/lib-option.rs
@@ -1,5 +1,5 @@
use std;
fn main() {
- auto x = std.Option.some[int](10);
+ auto x = std::option::some[int](10);
}
diff --git a/src/test/run-pass/lib-qsort.rs b/src/test/run-pass/lib-qsort.rs
index aed5009dd24ad..2f086667686c6 100644
--- a/src/test/run-pass/lib-qsort.rs
+++ b/src/test/run-pass/lib-qsort.rs
@@ -1,13 +1,13 @@
use std;
fn check_sort(vec[mutable int] v1, vec[mutable int] v2) {
- auto len = std.Vec.len[int](v1);
+ auto len = std::_vec::len[int](v1);
fn ltequal(&int a, &int b) -> bool {
ret a <= b;
}
auto f = ltequal;
- std.Sort.quick_sort[int](f, v1);
+ std::sort::quick_sort[int](f, v1);
auto i = 0u;
while (i < len) {
log v2.(i);
diff --git a/src/test/run-pass/lib-rand.rs b/src/test/run-pass/lib-rand.rs
index e423bcba53f48..388811bcb7c8d 100644
--- a/src/test/run-pass/lib-rand.rs
+++ b/src/test/run-pass/lib-rand.rs
@@ -4,14 +4,14 @@
// -*- rust -*-
use std;
-import std.Rand;
+import std::rand;
fn main() {
- let Rand.rng r1 = Rand.mk_rng();
+ let rand::rng r1 = rand::mk_rng();
log r1.next();
log r1.next();
{
- auto r2 = Rand.mk_rng();
+ auto r2 = rand::mk_rng();
log r1.next();
log r2.next();
log r1.next();
diff --git a/src/test/run-pass/lib-sha1.rs b/src/test/run-pass/lib-sha1.rs
index c89eca59c7101..18ea4f38fb7f7 100644
--- a/src/test/run-pass/lib-sha1.rs
+++ b/src/test/run-pass/lib-sha1.rs
@@ -5,9 +5,9 @@
use std;
-import std.SHA1;
-import std.Vec;
-import std.Str;
+import std::sha1;
+import std::_vec;
+import std::_str;
fn main() {
@@ -67,8 +67,8 @@ fn main() {
auto tests = fips_180_1_tests + wikipedia_tests;
fn check_vec_eq(vec[u8] v0, vec[u8] v1) {
- assert (Vec.len[u8](v0) == Vec.len[u8](v1));
- auto len = Vec.len[u8](v0);
+ assert (_vec::len[u8](v0) == _vec::len[u8](v1));
+ auto len = _vec::len[u8](v0);
auto i = 0u;
while (i < len) {
auto a = v0.(i);
@@ -79,7 +79,7 @@ fn main() {
}
// Test that it works when accepting the message all at once
- auto sh = SHA1.mk_sha1();
+ auto sh = sha1::mk_sha1();
for (test t in tests) {
sh.input_str(t.input);
auto out = sh.result();
@@ -89,11 +89,11 @@ fn main() {
// Test that it works when accepting the message in pieces
for (test t in tests) {
- auto len = Str.byte_len(t.input);
+ auto len = _str::byte_len(t.input);
auto left = len;
while (left > 0u) {
auto take = (left + 1u) / 2u;
- sh.input_str(Str.substr(t.input, len - left, take));
+ sh.input_str(_str::substr(t.input, len - left, take));
left = left - take;
}
auto out = sh.result();
diff --git a/src/test/run-pass/lib-sort.rs b/src/test/run-pass/lib-sort.rs
index 145d0175ddb95..6ec266fa2108d 100644
--- a/src/test/run-pass/lib-sort.rs
+++ b/src/test/run-pass/lib-sort.rs
@@ -1,12 +1,12 @@
use std;
fn check_sort(vec[int] v1, vec[int] v2) {
- auto len = std.Vec.len[int](v1);
+ auto len = std::_vec::len[int](v1);
fn lteq(&int a, &int b) -> bool {
ret a <= b;
}
auto f = lteq;
- auto v3 = std.Sort.merge_sort[int](f, v1);
+ auto v3 = std::sort::merge_sort[int](f, v1);
auto i = 0u;
while (i < len) {
log v3.(i);
diff --git a/src/test/run-pass/lib-str-buf.rs b/src/test/run-pass/lib-str-buf.rs
index cd8ba9e9fd012..af1148a5f8a23 100644
--- a/src/test/run-pass/lib-str-buf.rs
+++ b/src/test/run-pass/lib-str-buf.rs
@@ -4,14 +4,14 @@
// -*- rust -*-
use std;
-import std.Str;
+import std::_str;
fn main() {
auto s = "hello";
- auto sb = Str.rustrt.str_buf(s);
- auto s_cstr = Str.rustrt.str_from_cstr(sb);
- assert (Str.eq(s_cstr, s));
- auto s_buf = Str.rustrt.str_from_buf(sb, 5u);
- assert (Str.eq(s_buf, s));
+ auto sb = str.rustrt.str_buf(s);
+ auto s_cstr = str.rustrt.str_from_cstr(sb);
+ assert (str.eq(s_cstr, s));
+ auto s_buf = str.rustrt.str_from_buf(sb, 5u);
+ assert (str.eq(s_buf, s));
}
diff --git a/src/test/run-pass/lib-str.rs b/src/test/run-pass/lib-str.rs
index 8985c22e51fd1..eff9eef125891 100644
--- a/src/test/run-pass/lib-str.rs
+++ b/src/test/run-pass/lib-str.rs
@@ -2,38 +2,38 @@
// xfail-stage0
use std;
-import std.Str;
+import std::_str;
fn test_bytes_len() {
- assert (Str.byte_len("") == 0u);
- assert (Str.byte_len("hello world") == 11u);
- assert (Str.byte_len("\x63") == 1u);
- assert (Str.byte_len("\xa2") == 2u);
- assert (Str.byte_len("\u03c0") == 2u);
- assert (Str.byte_len("\u2620") == 3u);
- assert (Str.byte_len("\U0001d11e") == 4u);
+ assert (_str::byte_len("") == 0u);
+ assert (_str::byte_len("hello world") == 11u);
+ assert (_str::byte_len("\x63") == 1u);
+ assert (_str::byte_len("\xa2") == 2u);
+ assert (_str::byte_len("\u03c0") == 2u);
+ assert (_str::byte_len("\u2620") == 3u);
+ assert (_str::byte_len("\U0001d11e") == 4u);
}
fn test_index_and_rindex() {
- assert (Str.index("hello", 'e' as u8) == 1);
- assert (Str.index("hello", 'o' as u8) == 4);
- assert (Str.index("hello", 'z' as u8) == -1);
- assert (Str.rindex("hello", 'l' as u8) == 3);
- assert (Str.rindex("hello", 'h' as u8) == 0);
- assert (Str.rindex("hello", 'z' as u8) == -1);
+ assert (_str::index("hello", 'e' as u8) == 1);
+ assert (_str::index("hello", 'o' as u8) == 4);
+ assert (_str::index("hello", 'z' as u8) == -1);
+ assert (_str::rindex("hello", 'l' as u8) == 3);
+ assert (_str::rindex("hello", 'h' as u8) == 0);
+ assert (_str::rindex("hello", 'z' as u8) == -1);
}
fn test_split() {
fn t(&str s, char c, int i, &str k) {
log "splitting: " + s;
log i;
- auto v = Str.split(s, c as u8);
+ auto v = _str::split(s, c as u8);
log "split to: ";
for (str z in v) {
log z;
}
log "comparing: " + v.(i) + " vs. " + k;
- assert (Str.eq(v.(i), k));
+ assert (_str::eq(v.(i), k));
}
t("abc.hello.there", '.', 0, "abc");
t("abc.hello.there", '.', 1, "hello");
@@ -46,7 +46,7 @@ fn test_split() {
fn test_find() {
fn t(&str haystack, &str needle, int i) {
- let int j = Str.find(haystack,needle);
+ let int j = _str::find(haystack,needle);
log "searched for " + needle;
log j;
assert (i == j);
@@ -60,8 +60,8 @@ fn test_find() {
fn test_substr() {
fn t(&str a, &str b, int start) {
- assert (Str.eq(Str.substr(a, start as uint,
- Str.byte_len(b)), b));
+ assert (_str::eq(_str::substr(a, start as uint,
+ _str::byte_len(b)), b));
}
t("hello", "llo", 2);
@@ -71,7 +71,7 @@ fn test_substr() {
fn test_concat() {
fn t(&vec[str] v, &str s) {
- assert (Str.eq(Str.concat(v), s));
+ assert (_str::eq(_str::concat(v), s));
}
t(vec("you", "know", "I'm", "no", "good"), "youknowI'mnogood");
@@ -82,7 +82,7 @@ fn test_concat() {
fn test_connect() {
fn t(&vec[str] v, &str sep, &str s) {
- assert (Str.eq(Str.connect(v, sep), s));
+ assert (_str::eq(_str::connect(v, sep), s));
}
t(vec("you", "know", "I'm", "no", "good"), " ", "you know I'm no good");
@@ -97,14 +97,14 @@ fn test_to_upper() {
auto unicode = "\u65e5\u672c";
auto input = "abcDEF" + unicode + "xyz:.;";
auto expected = "ABCDEF" + unicode + "XYZ:.;";
- auto actual = Str.to_upper(input);
- assert (Str.eq(expected, actual));
+ auto actual = _str::to_upper(input);
+ assert (_str::eq(expected, actual));
}
fn test_slice() {
- assert (Str.eq("ab", Str.slice("abc", 0u, 2u)));
- assert (Str.eq("bc", Str.slice("abc", 1u, 3u)));
- assert (Str.eq("", Str.slice("abc", 1u, 1u)));
+ assert (_str::eq("ab", _str::slice("abc", 0u, 2u)));
+ assert (_str::eq("bc", _str::slice("abc", 1u, 3u)));
+ assert (_str::eq("", _str::slice("abc", 1u, 1u)));
fn a_million_letter_a() -> str {
auto i = 0;
@@ -126,8 +126,8 @@ fn test_slice() {
ret res;
}
- assert (Str.eq(half_a_million_letter_a(),
- Str.slice(a_million_letter_a(),
+ assert (_str::eq(half_a_million_letter_a(),
+ _str::slice(a_million_letter_a(),
0u,
500000u)));
}
diff --git a/src/test/run-pass/lib-task.rs b/src/test/run-pass/lib-task.rs
index 8e07962ce9e48..f1cca720ed7c3 100644
--- a/src/test/run-pass/lib-task.rs
+++ b/src/test/run-pass/lib-task.rs
@@ -1,6 +1,6 @@
use std;
-import std.Task;
+import std::_task;
fn main() {
- Task.sleep(1000000u);
+ _task::sleep(1000000u);
}
\ No newline at end of file
diff --git a/src/test/run-pass/lib-uint.rs b/src/test/run-pass/lib-uint.rs
index 4f7877450811d..3de24ba3d4963 100644
--- a/src/test/run-pass/lib-uint.rs
+++ b/src/test/run-pass/lib-uint.rs
@@ -1,47 +1,47 @@
// -*- rust -*-
use std;
-import std.UInt;
+import std::_uint;
fn main() {
- assert (UInt.next_power_of_two(0u) == 0u);
- assert (UInt.next_power_of_two(1u) == 1u);
- assert (UInt.next_power_of_two(2u) == 2u);
- assert (UInt.next_power_of_two(3u) == 4u);
- assert (UInt.next_power_of_two(4u) == 4u);
- assert (UInt.next_power_of_two(5u) == 8u);
- assert (UInt.next_power_of_two(6u) == 8u);
- assert (UInt.next_power_of_two(7u) == 8u);
- assert (UInt.next_power_of_two(8u) == 8u);
- assert (UInt.next_power_of_two(9u) == 16u);
- assert (UInt.next_power_of_two(10u) == 16u);
- assert (UInt.next_power_of_two(11u) == 16u);
- assert (UInt.next_power_of_two(12u) == 16u);
- assert (UInt.next_power_of_two(13u) == 16u);
- assert (UInt.next_power_of_two(14u) == 16u);
- assert (UInt.next_power_of_two(15u) == 16u);
- assert (UInt.next_power_of_two(16u) == 16u);
- assert (UInt.next_power_of_two(17u) == 32u);
- assert (UInt.next_power_of_two(18u) == 32u);
- assert (UInt.next_power_of_two(19u) == 32u);
- assert (UInt.next_power_of_two(20u) == 32u);
- assert (UInt.next_power_of_two(21u) == 32u);
- assert (UInt.next_power_of_two(22u) == 32u);
- assert (UInt.next_power_of_two(23u) == 32u);
- assert (UInt.next_power_of_two(24u) == 32u);
- assert (UInt.next_power_of_two(25u) == 32u);
- assert (UInt.next_power_of_two(26u) == 32u);
- assert (UInt.next_power_of_two(27u) == 32u);
- assert (UInt.next_power_of_two(28u) == 32u);
- assert (UInt.next_power_of_two(29u) == 32u);
- assert (UInt.next_power_of_two(30u) == 32u);
- assert (UInt.next_power_of_two(31u) == 32u);
- assert (UInt.next_power_of_two(32u) == 32u);
- assert (UInt.next_power_of_two(33u) == 64u);
- assert (UInt.next_power_of_two(34u) == 64u);
- assert (UInt.next_power_of_two(35u) == 64u);
- assert (UInt.next_power_of_two(36u) == 64u);
- assert (UInt.next_power_of_two(37u) == 64u);
- assert (UInt.next_power_of_two(38u) == 64u);
- assert (UInt.next_power_of_two(39u) == 64u);
+ assert (_uint::next_power_of_two(0u) == 0u);
+ assert (_uint::next_power_of_two(1u) == 1u);
+ assert (_uint::next_power_of_two(2u) == 2u);
+ assert (_uint::next_power_of_two(3u) == 4u);
+ assert (_uint::next_power_of_two(4u) == 4u);
+ assert (_uint::next_power_of_two(5u) == 8u);
+ assert (_uint::next_power_of_two(6u) == 8u);
+ assert (_uint::next_power_of_two(7u) == 8u);
+ assert (_uint::next_power_of_two(8u) == 8u);
+ assert (_uint::next_power_of_two(9u) == 16u);
+ assert (_uint::next_power_of_two(10u) == 16u);
+ assert (_uint::next_power_of_two(11u) == 16u);
+ assert (_uint::next_power_of_two(12u) == 16u);
+ assert (_uint::next_power_of_two(13u) == 16u);
+ assert (_uint::next_power_of_two(14u) == 16u);
+ assert (_uint::next_power_of_two(15u) == 16u);
+ assert (_uint::next_power_of_two(16u) == 16u);
+ assert (_uint::next_power_of_two(17u) == 32u);
+ assert (_uint::next_power_of_two(18u) == 32u);
+ assert (_uint::next_power_of_two(19u) == 32u);
+ assert (_uint::next_power_of_two(20u) == 32u);
+ assert (_uint::next_power_of_two(21u) == 32u);
+ assert (_uint::next_power_of_two(22u) == 32u);
+ assert (_uint::next_power_of_two(23u) == 32u);
+ assert (_uint::next_power_of_two(24u) == 32u);
+ assert (_uint::next_power_of_two(25u) == 32u);
+ assert (_uint::next_power_of_two(26u) == 32u);
+ assert (_uint::next_power_of_two(27u) == 32u);
+ assert (_uint::next_power_of_two(28u) == 32u);
+ assert (_uint::next_power_of_two(29u) == 32u);
+ assert (_uint::next_power_of_two(30u) == 32u);
+ assert (_uint::next_power_of_two(31u) == 32u);
+ assert (_uint::next_power_of_two(32u) == 32u);
+ assert (_uint::next_power_of_two(33u) == 64u);
+ assert (_uint::next_power_of_two(34u) == 64u);
+ assert (_uint::next_power_of_two(35u) == 64u);
+ assert (_uint::next_power_of_two(36u) == 64u);
+ assert (_uint::next_power_of_two(37u) == 64u);
+ assert (_uint::next_power_of_two(38u) == 64u);
+ assert (_uint::next_power_of_two(39u) == 64u);
}
diff --git a/src/test/run-pass/lib-vec-str-conversions.rs b/src/test/run-pass/lib-vec-str-conversions.rs
index cd8b64a889e24..c85374bf3cd79 100644
--- a/src/test/run-pass/lib-vec-str-conversions.rs
+++ b/src/test/run-pass/lib-vec-str-conversions.rs
@@ -1,8 +1,8 @@
// -*- rust -*-
use std;
-import std.Str;
-import std.Vec;
+import std::_str;
+import std::_vec;
fn test_simple() {
let str s1 = "All mimsy were the borogoves";
@@ -14,12 +14,12 @@ fn test_simple() {
* working, but we should implement is_utf8 before that happens.
*/
- let vec[u8] v = Str.bytes(s1);
- let str s2 = Str.from_bytes(v);
+ let vec[u8] v = _str::bytes(s1);
+ let str s2 = _str::from_bytes(v);
let uint i = 0u;
- let uint n1 = Str.byte_len(s1);
- let uint n2 = Vec.len[u8](v);
+ let uint n1 = _str::byte_len(s1);
+ let uint n2 = _vec::len[u8](v);
assert (n1 == n2);
@@ -33,7 +33,7 @@ fn test_simple() {
}
log "refcnt is";
- log Str.refcount(s1);
+ log _str::refcount(s1);
}
fn main() {
diff --git a/src/test/run-pass/lib-vec.rs b/src/test/run-pass/lib-vec.rs
index 0905652a5d009..f7e6157a14d5d 100644
--- a/src/test/run-pass/lib-vec.rs
+++ b/src/test/run-pass/lib-vec.rs
@@ -1,8 +1,8 @@
use std;
fn test_init_elt() {
- let vec[uint] v = std.Vec.init_elt[uint](5u, 3u);
- assert (std.Vec.len[uint](v) == 3u);
+ let vec[uint] v = std::_vec::init_elt[uint](5u, 3u);
+ assert (std::_vec::len[uint](v) == 3u);
assert (v.(0) == 5u);
assert (v.(1) == 5u);
assert (v.(2) == 5u);
@@ -13,8 +13,8 @@ fn id(uint x) -> uint {
}
fn test_init_fn() {
let fn(uint)->uint op = id;
- let vec[uint] v = std.Vec.init_fn[uint](op, 5u);
- assert (std.Vec.len[uint](v) == 5u);
+ let vec[uint] v = std::_vec::init_fn[uint](op, 5u);
+ assert (std::_vec::len[uint](v) == 5u);
assert (v.(0) == 0u);
assert (v.(1) == 1u);
assert (v.(2) == 2u);
@@ -24,17 +24,17 @@ fn test_init_fn() {
fn test_slice() {
let vec[int] v = vec(1,2,3,4,5);
- auto v2 = std.Vec.slice[int](v, 2u, 4u);
- assert (std.Vec.len[int](v2) == 2u);
+ auto v2 = std::_vec::slice[int](v, 2u, 4u);
+ assert (std::_vec::len[int](v2) == 2u);
assert (v2.(0) == 3);
assert (v2.(1) == 4);
}
fn test_map() {
fn square(&int x) -> int { ret x * x; }
- let std.Option.operator[int, int] op = square;
+ let std::option::operator[int, int] op = square;
let vec[int] v = vec(1, 2, 3, 4, 5);
- let vec[int] s = std.Vec.map[int, int](op, v);
+ let vec[int] s = std::_vec::map[int, int](op, v);
let int i = 0;
while (i < 5) {
assert (v.(i) * v.(i) == s.(i));
@@ -47,7 +47,7 @@ fn test_map2() {
auto f = times;
auto v0 = vec(1, 2, 3, 4, 5);
auto v1 = vec(5, 4, 3, 2, 1);
- auto u = std.Vec.map2[int,int,int](f, v0, v1);
+ auto u = std::_vec::map2[int,int,int](f, v0, v1);
auto i = 0;
while (i < 5) {
diff --git a/src/test/run-pass/mlist-cycle.rs b/src/test/run-pass/mlist-cycle.rs
index b5eff76f4dc28..7a884e41f438c 100644
--- a/src/test/run-pass/mlist-cycle.rs
+++ b/src/test/run-pass/mlist-cycle.rs
@@ -16,6 +16,6 @@ fn main() {
let @cell first = @tup(mutable @nil());
let @cell second = @tup(mutable @link(first));
first._0 = @link(second);
- std.Sys.rustrt.gc();
+ std::sys.rustrt.gc();
let @cell third = @tup(mutable @nil());
}
diff --git a/src/test/run-pass/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs
index 5919abdc5d4b2..c63220dfbfa97 100644
--- a/src/test/run-pass/mutable-alias-vec.rs
+++ b/src/test/run-pass/mutable-alias-vec.rs
@@ -11,7 +11,7 @@ fn main() {
grow(v);
grow(v);
grow(v);
- auto len = std.Vec.len[int](v);
+ auto len = std::_vec::len[int](v);
log len;
assert (len == (3 as uint));
}
diff --git a/src/test/run-pass/native2.rs b/src/test/run-pass/native2.rs
index 4815345add651..df2540aef041d 100644
--- a/src/test/run-pass/native2.rs
+++ b/src/test/run-pass/native2.rs
@@ -10,7 +10,7 @@ native mod zed {
}
native mod libc = "libc.dylib" {
- fn write(int fd, rustrt.vbuf buf, uint count) -> int;
+ fn write(int fd, rustrt::vbuf buf, uint count) -> int;
}
native "cdecl" mod baz {
diff --git a/src/test/run-pass/nested-pattern.rs b/src/test/run-pass/nested-pattern.rs
index cb244cc8b100f..c44c96e59e095 100644
--- a/src/test/run-pass/nested-pattern.rs
+++ b/src/test/run-pass/nested-pattern.rs
@@ -1,13 +1,13 @@
// a bug was causing this to complain about leaked memory on exit
use std;
-import std.Option;
-import std.Option.some;
-import std.Option.none;
+import std::option;
+import std::option::some;
+import std::option::none;
tag t {
foo(int, uint);
- bar(int, Option.t[int]);
+ bar(int, option::t[int]);
}
fn nested(t o) {
diff --git a/src/test/run-pass/path.rs b/src/test/run-pass/path.rs
index e94d32ebfa839..6b06e727ba04d 100644
--- a/src/test/run-pass/path.rs
+++ b/src/test/run-pass/path.rs
@@ -4,5 +4,5 @@ mod foo {
}
fn main(vec[str] args) {
- foo.bar(0u);
+ foo::bar(0u);
}
diff --git a/src/test/run-pass/rt-circular-buffer.rs b/src/test/run-pass/rt-circular-buffer.rs
index b6c545b2782bd..b742af7cd124d 100644
--- a/src/test/run-pass/rt-circular-buffer.rs
+++ b/src/test/run-pass/rt-circular-buffer.rs
@@ -5,9 +5,9 @@
use std;
-import std.Option;
-import std.UInt;
-import std.Vec;
+import std::option;
+import std::_uint;
+import std::_vec;
// A 12-byte unit to send over the channel
type record = rec(u32 val1, u32 val2, u32 val3);
@@ -33,7 +33,7 @@ fn test_grow() {
let record val = rec(val1=0u32, val2=0u32, val3=0u32);
- for each (uint i in UInt.range(0u, 100u)) {
+ for each (uint i in _uint::range(0u, 100u)) {
mychan <| val;
}
}
@@ -53,11 +53,11 @@ fn test_shrink2() {
let record val = rec(val1=0u32, val2=0u32, val3=0u32);
- for each (uint i in UInt.range(0u, 100u)) {
+ for each (uint i in _uint::range(0u, 100u)) {
mychan <| val;
}
- for each (uint i in UInt.range(0u, 100u)) {
+ for each (uint i in _uint::range(0u, 100u)) {
auto x <- myport;
}
}
@@ -67,7 +67,7 @@ fn test_rotate() {
let port[record] myport = port();
auto mychan = chan(myport);
- for each (uint i in UInt.range(0u, 100u)) {
+ for each (uint i in _uint::range(0u, 100u)) {
auto val = rec(val1=i as u32,
val2=i as u32,
val3=i as u32);
@@ -86,15 +86,15 @@ fn test_rotate_grow() {
let port[record] myport = port();
auto mychan = chan(myport);
- for each (uint j in UInt.range(0u, 10u)) {
- for each (uint i in UInt.range(0u, 10u)) {
+ for each (uint j in _uint::range(0u, 10u)) {
+ for each (uint i in _uint::range(0u, 10u)) {
let record val = rec(val1=i as u32,
val2=i as u32,
val3=i as u32);
mychan <| val;
}
- for each (uint i in UInt.range(0u, 10u)) {
+ for each (uint i in _uint::range(0u, 10u)) {
auto x <- myport;
assert (x.val1 == i as u32);
assert (x.val2 == i as u32);
diff --git a/src/test/run-pass/spawn-module-qualified.rs b/src/test/run-pass/spawn-module-qualified.rs
index 9f95ec952de9a..b4bd6017c93b6 100644
--- a/src/test/run-pass/spawn-module-qualified.rs
+++ b/src/test/run-pass/spawn-module-qualified.rs
@@ -2,7 +2,7 @@
// xfail-stage1
// xfail-stage2
fn main() {
- auto x = spawn m.child(10);
+ auto x = spawn m::child(10);
join x;
}
mod m {
diff --git a/src/test/run-pass/str-append.rs b/src/test/run-pass/str-append.rs
index afca72a8d1dad..ed2e3a7a90dbc 100644
--- a/src/test/run-pass/str-append.rs
+++ b/src/test/run-pass/str-append.rs
@@ -1,7 +1,7 @@
// -*- rust -*-
use std;
-import std.Str;
+import std::_str;
fn test1() {
let str s = "hello";
@@ -20,8 +20,8 @@ fn test2() {
log a;
log b;
- assert (Str.eq(a, "abcABCabc"));
- assert (Str.eq(b, "ABCabcABC"));
+ assert (_str::eq(a, "abcABCabc"));
+ assert (_str::eq(b, "ABCabcABC"));
}
fn main() {
diff --git a/src/test/run-pass/syntax-extension-fmt.rs b/src/test/run-pass/syntax-extension-fmt.rs
index 2e49e2198dbb8..f0da72a3e0cb9 100644
--- a/src/test/run-pass/syntax-extension-fmt.rs
+++ b/src/test/run-pass/syntax-extension-fmt.rs
@@ -1,11 +1,11 @@
// xfail-boot
use std;
-import std.Str;
+import std::_str;
fn test(str actual, str expected) {
log actual;
log expected;
- assert (Str.eq(actual, expected));
+ assert (_str::eq(actual, expected));
}
fn main() {
diff --git a/src/test/run-pass/task-comm-1.rs b/src/test/run-pass/task-comm-1.rs
index c8ebdd195a8a1..8adab6e9f0f65 100644
--- a/src/test/run-pass/task-comm-1.rs
+++ b/src/test/run-pass/task-comm-1.rs
@@ -6,7 +6,7 @@ fn main() -> () {
}
fn start() {
- log "Started / Finished Task.";
+ log "Started / Finished task.";
}
fn test00() {
diff --git a/src/test/run-pass/task-comm-12.rs b/src/test/run-pass/task-comm-12.rs
index d4a135c2a39e4..2aa38b86aa3d6 100644
--- a/src/test/run-pass/task-comm-12.rs
+++ b/src/test/run-pass/task-comm-12.rs
@@ -3,14 +3,14 @@
// xfail-stage1
// xfail-stage2
use std;
-import std.Task;
+import std::_task;
fn main() -> () {
test00();
}
fn start(int task_number) {
- log "Started / Finished Task.";
+ log "Started / Finished task.";
}
fn test00() {
@@ -18,10 +18,10 @@ fn test00() {
let task t = spawn thread "child" start(i);
// Sleep long enough for the task to finish.
- Task.sleep(10000u);
+ _task::sleep(10000u);
// Try joining tasks that have already finished.
join t;
- log "Joined Task.";
+ log "Joined task.";
}
\ No newline at end of file
diff --git a/src/test/run-pass/task-comm-13-thread.rs b/src/test/run-pass/task-comm-13-thread.rs
index fedc516bd59a8..72f3c9568fef3 100644
--- a/src/test/run-pass/task-comm-13-thread.rs
+++ b/src/test/run-pass/task-comm-13-thread.rs
@@ -2,7 +2,7 @@
// xfail-stage1
// xfail-stage2
use std;
-import std.Task;
+import std::_task;
fn start(chan[int] c, int start, int number_of_messages) {
let int i = 0;
@@ -17,5 +17,5 @@ fn main() -> () {
let port[int] p = port();
let task a = spawn thread "start" start(chan(p), 0, 10);
join a;
- log "Joined Task";
+ log "Joined task";
}
\ No newline at end of file
diff --git a/src/test/run-pass/task-comm-13.rs b/src/test/run-pass/task-comm-13.rs
index 1bf5d1f56f636..c6de853332e4e 100644
--- a/src/test/run-pass/task-comm-13.rs
+++ b/src/test/run-pass/task-comm-13.rs
@@ -2,7 +2,7 @@
// xfail-stage1
// xfail-stage2
use std;
-import std.Task;
+import std::_task;
fn start(chan[int] c, int start, int number_of_messages) {
let int i = 0;
@@ -17,5 +17,5 @@ fn main() -> () {
let port[int] p = port();
let task a = spawn "start" start(chan(p), 0, 10);
join a;
- log "Joined Task";
+ log "Joined task";
}
\ No newline at end of file
diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs
index 74faa149185bb..7199db0c9f10c 100644
--- a/src/test/run-pass/task-comm.rs
+++ b/src/test/run-pass/task-comm.rs
@@ -97,12 +97,12 @@ fn test03() {
}
fn test04_start() {
- log "Started Task";
+ log "Started task";
let int i = 1024 * 1024 * 64;
while (i > 0) {
i = i - 1;
}
- log "Finished Task";
+ log "Finished task";
}
fn test04() {
diff --git a/src/test/run-pass/type-sizes.rs b/src/test/run-pass/type-sizes.rs
index d39a2064828ae..fbc608ae8a6d0 100644
--- a/src/test/run-pass/type-sizes.rs
+++ b/src/test/run-pass/type-sizes.rs
@@ -2,7 +2,7 @@
// xfail-stage1
// xfail-stage2
-import size_of = std.Sys.rustrt.size_of;
+import size_of = std::sys.rustrt.size_of;
use std;
diff --git a/src/test/run-pass/use-import-export.rs b/src/test/run-pass/use-import-export.rs
index 3e0471499ab3c..f9ac5345bf3ec 100644
--- a/src/test/run-pass/use-import-export.rs
+++ b/src/test/run-pass/use-import-export.rs
@@ -15,7 +15,7 @@ mod bar {
}
fn main() {
- foo.x();
- bar.y();
+ foo::x();
+ bar::y();
}
diff --git a/src/test/run-pass/use.rs b/src/test/run-pass/use.rs
index 3d1a6947f7cb7..ee8ae10ad8761 100644
--- a/src/test/run-pass/use.rs
+++ b/src/test/run-pass/use.rs
@@ -7,8 +7,8 @@ use zed(name = "std");
use bar(name = "std", ver = "0.0.1");
// FIXME: commented out since resolve doesn't know how to handle crates yet.
-// import std.Str;
-// import x = std.Str;
+// import std::str;
+// import x = std::str;
mod baz {
use std;
@@ -16,8 +16,8 @@ mod baz {
use zed(name = "std");
use bar(name = "std", ver = "0.0.1");
- // import std.Str;
- // import x = std.Str;
+ // import std::str;
+ // import x = std::str;
}
fn main() {
diff --git a/src/test/run-pass/user.rs b/src/test/run-pass/user.rs
index 877c416bbb353..3281f448b05d2 100644
--- a/src/test/run-pass/user.rs
+++ b/src/test/run-pass/user.rs
@@ -8,10 +8,10 @@ use std (name = "std",
uuid = _, ver = _);
fn main() {
- auto s = std.Str.alloc(10 as uint);
+ auto s = std::str.alloc(10 as uint);
s += "hello ";
log s;
s += "there";
log s;
- auto z = std.Vec.alloc[int](10 as uint);
+ auto z = std::vec.alloc[int](10 as uint);
}
diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs
index 95cbc64e0ab68..a79294ec57274 100644
--- a/src/test/run-pass/utf8_chars.rs
+++ b/src/test/run-pass/utf8_chars.rs
@@ -2,34 +2,34 @@
// xfail-stage1
// xfail-stage2
use std;
-import std.Str;
-import std.Vec;
-import std.IO;
+import std::_str;
+import std::_vec;
+import std::io;
fn main() {
// Chars of 1, 2, 3, and 4 bytes
let vec[char] chs = vec('e', 'é', '€', 0x10000 as char);
- let str s = Str.from_chars(chs);
+ let str s = _str::from_chars(chs);
- assert (Str.byte_len(s) == 10u);
- assert (Str.char_len(s) == 4u);
- assert (Vec.len[char](Str.to_chars(s)) == 4u);
- assert (Str.eq(Str.from_chars(Str.to_chars(s)), s));
- assert (Str.char_at(s, 0u) == 'e');
- assert (Str.char_at(s, 1u) == 'é');
+ assert (_str::byte_len(s) == 10u);
+ assert (_str::char_len(s) == 4u);
+ assert (_vec::len[char](_str::to_chars(s)) == 4u);
+ assert (_str::eq(_str::from_chars(_str::to_chars(s)), s));
+ assert (_str::char_at(s, 0u) == 'e');
+ assert (_str::char_at(s, 1u) == 'é');
- assert (Str.is_utf8(Str.bytes(s)));
- assert (!Str.is_utf8(vec(0x80_u8)));
- assert (!Str.is_utf8(vec(0xc0_u8)));
- assert (!Str.is_utf8(vec(0xc0_u8, 0x10_u8)));
+ assert (_str::is_utf8(_str::bytes(s)));
+ assert (!_str::is_utf8(vec(0x80_u8)));
+ assert (!_str::is_utf8(vec(0xc0_u8)));
+ assert (!_str::is_utf8(vec(0xc0_u8, 0x10_u8)));
auto stack = "a×c€";
- assert (Str.pop_char(stack) == '€');
- assert (Str.pop_char(stack) == 'c');
- Str.push_char(stack, 'u');
- assert (Str.eq(stack, "a×u"));
- assert (Str.shift_char(stack) == 'a');
- assert (Str.shift_char(stack) == '×');
- Str.unshift_char(stack, 'ß');
- assert (Str.eq(stack, "ßu"));
+ assert (_str::pop_char(stack) == '€');
+ assert (_str::pop_char(stack) == 'c');
+ _str::push_char(stack, 'u');
+ assert (_str::eq(stack, "a×u"));
+ assert (_str::shift_char(stack) == 'a');
+ assert (_str::shift_char(stack) == '×');
+ _str::unshift_char(stack, 'ß');
+ assert (_str::eq(stack, "ßu"));
}
diff --git a/src/test/run-pass/vec-alloc-append.rs b/src/test/run-pass/vec-alloc-append.rs
index 4327e789cd572..d0ca6ab9c8c4c 100644
--- a/src/test/run-pass/vec-alloc-append.rs
+++ b/src/test/run-pass/vec-alloc-append.rs
@@ -6,7 +6,7 @@
use std;
fn slice[T](vec[T] e) {
- let vec[T] result = std.Vec.alloc[T](1 as uint);
+ let vec[T] result = std::vec.alloc[T](1 as uint);
log "alloced";
result += e;
log "appended";
diff --git a/src/test/run-pass/vec-append.rs b/src/test/run-pass/vec-append.rs
index cd87ec230ceca..dc36799bce4e3 100644
--- a/src/test/run-pass/vec-append.rs
+++ b/src/test/run-pass/vec-append.rs
@@ -4,11 +4,11 @@
// -*- rust -*-
use std;
-import std.Str;
-import std.Vec;
+import std::_str;
+import std::_vec;
-// FIXME: import std.Dbg.const_refcount. Currently
+// FIXME: import std::dbg::const_refcount. Currently
// cross-crate const references don't work.
const uint const_refcount = 0x7bad_face_u;
@@ -53,30 +53,30 @@ fn slow_growth2_helper(str s) { // ref up: s
let vec[str] v = vec(mumble); // ref up: v, mumble
let acc a = acc(v); // ref up: a, v
- log Vec.refcount[str](v);
- assert (Vec.refcount[str](v) == 2u);
+ log _vec::refcount[str](v);
+ assert (_vec::refcount[str](v) == 2u);
a.add(s); // ref up: mumble, s. ref down: v
- log Vec.refcount[str](v);
- log Str.refcount(s);
- log Str.refcount(mumble);
+ log _vec::refcount[str](v);
+ log _str::refcount(s);
+ log _str::refcount(mumble);
- assert (Vec.refcount[str](v) == 1u);
- assert (Str.refcount(s) == const_refcount);
- assert (Str.refcount(mumble) == const_refcount);
+ assert (_vec::refcount[str](v) == 1u);
+ assert (_str::refcount(s) == const_refcount);
+ assert (_str::refcount(mumble) == const_refcount);
log v.(0);
- log Vec.len[str](v);
- assert (Str.eq(v.(0), mumble));
- assert (Vec.len[str](v) == 1u);
+ log _vec::len[str](v);
+ assert (_str::eq(v.(0), mumble));
+ assert (_vec::len[str](v) == 1u);
} // ref down: a, mumble, s, v
- log Str.refcount(s);
- log Str.refcount(mumble);
+ log _str::refcount(s);
+ log _str::refcount(mumble);
- assert (Str.refcount(s) == const_refcount);
- assert (Str.refcount(mumble) == const_refcount);
+ assert (_str::refcount(s) == const_refcount);
+ assert (_str::refcount(mumble) == const_refcount);
log mumble;
log ss;
@@ -85,8 +85,8 @@ fn slow_growth2_helper(str s) { // ref up: s
fn slow_growth2() {
let str s = "hi"; // ref up: s
slow_growth2_helper(s);
- log Str.refcount(s);
- assert (Str.refcount(s) == const_refcount);
+ log _str::refcount(s);
+ assert (_str::refcount(s) == const_refcount);
}
fn main() {
diff --git a/src/test/run-pass/vec-ref-count.rs b/src/test/run-pass/vec-ref-count.rs
index 4534a86195a2a..86ba642b61f64 100644
--- a/src/test/run-pass/vec-ref-count.rs
+++ b/src/test/run-pass/vec-ref-count.rs
@@ -1,12 +1,12 @@
use std;
-import std.Vec;
+import std::_vec;
fn main() {
auto v = vec(1, 2, 3);
- log_err Vec.refcount[int](v);
- log_err Vec.refcount[int](v);
- log_err Vec.refcount[int](v);
- assert (Vec.refcount[int](v) == 1u || Vec.refcount[int](v) == 2u);
- assert (Vec.refcount[int](v) == 1u || Vec.refcount[int](v) == 2u);
+ log_err _vec::refcount[int](v);
+ log_err _vec::refcount[int](v);
+ log_err _vec::refcount[int](v);
+ assert (_vec::refcount[int](v) == 1u || _vec::refcount[int](v) == 2u);
+ assert (_vec::refcount[int](v) == 1u || _vec::refcount[int](v) == 2u);
}