Downcase std modules again, move to :: for module dereferencing

This should be a snapshot transition.

1 files changed, 105 insertions, 105 deletions

diff --git a/src/comp/front/extfmt.rs b/src/comp/front/extfmt.rs
index 36050e19..085e5d98 100644
--- a/src/comp/front/extfmt.rs
+++ b/src/comp/front/extfmt.rs
@@ -1,56 +1,56 @@
 /*
  * The compiler code necessary to support the #fmt extension.  Eventually this
- * should all get sucked into either the standard library ExtFmt module or the
+ * should all get sucked into either the standard library extfmt module or the
  * compiler syntax extension plugin interface.
  */
 
-import front.parser.parser;
-import util.common;
-
-import std.Str;
-import std.Vec;
-import std.Option;
-import std.Option.none;
-import std.Option.some;
-
-import std.ExtFmt.CT.signedness;
-import std.ExtFmt.CT.signed;
-import std.ExtFmt.CT.unsigned;
-import std.ExtFmt.CT.caseness;
-import std.ExtFmt.CT.case_upper;
-import std.ExtFmt.CT.case_lower;
-import std.ExtFmt.CT.ty;
-import std.ExtFmt.CT.ty_bool;
-import std.ExtFmt.CT.ty_str;
-import std.ExtFmt.CT.ty_char;
-import std.ExtFmt.CT.ty_int;
-import std.ExtFmt.CT.ty_bits;
-import std.ExtFmt.CT.ty_hex;
-import std.ExtFmt.CT.ty_octal;
-import std.ExtFmt.CT.flag;
-import std.ExtFmt.CT.flag_left_justify;
-import std.ExtFmt.CT.flag_left_zero_pad;
-import std.ExtFmt.CT.flag_space_for_sign;
-import std.ExtFmt.CT.flag_sign_always;
-import std.ExtFmt.CT.flag_alternate;
-import std.ExtFmt.CT.count;
-import std.ExtFmt.CT.count_is;
-import std.ExtFmt.CT.count_is_param;
-import std.ExtFmt.CT.count_is_next_param;
-import std.ExtFmt.CT.count_implied;
-import std.ExtFmt.CT.conv;
-import std.ExtFmt.CT.piece;
-import std.ExtFmt.CT.piece_string;
-import std.ExtFmt.CT.piece_conv;
-import std.ExtFmt.CT.parse_fmt_string;
+import front::parser::parser;
+import util::common;
+
+import std::_str;
+import std::_vec;
+import std::option;
+import std::option::none;
+import std::option::some;
+
+import std::extfmt::CT::signedness;
+import std::extfmt::CT::signed;
+import std::extfmt::CT::unsigned;
+import std::extfmt::CT::caseness;
+import std::extfmt::CT::case_upper;
+import std::extfmt::CT::case_lower;
+import std::extfmt::CT::ty;
+import std::extfmt::CT::ty_bool;
+import std::extfmt::CT::ty_str;
+import std::extfmt::CT::ty_char;
+import std::extfmt::CT::ty_int;
+import std::extfmt::CT::ty_bits;
+import std::extfmt::CT::ty_hex;
+import std::extfmt::CT::ty_octal;
+import std::extfmt::CT::flag;
+import std::extfmt::CT::flag_left_justify;
+import std::extfmt::CT::flag_left_zero_pad;
+import std::extfmt::CT::flag_space_for_sign;
+import std::extfmt::CT::flag_sign_always;
+import std::extfmt::CT::flag_alternate;
+import std::extfmt::CT::count;
+import std::extfmt::CT::count_is;
+import std::extfmt::CT::count_is_param;
+import std::extfmt::CT::count_is_next_param;
+import std::extfmt::CT::count_implied;
+import std::extfmt::CT::conv;
+import std::extfmt::CT::piece;
+import std::extfmt::CT::piece_string;
+import std::extfmt::CT::piece_conv;
+import std::extfmt::CT::parse_fmt_string;
 
 export expand_syntax_ext;
 
 fn expand_syntax_ext(parser p,
-                     vec[@ast.expr] args,
-                     Option.t[str] body) -> @ast.expr {
+                     vec[@ast::expr] args,
+                     option::t[str] body) -> @ast::expr {
 
-    if (Vec.len[@ast.expr](args) == 0u) {
+    if (_vec::len[@ast::expr](args) == 0u) {
         // FIXME: Handle error correctly.
         log_err "malformed #fmt call";
         fail;
@@ -62,16 +62,16 @@ fn expand_syntax_ext(parser p,
     // log fmt;
 
     auto pieces = parse_fmt_string(fmt);
-    auto args_len = Vec.len[@ast.expr](args);
-    auto fmt_args = Vec.slice[@ast.expr](args, 1u, args_len - 1u);
+    auto args_len = _vec::len[@ast::expr](args);
+    auto fmt_args = _vec::slice[@ast::expr](args, 1u, args_len - 1u);
     ret pieces_to_expr(p, pieces, args);
 }
 
-fn expr_to_str(@ast.expr expr) -> str {
+fn expr_to_str(@ast::expr expr) -> str {
     alt (expr.node) {
-        case (ast.expr_lit(?l, _)) {
+        case (ast::expr_lit(?l, _)) {
             alt (l.node) {
-                case (ast.lit_str(?s)) {
+                case (ast::lit_str(?s)) {
                     ret s;
                 }
             }
@@ -86,75 +86,75 @@ fn expr_to_str(@ast.expr expr) -> str {
 // be factored out in common with other code that builds expressions.
 // FIXME: Probably should be using the parser's span functions
 // FIXME: Cleanup the naming of these functions
-fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
-        -> @ast.expr {
+fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
+        -> @ast::expr {
 
-    fn make_new_lit(parser p, common.span sp, ast.lit_ lit) -> @ast.expr {
+    fn make_new_lit(parser p, common::span sp, ast::lit_ lit) -> @ast::expr {
         auto sp_lit = @rec(node=lit, span=sp);
-        auto expr = ast.expr_lit(sp_lit, p.get_ann());
+        auto expr = ast::expr_lit(sp_lit, p.get_ann());
         ret @rec(node=expr, span=sp);
     }
 
-    fn make_new_str(parser p, common.span sp, str s) -> @ast.expr {
-        auto lit = ast.lit_str(s);
+    fn make_new_str(parser p, common::span sp, str s) -> @ast::expr {
+        auto lit = ast::lit_str(s);
         ret make_new_lit(p, sp, lit);
     }
 
-    fn make_new_int(parser p, common.span sp, int i) -> @ast.expr {
-        auto lit = ast.lit_int(i);
+    fn make_new_int(parser p, common::span sp, int i) -> @ast::expr {
+        auto lit = ast::lit_int(i);
         ret make_new_lit(p, sp, lit);
     }
 
-    fn make_new_uint(parser p, common.span sp, uint u) -> @ast.expr {
-        auto lit = ast.lit_uint(u);
+    fn make_new_uint(parser p, common::span sp, uint u) -> @ast::expr {
+        auto lit = ast::lit_uint(u);
         ret make_new_lit(p, sp, lit);
     }
 
-    fn make_add_expr(parser p, common.span sp,
-                     @ast.expr lhs, @ast.expr rhs) -> @ast.expr {
-        auto binexpr = ast.expr_binary(ast.add, lhs, rhs, p.get_ann());
+    fn make_add_expr(parser p, common::span sp,
+                     @ast::expr lhs, @ast::expr rhs) -> @ast::expr {
+        auto binexpr = ast::expr_binary(ast::add, lhs, rhs, p.get_ann());
         ret @rec(node=binexpr, span=sp);
     }
 
-    fn make_path_expr(parser p, common.span sp, vec[ast.ident] idents)
-            -> @ast.expr {
-        let vec[@ast.ty] types = vec();
+    fn make_path_expr(parser p, common::span sp, vec[ast::ident] idents)
+            -> @ast::expr {
+        let vec[@ast::ty] types = vec();
         auto path = rec(idents=idents, types=types);
         auto sp_path = rec(node=path, span=sp);
-        auto pathexpr = ast.expr_path(sp_path, p.get_ann());
+        auto pathexpr = ast::expr_path(sp_path, p.get_ann());
         auto sp_pathexpr = @rec(node=pathexpr, span=sp);
         ret sp_pathexpr;
     }
 
-    fn make_vec_expr(parser p, common.span sp, vec[@ast.expr] exprs)
-            -> @ast.expr {
-        auto vecexpr = ast.expr_vec(exprs, ast.imm, p.get_ann());
+    fn make_vec_expr(parser p, common::span sp, vec[@ast::expr] exprs)
+            -> @ast::expr {
+        auto vecexpr = ast::expr_vec(exprs, ast::imm, p.get_ann());
         auto sp_vecexpr = @rec(node=vecexpr, span=sp);
         ret sp_vecexpr;
     }
 
-    fn make_call(parser p, common.span sp, vec[ast.ident] fn_path,
-                 vec[@ast.expr] args) -> @ast.expr {
+    fn make_call(parser p, common::span sp, vec[ast::ident] fn_path,
+                 vec[@ast::expr] args) -> @ast::expr {
         auto pathexpr = make_path_expr(p, sp, fn_path);
-        auto callexpr = ast.expr_call(pathexpr, args, p.get_ann());
+        auto callexpr = ast::expr_call(pathexpr, args, p.get_ann());
         auto sp_callexpr = @rec(node=callexpr, span=sp);
         ret sp_callexpr;
     }
 
-    fn make_rec_expr(parser p, common.span sp,
-                     vec[tup(ast.ident, @ast.expr)] fields) -> @ast.expr {
-        let vec[ast.field] astfields = vec();
-        for (tup(ast.ident, @ast.expr) field in fields) {
+    fn make_rec_expr(parser p, common::span sp,
+                     vec[tup(ast::ident, @ast::expr)] fields) -> @ast::expr {
+        let vec[ast::field] astfields = vec();
+        for (tup(ast::ident, @ast::expr) field in fields) {
             auto ident = field._0;
             auto val = field._1;
-            auto astfield = rec(mut = ast.imm,
+            auto astfield = rec(mut = ast::imm,
                                 ident = ident,
                                 expr = val);
             astfields += vec(astfield);
         }
 
-        auto recexpr = ast.expr_rec(astfields,
-                                    Option.none[@ast.expr],
+        auto recexpr = ast::expr_rec(astfields,
+                                    option::none[@ast::expr],
                                     p.get_ann());
         auto sp_recexpr = @rec(node=recexpr, span=sp);
         ret sp_recexpr;
@@ -166,18 +166,18 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
         ret vec("std", "extfmt", "RT", ident);
     }
 
-    fn make_rt_path_expr(parser p, common.span sp, str ident) -> @ast.expr {
+    fn make_rt_path_expr(parser p, common::span sp, str ident) -> @ast::expr {
         auto path = make_path_vec(ident);
         ret make_path_expr(p, sp, path);
     }
 
-    // Produces an AST expression that represents a RT.conv record,
-    // which tells the RT.conv* functions how to perform the conversion
-    fn make_rt_conv_expr(parser p, common.span sp, &conv cnv) -> @ast.expr {
+    // Produces an AST expression that represents a RT::conv record,
+    // which tells the RT::conv* functions how to perform the conversion
+    fn make_rt_conv_expr(parser p, common::span sp, &conv cnv) -> @ast::expr {
 
-        fn make_flags(parser p, common.span sp, vec[flag] flags)
-                -> @ast.expr {
-            let vec[@ast.expr] flagexprs = vec();
+        fn make_flags(parser p, common::span sp, vec[flag] flags)
+                -> @ast::expr {
+            let vec[@ast::expr] flagexprs = vec();
             for (flag f in flags) {
                 auto fstr;
                 alt (f) {
@@ -203,14 +203,14 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
             // FIXME: 0-length vectors can't have their type inferred
             // through the rec that these flags are a member of, so
             // this is a hack placeholder flag
-            if (Vec.len[@ast.expr](flagexprs) == 0u) {
+            if (_vec::len[@ast::expr](flagexprs) == 0u) {
                 flagexprs += vec(make_rt_path_expr(p, sp, "flag_none"));
             }
 
             ret make_vec_expr(p, sp, flagexprs);
         }
 
-        fn make_count(parser p, common.span sp, &count cnt) -> @ast.expr {
+        fn make_count(parser p, common::span sp, &count cnt) -> @ast::expr {
             alt (cnt) {
                 case (count_implied) {
                     ret make_rt_path_expr(p, sp, "count_implied");
@@ -228,7 +228,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
             }
         }
 
-        fn make_ty(parser p, common.span sp, &ty t) -> @ast.expr {
+        fn make_ty(parser p, common::span sp, &ty t) -> @ast::expr {
             auto rt_type;
             alt (t) {
                 case (ty_hex(?c)) {
@@ -256,11 +256,11 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
         }
 
         fn make_conv_rec(parser p,
-                         common.span sp,
-                         @ast.expr flags_expr,
-                         @ast.expr width_expr,
-                         @ast.expr precision_expr,
-                         @ast.expr ty_expr) -> @ast.expr {
+                         common::span sp,
+                         @ast::expr flags_expr,
+                         @ast::expr width_expr,
+                         @ast::expr precision_expr,
+                         @ast::expr ty_expr) -> @ast::expr {
             ret make_rec_expr(p, sp, vec(tup("flags", flags_expr),
                                          tup("width", width_expr),
                                          tup("precision", precision_expr),
@@ -279,8 +279,8 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
                           rt_conv_ty);
     }
 
-    fn make_conv_call(parser p, common.span sp, str conv_type,
-                      &conv cnv, @ast.expr arg) -> @ast.expr {
+    fn make_conv_call(parser p, common::span sp, str conv_type,
+                      &conv cnv, @ast::expr arg) -> @ast::expr {
         auto fname = "conv_" + conv_type;
         auto path = make_path_vec(fname);
         auto cnv_expr = make_rt_conv_expr(p, sp, cnv);
@@ -288,9 +288,9 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
         ret make_call(p, arg.span, path, args);
     }
 
-    fn make_new_conv(parser p, conv cnv, @ast.expr arg) -> @ast.expr {
+    fn make_new_conv(parser p, conv cnv, @ast::expr arg) -> @ast::expr {
 
-        // FIXME: Extract all this validation into ExtFmt.CT
+        // FIXME: Extract all this validation into extfmt::CT
         fn is_signed_type(conv cnv) -> bool {
             alt (cnv.ty) {
                 case (ty_int(?s)) {
@@ -312,7 +312,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
         auto unsupported = "conversion not supported in #fmt string";
 
         alt (cnv.param) {
-            case (Option.none[int]) {
+            case (option::none[int]) {
             }
             case (_) {
                 log_err unsupported;
@@ -407,7 +407,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
     fn log_conv(conv c) {
         alt (c.param) {
             case (some[int](?p)) {
-                log "param: " + std.Int.to_str(p, 10u);
+                log "param: " + std::_int::to_str(p, 10u);
             }
             case (_) {
                 log "param: none";
@@ -434,10 +434,10 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
         }
         alt (c.width) {
             case (count_is(?i)) {
-                log "width: count is " + std.Int.to_str(i, 10u);
+                log "width: count is " + std::_int::to_str(i, 10u);
             }
             case (count_is_param(?i)) {
-                log "width: count is param " + std.Int.to_str(i, 10u);
+                log "width: count is param " + std::_int::to_str(i, 10u);
             }
             case (count_is_next_param) {
                 log "width: count is next param";
@@ -448,10 +448,10 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
         }
         alt (c.precision) {
             case (count_is(?i)) {
-                log "prec: count is " + std.Int.to_str(i, 10u);
+                log "prec: count is " + std::_int::to_str(i, 10u);
             }
             case (count_is_param(?i)) {
-                log "prec: count is param " + std.Int.to_str(i, 10u);
+                log "prec: count is param " + std::_int::to_str(i, 10u);
             }
             case (count_is_next_param) {
                 log "prec: count is next param";
@@ -507,7 +507,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
                 tmp_expr = make_add_expr(p, sp, tmp_expr, s_expr);
             }
             case (piece_conv(?conv)) {
-                if (n >= Vec.len[@ast.expr](args)) {
+                if (n >= _vec::len[@ast::expr](args)) {
                     log_err "too many conversions in #fmt string";
                     fail;
                 }
@@ -526,7 +526,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
 
     // TODO: Remove this debug logging
     // log "dumping expanded ast:";
-    // log pretty.print_expr(tmp_expr);
+    // log pretty::print_expr(tmp_expr);
     ret tmp_expr;
 }