Copy first batch of material from libstd to libcore.

65 files changed, 215 insertions, 192 deletions

diff --git a/src/comp/back/link.rs b/src/comp/back/link.rs
index d6cbd2aa9fa..a451d9dbacc 100644
--- a/src/comp/back/link.rs
+++ b/src/comp/back/link.rs
@@ -5,10 +5,10 @@ import front::attr;
 import middle::ty;
 import metadata::{encoder, cstore};
 import middle::trans_common::crate_ctxt;
-import std::str;
+import str;
 import std::fs;
-import std::vec;
-import std::option;
+import vec;
+import option;
 import std::run;
 import option::some;
 import option::none;
@@ -32,7 +32,7 @@ tag output_type {
 
 fn llvm_err(sess: session::session, msg: str) unsafe {
     let buf = llvm::LLVMRustGetLastError();
-    if buf == std::ptr::null() {
+    if buf == ptr::null() {
         sess.fatal(msg);
     } else { sess.fatal(msg + ": " + str::str_from_cstr(buf)); }
 }
diff --git a/src/comp/back/rpath.rs b/src/comp/back/rpath.rs
index 048459dfcbf..a3b662e243f 100644
--- a/src/comp/back/rpath.rs
+++ b/src/comp/back/rpath.rs
@@ -1,11 +1,11 @@
 import std::os;
 import std::fs;
 import std::os_fs;
-import std::vec;
+import vec;
 import std::map;
 import std::math;
-import std::str;
-import std::uint;
+import str;
+import uint;
 import metadata::cstore;
 import driver::session;
 import util::filesearch;
diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs
index 76c51e35da7..9c2fabdb565 100644
--- a/src/comp/driver/rustc.rs
+++ b/src/comp/driver/rustc.rs
@@ -10,9 +10,10 @@ import middle::{trans, resolve, freevars, kind, ty, typeck, fn_usage,
 import syntax::print::{pp, pprust};
 import util::{ppaux, filesearch};
 import back::link;
-import std::{fs, option, str, vec, int, io, getopts, result};
-import std::option::{some, none};
-import std::getopts::{optopt, optmulti, optflag, optflagopt, opt_present};
+import core::{option, str, vec, int, result};
+import std::{fs, io, getopts};
+import option::{some, none};
+import getopts::{optopt, optmulti, optflag, optflagopt, opt_present};
 import back::{x86, x86_64};
 
 tag pp_mode { ppm_normal; ppm_expanded; ppm_typed; ppm_identified; }
@@ -104,7 +105,7 @@ fn time<T>(do_it: bool, what: str, thunk: fn@() -> T) -> T {
     let rv = thunk();
     let end = std::time::precise_time_s();
     log_err #fmt["time: %s took %s s", what,
-                 std::float::to_str(end - start, 3u)];
+                 float::to_str(end - start, 3u)];
     ret rv;
 }
 
diff --git a/src/comp/driver/session.rs b/src/comp/driver/session.rs
index 9b76d855ec7..f2d19f09965 100644
--- a/src/comp/driver/session.rs
+++ b/src/comp/driver/session.rs
@@ -3,8 +3,8 @@ import syntax::{ast, codemap};
 import syntax::ast::node_id;
 import codemap::span;
 import syntax::ast::{int_ty, uint_ty, float_ty};
-import std::{option};
-import std::option::{some, none};
+import option;
+import option::{some, none};
 import syntax::parse::parser::parse_sess;
 import util::filesearch;
 import back::target_strs;
diff --git a/src/comp/front/attr.rs b/src/comp/front/attr.rs
index 86864dc450e..0f0d21f695b 100644
--- a/src/comp/front/attr.rs
+++ b/src/comp/front/attr.rs
@@ -1,6 +1,7 @@
 // Functions dealing with attributes and meta_items
 
-import std::{either, vec, map, option};
+import core::{either, vec, option};
+import std::map;
 import syntax::{ast, ast_util};
 import driver::session;
 
diff --git a/src/comp/front/config.rs b/src/comp/front/config.rs
index 955510864ea..f58f8d0b97a 100644
--- a/src/comp/front/config.rs
+++ b/src/comp/front/config.rs
@@ -1,4 +1,4 @@
-import std::{vec, option};
+import core::{vec, option};
 import syntax::{ast, fold};
 import attr;
 
diff --git a/src/comp/front/test.rs b/src/comp/front/test.rs
index d128cdfac14..4756ee0b83e 100644
--- a/src/comp/front/test.rs
+++ b/src/comp/front/test.rs
@@ -1,6 +1,6 @@
 // Code that generates a test runner to run all the tests in a crate
 
-import std::{option, vec};
+import core::{option, vec};
 import syntax::{ast, ast_util};
 import syntax::ast_util::*;
 //import syntax::ast_util::dummy_sp;
diff --git a/src/comp/lib/llvm.rs b/src/comp/lib/llvm.rs
index 21c09d8ef42..9ff014699ab 100644
--- a/src/comp/lib/llvm.rs
+++ b/src/comp/lib/llvm.rs
@@ -1,5 +1,5 @@
-import std::{vec, str, option};
-import std::str::sbuf;
+import core::{vec, str, option};
+import str::sbuf;
 
 import llvm::{TypeRef, MemoryBufferRef,
               PassManagerRef, TargetDataRef,
@@ -960,7 +960,7 @@ fn type_to_str_inner(names: type_names, outer0: [TypeRef], ty: TypeRef) ->
       5 { ret "PPC_FP128"; }
       6 { ret "Label"; }
       7 {
-        ret "i" + std::int::str(llvm::LLVMGetIntTypeWidth(ty) as int);
+        ret "i" + int::str(llvm::LLVMGetIntTypeWidth(ty) as int);
       }
       8 {
         let s = "fn(";
@@ -996,7 +996,7 @@ fn type_to_str_inner(names: type_names, outer0: [TypeRef], ty: TypeRef) ->
             i += 1u;
             if tout as int == ty as int {
                 let n: uint = vec::len::<TypeRef>(outer0) - i;
-                ret "*\\" + std::int::str(n as int);
+                ret "*\\" + int::str(n as int);
             }
         }
         ret "*" +
diff --git a/src/comp/metadata/common.rs b/src/comp/metadata/common.rs
index 8002fddf3c9..60b1236398e 100644
--- a/src/comp/metadata/common.rs
+++ b/src/comp/metadata/common.rs
@@ -1,6 +1,6 @@
 // EBML tag definitions and utils shared by the encoder and decoder
 
-import std::str;
+import str;
 
 const tag_paths: uint = 0x01u;
 
diff --git a/src/comp/metadata/creader.rs b/src/comp/metadata/creader.rs
index b94110acb31..34da777a864 100644
--- a/src/comp/metadata/creader.rs
+++ b/src/comp/metadata/creader.rs
@@ -7,8 +7,9 @@ import front::attr;
 import syntax::visit;
 import syntax::codemap::span;
 import util::{filesearch};
-import std::{either, vec, str, fs, io, option};
-import std::option::{none, some};
+import core::{either, vec, str, option};
+import std::{io, fs};
+import option::{none, some};
 import std::map::{hashmap, new_int_hash};
 import syntax::print::pprust;
 import common::*;
@@ -206,7 +207,7 @@ fn get_metadata_section(sess: session::session,
             let cbuf = llvm::LLVMGetSectionContents(si.llsi);
             let csz = llvm::LLVMGetSectionSize(si.llsi);
             unsafe {
-                let cvbuf: *u8 = std::unsafe::reinterpret_cast(cbuf);
+                let cvbuf: *u8 = unsafe::reinterpret_cast(cbuf);
                 ret option::some::<@[u8]>(@vec::unsafe::from_buf(cvbuf, csz));
             }
         }
diff --git a/src/comp/metadata/csearch.rs b/src/comp/metadata/csearch.rs
index 603d125e93c..48b9774db51 100644
--- a/src/comp/metadata/csearch.rs
+++ b/src/comp/metadata/csearch.rs
@@ -2,7 +2,7 @@
 
 import syntax::ast;
 import middle::ty;
-import std::option;
+import option;
 import driver::session;
 
 export get_symbol;
diff --git a/src/comp/metadata/cstore.rs b/src/comp/metadata/cstore.rs
index e7ca671fea8..de74591c814 100644
--- a/src/comp/metadata/cstore.rs
+++ b/src/comp/metadata/cstore.rs
@@ -1,7 +1,8 @@
 // The crate store - a central repo for information collected about external
 // crates and libraries
 
-import std::{vec, map, str};
+import core::{vec, str};
+import std::map;
 import syntax::ast;
 
 export cstore;
diff --git a/src/comp/metadata/decoder.rs b/src/comp/metadata/decoder.rs
index 541b7c32635..bd8c02d0cb7 100644
--- a/src/comp/metadata/decoder.rs
+++ b/src/comp/metadata/decoder.rs
@@ -1,6 +1,7 @@
 // Decoding metadata from a single crate's metadata
 
-import std::{ebml, vec, option, str, io};
+import core::{vec, option, str};
+import std::{ebml, io};
 import syntax::{ast, ast_util};
 import front::attr;
 import middle::ty;
diff --git a/src/comp/metadata/encoder.rs b/src/comp/metadata/encoder.rs
index 646c016d97d..150c241ff60 100644
--- a/src/comp/metadata/encoder.rs
+++ b/src/comp/metadata/encoder.rs
@@ -1,6 +1,7 @@
 // Metadata encoding
 
-import std::{vec, str, uint, io, ebml, map};
+import core::{vec, str, uint};
+import std::{io, ebml, map};
 import syntax::ast::*;
 import syntax::ast_util;
 import syntax::ast_util::local_def;
diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs
index 3b71e09c1f7..0bf44376b63 100644
--- a/src/comp/metadata/tydecode.rs
+++ b/src/comp/metadata/tydecode.rs
@@ -1,7 +1,7 @@
 // Type decoding
 
-import std::{vec, str, uint};
-import std::option::{none, some};
+import core::{vec, str, uint};
+import option::{none, some};
 import syntax::ast;
 import syntax::ast::*;
 import syntax::ast_util;
diff --git a/src/comp/metadata/tyencode.rs b/src/comp/metadata/tyencode.rs
index dafae567244..9fb37e4f4bf 100644
--- a/src/comp/metadata/tyencode.rs
+++ b/src/comp/metadata/tyencode.rs
@@ -1,8 +1,9 @@
 // Type encoding
 
-import std::{io, int, uint};
+import core::{int, uint};
+import std::io;
 import std::map::hashmap;
-import std::option::{some, none};
+import option::{some, none};
 import syntax::ast::*;
 import middle::ty;
 import syntax::print::pprust::*;
diff --git a/src/comp/middle/alias.rs b/src/comp/middle/alias.rs
index 3d081c143f3..6600bf566af 100644
--- a/src/comp/middle/alias.rs
+++ b/src/comp/middle/alias.rs
@@ -4,8 +4,9 @@ import ast::{ident, fn_ident, node_id};
 import syntax::codemap::span;
 import syntax::visit;
 import visit::vt;
-import std::{vec, option, list};
-import std::option::{some, none, is_none};
+import core::{vec, option};
+import std::list;
+import option::{some, none, is_none};
 import list::list;
 
 // This is not an alias-analyser (though it would merit from becoming one, or
diff --git a/src/comp/middle/ast_map.rs b/src/comp/middle/ast_map.rs
index af4a5272246..a86208dd8c6 100644
--- a/src/comp/middle/ast_map.rs
+++ b/src/comp/middle/ast_map.rs
@@ -1,4 +1,5 @@
-import std::{smallintmap, option};
+import option;
+import std::smallintmap;
 import syntax::ast::*;
 import syntax::ast_util;
 import syntax::{visit, codemap};
diff --git a/src/comp/middle/check_alt.rs b/src/comp/middle/check_alt.rs
index 8e83105199a..0783504b682 100644
--- a/src/comp/middle/check_alt.rs
+++ b/src/comp/middle/check_alt.rs
@@ -2,7 +2,7 @@ import syntax::ast::*;
 import syntax::ast_util::{variant_def_ids, dummy_sp, compare_lit_exprs,
                           lit_expr_eq};
 import syntax::visit;
-import std::option::{some, none};
+import option::{some, none};
 
 fn check_crate(tcx: ty::ctxt, crate: @crate) {
     let v =
@@ -25,7 +25,7 @@ fn check_arms(tcx: ty::ctxt, arms: [arm]) {
             let reachable = true;
             let j = 0;
             while j < i {
-                if std::option::is_none(arms[j].guard) {
+                if option::is_none(arms[j].guard) {
                     for prev_pat: @pat in arms[j].pats {
                         if pattern_supersedes(tcx, prev_pat, arm_pat) {
                             reachable = false;
@@ -149,7 +149,7 @@ fn is_refutable(tcx: ty::ctxt, pat: @pat) -> bool {
       }
       pat_tag(_, args) {
         let vdef = variant_def_ids(tcx.def_map.get(pat.id));
-        if std::vec::len(ty::tag_variants(tcx, vdef.tg)) != 1u { ret true; }
+        if vec::len(ty::tag_variants(tcx, vdef.tg)) != 1u { ret true; }
         for p: @pat in args { if is_refutable(tcx, p) { ret true; } }
         false
       }
diff --git a/src/comp/middle/fn_usage.rs b/src/comp/middle/fn_usage.rs
index d09ba0b9fba..1bf9533f080 100644
--- a/src/comp/middle/fn_usage.rs
+++ b/src/comp/middle/fn_usage.rs
@@ -1,6 +1,6 @@
 import syntax::ast;
 import syntax::visit;
-import std::option::some;
+import option::some;
 import syntax::print::pprust::expr_to_str;
 
 export check_crate_fn_usage;
diff --git a/src/comp/middle/freevars.rs b/src/comp/middle/freevars.rs
index b645ad36d96..decdc220d16 100644
--- a/src/comp/middle/freevars.rs
+++ b/src/comp/middle/freevars.rs
@@ -1,9 +1,9 @@
 // A pass that annotates for each loops and functions with the free
 // variables that they contain.
 
-import std::{int};
+import int;
 import std::map::*;
-import std::option::*;
+import option::*;
 import syntax::{ast, ast_util, visit};
 import middle::resolve;
 import syntax::codemap::span;
@@ -101,7 +101,7 @@ fn get_freevars(tcx: ty::ctxt, fid: ast::node_id) -> freevar_info {
     }
 }
 fn has_freevars(tcx: ty::ctxt, fid: ast::node_id) -> bool {
-    ret std::vec::len(*get_freevars(tcx, fid)) != 0u;
+    ret vec::len(*get_freevars(tcx, fid)) != 0u;
 }
 
 // Local Variables:
diff --git a/src/comp/middle/gc.rs b/src/comp/middle/gc.rs
index c14ef93f362..f98bd259d4d 100644
--- a/src/comp/middle/gc.rs
+++ b/src/comp/middle/gc.rs
@@ -6,8 +6,8 @@ import middle::trans;
 import middle::trans::{get_tydesc, tps_normal};
 import middle::trans_common::*;
 import middle::ty;
-import std::option::none;
-import std::str;
+import option::none;
+import str;
 
 import lll = lib::llvm::llvm;
 import bld = trans_build;
diff --git a/src/comp/middle/kind.rs b/src/comp/middle/kind.rs
index 32f24913286..d771ba65faf 100644
--- a/src/comp/middle/kind.rs
+++ b/src/comp/middle/kind.rs
@@ -1,4 +1,4 @@
-import std::option::{some, none};
+import option::{some, none};
 import syntax::{visit, ast_util};
 import syntax::ast::*;
 import syntax::codemap::span;
@@ -64,7 +64,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
             let t = ty::expr_ty(cx.tcx, ex);
             let ty_fields = alt ty::struct(cx.tcx, t) { ty::ty_rec(f) { f } };
             for tf in ty_fields {
-                if !std::vec::any({|f| f.node.ident == tf.ident}, fields) &&
+                if !vec::any({|f| f.node.ident == tf.ident}, fields) &&
                    ty::type_kind(cx.tcx, tf.mt.ty) == kind_noncopyable {
                     cx.tcx.sess.span_err(ex.span,
                                          "copying a noncopyable value");
diff --git a/src/comp/middle/last_use.rs b/src/comp/middle/last_use.rs
index 0a78a5fb0cd..fac179f386f 100644
--- a/src/comp/middle/last_use.rs
+++ b/src/comp/middle/last_use.rs
@@ -1,7 +1,8 @@
 import syntax::{visit, ast_util};
 import syntax::ast::*;
 import std::list::{list, nil, cons, tail};
-import std::{vec, list, option};
+import core::{vec, option};
+import std::list;
 
 // Last use analysis pass.
 //
diff --git a/src/comp/middle/mut.rs b/src/comp/middle/mut.rs
index 63dadd347e1..adf6fe3e0ee 100644
--- a/src/comp/middle/mut.rs
+++ b/src/comp/middle/mut.rs
@@ -1,4 +1,4 @@
-import std::{vec, str, option};
+import core::{vec, str, option};
 import option::{some, none};
 import syntax::ast::*;
 import syntax::visit;
diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs
index 84f7007f2e4..1fe94a14345 100644
--- a/src/comp/middle/resolve.rs
+++ b/src/comp/middle/resolve.rs
@@ -11,10 +11,11 @@ import std::map::{new_int_hash, new_str_hash};
 import syntax::codemap::span;
 import syntax::visit;
 import visit::vt;
-import std::{vec, list, option, str};
+import core::{vec, option, str};
+import std::list;
 import std::map::hashmap;
 import std::list::{list, nil, cons};
-import std::option::{some, none, is_none};
+import option::{some, none, is_none};
 import syntax::print::pprust::*;
 
 export resolve_crate;
diff --git a/src/comp/middle/shape.rs b/src/comp/middle/shape.rs
index 6bf91384cbb..a84b9095a82 100644
--- a/src/comp/middle/shape.rs
+++ b/src/comp/middle/shape.rs
@@ -14,9 +14,9 @@ import syntax::ast_util::dummy_sp;
 import syntax::util::interner;
 import util::common;
 
-import std::{vec, str};
+import core::{vec, str};
 import std::map::hashmap;
-import std::option::{none, some};
+import option::{none, some};
 
 import ty_ctxt = middle::ty::ctxt;
 
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index fcae4dd45bf..69f232045f2 100644
--- a/src/comp/middle/trans.rs
+++ b/src/comp/middle/trans.rs
@@ -12,10 +12,12 @@
 //     pcwalton).  You can, instead, find out its TypeRef by calling val_ty,
 //     but many TypeRefs correspond to one ty::t; for instance, tup(int, int,
 //     int) and rec(x=int, y=int, z=int) will have the same TypeRef.
-import std::{either, str, uint, map, option, time, vec};
+
+import core::{either, str, uint, option, vec};
+import std::{map, time};
 import std::map::hashmap;
 import std::map::{new_int_hash, new_str_hash};
-import std::option::{some, none};
+import option::{some, none};
 import driver::session;
 import front::attr;
 import middle::{ty, gc};
@@ -205,7 +207,7 @@ fn type_of_inner(cx: @crate_ctxt, sp: span, t: ty::t)
 
 fn type_of_tag(cx: @crate_ctxt, sp: span, did: ast::def_id, t: ty::t)
     -> TypeRef {
-    let degen = std::vec::len(ty::tag_variants(cx.tcx, did)) == 1u;
+    let degen = vec::len(ty::tag_variants(cx.tcx, did)) == 1u;
     if check type_has_static_size(cx, t) {
         let size = static_size_of_tag(cx, sp, t);
         if !degen { T_tag(cx, size) }
@@ -225,7 +227,7 @@ fn type_of_ty_param_kinds_and_ty(lcx: @local_ctxt, sp: span,
     alt ty::struct(cx.tcx, t) {
       ty::ty_fn(_, _, _, _, _) | ty::ty_native_fn(_, _) {
         check returns_non_ty_var(cx, t);
-        ret type_of_fn_from_ty(cx, sp, t, std::vec::len(tpt.kinds));
+        ret type_of_fn_from_ty(cx, sp, t, vec::len(tpt.kinds));
       }
       _ {
         // fall through
@@ -328,7 +330,7 @@ fn get_simple_extern_fn(cx: @block_ctxt,
                         llmod: ModuleRef,
                         name: str, n_args: int) -> ValueRef {
     let ccx = cx.fcx.lcx.ccx;
-    let inputs = std::vec::init_elt::<TypeRef>(ccx.int_type, n_args as uint);
+    let inputs = vec::init_elt::<TypeRef>(ccx.int_type, n_args as uint);
     let output = ccx.int_type;
     let t = T_fn(inputs, output);
     ret get_extern_fn(externs, llmod, name, lib::llvm::LLVMCCallConv, t);
@@ -337,7 +339,7 @@ fn get_simple_extern_fn(cx: @block_ctxt,
 fn trans_native_call(cx: @block_ctxt, externs: hashmap<str, ValueRef>,
                      llmod: ModuleRef, name: str, args: [ValueRef]) ->
    ValueRef {
-    let n: int = std::vec::len::<ValueRef>(args) as int;
+    let n: int = vec::len::<ValueRef>(args) as int;
     let llnative: ValueRef =
         get_simple_extern_fn(cx, externs, llmod, name, n);
     let call_args: [ValueRef] = [];
@@ -600,7 +602,7 @@ fn dynamic_size_of(cx: @block_ctxt, t: ty::t, mode: align_mode) -> result {
         }
         let max_size_val = Load(bcx, max_size);
         let total_size =
-            if std::vec::len(variants) != 1u {
+            if vec::len(variants) != 1u {
                 Add(bcx, max_size_val, llsize_of(ccx, ccx.int_type))
             } else { max_size_val };
         ret rslt(bcx, total_size);
@@ -693,7 +695,7 @@ fn GEP_tup_like(cx: @block_ctxt, t: ty::t, base: ValueRef, ixs: [int])
 
     fn split_type(ccx: @crate_ctxt, t: ty::t, ixs: [int], n: uint) ->
        {prefix: [ty::t], target: ty::t} {
-        let len: uint = std::vec::len::<int>(ixs);
+        let len: uint = vec::len::<int>(ixs);
         // We don't support 0-index or 1-index GEPs: The former is nonsense
         // and the latter would only be meaningful if we supported non-0
         // values for the 0th index (we don't).
@@ -972,8 +974,8 @@ fn get_derived_tydesc(cx: @block_ctxt, t: ty::t, escapes: bool,
     // promising to do so itself.
     let n_params = ty::count_ty_params(bcx_tcx(bcx), t);
 
-    assert (n_params == std::vec::len::<uint>(tys.params));
-    assert (n_params == std::vec::len::<ValueRef>(tys.descs));
+    assert (n_params == vec::len::<uint>(tys.params));
+    assert (n_params == vec::len::<ValueRef>(tys.descs));
 
     let llparamtydescs =
         alloca(bcx, T_array(T_ptr(bcx_ccx(bcx).tydesc_type), n_params + 1u));
@@ -1042,7 +1044,7 @@ fn get_tydesc(cx: @block_ctxt, orig_t: ty::t, escapes: bool,
                                           "orig_t = " +
                                           ty_to_str(bcx_tcx(cx), orig_t) +
                                           " ty_param = " +
-                                          std::uint::str(id));
+                                          uint::str(id));
         }
       }
       none. {/* fall through */ }
@@ -1192,7 +1194,7 @@ fn make_generic_glue_inner(cx: @local_ctxt, sp: span, t: ty::t,
             T_ptr(type_of(ccx, sp, t))
         } else { T_ptr(T_i8()) };
 
-    let ty_param_count = std::vec::len::<uint>(ty_params);
+    let ty_param_count = vec::len::<uint>(ty_params);
     let lltyparams = llvm::LLVMGetParam(llfn, 2u);
     let load_env_bcx = new_raw_block_ctxt(fcx, fcx.llloadenv);
     let lltydescs = [mutable];
@@ -1200,7 +1202,7 @@ fn make_generic_glue_inner(cx: @local_ctxt, sp: span, t: ty::t,
     while p < ty_param_count {
         let llparam = GEPi(load_env_bcx, lltyparams, [p as int]);
         llparam = Load(load_env_bcx, llparam);
-        std::vec::grow_set(lltydescs, ty_params[p], 0 as ValueRef, llparam);
+        vec::grow_set(lltydescs, ty_params[p], 0 as ValueRef, llparam);
         p += 1u;
     }
 
@@ -1453,7 +1455,7 @@ fn trans_res_drop(cx: @block_ctxt, rs: ValueRef, did: ast::def_id,
     // for type variables.
     let val_llty = lib::llvm::fn_ty_param_tys
         (llvm::LLVMGetElementType
-         (llvm::LLVMTypeOf(dtor_addr)))[std::vec::len(args)];
+         (llvm::LLVMTypeOf(dtor_addr)))[vec::len(args)];
     let val_cast = BitCast(cx, val.val, val_llty);
     Call(cx, dtor_addr, args + [val_cast]);
 
@@ -1608,7 +1610,7 @@ fn iter_structural_ty(cx: @block_ctxt, av: ValueRef, t: ty::t,
     fn iter_variant(cx: @block_ctxt, a_tup: ValueRef,
                     variant: ty::variant_info, tps: [ty::t], tid: ast::def_id,
                     f: val_and_ty_fn) -> @block_ctxt {
-        if std::vec::len::<ty::t>(variant.args) == 0u { ret cx; }
+        if vec::len::<ty::t>(variant.args) == 0u { ret cx; }
         let fn_ty = variant.ctor_ty;
         let ccx = bcx_ccx(cx);
         let cx = cx;
@@ -1667,7 +1669,7 @@ fn iter_structural_ty(cx: @block_ctxt, av: ValueRef, t: ty::t,
       }
       ty::ty_tag(tid, tps) {
         let variants = ty::tag_variants(bcx_tcx(cx), tid);
-        let n_variants = std::vec::len(variants);
+        let n_variants = vec::len(variants);
 
         // Cast the tags to types we can GEP into.
         if n_variants == 1u {
@@ -2351,8 +2353,8 @@ fn autoderef(cx: @block_ctxt, v: ValueRef, t: ty::t) -> result_t {
           }
           ty::ty_tag(did, tps) {
             let variants = ty::tag_variants(ccx.tcx, did);
-            if std::vec::len(variants) != 1u ||
-                   std::vec::len(variants[0].args) != 1u {
+            if vec::len(variants) != 1u ||
+                   vec::len(variants[0].args) != 1u {
                 break;
             }
             t1 =
@@ -2580,9 +2582,9 @@ fn build_environment(bcx: @block_ctxt, lltydescs: [ValueRef],
 
     // Make a vector that contains ty_param_count copies of tydesc_ty.
     // (We'll need room for that many tydescs in the closure.)
-    let ty_param_count = std::vec::len(lltydescs);
+    let ty_param_count = vec::len(lltydescs);
     let tydesc_ty: ty::t = ty::mk_type(tcx);
-    let captured_tys: [ty::t] = std::vec::init_elt(tydesc_ty, ty_param_count);
+    let captured_tys: [ty::t] = vec::init_elt(tydesc_ty, ty_param_count);
 
     // Get all the types we've got (some of which we synthesized
     // ourselves) into a vector.  The whole things ends up looking
@@ -2746,7 +2748,7 @@ fn load_environment(enclosing_cx: @block_ctxt, fcx: @fn_ctxt, envty: ty::t,
     // Populate the type parameters from the environment. We need to
     // do this first because the tydescs are needed to index into
     // the bindings if they are dynamically sized.
-    let tydesc_count = std::vec::len(enclosing_cx.fcx.lltydescs);
+    let tydesc_count = vec::len(enclosing_cx.fcx.lltydescs);
     let lltydescs = find_environment_tydescs(bcx, envty, llclosure);
     let i = 0u;
     while i < tydesc_count {
@@ -2854,7 +2856,7 @@ fn lval_static_fn(bcx: @block_ctxt, tpt: ty::ty_param_kinds_and_ty,
     };
     let tys = ty::node_id_to_type_params(bcx_tcx(bcx), id);
     let gen = none, bcx = bcx;
-    if std::vec::len::<ty::t>(tys) != 0u {
+    if vec::len::<ty::t>(tys) != 0u {
         let tydescs = [], tis = [];
         for t in tys {
             // TODO: Doesn't always escape.
@@ -2950,7 +2952,7 @@ fn trans_var(cx: @block_ctxt, sp: span, def: ast::def, id: ast::node_id)
             let bcx = alloc_result.bcx;
             let lltagptr = PointerCast(bcx, lltagblob, T_ptr(lltagty));
             let lldiscrimptr = GEPi(bcx, lltagptr, [0, 0]);
-            let d = if std::vec::len(ty::tag_variants(ccx.tcx, tid)) != 1u {
+            let d = if vec::len(ty::tag_variants(ccx.tcx, tid)) != 1u {
                 let lldiscrim_gv = lookup_discriminant(bcx.fcx.lcx, vid);
                 let lldiscrim = Load(bcx, lldiscrim_gv);
                 lldiscrim
@@ -3166,8 +3168,8 @@ fn maybe_add_env(bcx: @block_ctxt, c: lval_maybe_callee)
 fn lval_maybe_callee_to_lval(c: lval_maybe_callee, ty: ty::t) -> lval_result {
     alt c.generic {
       some(gi) {
-        let n_args = std::vec::len(ty::ty_fn_args(bcx_tcx(c.bcx), ty));
-        let args = std::vec::init_elt(none::<@ast::expr>, n_args);
+        let n_args = vec::len(ty::ty_fn_args(bcx_tcx(c.bcx), ty));
+        let args = vec::init_elt(none::<@ast::expr>, n_args);
         let space = alloc_ty(c.bcx, ty);
         let bcx = trans_bind_1(space.bcx, ty, c, args, ty,
                                save_in(space.val));
@@ -3490,8 +3492,8 @@ fn trans_bind_1(cx: @block_ctxt, outgoing_fty: ty::t,
       }
     }
 
-    let ty_param_count = std::vec::len(lltydescs);
-    if std::vec::len(bound) == 0u && ty_param_count == 0u {
+    let ty_param_count = vec::len(lltydescs);
+    if vec::len(bound) == 0u && ty_param_count == 0u {
         // Trivial 'binding': just return the closure
         let lv = lval_maybe_callee_to_lval(f_res, pair_ty);
         bcx = lv.bcx;
@@ -4598,9 +4600,9 @@ fn trans_block_cleanups(bcx: @block_ctxt, cleanup_cx: @block_ctxt) ->
    @block_ctxt {
     if bcx.unreachable { ret bcx; }
     if cleanup_cx.kind == NON_SCOPE_BLOCK {
-        assert (std::vec::len::<cleanup>(cleanup_cx.cleanups) == 0u);
+        assert (vec::len::<cleanup>(cleanup_cx.cleanups) == 0u);
     }
-    let i = std::vec::len::<cleanup>(cleanup_cx.cleanups), bcx = bcx;
+    let i = vec::len::<cleanup>(cleanup_cx.cleanups), bcx = bcx;
     while i > 0u {
         i -= 1u;
         let c = cleanup_cx.cleanups[i];
@@ -4913,7 +4915,7 @@ fn populate_fn_ctxt_from_llself(fcx: @fn_ctxt, llself: val_self_pair) {
     // its magic.
 
     let fields_tup_ty = ty::mk_tup(fcx.lcx.ccx.tcx, field_tys);
-    let n_typarams = std::vec::len::<ast::ty_param>(bcx.fcx.lcx.obj_typarams);
+    let n_typarams = vec::len::<ast::ty_param>(bcx.fcx.lcx.obj_typarams);
     let llobj_box_ty: TypeRef = T_obj_ptr(ccx, n_typarams);
     let box_cell = GEPi(bcx, llself.v, [0, abi::obj_field_box]);
     let box_ptr = Load(bcx, box_cell);
@@ -5073,7 +5075,7 @@ fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id,
                      ty_params: [ast::ty_param]) {
     let ccx = cx.ccx;
 
-    if std::vec::len::<ast::variant_arg>(variant.node.args) == 0u {
+    if vec::len::<ast::variant_arg>(variant.node.args) == 0u {
         ret; // nullary constructors are just constants
 
     }
@@ -5474,7 +5476,7 @@ fn trans_item(cx: @local_ctxt, item: ast::item) {
       }
       ast::item_tag(variants, tps) {
         let sub_cx = extend_path(cx, item.ident);
-        let degen = std::vec::len(variants) == 1u;
+        let degen = vec::len(variants) == 1u;
         let i = 0;
         for variant: ast::variant in variants {
             trans_tag_variant(sub_cx, item.id, variant, i, degen, tps);
@@ -5522,7 +5524,7 @@ fn register_fn_full(ccx: @crate_ctxt, sp: span, path: [str], _flav: str,
     : returns_non_ty_var(ccx, node_type) {
     let path = path;
     let llfty =
-        type_of_fn_from_ty(ccx, sp, node_type, std::vec::len(ty_params));
+        type_of_fn_from_ty(ccx, sp, node_type, vec::len(ty_params));
     let ps: str = mangle_exported_name(ccx, path, node_type);
     let llfn: ValueRef = decl_cdecl_fn(ccx.llmod, ps, llfty);
     ccx.item_ids.insert(node_id, llfn);
@@ -5543,7 +5545,7 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef,
 
     let main_takes_argv =
         alt ty::struct(ccx.tcx, main_node_type) {
-          ty::ty_fn(_, args, _, _, _) { std::vec::len(args) != 0u }
+          ty::ty_fn(_, args, _, _, _) { vec::len(args) != 0u }
         };
 
     let llfn = create_main(ccx, sp, main_llfn, main_takes_argv);
@@ -5645,7 +5647,7 @@ fn native_fn_ty_param_count(cx: @crate_ctxt, id: ast::node_id) -> uint {
                         actually a fn");
       }
       ast::native_item_fn(_, tps) {
-        count = std::vec::len::<ast::ty_param>(tps);
+        count = vec::len::<ast::ty_param>(tps);
       }
     }
     ret count;
@@ -5812,7 +5814,7 @@ fn collect_tag_ctor(ccx: @crate_ctxt, i: @ast::item, &&pt: [str],
     alt i.node {
       ast::item_tag(variants, tps) {
         for variant: ast::variant in variants {
-            if std::vec::len(variant.node.args) != 0u {
+            if vec::len(variant.node.args) != 0u {
                 register_fn(ccx, i.span, new_pt + [variant.node.name],
                             "tag", tps, variant.node.id);
             }
@@ -5838,7 +5840,7 @@ fn trans_constant(ccx: @crate_ctxt, it: @ast::item, &&pt: [str],
     alt it.node {
       ast::item_tag(variants, _) {
         let i = 0u;
-        let n_variants = std::vec::len::<ast::variant>(variants);
+        let n_variants = vec::len::<ast::variant>(variants);
         while i < n_variants {
             let variant = variants[i];
             let p = new_pt + [it.ident, variant.node.name, "discrim"];
diff --git a/src/comp/middle/trans_alt.rs b/src/comp/middle/trans_alt.rs
index 3b729a819e3..8ca7adcfe26 100644
--- a/src/comp/middle/trans_alt.rs
+++ b/src/comp/middle/trans_alt.rs
@@ -1,4 +1,4 @@
-import std::{str, vec, option};
+import core::{str, vec, option};
 import option::{some, none};
 
 import lib::llvm::llvm;
diff --git a/src/comp/middle/trans_build.rs b/src/comp/middle/trans_build.rs
index b7756b0902d..210626deffb 100644
--- a/src/comp/middle/trans_build.rs
+++ b/src/comp/middle/trans_build.rs
@@ -1,5 +1,5 @@
-import std::{vec, str};
-import std::str::sbuf;
+import core::{vec, str};
+import str::sbuf;
 import lib::llvm::llvm;
 import syntax::codemap::span;
 import llvm::{ValueRef, TypeRef, BasicBlockRef, BuilderRef, Opcode,
@@ -84,7 +84,7 @@ fn IndirectBr(cx: @block_ctxt, Addr: ValueRef, NumDests: uint) {
 // lot more efficient) than doing str::as_buf("", ...) every time.
 fn noname() -> sbuf unsafe {
     const cnull: uint = 0u;
-    ret std::unsafe::reinterpret_cast(std::ptr::addr_of(cnull));
+    ret unsafe::reinterpret_cast(ptr::addr_of(cnull));
 }
 
 fn Invoke(cx: @block_ctxt, Fn: ValueRef, Args: [ValueRef],
@@ -491,8 +491,8 @@ fn Phi(cx: @block_ctxt, Ty: TypeRef, vals: [ValueRef], bbs: [BasicBlockRef])
 fn AddIncomingToPhi(phi: ValueRef, val: ValueRef, bb: BasicBlockRef) {
     if llvm::LLVMIsUndef(phi) == lib::llvm::True { ret; }
     unsafe {
-        let valptr = std::unsafe::reinterpret_cast(std::ptr::addr_of(val));
-        let bbptr = std::unsafe::reinterpret_cast(std::ptr::addr_of(bb));
+        let valptr = unsafe::reinterpret_cast(ptr::addr_of(val));
+        let bbptr = unsafe::reinterpret_cast(ptr::addr_of(bb));
         llvm::LLVMAddIncoming(phi, valptr, bbptr, 1u);
     }
 }
diff --git a/src/comp/middle/trans_common.rs b/src/comp/middle/trans_common.rs
index 703aa9fcd77..5cad1197b1d 100644
--- a/src/comp/middle/trans_common.rs
+++ b/src/comp/middle/trans_common.rs
@@ -3,10 +3,10 @@
 
 */
 
-import std::{int, vec, str, uint, option, unsafe};
-import std::vec::to_ptr;
+import core::{int, vec, str, uint, option, unsafe};
+import vec::to_ptr;
 import std::map::hashmap;
-import std::option::some;
+import option::some;
 import syntax::ast;
 import driver::session;
 import middle::ty;
@@ -301,9 +301,9 @@ fn revoke_clean(cx: @block_ctxt, val: ValueRef) {
     if found == -1 { ret; }
     // We found the cleanup and remove it
     sc_cx.cleanups =
-        std::vec::slice(sc_cx.cleanups, 0u, found as uint) +
-            std::vec::slice(sc_cx.cleanups, (found as uint) + 1u,
-                            std::vec::len(sc_cx.cleanups));
+        vec::slice(sc_cx.cleanups, 0u, found as uint) +
+            vec::slice(sc_cx.cleanups, (found as uint) + 1u,
+                            vec::len(sc_cx.cleanups));
     sc_cx.lpad_dirty = true;
     ret;
 }
@@ -411,7 +411,7 @@ fn val_str(tn: type_names, v: ValueRef) -> str { ret ty_str(tn, val_ty(v)); }
 fn struct_elt(llstructty: TypeRef, n: uint) -> TypeRef unsafe {
     let elt_count = llvm::LLVMCountStructElementTypes(llstructty);
     assert (n < elt_count);
-    let elt_tys = std::vec::init_elt(T_nil(), elt_count);
+    let elt_tys = vec::init_elt(T_nil(), elt_count);
     llvm::LLVMGetStructElementTypes(llstructty, to_ptr(elt_tys));
     ret llvm::LLVMGetElementType(elt_tys[n]);
 }
@@ -531,7 +531,7 @@ fn T_size_t(targ_cfg: @session::config) -> TypeRef {
 fn T_fn(inputs: [TypeRef], output: TypeRef) -> TypeRef {
     unsafe {
         ret llvm::LLVMFunctionType(output, to_ptr(inputs),
-                                   std::vec::len::<TypeRef>(inputs), False);
+                                   vec::len::<TypeRef>(inputs), False);
     }
 }
 
@@ -543,7 +543,7 @@ fn T_ptr(t: TypeRef) -> TypeRef { ret llvm::LLVMPointerType(t, 0u); }
 
 fn T_struct(elts: [TypeRef]) -> TypeRef {
     unsafe {
-        ret llvm::LLVMStructType(to_ptr(elts), std::vec::len(elts), False);
+        ret llvm::LLVMStructType(to_ptr(elts), vec::len(elts), False);
     }
 }
 
@@ -553,7 +553,7 @@ fn T_named_struct(name: str) -> TypeRef {
 }
 
 fn set_struct_body(t: TypeRef, elts: [TypeRef]) unsafe {
-    llvm::LLVMStructSetBody(t, to_ptr(elts), std::vec::len(elts), False);
+    llvm::LLVMStructSetBody(t, to_ptr(elts), vec::len(elts), False);
 }
 
 fn T_empty_struct() -> TypeRef { ret T_struct([]); }
@@ -595,7 +595,7 @@ fn T_tydesc_field(cx: @crate_ctxt, field: int) -> TypeRef unsafe {
     // Bit of a kludge: pick the fn typeref out of the tydesc..
 
     let tydesc_elts: [TypeRef] =
-        std::vec::init_elt::<TypeRef>(T_nil(),
+        vec::init_elt::<TypeRef>(T_nil(),
                                       abi::n_tydesc_fields as uint);
     llvm::LLVMGetStructElementTypes(cx.tydesc_type,
                                     to_ptr::<TypeRef>(tydesc_elts));
@@ -733,7 +733,7 @@ fn T_opaque_tag_ptr(cx: @crate_ctxt) -> TypeRef {
 }
 
 fn T_captured_tydescs(cx: @crate_ctxt, n: uint) -> TypeRef {
-    ret T_struct(std::vec::init_elt::<TypeRef>(T_ptr(cx.tydesc_type), n));
+    ret T_struct(vec::init_elt::<TypeRef>(T_ptr(cx.tydesc_type), n));
 }
 
 fn T_obj_ptr(cx: @crate_ctxt, n_captured_tydescs: uint) -> TypeRef {
@@ -823,23 +823,23 @@ fn C_zero_byte_arr(size: uint) -> ValueRef unsafe {
     let i = 0u;
     let elts: [ValueRef] = [];
     while i < size { elts += [C_u8(0u)]; i += 1u; }
-    ret llvm::LLVMConstArray(T_i8(), std::vec::to_ptr(elts),
-                             std::vec::len(elts));
+    ret llvm::LLVMConstArray(T_i8(), vec::to_ptr(elts),
+                             vec::len(elts));
 }
 
 fn C_struct(elts: [ValueRef]) -> ValueRef unsafe {
-    ret llvm::LLVMConstStruct(std::vec::to_ptr(elts), std::vec::len(elts),
+    ret llvm::LLVMConstStruct(vec::to_ptr(elts), vec::len(elts),
                               False);
 }
 
 fn C_named_struct(T: TypeRef, elts: [ValueRef]) -> ValueRef unsafe {
-    ret llvm::LLVMConstNamedStruct(T, std::vec::to_ptr(elts),
-                                   std::vec::len(elts));
+    ret llvm::LLVMConstNamedStruct(T, vec::to_ptr(elts),
+                                   vec::len(elts));
 }
 
 fn C_array(ty: TypeRef, elts: [ValueRef]) -> ValueRef unsafe {
-    ret llvm::LLVMConstArray(ty, std::vec::to_ptr(elts),
-                             std::vec::len(elts));
+    ret llvm::LLVMConstArray(ty, vec::to_ptr(elts),
+                             vec::len(elts));
 }
 
 fn C_bytes(bytes: [u8]) -> ValueRef unsafe {
diff --git a/src/comp/middle/trans_objects.rs b/src/comp/middle/trans_objects.rs
index ba3e32c411a..4b8795deea8 100644
--- a/src/comp/middle/trans_objects.rs
+++ b/src/comp/middle/trans_objects.rs
@@ -1,6 +1,6 @@
 // Translation of object-related things to LLVM IR.
 
-import std::{str, option, vec};
+import core::{str, option, vec};
 import option::{none, some};
 
 import lib::llvm::{llvm, True};
diff --git a/src/comp/middle/trans_vec.rs b/src/comp/middle/trans_vec.rs
index 670dbc41436..dba2b67410e 100644
--- a/src/comp/middle/trans_vec.rs
+++ b/src/comp/middle/trans_vec.rs
@@ -1,5 +1,5 @@
-import std::vec;
-import std::option::none;
+import vec;
+import option::none;
 import syntax::ast;
 import lib::llvm::llvm::{ValueRef, TypeRef};
 import back::abi;
@@ -131,7 +131,7 @@ fn trans_vec(bcx: @block_ctxt, args: [@ast::expr], id: ast::node_id,
 }
 
 fn trans_str(bcx: @block_ctxt, s: str, dest: dest) -> @block_ctxt {
-    let veclen = std::str::byte_len(s) + 1u; // +1 for \0
+    let veclen = str::byte_len(s) + 1u; // +1 for \0
     let {bcx: bcx, val: sptr, _} =
         alloc(bcx, ty::mk_str(bcx_tcx(bcx)), veclen);
 
diff --git a/src/comp/middle/tstate/annotate.rs b/src/comp/middle/tstate/annotate.rs
index 77807768fce..0ca72c569a2 100644
--- a/src/comp/middle/tstate/annotate.rs
+++ b/src/comp/middle/tstate/annotate.rs
@@ -1,5 +1,5 @@
 
-import std::{int, uint};
+import core::{int, uint};
 import syntax::ast::*;
 import syntax::ast_util::pat_binding_ids;
 import syntax::visit;
diff --git a/src/comp/middle/tstate/auxiliary.rs b/src/comp/middle/tstate/auxiliary.rs
index c156bb739ff..ec1c268e775 100644
--- a/src/comp/middle/tstate/auxiliary.rs
+++ b/src/comp/middle/tstate/auxiliary.rs
@@ -1,5 +1,5 @@
-import std::{vec, int, uint, option};
-import std::option::*;
+import core::{vec, int, uint, option};
+import option::*;
 import syntax::ast::*;
 import syntax::ast_util::*;
 import syntax::codemap::span;
@@ -989,7 +989,7 @@ fn args_mention<T>(args: [@constr_arg_use], q: fn([T], node_id) -> bool,
 
 fn use_var(fcx: fn_ctxt, v: node_id) { *fcx.enclosing.used_vars += [v]; }
 
-// FIXME: This should be a function in std::vec::.
+// FIXME: This should be a function in vec::.
 fn vec_contains(v: @mutable [node_id], i: node_id) -> bool {
     for d: node_id in *v { if d == i { ret true; } }
     ret false;
diff --git a/src/comp/middle/tstate/bitvectors.rs b/src/comp/middle/tstate/bitvectors.rs
index d6b72954261..9cfe4e3c178 100644
--- a/src/comp/middle/tstate/bitvectors.rs
+++ b/src/comp/middle/tstate/bitvectors.rs
@@ -1,7 +1,7 @@
 import syntax::ast::*;
 import syntax::visit;
-import std::vec;
-import std::option::*;
+import vec;
+import option::*;
 import aux::*;
 import tstate::ann::{pre_and_post, precond, postcond, prestate, poststate,
                      relax_prestate, relax_precond, relax_poststate,
diff --git a/src/comp/middle/tstate/ck.rs b/src/comp/middle/tstate/ck.rs
index 39f16ef2fc4..3fd1721c8f0 100644
--- a/src/comp/middle/tstate/ck.rs
+++ b/src/comp/middle/tstate/ck.rs
@@ -9,7 +9,7 @@ import middle::ty::{type_is_nil, ret_ty_of_fn};
 import tstate::ann::{
                      precond, prestate,
                      implies, ann_precond, ann_prestate};
-import std::{option};
+import option;
 import aux::*;
 import syntax::print::pprust::ty_to_str;
 import bitvectors::*;
diff --git a/src/comp/middle/tstate/collect_locals.rs b/src/comp/middle/tstate/collect_locals.rs
index e5166a5e6ba..14999d8ad97 100644
--- a/src/comp/middle/tstate/collect_locals.rs
+++ b/src/comp/middle/tstate/collect_locals.rs
@@ -1,7 +1,7 @@
 import syntax::ast::*;
 import syntax::ast_util::*;
 import util::ppaux::fn_ident_to_string;
-import std::option::*;
+import option::*;
 import syntax::visit;
 import aux::*;
 import util::common::new_def_hash;
@@ -60,7 +60,7 @@ fn find_locals(tcx: ty::ctxt, f: _fn, tps: [ty_param], sp: span, i: fn_ident,
 
 fn add_constraint(tcx: ty::ctxt, c: sp_constr, next: uint, tbl: constr_map) ->
    uint {
-    log constraint_to_str(tcx, c) + " |-> " + std::uint::str(next);
+    log constraint_to_str(tcx, c) + " |-> " + uint::str(next);
     alt c.node {
       ninit(id, i) { tbl.insert(local_def(id), cinit(next, c.span, i)); }
       npred(p, d_id, args) {
@@ -142,7 +142,7 @@ fn mk_fn_info(ccx: crate_ctxt, f: _fn, tp: [ty_param], f_sp: span,
          i_diverge: ninit(diverges_id, diverges_name),
          used_vars: v};
     ccx.fm.insert(id, rslt);
-    log name + " has " + std::uint::str(num_constraints(rslt)) +
+    log name + " has " + uint::str(num_constraints(rslt)) +
             " constraints";
 }
 
diff --git a/src/comp/middle/tstate/pre_post_conditions.rs b/src/comp/middle/tstate/pre_post_conditions.rs
index 4e54b405542..0663682884c 100644
--- a/src/comp/middle/tstate/pre_post_conditions.rs
+++ b/src/comp/middle/tstate/pre_post_conditions.rs
@@ -1,6 +1,6 @@
 
-import std::{vec, option};
-import std::option::{none, some};
+import core::{vec, option};
+import option::{none, some};
 
 import tstate::ann::*;
 import aux::*;
diff --git a/src/comp/middle/tstate/states.rs b/src/comp/middle/tstate/states.rs
index 2b47baed9ee..1ac92efac69 100644
--- a/src/comp/middle/tstate/states.rs
+++ b/src/comp/middle/tstate/states.rs
@@ -1,5 +1,5 @@
-import std::{vec, option};
-import std::option::{none, some};
+import core::{vec, option};
+import option::{none, some};
 import ann::*;
 import aux::*;
 import tritv::{tritv_clone, tritv_set, ttrue};
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index 00699238b7f..bb6deac5a02 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -1,13 +1,13 @@
-import std::vec;
-import std::str;
-import std::uint;
+import vec;
+import str;
+import uint;
 import std::ufind;
 import std::map;
 import std::map::hashmap;
 import std::math;
-import std::option;
-import std::option::none;
-import std::option::some;
+import option;
+import option::none;
+import option::some;
 import std::smallintmap;
 import driver::session;
 import syntax::ast;
@@ -1471,7 +1471,7 @@ fn node_id_to_ty_param_substs_opt_and_ty(cx: ctxt, id: ast::node_id) ->
     alt smallintmap::find(*cx.node_types, id as uint) {
       none. {
         cx.sess.bug("node_id_to_ty_param_substs_opt_and_ty() called on " +
-                        "an untyped node (" + std::int::to_str(id, 10u) +
+                        "an untyped node (" + int::to_str(id, 10u) +
                         ")");
       }
       some(tpot) { ret tpot; }
@@ -2712,7 +2712,7 @@ fn tag_variants(cx: ctxt, id: ast::def_id) -> [variant_info] {
             for variant: ast::variant in variants {
                 let ctor_ty = node_id_to_monotype(cx, variant.node.id);
                 let arg_tys: [t] = [];
-                if std::vec::len(variant.node.args) > 0u {
+                if vec::len(variant.node.args) > 0u {
                     for a: arg in ty_fn_args(cx, ctor_ty) {
                         arg_tys += [a.ty];
                     }
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index 0bef6035016..c8607fab723 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -12,9 +12,10 @@ import middle::ty::{node_id_to_type, arg, bind_params_in_type, block_ty,
                     ty_param_substs_opt_and_ty, ty_param_kinds_and_ty};
 import util::ppaux::ty_to_str;
 import middle::ty::unify::{ures_ok, ures_err, fix_ok, fix_err};
-import std::{int, vec, str, option, smallintmap};
+import core::{int, vec, str, option};
+import std::smallintmap;
 import std::map::{hashmap, new_int_hash};
-import std::option::{none, some};
+import option::{none, some};
 import syntax::print::pprust::*;
 
 export check_crate;
@@ -1256,8 +1257,8 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,
             let arg_types =
                 variant_arg_types(fcx.ccx, pat.span, v_def_ids.var,
                                   expected_tps);
-            let subpats_len = std::vec::len::<@ast::pat>(subpats);
-            if std::vec::len::<ty::t>(arg_types) > 0u {
+            let subpats_len = vec::len::<@ast::pat>(subpats);
+            if vec::len::<ty::t>(arg_types) > 0u {
                 // N-ary variant.
 
                 let arg_len = vec::len::<ty::t>(arg_types);
@@ -2270,7 +2271,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
 
             let f = bind filtering_fn(fcx.ccx, _, ao.methods);
             inner_obj_methods =
-                std::vec::filter_map::<ty::method,
+                vec::filter_map::<ty::method,
                                        ty::method>(f, inner_obj_methods);
 
             method_types += inner_obj_methods;
diff --git a/src/comp/syntax/ast.rs b/src/comp/syntax/ast.rs
index 30acee6dc68..a20d1ae5c6f 100644
--- a/src/comp/syntax/ast.rs
+++ b/src/comp/syntax/ast.rs
@@ -1,6 +1,6 @@
 // The Rust abstract syntax tree.
 
-import std::option;
+import option;
 import codemap::{span, filename};
 
 type spanned<T> = {node: T, span: span};
diff --git a/src/comp/syntax/ast_util.rs b/src/comp/syntax/ast_util.rs
index 794d4bf5339..2ab55edcb74 100644
--- a/src/comp/syntax/ast_util.rs
+++ b/src/comp/syntax/ast_util.rs
@@ -1,4 +1,5 @@
-import std::{str, option, int, map};
+import core::{str, option, int};
+import std::map;
 import codemap::span;
 import ast::*;
 
@@ -212,7 +213,7 @@ fn is_constraint_arg(e: @expr) -> bool {
     }
 }
 
-fn eq_ty(&&a: @ty, &&b: @ty) -> bool { ret std::box::ptr_eq(a, b); }
+fn eq_ty(&&a: @ty, &&b: @ty) -> bool { ret box::ptr_eq(a, b); }
 
 fn hash_ty(&&t: @ty) -> uint {
     let res = (t.span.lo << 16u) + t.span.hi;
@@ -333,7 +334,7 @@ fn lit_to_const(lit: @lit) -> const_val {
       lit_str(s) { const_str(s) }
       lit_int(n, _) { const_int(n) }
       lit_uint(n, _) { const_uint(n) }
-      lit_float(n, _) { const_float(std::float::from_str(n)) }
+      lit_float(n, _) { const_float(float::from_str(n)) }
       lit_nil. { const_int(0i64) }
       lit_bool(b) { const_int(b as i64) }
     }
diff --git a/src/comp/syntax/codemap.rs b/src/comp/syntax/codemap.rs
index 106a4dae46a..9725517ed28 100644
--- a/src/comp/syntax/codemap.rs
+++ b/src/comp/syntax/codemap.rs
@@ -1,5 +1,6 @@
-import std::{vec, uint, str, term, io, option, result};
-import std::option::{some, none};
+import core::{vec, uint, str, option, result};
+import std::{term, io};
+import option::{some, none};
 
 type filename = str;
 
diff --git a/src/comp/syntax/ext/base.rs b/src/comp/syntax/ext/base.rs
index 55948be708f..55294000f66 100644
--- a/src/comp/syntax/ext/base.rs
+++ b/src/comp/syntax/ext/base.rs
@@ -1,4 +1,4 @@
-import std::{vec, option};
+import core::{vec, option};
 import std::map::hashmap;
 import driver::session::session;
 import codemap::span;
diff --git a/src/comp/syntax/ext/concat_idents.rs b/src/comp/syntax/ext/concat_idents.rs
index 711a180c9a0..c487a3ecc36 100644
--- a/src/comp/syntax/ext/concat_idents.rs
+++ b/src/comp/syntax/ext/concat_idents.rs
@@ -1,4 +1,4 @@
-import std::option;
+import option;
 import base::*;
 import syntax::ast;
 
diff --git a/src/comp/syntax/ext/env.rs b/src/comp/syntax/ext/env.rs
index 413ea1ac9d3..0b536159367 100644
--- a/src/comp/syntax/ext/env.rs
+++ b/src/comp/syntax/ext/env.rs
@@ -4,7 +4,8 @@
  * should all get sucked into either the compiler syntax extension plugin
  * interface.
  */
-import std::{vec, option, generic_os};
+import core::{vec, option};
+import std::generic_os;
 import base::*;
 export expand_syntax_ext;
 
diff --git a/src/comp/syntax/ext/expand.rs b/src/comp/syntax/ext/expand.rs
index 072f773e4da..ef2105b4271 100644
--- a/src/comp/syntax/ext/expand.rs
+++ b/src/comp/syntax/ext/expand.rs
@@ -1,9 +1,9 @@
 import driver::session;
 
-import std::option::{none, some};
+import option::{none, some};
 
 import std::map::hashmap;
-import std::{vec};
+import vec;
 
 import syntax::ast::{crate, expr_, expr_mac, mac_invoc};
 import syntax::fold::*;
diff --git a/src/comp/syntax/ext/fmt.rs b/src/comp/syntax/ext/fmt.rs
index 2d36d973870..c8721d058a3 100644
--- a/src/comp/syntax/ext/fmt.rs
+++ b/src/comp/syntax/ext/fmt.rs
@@ -5,9 +5,9 @@
  * should all get sucked into either the standard library extfmt module or the
  * compiler syntax extension plugin interface.
  */
-import std::{vec, str, option};
-import std::option::{some};
-import std::extfmt::ct::*;
+import core::{vec, str, option};
+import option::{some};
+import extfmt::ct::*;
 import base::*;
 import codemap::span;
 export expand_syntax_ext;
@@ -257,7 +257,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, pieces: [piece], args: [@ast::expr])
     }
     fn log_conv(c: conv) {
         alt c.param {
-          some(p) { log "param: " + std::int::to_str(p, 10u); }
+          some(p) { log "param: " + int::to_str(p, 10u); }
           _ { log "param: none"; }
         }
         for f: flag in c.flags {
@@ -270,17 +270,17 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, pieces: [piece], args: [@ast::expr])
             }
         }
         alt c.width {
-          count_is(i) { log "width: count is " + std::int::to_str(i, 10u); }
+          count_is(i) { log "width: count is " + int::to_str(i, 10u); }
           count_is_param(i) {
-            log "width: count is param " + std::int::to_str(i, 10u);
+            log "width: count is param " + int::to_str(i, 10u);
           }
           count_is_next_param. { log "width: count is next param"; }
           count_implied. { log "width: count is implied"; }
         }
         alt c.precision {
-          count_is(i) { log "prec: count is " + std::int::to_str(i, 10u); }
+          count_is(i) { log "prec: count is " + int::to_str(i, 10u); }
           count_is_param(i) {
-            log "prec: count is param " + std::int::to_str(i, 10u);
+            log "prec: count is param " + int::to_str(i, 10u);
           }
           count_is_next_param. { log "prec: count is next param"; }
           count_implied. { log "prec: count is implied"; }
diff --git a/src/comp/syntax/ext/ident_to_str.rs b/src/comp/syntax/ext/ident_to_str.rs
index 5a08399da49..d6093b61dbf 100644
--- a/src/comp/syntax/ext/ident_to_str.rs
+++ b/src/comp/syntax/ext/ident_to_str.rs
@@ -1,4 +1,4 @@
-import std::{vec, option};
+import core::{vec, option};
 import base::*;
 import syntax::ast;
 
diff --git a/src/comp/syntax/ext/log_syntax.rs b/src/comp/syntax/ext/log_syntax.rs
index 67b92913602..40bc90e510d 100644
--- a/src/comp/syntax/ext/log_syntax.rs
+++ b/src/comp/syntax/ext/log_syntax.rs
@@ -1,4 +1,4 @@
-import std::{option};
+import option;
 import base::*;
 import syntax::ast;
 
diff --git a/src/comp/syntax/ext/simplext.rs b/src/comp/syntax/ext/simplext.rs
index 96d214584e7..8243483f2c4 100644
--- a/src/comp/syntax/ext/simplext.rs
+++ b/src/comp/syntax/ext/simplext.rs
@@ -1,7 +1,7 @@
 use std;
 
 import codemap::span;
-import std::{vec, option};
+import core::{vec, option};
 import std::map::{hashmap, new_str_hash};
 import option::{some, none};
 
diff --git a/src/comp/syntax/fold.rs b/src/comp/syntax/fold.rs
index ce82c4d7c3b..fc1a45366fe 100644
--- a/src/comp/syntax/fold.rs
+++ b/src/comp/syntax/fold.rs
@@ -1,7 +1,7 @@
 import syntax::codemap::span;
 import ast::*;
 
-import std::{vec, option};
+import core::{vec, option};
 
 export ast_fold_precursor;
 export ast_fold;
diff --git a/src/comp/syntax/parse/eval.rs b/src/comp/syntax/parse/eval.rs
index bc8a51e1f34..2b0fcab9b8e 100644
--- a/src/comp/syntax/parse/eval.rs
+++ b/src/comp/syntax/parse/eval.rs
@@ -1,7 +1,8 @@
 
 import front::attr;
-import std::{option, result, io, fs};
-import std::option::{some, none};
+import core::{option, result};
+import std::{io, fs};
+import option::{some, none};
 import syntax::ast;
 import syntax::parse::token;
 import syntax::parse::parser::{parser, new_parser_from_file,
diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs
index bd841b94051..299a7ecafeb 100644
--- a/src/comp/syntax/parse/lexer.rs
+++ b/src/comp/syntax/parse/lexer.rs
@@ -1,6 +1,7 @@
 
-import std::{io, vec, str, option, either};
-import std::option::{some, none};
+import core::{vec, str, option, either};
+import std::io;
+import option::{some, none};
 import util::interner;
 import util::interner::intern;
 import codemap;
@@ -180,7 +181,7 @@ fn scan_digits(rdr: reader, radix: uint) -> str {
     while true {
         let c = rdr.curr();
         if c == '_' { rdr.bump(); cont; }
-        alt std::char::maybe_digit(c) {
+        alt char::maybe_digit(c) {
           some(d) when (d as uint) < radix {
             str::push_byte(rslt, c as u8);
             rdr.bump();
@@ -232,7 +233,7 @@ fn scan_number(c: char, rdr: reader) -> token::token {
             tp = signed ? either::left(ast::ty_i64)
                         : either::right(ast::ty_u64);
         }
-        let parsed = std::u64::from_str(num_str, base as u64);
+        let parsed = u64::from_str(num_str, base as u64);
         alt tp {
           either::left(t) { ret token::LIT_INT(parsed as i64, t); }
           either::right(t) { ret token::LIT_UINT(parsed, t); }
@@ -276,7 +277,7 @@ fn scan_number(c: char, rdr: reader) -> token::token {
         ret token::LIT_FLOAT(interner::intern(*rdr.get_interner(), num_str),
                              ast::ty_f);
     } else {
-        let parsed = std::u64::from_str(num_str, base as u64);
+        let parsed = u64::from_str(num_str, base as u64);
         ret token::LIT_INT(parsed as i64, ast::ty_i);
     }
 }
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index 7b8bd726eed..7ff08181e1a 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -1,7 +1,8 @@
 
-import std::{io, vec, str, option, either, result, fs};
-import std::option::{some, none};
-import std::either::{left, right};
+import core::{vec, str, option, either, result};
+import std::{io, fs};
+import option::{some, none};
+import either::{left, right};
 import std::map::{hashmap, new_str_hash};
 import token::can_begin_expr;
 import codemap::span;
diff --git a/src/comp/syntax/parse/token.rs b/src/comp/syntax/parse/token.rs
index 6740ba74c00..5ff688ecc68 100644
--- a/src/comp/syntax/parse/token.rs
+++ b/src/comp/syntax/parse/token.rs
@@ -1,6 +1,6 @@
 
 import util::interner;
-import std::{int, uint, str};
+import core::{int, uint, str};
 
 type str_num = uint;
 
diff --git a/src/comp/syntax/print/pp.rs b/src/comp/syntax/print/pp.rs
index 19f2b007594..b870f9f93da 100644
--- a/src/comp/syntax/print/pp.rs
+++ b/src/comp/syntax/print/pp.rs
@@ -1,5 +1,6 @@
 
-import std::{io, vec, str};
+import core::{vec, str};
+import std::io;
 
 /*
  * This pretty-printer is a direct reimplementation of Philip Karlton's
diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs
index ff28edd057a..f58bea2ee74 100644
--- a/src/comp/syntax/print/pprust.rs
+++ b/src/comp/syntax/print/pprust.rs
@@ -1,5 +1,6 @@
 
-import std::{vec, int, io, str, uint, option};
+import core::{vec, int, str, uint, option};
+import std::io;
 import parse::lexer;
 import syntax::codemap::codemap;
 import ast;
diff --git a/src/comp/syntax/util/interner.rs b/src/comp/syntax/util/interner.rs
index 6993eeee35e..2c1589085f2 100644
--- a/src/comp/syntax/util/interner.rs
+++ b/src/comp/syntax/util/interner.rs
@@ -1,9 +1,10 @@
 // An "interner" is a data structure that associates values with uint tags and
 // allows bidirectional lookup; i.e. given a value, one can easily find the
 // type, and vice versa.
-import std::{vec, map};
+import core::vec;
+import std::map;
 import std::map::{hashmap, hashfn, eqfn};
-import std::option::{none, some};
+import option::{none, some};
 
 type interner<T> =
     {map: hashmap<T, uint>,
diff --git a/src/comp/syntax/visit.rs b/src/comp/syntax/visit.rs
index 9e61d82287c..310d169805b 100644
--- a/src/comp/syntax/visit.rs
+++ b/src/comp/syntax/visit.rs
@@ -1,7 +1,7 @@
 
 import ast::*;
-import std::option;
-import std::option::{none, some};
+import option;
+import option::{none, some};
 import codemap::span;
 
 
diff --git a/src/comp/util/common.rs b/src/comp/util/common.rs
index f4f6f9cec24..c9bf34d69c7 100644
--- a/src/comp/util/common.rs
+++ b/src/comp/util/common.rs
@@ -1,7 +1,7 @@
-import std::{str, option};
+import core::{str, option};
 import std::math::{max, min};
 import std::map::hashmap;
-import std::option::{some};
+import option::{some};
 import syntax::ast;
 import ast::{ty, pat};
 import syntax::codemap::{span};
@@ -82,7 +82,7 @@ fn local_rhs_span(l: @ast::local, def: span) -> span {
 }
 
 fn is_main_name(path: [ast::ident]) -> bool {
-    str::eq(option::get(std::vec::last(path)), "main")
+    str::eq(option::get(vec::last(path)), "main")
 }
 
 
diff --git a/src/comp/util/filesearch.rs b/src/comp/util/filesearch.rs
index bd9735034e3..de07a213a3f 100644
--- a/src/comp/util/filesearch.rs
+++ b/src/comp/util/filesearch.rs
@@ -2,9 +2,9 @@
 // FIXME: I'm not happy how this module turned out. Should probably
 // just be folded into cstore.
 
-import std::option;
+import core::option;
 import std::fs;
-import std::vec;
+import vec;
 import std::os;
 
 export filesearch;
diff --git a/src/comp/util/ppaux.rs b/src/comp/util/ppaux.rs
index 26db274875e..540f8917f7d 100644
--- a/src/comp/util/ppaux.rs
+++ b/src/comp/util/ppaux.rs
@@ -1,5 +1,5 @@
-import std::{vec, str, int, option};
-import std::option::{none, some};
+import core::{vec, str, int, option};
+import option::{none, some};
 import middle::ty;
 import middle::ty::*;
 import metadata::encoder;