Copy first batch of material from libstd to libcore.

26 files changed, 120 insertions, 113 deletions

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;