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

This should be a snapshot transition.

4 files changed, 114 insertions, 114 deletions

diff --git a/src/comp/back/Link.rs b/src/comp/back/Link.rs
index 50f10a80..50b07915 100644
--- a/src/comp/back/Link.rs
+++ b/src/comp/back/Link.rs
@@ -1,16 +1,16 @@
-import driver.session;
-import lib.llvm.llvm;
-import middle.trans;
-import std.Str;
-import std.FS;
-
-import lib.llvm.llvm.ModuleRef;
-import lib.llvm.llvm.ValueRef;
-import lib.llvm.mk_pass_manager;
-import lib.llvm.mk_target_data;
-import lib.llvm.mk_type_names;
-import lib.llvm.False;
-import lib.llvm.True;
+import driver::session;
+import lib::llvm::llvm;
+import middle::trans;
+import std::_str;
+import std::fs;
+
+import lib::llvm::llvm::ModuleRef;
+import lib::llvm::llvm::ValueRef;
+import lib::llvm::mk_pass_manager;
+import lib::llvm::mk_target_data;
+import lib::llvm::mk_type_names;
+import lib::llvm::False;
+import lib::llvm::True;
 
 tag output_type {
     output_type_none;
@@ -19,32 +19,32 @@ tag output_type {
     output_type_object;
 }
 
-fn llvm_err(session.session sess, str msg) {
-    auto buf = llvm.LLVMRustGetLastError();
+fn llvm_err(session::session sess, str msg) {
+    auto buf = llvm::LLVMRustGetLastError();
     if ((buf as uint) == 0u) {
         sess.err(msg);
     } else {
-        sess.err(msg + ": " + Str.str_from_cstr(buf));
+        sess.err(msg + ": " + _str::str_from_cstr(buf));
     }
     fail;
 }
 
-fn link_intrinsics(session.session sess, ModuleRef llmod) {
-    auto path = FS.connect(sess.get_opts().sysroot, "intrinsics.bc");
+fn link_intrinsics(session::session sess, ModuleRef llmod) {
+    auto path = fs::connect(sess.get_opts().sysroot, "intrinsics.bc");
     auto membuf =
-        llvm.LLVMRustCreateMemoryBufferWithContentsOfFile(Str.buf(path));
+        llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(_str::buf(path));
     if ((membuf as uint) == 0u) {
         llvm_err(sess, "installation problem: couldn't open intrinstics.bc");
         fail;
     }
 
-    auto llintrinsicsmod = llvm.LLVMRustParseBitcode(membuf);
+    auto llintrinsicsmod = llvm::LLVMRustParseBitcode(membuf);
     if ((llintrinsicsmod as uint) == 0u) {
         llvm_err(sess, "installation problem: couldn't parse intrinstics.bc");
         fail;
     }
 
-    if (llvm.LLVMLinkModules(llmod, llintrinsicsmod) == False) {
+    if (llvm::LLVMLinkModules(llmod, llintrinsicsmod) == False) {
         llvm_err(sess, "couldn't link the module with the intrinsics");
         fail;
     }
@@ -64,29 +64,29 @@ mod Write {
     // Decides what to call an intermediate file, given the name of the output
     // and the extension to use.
     fn mk_intermediate_name(str output_path, str extension) -> str {
-        auto dot_pos = Str.index(output_path, '.' as u8);
+        auto dot_pos = _str::index(output_path, '.' as u8);
         auto stem;
         if (dot_pos < 0) {
             stem = output_path;
         } else {
-            stem = Str.substr(output_path, 0u, dot_pos as uint);
+            stem = _str::substr(output_path, 0u, dot_pos as uint);
         }
         ret stem + "." + extension;
     }
 
-    fn run_passes(session.session sess, ModuleRef llmod, str output) {
+    fn run_passes(session::session sess, ModuleRef llmod, str output) {
 
         auto opts = sess.get_opts();
 
         if (opts.time_llvm_passes) {
-          llvm.LLVMRustEnableTimePasses();
+          llvm::LLVMRustEnableTimePasses();
         }
 
         link_intrinsics(sess, llmod);
 
         auto pm = mk_pass_manager();
-        auto td = mk_target_data(x86.get_data_layout());
-        llvm.LLVMAddTargetData(td.lltd, pm.llpm);
+        auto td = mk_target_data(x86::get_data_layout());
+        llvm::LLVMAddTargetData(td.lltd, pm.llpm);
 
         // TODO: run the linter here also, once there are llvm-c bindings for
         // it.
@@ -99,13 +99,13 @@ mod Write {
                     if (opts.optimize) {
                         auto filename = mk_intermediate_name(output,
                                                              "no-opt.bc");
-                        llvm.LLVMWriteBitcodeToFile(llmod,
-                                                    Str.buf(filename));
+                        llvm::LLVMWriteBitcodeToFile(llmod,
+                                                    _str::buf(filename));
                     }
                 }
                 case (_) {
                     auto filename = mk_intermediate_name(output, "bc");
-                    llvm.LLVMWriteBitcodeToFile(llmod, Str.buf(filename));
+                    llvm::LLVMWriteBitcodeToFile(llmod, _str::buf(filename));
                 }
             }
         }
@@ -118,13 +118,13 @@ mod Write {
         // tool?
         if (opts.optimize) {
             auto fpm = mk_pass_manager();
-            llvm.LLVMAddTargetData(td.lltd, fpm.llpm);
-            llvm.LLVMAddStandardFunctionPasses(fpm.llpm, 2u);
-            llvm.LLVMRunPassManager(fpm.llpm, llmod);
+            llvm::LLVMAddTargetData(td.lltd, fpm.llpm);
+            llvm::LLVMAddStandardFunctionPasses(fpm.llpm, 2u);
+            llvm::LLVMRunPassManager(fpm.llpm, llmod);
 
             // TODO: On -O3, use 275 instead of 225 for the inlining
             // threshold.
-            llvm.LLVMAddStandardModulePasses(pm.llpm,
+            llvm::LLVMAddStandardModulePasses(pm.llpm,
                                              2u,    // optimization level
                                              False, // optimize for size
                                              True,  // unit-at-a-time
@@ -135,7 +135,7 @@ mod Write {
         }
 
         if (opts.verify) {
-            llvm.LLVMAddVerifierPass(pm.llpm);
+            llvm::LLVMAddVerifierPass(pm.llpm);
         }
 
         // TODO: Write .s if -c was specified and -save-temps was on.
@@ -157,32 +157,32 @@ mod Write {
                     case (_) {
                         auto filename = mk_intermediate_name(output,
                                                              "opt.bc");
-                        llvm.LLVMRunPassManager(pm.llpm, llmod);
-                        llvm.LLVMWriteBitcodeToFile(llmod,
-                                                    Str.buf(filename));
+                        llvm::LLVMRunPassManager(pm.llpm, llmod);
+                        llvm::LLVMWriteBitcodeToFile(llmod,
+                                                    _str::buf(filename));
                         pm = mk_pass_manager();
                     }
                 }
             }
 
-            llvm.LLVMRustWriteOutputFile(pm.llpm, llmod,
-                                         Str.buf(x86.get_target_triple()),
-                                         Str.buf(output),
+            llvm::LLVMRustWriteOutputFile(pm.llpm, llmod,
+                                         _str::buf(x86::get_target_triple()),
+                                         _str::buf(output),
                                          FileType);
-            llvm.LLVMDisposeModule(llmod);
+            llvm::LLVMDisposeModule(llmod);
             if (opts.time_llvm_passes) {
-              llvm.LLVMRustPrintPassTimings();
+              llvm::LLVMRustPrintPassTimings();
             }
             ret;
         }
 
-        llvm.LLVMRunPassManager(pm.llpm, llmod);
+        llvm::LLVMRunPassManager(pm.llpm, llmod);
 
-        llvm.LLVMWriteBitcodeToFile(llmod, Str.buf(output));
-        llvm.LLVMDisposeModule(llmod);
+        llvm::LLVMWriteBitcodeToFile(llmod, _str::buf(output));
+        llvm::LLVMDisposeModule(llmod);
 
         if (opts.time_llvm_passes) {
-          llvm.LLVMRustPrintPassTimings();
+          llvm::LLVMRustPrintPassTimings();
         }
     }
 }
diff --git a/src/comp/back/abi.rs b/src/comp/back/abi.rs
index 1ad32895..078c1f3d 100644
--- a/src/comp/back/abi.rs
+++ b/src/comp/back/abi.rs
@@ -2,7 +2,7 @@
 
 const int rc_base_field_refcnt = 0;
 
-// FIXME: import from std.dbg when imported consts work.
+// FIXME: import from std::dbg when imported consts work.
 const uint const_refcount = 0x7bad_face_u;
 
 const int task_field_refcnt = 0;
@@ -97,7 +97,7 @@ fn native_glue_name(int n, native_glue_type ngt) -> str {
         case (ngt_pure_rust)    { prefix = "rust_native_pure_rust_"; }
         case (ngt_cdecl)        { prefix = "rust_native_cdecl_"; }
     }
-    ret prefix + util.common.istr(n);
+    ret prefix + util::common::istr(n);
 }
 
 fn activate_glue_name() -> str {
diff --git a/src/comp/back/upcall.rs b/src/comp/back/upcall.rs
index 9e166737..c4abeec1 100644
--- a/src/comp/back/upcall.rs
+++ b/src/comp/back/upcall.rs
@@ -1,27 +1,27 @@
-import middle.trans;
+import middle::trans;
 
-import trans.decl_cdecl_fn;
-import trans.type_names;
-import trans.ModuleRef;
-import trans.TypeRef;
-import trans.ValueRef;
+import trans::decl_cdecl_fn;
+import trans::type_names;
+import trans::ModuleRef;
+import trans::TypeRef;
+import trans::ValueRef;
 
-import trans.T_crate;
-import trans.T_f32;
-import trans.T_f64;
-import trans.T_fn;
-import trans.T_i8;
-import trans.T_i32;
-import trans.T_int;
-import trans.T_opaque_chan_ptr;
-import trans.T_opaque_port_ptr;
-import trans.T_opaque_vec_ptr;
-import trans.T_ptr;
-import trans.T_size_t;
-import trans.T_str;
-import trans.T_taskptr;
-import trans.T_tydesc;
-import trans.T_void;
+import trans::T_crate;
+import trans::T_f32;
+import trans::T_f64;
+import trans::T_fn;
+import trans::T_i8;
+import trans::T_i32;
+import trans::T_int;
+import trans::T_opaque_chan_ptr;
+import trans::T_opaque_port_ptr;
+import trans::T_opaque_vec_ptr;
+import trans::T_ptr;
+import trans::T_size_t;
+import trans::T_str;
+import trans::T_taskptr;
+import trans::T_tydesc;
+import trans::T_void;
 
 type upcalls = rec(
     ValueRef grow_task,
@@ -66,13 +66,13 @@ fn declare_upcalls(type_names tn, ModuleRef llmod) -> @upcalls {
         let vec[TypeRef] arg_tys = vec(T_taskptr(tn));
         for (TypeRef t in tys) { arg_tys += vec(t); }
         auto fn_ty = T_fn(arg_tys, rv);
-        ret trans.decl_cdecl_fn(llmod, "upcall_" + name, fn_ty);
+        ret trans::decl_cdecl_fn(llmod, "upcall_" + name, fn_ty);
     }
 
     auto dv = bind decl(tn, llmod, _, _, T_void());
     auto d = bind decl(tn, llmod, _, _, _);
 
-    // FIXME: Sigh... remove this when I fix the typechecker pushdown.
+    // FIXME: Sigh:.. remove this when I fix the typechecker pushdown.
     // --pcwalton
     let vec[TypeRef] empty_vec = vec();
 
diff --git a/src/comp/back/x86.rs b/src/comp/back/x86.rs
index bad4eb3e..7d578c2f 100644
--- a/src/comp/back/x86.rs
+++ b/src/comp/back/x86.rs
@@ -1,9 +1,9 @@
-import lib.llvm.llvm;
-import lib.llvm.llvm.ModuleRef;
-import std.Str;
-import std.Vec;
-import std.OS.target_os;
-import util.common.istr;
+import lib::llvm::llvm;
+import lib::llvm::llvm::ModuleRef;
+import std::_str;
+import std::_vec;
+import std::os::target_os;
+import util::common::istr;
 
 const int wordsz = 4;
 
@@ -55,35 +55,35 @@ fn restore_callee_saves() -> vec[str] {
 }
 
 fn load_esp_from_rust_sp_first_arg() -> vec[str] {
-    ret vec("movl  " + wstr(abi.task_field_rust_sp) + "(%ecx), %esp");
+    ret vec("movl  " + wstr(abi::task_field_rust_sp) + "(%ecx), %esp");
 }
 
 fn load_esp_from_runtime_sp_first_arg() -> vec[str] {
-    ret vec("movl  " + wstr(abi.task_field_runtime_sp) + "(%ecx), %esp");
+    ret vec("movl  " + wstr(abi::task_field_runtime_sp) + "(%ecx), %esp");
 }
 
 fn store_esp_to_rust_sp_first_arg() -> vec[str] {
-    ret vec("movl  %esp, " + wstr(abi.task_field_rust_sp) + "(%ecx)");
+    ret vec("movl  %esp, " + wstr(abi::task_field_rust_sp) + "(%ecx)");
 }
 
 fn store_esp_to_runtime_sp_first_arg() -> vec[str] {
-    ret vec("movl  %esp, " + wstr(abi.task_field_runtime_sp) + "(%ecx)");
+    ret vec("movl  %esp, " + wstr(abi::task_field_runtime_sp) + "(%ecx)");
 }
 
 fn load_esp_from_rust_sp_second_arg() -> vec[str] {
-    ret vec("movl  " + wstr(abi.task_field_rust_sp) + "(%edx), %esp");
+    ret vec("movl  " + wstr(abi::task_field_rust_sp) + "(%edx), %esp");
 }
 
 fn load_esp_from_runtime_sp_second_arg() -> vec[str] {
-    ret vec("movl  " + wstr(abi.task_field_runtime_sp) + "(%edx), %esp");
+    ret vec("movl  " + wstr(abi::task_field_runtime_sp) + "(%edx), %esp");
 }
 
 fn store_esp_to_rust_sp_second_arg() -> vec[str] {
-    ret vec("movl  %esp, " + wstr(abi.task_field_rust_sp) + "(%edx)");
+    ret vec("movl  %esp, " + wstr(abi::task_field_rust_sp) + "(%edx)");
 }
 
 fn store_esp_to_runtime_sp_second_arg() -> vec[str] {
-    ret vec("movl  %esp, " + wstr(abi.task_field_runtime_sp) + "(%edx)");
+    ret vec("movl  %esp, " + wstr(abi::task_field_runtime_sp) + "(%edx)");
 }
 
 
@@ -157,7 +157,7 @@ fn rust_activate_glue() -> vec[str] {
          *      will be a no-op. Esp won't move, and the task's stack won't
          *      grow.
          */
-        + vec("addl  $20, " + wstr(abi.task_field_rust_sp) + "(%ecx)")
+        + vec("addl  $20, " + wstr(abi::task_field_rust_sp) + "(%ecx)")
 
 
         /*
@@ -209,13 +209,13 @@ fn rust_yield_glue() -> vec[str] {
         + vec("ret");
 }
 
-fn native_glue(int n_args, abi.native_glue_type ngt) -> vec[str] {
+fn native_glue(int n_args, abi::native_glue_type ngt) -> vec[str] {
 
     let bool pass_task;
     alt (ngt) {
-        case (abi.ngt_rust)         { pass_task = true; }
-        case (abi.ngt_pure_rust)    { pass_task = true; }
-        case (abi.ngt_cdecl)        { pass_task = false; }
+        case (abi::ngt_rust)         { pass_task = true; }
+        case (abi::ngt_pure_rust)    { pass_task = true; }
+        case (abi::ngt_cdecl)        { pass_task = false; }
     }
 
     /*
@@ -241,7 +241,7 @@ fn native_glue(int n_args, abi.native_glue_type ngt) -> vec[str] {
         }
         auto m = vec("movl  " + src_off + "(%ebp),%eax",
                      "movl  %eax," + dst_off + "(%esp)");
-        ret Str.connect(m, "\n\t");
+        ret _str::connect(m, "\n\t");
     }
 
     auto carg = bind copy_arg(pass_task, _);
@@ -259,7 +259,7 @@ fn native_glue(int n_args, abi.native_glue_type ngt) -> vec[str] {
         + vec("subl  $" + wstr(n_args) + ", %esp   # esp -= args",
               "andl  $~0xf, %esp    # align esp down")
 
-        + Vec.init_fn[str](carg, (n_args) as uint)
+        + _vec::init_fn[str](carg, (n_args) as uint)
 
         +  vec("movl  %edx, %edi     # save task from edx to edi",
                "call  *%ecx          # call *%ecx",
@@ -278,21 +278,21 @@ fn decl_glue(int align, str prefix, str name, vec[str] insns) -> str {
     ret "\t.globl " + sym + "\n" +
         "\t.balign " + istr(align) + "\n" +
         sym + ":\n" +
-        "\t" + Str.connect(insns, "\n\t");
+        "\t" + _str::connect(insns, "\n\t");
 }
 
 
-fn decl_native_glue(int align, str prefix, abi.native_glue_type ngt, uint n)
+fn decl_native_glue(int align, str prefix, abi::native_glue_type ngt, uint n)
         -> str {
     let int i = n as int;
     ret decl_glue(align, prefix,
-                  abi.native_glue_name(i, ngt),
+                  abi::native_glue_name(i, ngt),
                   native_glue(i, ngt));
 }
 
 fn get_symbol_prefix() -> str {
-    if (Str.eq(target_os(), "macos") ||
-        Str.eq(target_os(), "win32")) {
+    if (_str::eq(target_os(), "macos") ||
+        _str::eq(target_os(), "win32")) {
         ret "_";
     } else {
         ret "";
@@ -306,51 +306,51 @@ fn get_module_asm() -> str {
 
     auto glues =
         vec(decl_glue(align, prefix,
-                      abi.activate_glue_name(),
+                      abi::activate_glue_name(),
                       rust_activate_glue()),
 
             decl_glue(align, prefix,
-                      abi.yield_glue_name(),
+                      abi::yield_glue_name(),
                       rust_yield_glue()))
 
-        + Vec.init_fn[str](bind decl_native_glue(align, prefix,
-            abi.ngt_rust, _), (abi.n_native_glues + 1) as uint)
-        + Vec.init_fn[str](bind decl_native_glue(align, prefix,
-            abi.ngt_pure_rust, _), (abi.n_native_glues + 1) as uint)
-        + Vec.init_fn[str](bind decl_native_glue(align, prefix,
-            abi.ngt_cdecl, _), (abi.n_native_glues + 1) as uint);
+        + _vec::init_fn[str](bind decl_native_glue(align, prefix,
+            abi::ngt_rust, _), (abi::n_native_glues + 1) as uint)
+        + _vec::init_fn[str](bind decl_native_glue(align, prefix,
+            abi::ngt_pure_rust, _), (abi::n_native_glues + 1) as uint)
+        + _vec::init_fn[str](bind decl_native_glue(align, prefix,
+            abi::ngt_cdecl, _), (abi::n_native_glues + 1) as uint);
 
 
-    ret Str.connect(glues, "\n\n");
+    ret _str::connect(glues, "\n\n");
 }
 
 fn get_meta_sect_name() -> str {
-    if (Str.eq(target_os(), "macos")) {
+    if (_str::eq(target_os(), "macos")) {
         ret "__DATA,__note.rustc";
     }
-    if (Str.eq(target_os(), "win32")) {
+    if (_str::eq(target_os(), "win32")) {
         ret ".note.rustc";
     }
     ret ".note.rustc";
 }
 
 fn get_data_layout() -> str {
-    if (Str.eq(target_os(), "macos")) {
+    if (_str::eq(target_os(), "macos")) {
       ret "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64" +
         "-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" +
         "-n8:16:32";
     }
-    if (Str.eq(target_os(), "win32")) {
+    if (_str::eq(target_os(), "win32")) {
       ret "e-p:32:32-f64:64:64-i64:64:64-f80:32:32-n8:16:32";
     }
     ret "e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32";
 }
 
 fn get_target_triple() -> str {
-    if (Str.eq(target_os(), "macos")) {
+    if (_str::eq(target_os(), "macos")) {
         ret "i686-apple-darwin";
     }
-    if (Str.eq(target_os(), "win32")) {
+    if (_str::eq(target_os(), "win32")) {
         ret "i686-pc-mingw32";
     }
     ret "i686-unknown-linux-gnu";