From a770d86201d5b41573b6b5f5bdfe3b70df919b28 Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Tue, 25 Sep 2012 15:21:16 -0700
Subject: rustc: Move generally useful functions out of shape.rs in preparation
 for its destruction

---
 src/rustc/middle/trans/machine.rs | 148 ++++++++++++++++++++++++++++++++++++++
 src/rustc/middle/trans/shape.rs   | 144 +------------------------------------
 src/rustc/rustc.rc                |   1 +
 3 files changed, 150 insertions(+), 143 deletions(-)
 create mode 100644 src/rustc/middle/trans/machine.rs

(limited to 'src/rustc')

diff --git a/src/rustc/middle/trans/machine.rs b/src/rustc/middle/trans/machine.rs
new file mode 100644
index 00000000000..5515d80f4bd
--- /dev/null
+++ b/src/rustc/middle/trans/machine.rs
@@ -0,0 +1,148 @@
+// Information concerning the machine representation of various types.
+
+use middle::trans::common::*;
+
+// Creates a simpler, size-equivalent type. The resulting type is guaranteed
+// to have (a) the same size as the type that was passed in; (b) to be non-
+// recursive. This is done by replacing all boxes in a type with boxed unit
+// types.
+// This should reduce all pointers to some simple pointer type, to
+// ensure that we don't recurse endlessly when computing the size of a
+// nominal type that has pointers to itself in it.
+pub fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t {
+    fn nilptr(tcx: ty::ctxt) -> ty::t {
+        ty::mk_ptr(tcx, {ty: ty::mk_nil(tcx), mutbl: ast::m_imm})
+    }
+    fn simplifier(tcx: ty::ctxt, typ: ty::t) -> ty::t {
+        match ty::get(typ).sty {
+          ty::ty_box(_) | ty::ty_opaque_box | ty::ty_uniq(_) |
+          ty::ty_evec(_, ty::vstore_uniq) | ty::ty_evec(_, ty::vstore_box) |
+          ty::ty_estr(ty::vstore_uniq) | ty::ty_estr(ty::vstore_box) |
+          ty::ty_ptr(_) | ty::ty_rptr(_,_) => nilptr(tcx),
+          ty::ty_fn(_) => ty::mk_tup(tcx, ~[nilptr(tcx), nilptr(tcx)]),
+          ty::ty_evec(_, ty::vstore_slice(_)) |
+          ty::ty_estr(ty::vstore_slice(_)) => {
+            ty::mk_tup(tcx, ~[nilptr(tcx), ty::mk_int(tcx)])
+          }
+          // Reduce a class type to a record type in which all the fields are
+          // simplified
+          ty::ty_class(did, ref substs) => {
+            let simpl_fields = (if ty::ty_dtor(tcx, did).is_some() {
+                // remember the drop flag
+                  ~[{ident: syntax::parse::token::special_idents::dtor,
+                     mt: {ty: ty::mk_u8(tcx),
+                          mutbl: ast::m_mutbl}}] }
+                else { ~[] }) +
+                do ty::lookup_class_fields(tcx, did).map |f| {
+                 let t = ty::lookup_field_type(tcx, did, f.id, substs);
+                 {ident: f.ident,
+                  mt: {ty: simplify_type(tcx, t), mutbl: ast::m_const}}
+            };
+            ty::mk_rec(tcx, simpl_fields)
+          }
+          _ => typ
+        }
+    }
+    ty::fold_ty(tcx, typ, |t| simplifier(tcx, t))
+}
+
+// ______________________________________________________________________
+// compute sizeof / alignof
+
+pub type metrics = {
+    bcx: block,
+    sz: ValueRef,
+    align: ValueRef
+};
+
+pub type tag_metrics = {
+    bcx: block,
+    sz: ValueRef,
+    align: ValueRef,
+    payload_align: ValueRef
+};
+
+// Returns the number of bytes clobbered by a Store to this type.
+pub fn llsize_of_store(cx: @crate_ctxt, t: TypeRef) -> uint {
+    return llvm::LLVMStoreSizeOfType(cx.td.lltd, t) as uint;
+}
+
+// Returns the number of bytes between successive elements of type T in an
+// array of T. This is the "ABI" size. It includes any ABI-mandated padding.
+pub fn llsize_of_alloc(cx: @crate_ctxt, t: TypeRef) -> uint {
+    return llvm::LLVMABISizeOfType(cx.td.lltd, t) as uint;
+}
+
+// Returns, as near as we can figure, the "real" size of a type. As in, the
+// bits in this number of bytes actually carry data related to the datum
+// with the type. Not junk, padding, accidentally-damaged words, or
+// whatever. Rounds up to the nearest byte though, so if you have a 1-bit
+// value, we return 1 here, not 0. Most of rustc works in bytes.
+pub fn llsize_of_real(cx: @crate_ctxt, t: TypeRef) -> uint {
+    let nbits = llvm::LLVMSizeOfTypeInBits(cx.td.lltd, t) as uint;
+    if nbits & 7u != 0u {
+        // Not an even number of bytes, spills into "next" byte.
+        1u + (nbits >> 3)
+    } else {
+        nbits >> 3
+    }
+}
+
+// Returns the "default" size of t, which is calculated by casting null to a
+// *T and then doing gep(1) on it and measuring the result. Really, look in
+// the LLVM sources. It does that. So this is likely similar to the ABI size
+// (i.e. including alignment-padding), but goodness knows which alignment it
+// winds up using. Probably the ABI one? Not recommended.
+pub fn llsize_of(cx: @crate_ctxt, t: TypeRef) -> ValueRef {
+    return llvm::LLVMConstIntCast(lib::llvm::llvm::LLVMSizeOf(t), cx.int_type,
+                               False);
+}
+
+// Returns the preferred alignment of the given type for the current target.
+// The preffered alignment may be larger than the alignment used when
+// packing the type into structs. This will be used for things like
+// allocations inside a stack frame, which LLVM has a free hand in.
+pub fn llalign_of_pref(cx: @crate_ctxt, t: TypeRef) -> uint {
+    return llvm::LLVMPreferredAlignmentOfType(cx.td.lltd, t) as uint;
+}
+
+// Returns the minimum alignment of a type required by the plattform.
+// This is the alignment that will be used for struct fields, arrays,
+// and similar ABI-mandated things.
+pub fn llalign_of_min(cx: @crate_ctxt, t: TypeRef) -> uint {
+    return llvm::LLVMABIAlignmentOfType(cx.td.lltd, t) as uint;
+}
+
+// Returns the "default" alignment of t, which is calculated by casting
+// null to a record containing a single-bit followed by a t value, then
+// doing gep(0,1) to get at the trailing (and presumably padded) t cell.
+pub fn llalign_of(cx: @crate_ctxt, t: TypeRef) -> ValueRef {
+    return llvm::LLVMConstIntCast(
+        lib::llvm::llvm::LLVMAlignOf(t), cx.int_type, False);
+}
+
+// Computes the size of the data part of an enum.
+pub fn static_size_of_enum(cx: @crate_ctxt, t: ty::t) -> uint {
+    if cx.enum_sizes.contains_key(t) { return cx.enum_sizes.get(t); }
+    match ty::get(t).sty {
+      ty::ty_enum(tid, ref substs) => {
+        // Compute max(variant sizes).
+        let mut max_size = 0u;
+        let variants = ty::enum_variants(cx.tcx, tid);
+        for vec::each(*variants) |variant| {
+            let tup_ty = simplify_type(cx.tcx,
+                                       ty::mk_tup(cx.tcx, variant.args));
+            // Perform any type parameter substitutions.
+            let tup_ty = ty::subst(cx.tcx, substs, tup_ty);
+            // Here we possibly do a recursive call.
+            let this_size =
+                llsize_of_real(cx, type_of::type_of(cx, tup_ty));
+            if max_size < this_size { max_size = this_size; }
+        }
+        cx.enum_sizes.insert(t, max_size);
+        return max_size;
+      }
+      _ => cx.sess.bug(~"static_size_of_enum called on non-enum")
+    }
+}
+
diff --git a/src/rustc/middle/trans/shape.rs b/src/rustc/middle/trans/shape.rs
index e09e3d9493d..28d24be77df 100644
--- a/src/rustc/middle/trans/shape.rs
+++ b/src/rustc/middle/trans/shape.rs
@@ -7,6 +7,7 @@ use driver::session;
 use driver::session::session;
 use trans::base;
 use middle::trans::common::*;
+use middle::trans::machine::*;
 use back::abi;
 use middle::ty;
 use middle::ty::field;
@@ -634,151 +635,8 @@ fn gen_shape_tables(ccx: @crate_ctxt) {
                           lib::llvm::InternalLinkage);
 }
 
-// ______________________________________________________________________
-// compute sizeof / alignof
-
-type metrics = {
-    bcx: block,
-    sz: ValueRef,
-    align: ValueRef
-};
-
-type tag_metrics = {
-    bcx: block,
-    sz: ValueRef,
-    align: ValueRef,
-    payload_align: ValueRef
-};
-
-// Returns the number of bytes clobbered by a Store to this type.
-fn llsize_of_store(cx: @crate_ctxt, t: TypeRef) -> uint {
-    return llvm::LLVMStoreSizeOfType(cx.td.lltd, t) as uint;
-}
-
-// Returns the number of bytes between successive elements of type T in an
-// array of T. This is the "ABI" size. It includes any ABI-mandated padding.
-fn llsize_of_alloc(cx: @crate_ctxt, t: TypeRef) -> uint {
-    return llvm::LLVMABISizeOfType(cx.td.lltd, t) as uint;
-}
-
-// Returns, as near as we can figure, the "real" size of a type. As in, the
-// bits in this number of bytes actually carry data related to the datum
-// with the type. Not junk, padding, accidentally-damaged words, or
-// whatever. Rounds up to the nearest byte though, so if you have a 1-bit
-// value, we return 1 here, not 0. Most of rustc works in bytes.
-fn llsize_of_real(cx: @crate_ctxt, t: TypeRef) -> uint {
-    let nbits = llvm::LLVMSizeOfTypeInBits(cx.td.lltd, t) as uint;
-    if nbits & 7u != 0u {
-        // Not an even number of bytes, spills into "next" byte.
-        1u + (nbits >> 3)
-    } else {
-        nbits >> 3
-    }
-}
-
-// Returns the "default" size of t, which is calculated by casting null to a
-// *T and then doing gep(1) on it and measuring the result. Really, look in
-// the LLVM sources. It does that. So this is likely similar to the ABI size
-// (i.e. including alignment-padding), but goodness knows which alignment it
-// winds up using. Probably the ABI one? Not recommended.
-fn llsize_of(cx: @crate_ctxt, t: TypeRef) -> ValueRef {
-    return llvm::LLVMConstIntCast(lib::llvm::llvm::LLVMSizeOf(t), cx.int_type,
-                               False);
-}
-
-// Returns the preferred alignment of the given type for the current target.
-// The preffered alignment may be larger than the alignment used when
-// packing the type into structs. This will be used for things like
-// allocations inside a stack frame, which LLVM has a free hand in.
-fn llalign_of_pref(cx: @crate_ctxt, t: TypeRef) -> uint {
-    return llvm::LLVMPreferredAlignmentOfType(cx.td.lltd, t) as uint;
-}
-
-// Returns the minimum alignment of a type required by the plattform.
-// This is the alignment that will be used for struct fields, arrays,
-// and similar ABI-mandated things.
-fn llalign_of_min(cx: @crate_ctxt, t: TypeRef) -> uint {
-    return llvm::LLVMABIAlignmentOfType(cx.td.lltd, t) as uint;
-}
-
-// Returns the "default" alignment of t, which is calculated by casting
-// null to a record containing a single-bit followed by a t value, then
-// doing gep(0,1) to get at the trailing (and presumably padded) t cell.
-fn llalign_of(cx: @crate_ctxt, t: TypeRef) -> ValueRef {
-    return llvm::LLVMConstIntCast(
-        lib::llvm::llvm::LLVMAlignOf(t), cx.int_type, False);
-}
-
 // Computes the static size of a enum, without using mk_tup(), which is
 // bad for performance.
 //
 // NB: Migrate trans over to use this.
 
-// Computes the size of the data part of an enum.
-fn static_size_of_enum(cx: @crate_ctxt, t: ty::t) -> uint {
-    if cx.enum_sizes.contains_key(t) { return cx.enum_sizes.get(t); }
-    match ty::get(t).sty {
-      ty::ty_enum(tid, ref substs) => {
-        // Compute max(variant sizes).
-        let mut max_size = 0u;
-        let variants = ty::enum_variants(cx.tcx, tid);
-        for vec::each(*variants) |variant| {
-            let tup_ty = simplify_type(cx.tcx,
-                                       ty::mk_tup(cx.tcx, variant.args));
-            // Perform any type parameter substitutions.
-            let tup_ty = ty::subst(cx.tcx, substs, tup_ty);
-            // Here we possibly do a recursive call.
-            let this_size =
-                llsize_of_real(cx, type_of::type_of(cx, tup_ty));
-            if max_size < this_size { max_size = this_size; }
-        }
-        cx.enum_sizes.insert(t, max_size);
-        return max_size;
-      }
-      _ => cx.sess.bug(~"static_size_of_enum called on non-enum")
-    }
-}
-
-// Creates a simpler, size-equivalent type. The resulting type is guaranteed
-// to have (a) the same size as the type that was passed in; (b) to be non-
-// recursive. This is done by replacing all boxes in a type with boxed unit
-// types.
-// This should reduce all pointers to some simple pointer type, to
-// ensure that we don't recurse endlessly when computing the size of a
-// nominal type that has pointers to itself in it.
-fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t {
-    fn nilptr(tcx: ty::ctxt) -> ty::t {
-        ty::mk_ptr(tcx, {ty: ty::mk_nil(tcx), mutbl: ast::m_imm})
-    }
-    fn simplifier(tcx: ty::ctxt, typ: ty::t) -> ty::t {
-        match ty::get(typ).sty {
-          ty::ty_box(_) | ty::ty_opaque_box | ty::ty_uniq(_) |
-          ty::ty_evec(_, ty::vstore_uniq) | ty::ty_evec(_, ty::vstore_box) |
-          ty::ty_estr(ty::vstore_uniq) | ty::ty_estr(ty::vstore_box) |
-          ty::ty_ptr(_) | ty::ty_rptr(_,_) => nilptr(tcx),
-          ty::ty_fn(_) => ty::mk_tup(tcx, ~[nilptr(tcx), nilptr(tcx)]),
-          ty::ty_evec(_, ty::vstore_slice(_)) |
-          ty::ty_estr(ty::vstore_slice(_)) => {
-            ty::mk_tup(tcx, ~[nilptr(tcx), ty::mk_int(tcx)])
-          }
-          // Reduce a class type to a record type in which all the fields are
-          // simplified
-          ty::ty_class(did, ref substs) => {
-            let simpl_fields = (if ty::ty_dtor(tcx, did).is_some() {
-                // remember the drop flag
-                  ~[{ident: syntax::parse::token::special_idents::dtor,
-                     mt: {ty: ty::mk_u8(tcx),
-                          mutbl: ast::m_mutbl}}] }
-                else { ~[] }) +
-                do ty::lookup_class_fields(tcx, did).map |f| {
-                 let t = ty::lookup_field_type(tcx, did, f.id, substs);
-                 {ident: f.ident,
-                  mt: {ty: simplify_type(tcx, t), mutbl: ast::m_const}}
-            };
-            ty::mk_rec(tcx, simpl_fields)
-          }
-          _ => typ
-        }
-    }
-    ty::fold_ty(tcx, typ, |t| simplifier(tcx, t))
-}
diff --git a/src/rustc/rustc.rc b/src/rustc/rustc.rc
index d34ae4e35f3..ca5491245e0 100644
--- a/src/rustc/rustc.rc
+++ b/src/rustc/rustc.rc
@@ -86,6 +86,7 @@ mod middle {
         mod type_use;
         #[legacy_exports]
         mod reachable;
+        mod machine;
     }
     #[legacy_exports]
     mod ty;
-- 
cgit 1.4.1-3-g733a5


From 12a0401d84dc033fc4e03484b334de3cb20bab30 Mon Sep 17 00:00:00 2001
From: Niko Matsakis <niko@alum.mit.edu>
Date: Tue, 25 Sep 2012 15:15:42 -0700
Subject: Change method res to try autoref more often. Fixes #3585.

---
 src/rustc/middle/typeck/check/method.rs            | 64 ++++------------------
 .../autoref-intermediate-types-issue-3585.rs       | 20 +++++++
 src/test/run-pass/autoref-vec-push.rs              | 17 ++++++
 3 files changed, 48 insertions(+), 53 deletions(-)
 create mode 100644 src/test/run-pass/autoref-intermediate-types-issue-3585.rs
 create mode 100644 src/test/run-pass/autoref-vec-push.rs

(limited to 'src/rustc')

diff --git a/src/rustc/middle/typeck/check/method.rs b/src/rustc/middle/typeck/check/method.rs
index 815101a1448..085ee51eff7 100644
--- a/src/rustc/middle/typeck/check/method.rs
+++ b/src/rustc/middle/typeck/check/method.rs
@@ -48,11 +48,12 @@ candidates in the same way.
 
 If find no matching candidate at all, we proceed to auto-deref the
 receiver type and search again.  We keep doing that until we cannot
-auto-deref any longer.  At that point, we will attempt an auto-ref.
-If THAT fails, method lookup fails altogether.  Autoref itself comes
-in two varieties, autoslice and autoptr.  The former converts `~[]` to
-`&[]` and the latter converts any type `T` to `&mut T`, `&const T`, or
-`&T`.
+auto-deref any longer.  At each step, we also check for candidates
+based on "autoptr", which if the current type is `T`, checks for `&mut
+T`, `&const T`, and `&T` receivers.  Finally, at the very end, we will
+also try autoslice, which converts `~[]` to `&[]` (there is no point
+at trying autoslice earlier, because no autoderefable type is also
+sliceable).
 
 ## Why two phases?
 
@@ -159,22 +160,9 @@ impl LookupContext {
                 None => {}
             }
 
-            // some special logic around newtypes:
-            match ty::get(self_ty).sty {
-                ty_enum(*) => {
-                    // Note: in general, we prefer not to auto-ref a
-                    // partially autoderef'd type, because it
-                    // seems... crazy.  But we have to be careful
-                    // around newtype enums.  They can be further
-                    // deref'd, but they may also have intrinsic
-                    // methods hanging off of them with interior type.
-                    match self.search_for_any_autorefd_method(self_ty,
-                                                              autoderefs) {
-                        Some(move mme) => { return Some(mme); }
-                        None => {}
-                    }
-                }
-                _ => {}
+            match self.search_for_autoptrd_method(self_ty, autoderefs) {
+                Some(move mme) => { return Some(move mme); }
+                None => {}
             }
 
             match self.deref(self_ty, &enum_dids) {
@@ -186,7 +174,7 @@ impl LookupContext {
             }
         }
 
-        self.search_for_any_autorefd_method(self_ty, autoderefs)
+        self.search_for_autosliced_method(self_ty, autoderefs)
     }
 
     fn deref(ty: ty::t, enum_dids: &DVec<ast::def_id>) -> Option<ty::t> {
@@ -516,30 +504,6 @@ impl LookupContext {
         }
     }
 
-    fn search_for_any_autorefd_method(
-        &self,
-        self_ty: ty::t,
-        autoderefs: uint)
-        -> Option<method_map_entry>
-    {
-        /*!
-         *
-         * Attempts both auto-slice and auto-ptr, as appropriate.
-         */
-
-        match self.search_for_autosliced_method(self_ty, autoderefs) {
-            Some(move mme) => { return Some(move mme); }
-            None => {}
-        }
-
-        match self.search_for_autoptrd_method(self_ty, autoderefs) {
-            Some(move mme) => { return Some(move mme); }
-            None => {}
-        }
-
-        return None;
-    }
-
     fn search_for_autosliced_method(
         &self,
         self_ty: ty::t,
@@ -594,13 +558,7 @@ impl LookupContext {
 
         let tcx = self.tcx();
         match ty::get(self_ty).sty {
-            ty_box(*) | ty_uniq(*) | ty_rptr(*) => {
-                // we should be fully autoderef'd
-                self.bug(fmt!("Receiver type %s should be fully \
-                               autoderef'd by this point",
-                              self.ty_to_str(self_ty)));
-            }
-
+            ty_box(*) | ty_uniq(*) | ty_rptr(*) |
             ty_infer(IntVar(_)) | // FIXME(#3211)---should be resolved
             ty_self | ty_param(*) | ty_nil | ty_bot | ty_bool |
             ty_int(*) | ty_uint(*) |
diff --git a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
new file mode 100644
index 00000000000..68e172bacad
--- /dev/null
+++ b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
@@ -0,0 +1,20 @@
+trait Foo {
+    fn foo(&self) -> ~str;
+}
+
+impl<T: Foo> @T: Foo {
+    fn foo(&self) -> ~str {
+        fmt!("@%s", (**self).foo())
+    }
+}
+
+impl uint: Foo {
+    fn foo(&self) -> ~str {
+        fmt!("%u", *self)
+    }
+}
+
+fn main() {
+    let x = @3u;
+    assert x.foo() == ~"@3";
+}
\ No newline at end of file
diff --git a/src/test/run-pass/autoref-vec-push.rs b/src/test/run-pass/autoref-vec-push.rs
new file mode 100644
index 00000000000..cb70a1810b7
--- /dev/null
+++ b/src/test/run-pass/autoref-vec-push.rs
@@ -0,0 +1,17 @@
+trait VecPush<T> {
+    fn push(&mut self, +t: T);
+}
+
+impl<T> ~[T]: VecPush<T> {
+    fn push(&mut self, +t: T) {
+        vec::push(*self, t);
+    }
+}
+
+fn main() {
+    let mut x = ~[];
+    x.push(1);
+    x.push(2);
+    x.push(3);
+    assert x == ~[1, 2, 3];
+}
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From fdd48dd903e07bdb107bcc82a97daf533285120c Mon Sep 17 00:00:00 2001
From: Graydon Hoare <graydon@mozilla.com>
Date: Tue, 25 Sep 2012 15:22:28 -0700
Subject: Respect privacy qualifiers on view items, add to import resolutions.

---
 src/rustc/middle/resolve.rs          | 130 ++++++++++++++++++++---------------
 src/rustc/rustc.rc                   |   1 +
 src/test/auxiliary/cci_class.rs      |   1 +
 src/test/auxiliary/cci_class_2.rs    |   2 +
 src/test/auxiliary/cci_class_3.rs    |   2 +
 src/test/auxiliary/cci_class_4.rs    |   1 +
 src/test/auxiliary/cci_class_6.rs    |   2 +
 src/test/auxiliary/cci_class_cast.rs |   2 +
 src/test/auxiliary/crateresolve7x.rs |   1 +
 src/test/auxiliary/foreign_lib.rs    |   1 +
 src/test/auxiliary/issue-3012-1.rs   |   1 +
 11 files changed, 90 insertions(+), 54 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs
index f7c389e67ff..afb1cbc36f4 100644
--- a/src/rustc/middle/resolve.rs
+++ b/src/rustc/middle/resolve.rs
@@ -167,8 +167,8 @@ enum CaptureClause {
 type ResolveVisitor = vt<()>;
 
 enum ModuleDef {
-    NoModuleDef,            // Does not define a module.
-    ModuleDef(@Module),     // Defines a module.
+    NoModuleDef,                     // Does not define a module.
+    ModuleDef(Privacy, @Module),     // Defines a module.
 }
 
 impl ModuleDef {
@@ -333,15 +333,18 @@ fn Rib(kind: RibKind) -> Rib {
 
 /// One import directive.
 struct ImportDirective {
+    privacy: Privacy,
     module_path: @DVec<Atom>,
     subclass: @ImportDirectiveSubclass,
     span: span,
 }
 
-fn ImportDirective(module_path: @DVec<Atom>,
+fn ImportDirective(privacy: Privacy,
+                   module_path: @DVec<Atom>,
                    subclass: @ImportDirectiveSubclass,
                    span: span) -> ImportDirective {
     ImportDirective {
+        privacy: privacy,
         module_path: module_path,
         subclass: subclass,
         span: span
@@ -362,6 +365,7 @@ fn Target(target_module: @Module, bindings: @NameBindings) -> Target {
 }
 
 struct ImportResolution {
+    privacy: Privacy,
     span: span,
 
     // The number of outstanding references to this name. When this reaches
@@ -377,8 +381,10 @@ struct ImportResolution {
     mut used: bool,
 }
 
-fn ImportResolution(span: span) -> ImportResolution {
+fn ImportResolution(privacy: Privacy,
+                    span: span) -> ImportResolution {
     ImportResolution {
+        privacy: privacy,
         span: span,
         outstanding_references: 0u,
         module_target: None,
@@ -533,13 +539,14 @@ struct NameBindings {
 impl NameBindings {
 
     /// Creates a new module in this set of name bindings.
-    fn define_module(parent_link: ParentLink,
+    fn define_module(privacy: Privacy,
+                     parent_link: ParentLink,
                      def_id: Option<def_id>,
                      legacy_exports: bool,
                      sp: span) {
         if self.module_def.is_none() {
             let module_ = @Module(parent_link, def_id, legacy_exports);
-            self.module_def = ModuleDef(module_);
+            self.module_def = ModuleDef(privacy, module_);
             self.module_span = Some(sp);
         }
     }
@@ -560,7 +567,7 @@ impl NameBindings {
     fn get_module_if_available() -> Option<@Module> {
         match self.module_def {
             NoModuleDef         => return None,
-            ModuleDef(module_)  => return Some(module_)
+            ModuleDef(_privacy, module_)  => return Some(module_)
         }
     }
 
@@ -574,7 +581,7 @@ impl NameBindings {
                 fail
                     ~"get_module called on a node with no module definition!";
             }
-            ModuleDef(module_) => {
+            ModuleDef(_, module_) => {
                 return module_;
             }
         }
@@ -599,12 +606,12 @@ impl NameBindings {
           ValueNS => return self.value_def,
           ModuleNS => match self.module_def {
             NoModuleDef => return None,
-            ModuleDef(module_) =>
+            ModuleDef(privacy, module_) =>
                 match module_.def_id {
                     None => return None,
                     Some(def_id) => {
                         return Some(Definition {
-                            privacy: Public,
+                            privacy: privacy,
                             def: def_mod(def_id)
                         });
                     }
@@ -703,7 +710,8 @@ fn Resolver(session: session, lang_items: LanguageItems,
 
     let graph_root = @NameBindings();
 
-    (*graph_root).define_module(NoParentLink,
+    (*graph_root).define_module(Public,
+                                NoParentLink,
                                 Some({ crate: 0, node: 0 }),
                                 has_legacy_export_attr(crate.node.attrs),
                                 crate.span);
@@ -991,6 +999,7 @@ impl Resolver {
         let legacy = match parent {
           ModuleReducedGraphParent(m) => m.legacy_exports
         };
+        let privacy = self.visibility_to_privacy(item.vis, legacy);
 
         match item.node {
             item_mod(module_) => {
@@ -1000,8 +1009,8 @@ impl Resolver {
 
                 let parent_link = self.get_parent_link(new_parent, atom);
                 let def_id = { crate: 0, node: item.id };
-              (*name_bindings).define_module(parent_link, Some(def_id),
-                                             legacy, sp);
+              (*name_bindings).define_module(privacy, parent_link,
+                                             Some(def_id), legacy, sp);
 
                 let new_parent =
                     ModuleReducedGraphParent((*name_bindings).get_module());
@@ -1017,8 +1026,8 @@ impl Resolver {
 
                   let parent_link = self.get_parent_link(new_parent, atom);
                   let def_id = { crate: 0, node: item.id };
-                  (*name_bindings).define_module(parent_link, Some(def_id),
-                                                 legacy, sp);
+                  (*name_bindings).define_module(privacy, parent_link,
+                                                 Some(def_id), legacy, sp);
 
                   ModuleReducedGraphParent((*name_bindings).get_module())
                 }
@@ -1036,17 +1045,14 @@ impl Resolver {
                                                       ~[ValueNS], sp);
 
                 (*name_bindings).define_value
-                    (self.visibility_to_privacy(item.vis, legacy),
-                     def_const(local_def(item.id)),
-                     sp);
+                    (privacy, def_const(local_def(item.id)), sp);
             }
             item_fn(_, purity, _, _) => {
               let (name_bindings, new_parent) = self.add_child(atom, parent,
                                                         ~[ValueNS], sp);
 
                 let def = def_fn(local_def(item.id), purity);
-                (*name_bindings).define_value
-                    (self.visibility_to_privacy(item.vis, legacy), def, sp);
+                (*name_bindings).define_value(privacy, def, sp);
                 visit_item(item, new_parent, visitor);
             }
 
@@ -1056,9 +1062,7 @@ impl Resolver {
                                                       ~[TypeNS], sp);
 
                 (*name_bindings).define_type
-                    (self.visibility_to_privacy(item.vis, legacy),
-                     def_ty(local_def(item.id)),
-                     sp);
+                    (privacy, def_ty(local_def(item.id)), sp);
             }
 
             item_enum(enum_definition, _) => {
@@ -1067,9 +1071,7 @@ impl Resolver {
                                                                ~[TypeNS], sp);
 
                 (*name_bindings).define_type
-                    (self.visibility_to_privacy(item.vis, legacy),
-                     def_ty(local_def(item.id)),
-                     sp);
+                    (privacy, def_ty(local_def(item.id)), sp);
 
                 for enum_definition.variants.each |variant| {
                     self.build_reduced_graph_for_variant(*variant,
@@ -1088,9 +1090,7 @@ impl Resolver {
                             self.add_child(atom, parent, ~[TypeNS], sp);
 
                         (*name_bindings).define_type
-                            (self.visibility_to_privacy(item.vis, legacy),
-                             def_ty(local_def(item.id)),
-                             sp);
+                            (privacy, def_ty(local_def(item.id)), sp);
                         new_parent
                     }
                     Some(ctor) => {
@@ -1098,9 +1098,6 @@ impl Resolver {
                             self.add_child(atom, parent, ~[ValueNS, TypeNS],
                                            sp);
 
-                        let privacy = self.visibility_to_privacy(item.vis,
-                                                                 legacy);
-
                         (*name_bindings).define_type
                             (privacy, def_ty(local_def(item.id)), sp);
 
@@ -1156,7 +1153,7 @@ impl Resolver {
                 self.trait_info.insert(def_id, method_names);
 
                 (*name_bindings).define_type
-                    (self.visibility_to_privacy(item.vis, legacy),
+                    (privacy,
                      def_ty(def_id),
                      sp);
                 visit_item(item, new_parent, visitor);
@@ -1218,6 +1215,10 @@ impl Resolver {
                                          parent: ReducedGraphParent,
                                          &&_visitor: vt<ReducedGraphParent>) {
 
+        let legacy = match parent {
+          ModuleReducedGraphParent(m) => m.legacy_exports
+        };
+        let privacy = self.visibility_to_privacy(view_item.vis, legacy);
         match view_item.node {
             view_item_import(view_paths) => {
                 for view_paths.each |view_path| {
@@ -1259,7 +1260,8 @@ impl Resolver {
                             let subclass = @SingleImport(binding,
                                                          source_ident,
                                                          ns);
-                            self.build_import_directive(module_,
+                            self.build_import_directive(privacy,
+                                                        module_,
                                                         module_path,
                                                         subclass,
                                                         view_path.span);
@@ -1270,14 +1272,16 @@ impl Resolver {
                                 let subclass = @SingleImport(name,
                                                              name,
                                                              AnyNS);
-                                self.build_import_directive(module_,
+                                self.build_import_directive(privacy,
+                                                            module_,
                                                             module_path,
                                                             subclass,
                                                             view_path.span);
                             }
                         }
                         view_path_glob(_, _) => {
-                            self.build_import_directive(module_,
+                            self.build_import_directive(privacy,
+                                                        module_,
                                                         module_path,
                                                         @GlobImport,
                                                         view_path.span);
@@ -1356,7 +1360,8 @@ impl Resolver {
                         let parent_link = ModuleParentLink
                             (self.get_module_from_parent(new_parent), name);
 
-                        (*child_name_bindings).define_module(parent_link,
+                        (*child_name_bindings).define_module(privacy,
+                                                             parent_link,
                                                              Some(def_id),
                                                              false,
                                                              view_item.span);
@@ -1440,7 +1445,8 @@ impl Resolver {
 
                 match modules.find(def_id) {
                   None => {
-                    child_name_bindings.define_module(parent_link,
+                    child_name_bindings.define_module(Public,
+                                                      parent_link,
                                                       Some(def_id),
                                                       false,
                                                       dummy_sp());
@@ -1452,7 +1458,7 @@ impl Resolver {
                     // avoid creating cycles in the
                     // module graph.
 
-                    let resolution = @ImportResolution(dummy_sp());
+                    let resolution = @ImportResolution(Public, dummy_sp());
                     resolution.outstanding_references = 0;
 
                     match existing_module.parent_link {
@@ -1476,7 +1482,7 @@ impl Resolver {
                   }
                 }
               }
-              ModuleDef(module_) => {
+              ModuleDef(_priv, module_) => {
                 debug!("(building reduced graph for \
                         external crate) already created \
                         module");
@@ -1585,11 +1591,12 @@ impl Resolver {
                                 autovivifying %s", *ident_str);
                         let parent_link = self.get_parent_link(new_parent,
                                                                ident);
-                        (*child_name_bindings).define_module(parent_link,
-                                                       None, false,
+                        (*child_name_bindings).define_module(Public,
+                                                             parent_link,
+                                                             None, false,
                                                              dummy_sp());
                     }
-                    ModuleDef(_) => { /* Fall through. */ }
+                    ModuleDef(*) => { /* Fall through. */ }
                 }
 
                 current_module = (*child_name_bindings).get_module();
@@ -1625,12 +1632,14 @@ impl Resolver {
     }
 
     /// Creates and adds an import directive to the given module.
-    fn build_import_directive(module_: @Module,
+    fn build_import_directive(privacy: Privacy,
+                              module_: @Module,
                               module_path: @DVec<Atom>,
                               subclass: @ImportDirectiveSubclass,
                               span: span) {
 
-        let directive = @ImportDirective(module_path, subclass, span);
+        let directive = @ImportDirective(privacy, module_path,
+                                         subclass, span);
         module_.imports.push(directive);
 
         // Bump the reference count on the name. Or, if this is a glob, set
@@ -1643,7 +1652,7 @@ impl Resolver {
                         resolution.outstanding_references += 1u;
                     }
                     None => {
-                        let resolution = @ImportResolution(span);
+                        let resolution = @ImportResolution(privacy, span);
                         resolution.outstanding_references = 1u;
                         module_.import_resolutions.insert(target, resolution);
                     }
@@ -1829,8 +1838,9 @@ impl Resolver {
                         }
                         GlobImport => {
                             let span = import_directive.span;
+                            let p = import_directive.privacy;
                             resolution_result =
-                                self.resolve_glob_import(module_,
+                                self.resolve_glob_import(p, module_,
                                                          containing_module,
                                                          span);
                         }
@@ -2196,7 +2206,8 @@ impl Resolver {
      * succeeds or bails out (as importing * from an empty module or a module
      * that exports nothing is valid).
      */
-    fn resolve_glob_import(module_: @Module,
+    fn resolve_glob_import(privacy: Privacy,
+                           module_: @Module,
                            containing_module: @Module,
                            span: span)
                         -> ResolveResult<()> {
@@ -2236,7 +2247,8 @@ impl Resolver {
                 None => {
                     // Simple: just copy the old import resolution.
                     let new_import_resolution =
-                        @ImportResolution(target_import_resolution.span);
+                        @ImportResolution(privacy,
+                                          target_import_resolution.span);
                     new_import_resolution.module_target =
                         copy target_import_resolution.module_target;
                     new_import_resolution.value_target =
@@ -2294,7 +2306,8 @@ impl Resolver {
             match module_.import_resolutions.find(atom) {
                 None => {
                     // Create a new import resolution from this child.
-                    dest_import_resolution = @ImportResolution(span);
+                    dest_import_resolution = @ImportResolution(privacy,
+                                                               span);
                     module_.import_resolutions.insert
                         (atom, dest_import_resolution);
                 }
@@ -2372,7 +2385,7 @@ impl Resolver {
                                                            str_of(name)));
                             return Failed;
                         }
-                        ModuleDef(copy module_) => {
+                        ModuleDef(_, copy module_) => {
                             search_module = module_;
                         }
                     }
@@ -2528,7 +2541,7 @@ impl Resolver {
                                 wasn't actually a module!");
                         return Failed;
                     }
-                    ModuleDef(module_) => {
+                    ModuleDef(_, module_) => {
                         return Success(module_);
                     }
                 }
@@ -2892,6 +2905,11 @@ impl Resolver {
         for [ModuleNS, TypeNS, ValueNS].each |ns| {
             match namebindings.def_for_namespace(*ns) {
                 Some(d) if d.privacy == Public => {
+                    debug!("(computing exports) YES: %s '%s' \
+                            => %?",
+                           if reexport { ~"reexport" } else { ~"export"},
+                           self.session.str_of(atom),
+                           def_id_of_def(d.def));
                     vec::push(*exports2,  Export2 {
                         reexport: reexport,
                         name: self.session.str_of(atom),
@@ -2906,6 +2924,8 @@ impl Resolver {
     fn add_exports_for_module(exports2: &mut ~[Export2], module_: @Module) {
 
         for module_.children.each_ref |atom, namebindings| {
+            debug!("(computing exports) maybe export '%s'",
+                   self.session.str_of(*atom));
             self.add_exports_of_namebindings(exports2, *atom,
                                              *namebindings, false)
         }
@@ -2914,6 +2934,8 @@ impl Resolver {
             for [ModuleNS, TypeNS, ValueNS].each |ns| {
                 match importresolution.target_for_namespace(*ns) {
                     Some(target) => {
+                        debug!("(computing exports) maybe reexport '%s'",
+                               self.session.str_of(*atom));
                         self.add_exports_of_namebindings(exports2, *atom,
                                                          target.bindings,
                                                          true)
@@ -2936,7 +2958,7 @@ impl Resolver {
                         // Nothing to do.
                     }
                     ChildNameDefinition(target_def) => {
-                        debug!("(computing exports) found child export '%s' \
+                        debug!("(computing exports) legacy export '%s' \
                                 for %?",
                                self.session.str_of(name),
                                module_.def_id);
@@ -2947,7 +2969,7 @@ impl Resolver {
                         });
                     }
                     ImportNameDefinition(target_def) => {
-                        debug!("(computing exports) found reexport '%s' for \
+                        debug!("(computing exports) legacy reexport '%s' for \
                                 %?",
                                self.session.str_of(name),
                                module_.def_id);
diff --git a/src/rustc/rustc.rc b/src/rustc/rustc.rc
index ca5491245e0..c021a4e2854 100644
--- a/src/rustc/rustc.rc
+++ b/src/rustc/rustc.rc
@@ -12,6 +12,7 @@
 #[no_core];
 
 #[legacy_modes];
+#[legacy_exports];
 
 #[allow(vecs_implicitly_copyable)];
 #[allow(non_camel_case_types)];
diff --git a/src/test/auxiliary/cci_class.rs b/src/test/auxiliary/cci_class.rs
index 8f4055cd415..bb286f956bc 100644
--- a/src/test/auxiliary/cci_class.rs
+++ b/src/test/auxiliary/cci_class.rs
@@ -1,3 +1,4 @@
+#[legacy_exports];
 mod kitties {
     #[legacy_exports];
 
diff --git a/src/test/auxiliary/cci_class_2.rs b/src/test/auxiliary/cci_class_2.rs
index e572f41322c..186f021a81f 100644
--- a/src/test/auxiliary/cci_class_2.rs
+++ b/src/test/auxiliary/cci_class_2.rs
@@ -1,3 +1,5 @@
+#[legacy_exports];
+
 mod kitties {
     #[legacy_exports];
 
diff --git a/src/test/auxiliary/cci_class_3.rs b/src/test/auxiliary/cci_class_3.rs
index 79583a6134c..dbae452a8f9 100644
--- a/src/test/auxiliary/cci_class_3.rs
+++ b/src/test/auxiliary/cci_class_3.rs
@@ -1,3 +1,5 @@
+#[legacy_exports];
+
 mod kitties {
     #[legacy_exports];
 
diff --git a/src/test/auxiliary/cci_class_4.rs b/src/test/auxiliary/cci_class_4.rs
index 57c6f2f4b52..436f92e5e78 100644
--- a/src/test/auxiliary/cci_class_4.rs
+++ b/src/test/auxiliary/cci_class_4.rs
@@ -1,3 +1,4 @@
+#[legacy_exports];
 mod kitties {
     #[legacy_exports];
 
diff --git a/src/test/auxiliary/cci_class_6.rs b/src/test/auxiliary/cci_class_6.rs
index 72262781222..6cf86aff055 100644
--- a/src/test/auxiliary/cci_class_6.rs
+++ b/src/test/auxiliary/cci_class_6.rs
@@ -1,3 +1,5 @@
+#[legacy_exports];
+
 mod kitties {
     #[legacy_exports];
 
diff --git a/src/test/auxiliary/cci_class_cast.rs b/src/test/auxiliary/cci_class_cast.rs
index 550dfb6886a..288fe66dd20 100644
--- a/src/test/auxiliary/cci_class_cast.rs
+++ b/src/test/auxiliary/cci_class_cast.rs
@@ -1,3 +1,5 @@
+#[legacy_exports];
+
 use to_str::*;
 use to_str::ToStr;
 
diff --git a/src/test/auxiliary/crateresolve7x.rs b/src/test/auxiliary/crateresolve7x.rs
index 520a207345f..e7bf211d3f0 100644
--- a/src/test/auxiliary/crateresolve7x.rs
+++ b/src/test/auxiliary/crateresolve7x.rs
@@ -3,6 +3,7 @@
 // aux-build:crateresolve_calories-2.rs
 
 // These both have the same version but differ in other metadata
+#[legacy_exports];
 mod a {
     #[legacy_exports];
     extern mod cr_1 (name = "crateresolve_calories", vers = "0.1", calories="100");
diff --git a/src/test/auxiliary/foreign_lib.rs b/src/test/auxiliary/foreign_lib.rs
index 6ea28255421..bb6d425de34 100644
--- a/src/test/auxiliary/foreign_lib.rs
+++ b/src/test/auxiliary/foreign_lib.rs
@@ -1,4 +1,5 @@
 #[link(name="foreign_lib", vers="0.0")];
+#[legacy_exports];
 
 extern mod rustrt {
     #[legacy_exports];
diff --git a/src/test/auxiliary/issue-3012-1.rs b/src/test/auxiliary/issue-3012-1.rs
index a9d371321f8..d774669cd13 100644
--- a/src/test/auxiliary/issue-3012-1.rs
+++ b/src/test/auxiliary/issue-3012-1.rs
@@ -1,5 +1,6 @@
 #[link(name="socketlib", vers="0.0")];
 #[crate_type = "lib"];
+#[legacy_exports];
 
 mod socket {
     #[legacy_exports];
-- 
cgit 1.4.1-3-g733a5


From a66e23d236bfcfbd1fd1829565ce56d696b19b8b Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Tue, 25 Sep 2012 16:39:52 -0700
Subject: rustc: Stop generating shape tables

---
 src/rustc/middle/trans/base.rs  |  4 ----
 src/rustc/middle/trans/glue.rs  | 10 ++++-----
 src/rustc/middle/trans/shape.rs | 49 -----------------------------------------
 3 files changed, 4 insertions(+), 59 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs
index 65a788991bf..2e2e2937cf1 100644
--- a/src/rustc/middle/trans/base.rs
+++ b/src/rustc/middle/trans/base.rs
@@ -2701,11 +2701,7 @@ fn trans_crate(sess: session::session,
 
     decl_gc_metadata(ccx, llmod_id);
     fill_crate_map(ccx, crate_map);
-    // NB: Must call force_declare_tydescs before emit_tydescs to break
-    // cyclical dependency with shape code! See shape.rs for details.
-    force_declare_tydescs(ccx);
     glue::emit_tydescs(ccx);
-    gen_shape_tables(ccx);
     write_abi_version(ccx);
 
     // Translate the metadata.
diff --git a/src/rustc/middle/trans/glue.rs b/src/rustc/middle/trans/glue.rs
index 8ac42bc2284..0fc72e8dc15 100644
--- a/src/rustc/middle/trans/glue.rs
+++ b/src/rustc/middle/trans/glue.rs
@@ -679,7 +679,7 @@ fn emit_tydescs(ccx: @crate_ctxt) {
     let _icx = ccx.insn_ctxt("emit_tydescs");
     // As of this point, allow no more tydescs to be created.
     ccx.finished_tydescs = true;
-    for ccx.tydescs.each |key, val| {
+    for ccx.tydescs.each |_key, val| {
         let glue_fn_ty = T_ptr(T_generic_glue_fn(ccx));
         let ti = val;
 
@@ -720,10 +720,8 @@ fn emit_tydescs(ccx: @crate_ctxt) {
               }
             };
 
-        let shape = shape_of(ccx, key);
-        let shape_tables =
-            llvm::LLVMConstPointerCast(ccx.shape_cx.llshapetables,
-                                       T_ptr(T_i8()));
+        let shape = C_null(T_ptr(T_i8()));
+        let shape_tables = C_null(T_ptr(T_i8()));
 
         let tydesc =
             C_named_struct(ccx.tydesc_type,
@@ -733,7 +731,7 @@ fn emit_tydescs(ccx: @crate_ctxt) {
                              drop_glue, // drop_glue
                              free_glue, // free_glue
                              visit_glue, // visit_glue
-                             C_shape(ccx, shape), // shape
+                             shape, // shape
                              shape_tables]); // shape_tables
 
         let gvar = ti.tydesc;
diff --git a/src/rustc/middle/trans/shape.rs b/src/rustc/middle/trans/shape.rs
index 28d24be77df..708bf149d07 100644
--- a/src/rustc/middle/trans/shape.rs
+++ b/src/rustc/middle/trans/shape.rs
@@ -591,52 +591,3 @@ fn gen_resource_shapes(ccx: @crate_ctxt) -> ValueRef {
     return mk_global(ccx, ~"resource_shapes", C_struct(dtors), true);
 }
 
-// This function serves to break a cyclical dependence between
-// emit_tydescs and gen_shape_tables.
-//
-//  * emit_tydescs calls shape_of, which causes changes to the shape
-//    tables
-//  * gen_shape_tables transitively calls get_tydesc, which causes new
-//    tydescs to be created
-//
-// We force those tydescs to be emitted now, thus breaking the
-// dependency.
-fn force_declare_tydescs(ccx: @crate_ctxt) {
-    // Walk all known tydescs first to force shape code to declare
-    // dependencies.
-    for ccx.tydescs.each |key, _val| {
-        shape_of(ccx, key);
-    }
-
-    // Then walk all resource shapes to force emit all dtors.
-    let len = ccx.shape_cx.resources.len();
-    for uint::range(0u, len) |i| {
-        let ri = ccx.shape_cx.resources.get(i);
-        for ri.tps.each() |s| { assert !ty::type_has_params(*s); }
-        do ri.parent_id.iter |id| {
-            trans::base::get_res_dtor(ccx, ri.did, id, ri.tps);
-        }
-    }
-}
-
-fn gen_shape_tables(ccx: @crate_ctxt) {
-    let lltagstable = gen_enum_shapes(ccx);
-    let llresourcestable = gen_resource_shapes(ccx);
-    trans::common::set_struct_body(ccx.shape_cx.llshapetablesty,
-                                   ~[val_ty(lltagstable),
-                                    val_ty(llresourcestable)]);
-
-    let lltables =
-        C_named_struct(ccx.shape_cx.llshapetablesty,
-                       ~[lltagstable, llresourcestable]);
-    lib::llvm::llvm::LLVMSetInitializer(ccx.shape_cx.llshapetables, lltables);
-    lib::llvm::llvm::LLVMSetGlobalConstant(ccx.shape_cx.llshapetables, True);
-    lib::llvm::SetLinkage(ccx.shape_cx.llshapetables,
-                          lib::llvm::InternalLinkage);
-}
-
-// Computes the static size of a enum, without using mk_tup(), which is
-// bad for performance.
-//
-// NB: Migrate trans over to use this.
-
-- 
cgit 1.4.1-3-g733a5


From 42b60372974ded4a259e40c53ad333d84e3722f7 Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Tue, 25 Sep 2012 16:53:23 -0700
Subject: rustc: Remove most of the code that generates shapes

---
 src/rustc/middle/trans/shape.rs | 376 ----------------------------------------
 1 file changed, 376 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/middle/trans/shape.rs b/src/rustc/middle/trans/shape.rs
index 708bf149d07..7640cd095dc 100644
--- a/src/rustc/middle/trans/shape.rs
+++ b/src/rustc/middle/trans/shape.rs
@@ -215,379 +215,3 @@ fn add_substr(&dest: ~[u8], src: ~[u8]) {
     dest += src;
 }
 
-fn shape_of(ccx: @crate_ctxt, t: ty::t) -> ~[u8] {
-    match ty::get(t).sty {
-        ty::ty_nil | ty::ty_bool | ty::ty_uint(ast::ty_u8) |
-        ty::ty_bot => ~[shape_u8],
-        ty::ty_int(ast::ty_i) => ~[s_int(ccx.tcx)],
-        ty::ty_float(ast::ty_f) => ~[s_float(ccx.tcx)],
-        ty::ty_uint(ast::ty_u) | ty::ty_ptr(_) => ~[s_uint(ccx.tcx)],
-        ty::ty_type => ~[s_tydesc(ccx.tcx)],
-        ty::ty_int(ast::ty_i8) => ~[shape_i8],
-        ty::ty_uint(ast::ty_u16) => ~[shape_u16],
-        ty::ty_int(ast::ty_i16) => ~[shape_i16],
-        ty::ty_uint(ast::ty_u32) => ~[shape_u32],
-        ty::ty_int(ast::ty_i32) | ty::ty_int(ast::ty_char) => ~[shape_i32],
-        ty::ty_uint(ast::ty_u64) => ~[shape_u64],
-        ty::ty_int(ast::ty_i64) => ~[shape_i64],
-        ty::ty_float(ast::ty_f32) => ~[shape_f32],
-        ty::ty_float(ast::ty_f64) => ~[shape_f64],
-        ty::ty_estr(ty::vstore_uniq) => {
-            shape_of(ccx, tvec::expand_boxed_vec_ty(ccx.tcx, t))
-        }
-        ty::ty_enum(did, substs) => {
-            match enum_kind(ccx, did) {
-                tk_unit => ~[s_variant_enum_t(ccx.tcx)],
-                tk_enum => ~[s_variant_enum_t(ccx.tcx)],
-                tk_newtype | tk_complex => {
-                    let mut s = ~[shape_enum], id;
-                    let nom_id = mk_nominal_id(ccx.tcx, did,
-                                               None, substs.tps);
-                    match ccx.shape_cx.tag_id_to_index.find(nom_id) {
-                        None => {
-                            id = ccx.shape_cx.next_tag_id;
-                            ccx.shape_cx.tag_id_to_index.insert(nom_id, id);
-                            ccx.shape_cx.tag_order.push({did: did,
-                                                         substs: substs});
-                            ccx.shape_cx.next_tag_id += 1u16;
-                        }
-                        Some(existing_id) => id = existing_id,
-                    }
-                    add_u16(s, id as u16);
-
-                    s
-                }
-            }
-        }
-        ty::ty_estr(ty::vstore_box) |
-        ty::ty_evec(_, ty::vstore_box) |
-        ty::ty_box(_) | ty::ty_opaque_box => ~[shape_box],
-        ty::ty_uniq(mt) => {
-            let mut s = ~[shape_uniq];
-            add_substr(s, shape_of(ccx, mt.ty));
-            s
-        }
-        ty::ty_unboxed_vec(mt) => {
-            let mut s = ~[shape_unboxed_vec];
-            add_bool(s, ty::type_is_pod(ccx.tcx, mt.ty));
-            add_substr(s, shape_of(ccx, mt.ty));
-            s
-        }
-        ty::ty_evec(_, ty::vstore_uniq) => {
-            shape_of(ccx, tvec::expand_boxed_vec_ty(ccx.tcx, t))
-        }
-
-        ty::ty_estr(ty::vstore_fixed(n)) => {
-            let mut s = ~[shape_fixedvec];
-            let u8_t = ty::mk_mach_uint(ccx.tcx, ast::ty_u8);
-            assert (n + 1u) <= 0xffffu;
-            add_u16(s, (n + 1u) as u16);
-            add_bool(s, true);
-            add_substr(s, shape_of(ccx, u8_t));
-            s
-        }
-
-        ty::ty_evec(mt, ty::vstore_fixed(n)) => {
-            let mut s = ~[shape_fixedvec];
-            assert n <= 0xffffu;
-            add_u16(s, n as u16);
-            add_bool(s, ty::type_is_pod(ccx.tcx, mt.ty));
-            add_substr(s, shape_of(ccx, mt.ty));
-            s
-        }
-
-        ty::ty_estr(ty::vstore_slice(_)) => {
-            let mut s = ~[shape_slice];
-            let u8_t = ty::mk_mach_uint(ccx.tcx, ast::ty_u8);
-            add_bool(s, true); // is_pod
-            add_bool(s, true); // is_str
-            add_substr(s, shape_of(ccx, u8_t));
-            s
-        }
-
-        ty::ty_evec(mt, ty::vstore_slice(_)) => {
-            let mut s = ~[shape_slice];
-            add_bool(s, ty::type_is_pod(ccx.tcx, mt.ty));
-            add_bool(s, false); // is_str
-            add_substr(s, shape_of(ccx, mt.ty));
-            s
-        }
-
-        ty::ty_rec(fields) => {
-            let mut s = ~[shape_struct], sub = ~[];
-            for vec::each(fields) |f| {
-                sub += shape_of(ccx, f.mt.ty);
-            }
-            add_substr(s, sub);
-            s
-        }
-        ty::ty_tup(elts) => {
-            let mut s = ~[shape_struct], sub = ~[];
-            for vec::each(elts) |elt| {
-                sub += shape_of(ccx, *elt);
-            }
-            add_substr(s, sub);
-            s
-        }
-        ty::ty_trait(_, _, _) => ~[shape_box_fn],
-        ty::ty_class(did, ref substs) => {
-            // same as records, unless there's a dtor
-            let tps = substs.tps;
-            let m_dtor_did = ty::ty_dtor(ccx.tcx, did);
-            let mut s = if m_dtor_did.is_some() {
-                ~[shape_res]
-            }
-            else { ~[shape_struct] }, sub = ~[];
-            do m_dtor_did.iter |dtor_did| {
-                let ri = @{did: dtor_did, parent_id: Some(did), tps: tps};
-                let id = ccx.shape_cx.resources.intern(ri);
-                add_u16(s, id as u16);
-            };
-            for ty::class_items_as_mutable_fields(ccx.tcx, did,
-                                                  substs).each |f| {
-                sub += shape_of(ccx, f.mt.ty);
-            }
-            add_substr(s, sub);
-            s
-        }
-        ty::ty_rptr(_, mt) => {
-            let mut s = ~[shape_rptr];
-            add_substr(s, shape_of(ccx, mt.ty));
-            s
-        }
-        ty::ty_param(*) => {
-            ccx.tcx.sess.bug(~"non-monomorphized type parameter");
-        }
-        ty::ty_fn(ref fn_ty) => {
-            match fn_ty.meta.proto {
-                ty::proto_vstore(ty::vstore_box) => ~[shape_box_fn],
-                ty::proto_vstore(ty::vstore_uniq) => ~[shape_uniq_fn],
-                ty::proto_vstore(ty::vstore_slice(_)) => ~[shape_stack_fn],
-                ty::proto_bare => ~[shape_bare_fn],
-                ty::proto_vstore(ty::vstore_fixed(_)) =>
-                fail ~"fixed vstore is impossible",
-            }
-        }
-        ty::ty_opaque_closure_ptr(_) => ~[shape_opaque_closure_ptr],
-        ty::ty_infer(_) | ty::ty_self => {
-            ccx.sess.bug(~"shape_of: unexpected type struct found")
-        }
-    }
-}
-
-fn shape_of_variant(ccx: @crate_ctxt, v: ty::variant_info) -> ~[u8] {
-    let mut s = ~[];
-    for vec::each(v.args) |t| { s += shape_of(ccx, *t); }
-    return s;
-}
-
-fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef {
-    // Loop over all the enum variants and write their shapes into a
-    // data buffer. As we do this, it's possible for us to discover
-    // new enums, so we must do this first.
-    let mut data = ~[];
-    let mut offsets = ~[];
-    let mut i = 0u;
-    let mut enum_variants = ~[];
-    while i < ccx.shape_cx.tag_order.len() {
-        let {did, substs} = ccx.shape_cx.tag_order[i];
-        let variants = @ty::substd_enum_variants(ccx.tcx, did, &substs);
-        for vec::each(*variants) |v| {
-            offsets += ~[vec::len(data) as u16];
-
-            let variant_shape = shape_of_variant(ccx, *v);
-            add_substr(data, variant_shape);
-
-            let zname = str::to_bytes(ccx.sess.str_of(v.name)) + ~[0u8];
-            add_substr(data, zname);
-        }
-        enum_variants += ~[variants];
-        i += 1u;
-    }
-
-    // Now calculate the sizes of the header space (which contains offsets to
-    // info records for each enum) and the info space (which contains offsets
-    // to each variant shape). As we do so, build up the header.
-
-    let mut header = ~[];
-    let mut inf = ~[];
-    let header_sz = 2u16 * ccx.shape_cx.next_tag_id;
-    let data_sz = vec::len(data) as u16;
-
-    let mut inf_sz = 0u16;
-    for enum_variants.each |variants| {
-        let num_variants = vec::len(**variants) as u16;
-        add_u16(header, header_sz + inf_sz);
-        inf_sz += 2u16 * (num_variants + 2u16) + 3u16;
-    }
-
-    // Construct the info tables, which contain offsets to the shape of each
-    // variant. Also construct the largest-variant table for each enum, which
-    // contains the variants that the size-of operation needs to look at.
-
-    let mut lv_table = ~[];
-    let mut i = 0u;
-    for enum_variants.each |variants| {
-        add_u16(inf, vec::len(**variants) as u16);
-
-        // Construct the largest-variants table.
-        add_u16(inf,
-                header_sz + inf_sz + data_sz + (vec::len(lv_table) as u16));
-
-        let lv = largest_variants(ccx, *variants);
-        add_u16(lv_table, vec::len(lv) as u16);
-        for vec::each(lv) |v| { add_u16(lv_table, *v as u16); }
-
-        // Determine whether the enum has dynamic size.
-        assert !variants.any(|v| v.args.any(|t| ty::type_has_params(t)));
-
-        // If we can, write in the static size and alignment of the enum.
-        // Otherwise, write a placeholder.
-        let size_align = compute_static_enum_size(ccx, lv, *variants);
-
-        // Write in the static size and alignment of the enum.
-        add_u16(inf, size_align.size);
-        inf += ~[size_align.align];
-
-        // Now write in the offset of each variant.
-        for variants.each |_v| {
-            add_u16(inf, header_sz + inf_sz + offsets[i]);
-            i += 1u;
-        }
-    }
-
-    assert (i == vec::len(offsets));
-    assert (header_sz == vec::len(header) as u16);
-    assert (inf_sz == vec::len(inf) as u16);
-    assert (data_sz == vec::len(data) as u16);
-
-    header += inf;
-    header += data;
-    header += lv_table;
-
-    return mk_global(ccx, ~"tag_shapes", C_bytes(header), true);
-
-/* tjc: Not annotating FIXMEs in this module because of #1498 */
-    fn largest_variants(ccx: @crate_ctxt,
-                        variants: @~[ty::variant_info]) -> ~[uint] {
-        // Compute the minimum and maximum size and alignment for each
-        // variant.
-        //
-        // NB: We could do better here; e.g. we know that any
-        // variant that contains (T,T) must be as least as large as
-        // any variant that contains just T.
-        let mut ranges = ~[];
-        for vec::each(*variants) |variant| {
-            let mut bounded = true;
-            let mut min_size = 0u, min_align = 0u;
-            for vec::each(variant.args) |elem_t| {
-                if ty::type_has_params(*elem_t) {
-                    // NB: We could do better here; this causes us to
-                    // conservatively assume that (int, T) has minimum size 0,
-                    // when in fact it has minimum size sizeof(int).
-                    bounded = false;
-                } else {
-                    let llty = type_of::type_of(ccx, *elem_t);
-                    min_size += llsize_of_real(ccx, llty);
-                    min_align += llalign_of_pref(ccx, llty);
-                }
-            }
-
-            ranges +=
-                ~[{size: {min: min_size, bounded: bounded},
-                  align: {min: min_align, bounded: bounded}}];
-        }
-
-        // Initialize the candidate set to contain all variants.
-        let mut candidates = ~[mut];
-        for vec::each(*variants) |_v| { candidates += ~[mut true]; }
-
-        // Do a pairwise comparison among all variants still in the
-        // candidate set.  Throw out any variant that we know has size
-        // and alignment at least as small as some other variant.
-        let mut i = 0u;
-        while i < vec::len(ranges) - 1u {
-            if candidates[i] {
-                let mut j = i + 1u;
-                while j < vec::len(ranges) {
-                    if candidates[j] {
-                        if ranges[i].size.bounded &&
-                            ranges[i].align.bounded &&
-                            ranges[j].size.bounded &&
-                            ranges[j].align.bounded {
-                            if ranges[i].size.min >= ranges[j].size.min &&
-                                ranges[i].align.min >= ranges[j].align.min {
-                                // Throw out j.
-                                candidates[j] = false;
-                            } else if ranges[j].size.min >=
-                                    ranges[i].size.min &&
-                                ranges[j].align.min >=
-                                    ranges[j].align.min {
-                                // Throw out i.
-                                candidates[i] = false;
-                            }
-                        }
-                    }
-                    j += 1u;
-                }
-            }
-            i += 1u;
-        }
-
-        // Return the resulting set.
-        let mut result = ~[];
-        let mut i = 0u;
-        while i < vec::len(candidates) {
-            if candidates[i] { vec::push(result, i); }
-            i += 1u;
-        }
-        return result;
-    }
-
-    fn compute_static_enum_size(ccx: @crate_ctxt, largest_variants: ~[uint],
-                                variants: @~[ty::variant_info])
-        -> size_align {
-        let mut max_size = 0u16;
-        let mut max_align = 1u8;
-        for vec::each(largest_variants) |vid| {
-            // We increment a "virtual data pointer" to compute the size.
-            let mut lltys = ~[];
-            for vec::each(variants[*vid].args) |typ| {
-                lltys += ~[type_of::type_of(ccx, *typ)];
-            }
-
-            let llty = trans::common::T_struct(lltys);
-            let dp = llsize_of_real(ccx, llty) as u16;
-            let variant_align = llalign_of_pref(ccx, llty) as u8;
-
-            if max_size < dp { max_size = dp; }
-            if max_align < variant_align { max_align = variant_align; }
-        }
-
-        // Add space for the enum if applicable.
-        // FIXME (issue #792): This is wrong. If the enum starts with an
-        // 8 byte aligned quantity, we don't align it.
-        if vec::len(*variants) > 1u {
-            let variant_t = T_enum_discrim(ccx);
-            max_size += llsize_of_real(ccx, variant_t) as u16;
-            let align = llalign_of_pref(ccx, variant_t) as u8;
-            if max_align < align { max_align = align; }
-        }
-
-        return {size: max_size, align: max_align};
-    }
-}
-
-fn gen_resource_shapes(ccx: @crate_ctxt) -> ValueRef {
-    let mut dtors = ~[];
-    let len = ccx.shape_cx.resources.len();
-    for uint::range(0u, len) |i| {
-        let ri = ccx.shape_cx.resources.get(i);
-        for ri.tps.each() |s| { assert !ty::type_has_params(*s); }
-        do ri.parent_id.iter |id| {
-            dtors += ~[trans::base::get_res_dtor(ccx, ri.did, id, ri.tps)];
-        }
-    }
-    return mk_global(ccx, ~"resource_shapes", C_struct(dtors), true);
-}
-
-- 
cgit 1.4.1-3-g733a5


From e500659eb5482aea8b4675416449b03d5cfbe898 Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Tue, 25 Sep 2012 17:39:23 -0700
Subject: rustc: Reduce shape.rs to the bare minimum needed to not trigger bugs

---
 src/rustc/middle/trans/shape.rs | 169 ++--------------------------------------
 1 file changed, 6 insertions(+), 163 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/middle/trans/shape.rs b/src/rustc/middle/trans/shape.rs
index 7640cd095dc..cf58b5b51c4 100644
--- a/src/rustc/middle/trans/shape.rs
+++ b/src/rustc/middle/trans/shape.rs
@@ -23,92 +23,13 @@ use option::is_some;
 
 use ty_ctxt = middle::ty::ctxt;
 
-type nominal_id_ = {did: ast::def_id, parent_id: Option<ast::def_id>,
-                    tps: ~[ty::t]};
-type nominal_id = @nominal_id_;
-
-impl nominal_id_ : core::cmp::Eq {
-    pure fn eq(other: &nominal_id_) -> bool {
-        if self.did != other.did ||
-            self.parent_id != other.parent_id {
-            false
-        } else {
-            do vec::all2(self.tps, other.tps) |m_tp, n_tp| {
-                ty::type_id(m_tp) == ty::type_id(n_tp)
-            }
-        }
-    }
-    pure fn ne(other: &nominal_id_) -> bool {
-        ! (self == *other)
-    }
-}
-
-impl nominal_id_ : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
-        to_bytes::iter_bytes_2(&self.did, &self.parent_id, lsb0, f);
-        for self.tps.each |t| {
-            ty::type_id(*t).iter_bytes(lsb0, f);
-        }
-    }
-}
-
-fn mk_nominal_id(tcx: ty::ctxt, did: ast::def_id,
-                 parent_id: Option<ast::def_id>,
-                 tps: ~[ty::t]) -> nominal_id {
-    let tps_norm = tps.map(|t| ty::normalize_ty(tcx, *t));
-    @{did: did, parent_id: parent_id, tps: tps_norm}
-}
-
-fn new_nominal_id_hash<T: Copy>() -> HashMap<nominal_id, T> {
-    return HashMap();
-}
-
-type enum_data = {did: ast::def_id, substs: ty::substs};
-
-type ctxt =
-    {mut next_tag_id: u16,
-     pad: u16,
-     tag_id_to_index: HashMap<nominal_id, u16>,
-     tag_order: DVec<enum_data>,
-     resources: interner::interner<nominal_id>,
-     llshapetablesty: TypeRef,
-     llshapetables: ValueRef};
-
-const shape_u8: u8 = 0u8;
-const shape_u16: u8 = 1u8;
-const shape_u32: u8 = 2u8;
-const shape_u64: u8 = 3u8;
-const shape_i8: u8 = 4u8;
-const shape_i16: u8 = 5u8;
-const shape_i32: u8 = 6u8;
-const shape_i64: u8 = 7u8;
-const shape_f32: u8 = 8u8;
-const shape_f64: u8 = 9u8;
-const shape_box: u8 = 10u8;
-const shape_enum: u8 = 12u8;
-const shape_struct: u8 = 17u8;
-const shape_box_fn: u8 = 18u8;
-const shape_res: u8 = 20u8;
-const shape_uniq: u8 = 22u8;
-const shape_opaque_closure_ptr: u8 = 23u8; // the closure itself.
-const shape_uniq_fn: u8 = 25u8;
-const shape_stack_fn: u8 = 26u8;
-const shape_bare_fn: u8 = 27u8;
-const shape_tydesc: u8 = 28u8;
-const shape_send_tydesc: u8 = 29u8;
-const shape_rptr: u8 = 31u8;
-const shape_fixedvec: u8 = 32u8;
-const shape_slice: u8 = 33u8;
-const shape_unboxed_vec: u8 = 34u8;
+type ctxt = {mut next_tag_id: u16, pad: u16, pad2: u32};
 
 fn mk_global(ccx: @crate_ctxt, name: ~str, llval: ValueRef, internal: bool) ->
    ValueRef {
-    let llglobal =
-        str::as_c_str(name,
-                      |buf| {
-                        lib::llvm::llvm::LLVMAddGlobal(ccx.llmod,
-                                                       val_ty(llval), buf)
-                    });
+    let llglobal = do str::as_c_str(name) |buf| {
+        lib::llvm::llvm::LLVMAddGlobal(ccx.llmod, val_ty(llval), buf)
+    };
     lib::llvm::llvm::LLVMSetInitializer(llglobal, llval);
     lib::llvm::llvm::LLVMSetGlobalConstant(llglobal, True);
 
@@ -119,91 +40,13 @@ fn mk_global(ccx: @crate_ctxt, name: ~str, llval: ValueRef, internal: bool) ->
     return llglobal;
 }
 
-
-// Computes a set of variants of a enum that are guaranteed to have size and
-// alignment at least as large as any other variant of the enum. This is an
-// important performance optimization.
-
-fn round_up(size: u16, align: u8) -> u16 {
-    assert (align >= 1u8);
-    let alignment = align as u16;
-    return size - 1u16 + alignment & !(alignment - 1u16);
-}
-
-type size_align = {size: u16, align: u8};
-
-enum enum_kind {
-    tk_unit,    // 1 variant, no data
-    tk_enum,    // N variants, no data
-    tk_newtype, // 1 variant, data
-    tk_complex  // N variants, no data
-}
-
-fn enum_kind(ccx: @crate_ctxt, did: ast::def_id) -> enum_kind {
-    let variants = ty::enum_variants(ccx.tcx, did);
-    if vec::any(*variants, |v| vec::len(v.args) > 0u) {
-        if vec::len(*variants) == 1u { tk_newtype }
-        else { tk_complex }
-    } else {
-        if vec::len(*variants) <= 1u { tk_unit }
-        else { tk_enum }
-    }
-}
-
-// Returns the code corresponding to the pointer size on this architecture.
-fn s_int(tcx: ty_ctxt) -> u8 {
-    return match tcx.sess.targ_cfg.arch {
-        session::arch_x86 => shape_i32,
-        session::arch_x86_64 => shape_i64,
-        session::arch_arm => shape_i32
-    };
-}
-
-fn s_uint(tcx: ty_ctxt) -> u8 {
-    return match tcx.sess.targ_cfg.arch {
-        session::arch_x86 => shape_u32,
-        session::arch_x86_64 => shape_u64,
-        session::arch_arm => shape_u32
-    };
-}
-
-fn s_float(tcx: ty_ctxt) -> u8 {
-    return match tcx.sess.targ_cfg.arch {
-        session::arch_x86 => shape_f64,
-        session::arch_x86_64 => shape_f64,
-        session::arch_arm => shape_f64
-    };
-}
-
-fn s_variant_enum_t(tcx: ty_ctxt) -> u8 {
-    return s_int(tcx);
-}
-
-fn s_tydesc(_tcx: ty_ctxt) -> u8 {
-    return shape_tydesc;
-}
-
-fn s_send_tydesc(_tcx: ty_ctxt) -> u8 {
-    return shape_send_tydesc;
-}
-
 fn mk_ctxt(llmod: ModuleRef) -> ctxt {
     let llshapetablesty = trans::common::T_named_struct(~"shapes");
-    let llshapetables = str::as_c_str(~"shapes", |buf| {
+    let _llshapetables = str::as_c_str(~"shapes", |buf| {
         lib::llvm::llvm::LLVMAddGlobal(llmod, llshapetablesty, buf)
     });
 
-    return {mut next_tag_id: 0u16,
-         pad: 0u16,
-         tag_id_to_index: new_nominal_id_hash(),
-         tag_order: DVec(),
-         resources: interner::mk(),
-         llshapetablesty: llshapetablesty,
-         llshapetables: llshapetables};
-}
-
-fn add_bool(&dest: ~[u8], val: bool) {
-    dest += ~[if val { 1u8 } else { 0u8 }];
+    return {mut next_tag_id: 0u16, pad: 0u16, pad2: 0u32};
 }
 
 fn add_u16(&dest: ~[u8], val: u16) {
-- 
cgit 1.4.1-3-g733a5


From 62649f0412630f8bfe284996c82b6a723d2ffea9 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Tue, 25 Sep 2012 17:02:22 -0700
Subject: Check more things with deprecated_modes

---
 src/libcore/option.rs                           |   2 +-
 src/libstd/fun_treemap.rs                       |   2 +-
 src/libstd/list.rs                              |   2 +-
 src/libstd/test.rs                              |   2 +-
 src/libstd/treemap.rs                           |   2 +-
 src/rustc/middle/lint.rs                        | 127 ++++++++++++++++++------
 src/test/compile-fail/deprecated-mode-fn-arg.rs |   9 ++
 7 files changed, 110 insertions(+), 36 deletions(-)
 create mode 100644 src/test/compile-fail/deprecated-mode-fn-arg.rs

(limited to 'src/rustc')

diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index 6ab9a86d8f3..518775ec751 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -9,7 +9,7 @@
  */
 
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+#[warn(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
 use cmp::Eq;
diff --git a/src/libstd/fun_treemap.rs b/src/libstd/fun_treemap.rs
index d3cc11d2a31..714d6c93ffa 100644
--- a/src/libstd/fun_treemap.rs
+++ b/src/libstd/fun_treemap.rs
@@ -1,4 +1,4 @@
-#[forbid(deprecated_mode)];
+#[warn(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
 /*!
diff --git a/src/libstd/list.rs b/src/libstd/list.rs
index 45eafb3d018..b4e8678f6ae 100644
--- a/src/libstd/list.rs
+++ b/src/libstd/list.rs
@@ -1,5 +1,5 @@
 //! A standard linked list
-#[forbid(deprecated_mode)];
+#[warn(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
 use core::cmp::Eq;
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 51c0ad385ce..e872cba5dc9 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -5,7 +5,7 @@
 // simplest interface possible for representing and running tests
 // while providing a base that other test frameworks may build off of.
 
-#[forbid(deprecated_mode)];
+#[warn(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
 use core::cmp::Eq;
diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs
index 598a680f706..d6946590d80 100644
--- a/src/libstd/treemap.rs
+++ b/src/libstd/treemap.rs
@@ -5,7 +5,7 @@
  * very naive algorithm, but it will probably be updated to be a
  * red-black tree or something else.
  */
-#[forbid(deprecated_mode)];
+#[warn(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
 use core::cmp::{Eq, Ord};
diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs
index a6778d83b99..473931d8179 100644
--- a/src/rustc/middle/lint.rs
+++ b/src/rustc/middle/lint.rs
@@ -396,6 +396,7 @@ fn check_item(i: @ast::item, cx: ty::ctxt) {
     check_item_non_camel_case_types(cx, i);
     check_item_heap(cx, i);
     check_item_structural_records(cx, i);
+    check_item_deprecated_modes(cx, i);
 }
 
 // Take a visitor, and modify it so that it will not proceed past subitems.
@@ -666,43 +667,107 @@ fn check_fn(tcx: ty::ctxt, fk: visit::fn_kind, decl: ast::fn_decl,
     }
 
     let fn_ty = ty::node_id_to_type(tcx, id);
+    check_fn_deprecated_modes(tcx, fn_ty, decl, span, id);
+}
+
+fn check_fn_deprecated_modes(tcx: ty::ctxt, fn_ty: ty::t, decl: ast::fn_decl,
+                             span: span, id: ast::node_id) {
     match ty::get(fn_ty).sty {
-      ty::ty_fn(fn_ty) => {
-        let mut counter = 0;
-        do vec::iter2(fn_ty.sig.inputs, decl.inputs) |arg_ty, arg_ast| {
-            counter += 1;
-            debug!("arg %d, ty=%s, mode=%s",
-                   counter,
-                   ty_to_str(tcx, arg_ty.ty),
-                   mode_to_str(arg_ast.mode));
-            match arg_ast.mode {
-              ast::expl(ast::by_copy) => {
-                /* always allow by-copy */
-              }
+        ty::ty_fn(fn_ty) => {
+            let mut counter = 0;
+            do vec::iter2(fn_ty.sig.inputs, decl.inputs) |arg_ty, arg_ast| {
+                counter += 1;
+                debug!("arg %d, ty=%s, mode=%s",
+                       counter,
+                       ty_to_str(tcx, arg_ty.ty),
+                       mode_to_str(arg_ast.mode));
+                match arg_ast.mode {
+                    ast::expl(ast::by_copy) => {
+                        /* always allow by-copy */
+                    }
 
-              ast::expl(_) => {
-                tcx.sess.span_lint(
-                    deprecated_mode, id, id,
-                    span,
-                    fmt!("argument %d uses an explicit mode", counter));
-              }
+                    ast::expl(_) => {
+                        tcx.sess.span_lint(
+                            deprecated_mode, id, id,
+                            span,
+                            fmt!("argument %d uses an explicit mode", counter));
+                    }
 
-              ast::infer(_) => {
-                let kind = ty::type_kind(tcx, arg_ty.ty);
-                if !ty::kind_is_safe_for_default_mode(kind) {
-                    tcx.sess.span_lint(
-                        deprecated_mode, id, id,
-                        span,
-                        fmt!("argument %d uses the default mode \
-                              but shouldn't",
-                             counter));
+                    ast::infer(_) => {
+                        let kind = ty::type_kind(tcx, arg_ty.ty);
+                        if !ty::kind_is_safe_for_default_mode(kind) {
+                            tcx.sess.span_lint(
+                                deprecated_mode, id, id,
+                                span,
+                                fmt!("argument %d uses the default mode \
+                                      but shouldn't",
+                                     counter));
+                        }
+                    }
+                }
+
+                match ty::get(arg_ty.ty).sty {
+                    ty::ty_fn(*) => {
+                        let span = arg_ast.ty.span;
+                        // Recurse to check fn-type argument
+                        match arg_ast.ty.node {
+                            ast::ty_fn(_, _, _, decl) => {
+                                check_fn_deprecated_modes(tcx, arg_ty.ty,
+                                                          decl, span, id);
+                            }
+                            ast::ty_path(*) => {
+                                // This is probably a typedef, so we can't
+                                // see the actual fn decl
+                                // e.g. fn foo(f: InitOp<T>)
+                            }
+                            ast::ty_rptr(_, mt)
+                            | ast::ty_box(mt)
+                            | ast::ty_uniq(mt) => {
+                                // Functions with preceding sigil are parsed
+                                // as pointers of functions
+                                match mt.ty.node {
+                                    ast::ty_fn(_, _, _, decl) => {
+                                        check_fn_deprecated_modes(
+                                            tcx, arg_ty.ty,
+                                            decl, span, id);
+                                    }
+                                    _ => fail
+                                }
+                            }
+                            _ => {
+                                tcx.sess.span_warn(span, ~"what");
+                                error!("arg %d, ty=%s, mode=%s",
+                                       counter,
+                                       ty_to_str(tcx, arg_ty.ty),
+                                       mode_to_str(arg_ast.mode));
+                                error!("%?",arg_ast.ty.node);
+                                fail
+                            }
+                        };
+                    }
+                    _ => ()
                 }
-              }
             }
         }
-      }
-      _ => tcx.sess.impossible_case(span, ~"check_fn: function has \
-             non-fn type")
+
+        _ => tcx.sess.impossible_case(span, ~"check_fn: function has \
+                                              non-fn type")
+    }
+}
+
+fn check_item_deprecated_modes(tcx: ty::ctxt, it: @ast::item) {
+    match it.node {
+        ast::item_ty(ty, _) => {
+            match ty.node {
+                ast::ty_fn(_, _, _, decl) => {
+                    let fn_ty = ty::node_id_to_type(tcx, it.id);
+                    check_fn_deprecated_modes(
+                        tcx, fn_ty, decl, ty.span, it.id)
+                }
+                _ => ()
+            }
+        }
+        _ => ()
     }
 }
 
diff --git a/src/test/compile-fail/deprecated-mode-fn-arg.rs b/src/test/compile-fail/deprecated-mode-fn-arg.rs
new file mode 100644
index 00000000000..5afffb59dfc
--- /dev/null
+++ b/src/test/compile-fail/deprecated-mode-fn-arg.rs
@@ -0,0 +1,9 @@
+#[forbid(deprecated_mode)];
+
+fn foo(_f: fn(&i: int)) { //~ ERROR explicit mode
+}
+
+type Bar = fn(&i: int); //~ ERROR explicit mode
+
+fn main() {
+}
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From d05e2ad66c7bb2418b7c746f87486d4f74180193 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Tue, 25 Sep 2012 16:23:04 -0700
Subject: Demode core::result

---
 src/cargo/cargo.rs                            |  10 +--
 src/compiletest/errors.rs                     |   2 +-
 src/compiletest/header.rs                     |   2 +-
 src/compiletest/runtest.rs                    |   8 +-
 src/fuzzer/fuzzer.rs                          |   6 +-
 src/libcore/comm.rs                           |   2 +-
 src/libcore/io.rs                             |   6 +-
 src/libcore/private.rs                        |   2 +-
 src/libcore/result.rs                         | 116 ++++++++++++++------------
 src/libstd/json.rs                            |  14 ++--
 src/libstd/net_ip.rs                          |  16 ++--
 src/libstd/net_tcp.rs                         |  28 +++----
 src/libstd/net_url.rs                         |  32 +++----
 src/rustc/middle/typeck/astconv.rs            |   4 +-
 src/rustc/middle/typeck/infer/combine.rs      |   8 +-
 src/rustdoc/config.rs                         |  28 +++----
 src/test/bench/core-std.rs                    |   2 +-
 src/test/bench/shootout-fasta.rs              |   2 +-
 src/test/bench/shootout-k-nucleotide-pipes.rs |   2 +-
 src/test/bench/shootout-k-nucleotide.rs       |   2 +-
 src/test/bench/shootout-mandelbrot.rs         |   2 +-
 src/test/run-fail/result-get-fail.rs          |   2 +-
 src/test/run-pass/cleanup-copy-mode.rs        |   2 +-
 23 files changed, 153 insertions(+), 145 deletions(-)

(limited to 'src/rustc')

diff --git a/src/cargo/cargo.rs b/src/cargo/cargo.rs
index 4dcfc608e0e..6f356a6e943 100644
--- a/src/cargo/cargo.rs
+++ b/src/cargo/cargo.rs
@@ -460,7 +460,7 @@ fn parse_source(name: ~str, j: json::Json) -> source {
 fn try_parse_sources(filename: &Path, sources: map::HashMap<~str, source>) {
     if !os::path_exists(filename)  { return; }
     let c = io::read_whole_file_str(filename);
-    match json::from_str(result::get(c)) {
+    match json::from_str(c.get()) {
         Ok(json::Dict(j)) => {
           for j.each |k, v| {
                 sources.insert(k, parse_source(k, v));
@@ -579,7 +579,7 @@ fn load_source_info(c: &cargo, src: source) {
     let srcfile = dir.push("source.json");
     if !os::path_exists(&srcfile) { return; }
     let srcstr = io::read_whole_file_str(&srcfile);
-    match json::from_str(result::get(srcstr)) {
+    match json::from_str(srcstr.get()) {
         Ok(json::Dict(s)) => {
             let o = parse_source(src.name, json::Dict(s));
 
@@ -601,7 +601,7 @@ fn load_source_packages(c: &cargo, src: source) {
     let pkgfile = dir.push("packages.json");
     if !os::path_exists(&pkgfile) { return; }
     let pkgstr = io::read_whole_file_str(&pkgfile);
-    match json::from_str(result::get(pkgstr)) {
+    match json::from_str(pkgstr.get()) {
         Ok(json::List(js)) => {
           for (*js).each |j| {
                 match *j {
@@ -659,7 +659,7 @@ fn build_cargo_options(argv: ~[~str]) -> options {
 fn configure(opts: options) -> cargo {
     let home = match get_cargo_root() {
         Ok(home) => home,
-        Err(_err) => result::get(get_cargo_sysroot())
+        Err(_err) => get_cargo_sysroot().get()
     };
 
     let get_cargo_dir = match opts.mode {
@@ -668,7 +668,7 @@ fn configure(opts: options) -> cargo {
         local_mode => get_cargo_root_nearest
     };
 
-    let p = result::get(get_cargo_dir());
+    let p = get_cargo_dir().get();
 
     let sources = map::HashMap();
     try_parse_sources(&home.push("sources.json"), sources);
diff --git a/src/compiletest/errors.rs b/src/compiletest/errors.rs
index e7d6593061d..a8b69201a22 100644
--- a/src/compiletest/errors.rs
+++ b/src/compiletest/errors.rs
@@ -9,7 +9,7 @@ type expected_error = { line: uint, kind: ~str, msg: ~str };
 // Load any test directives embedded in the file
 fn load_errors(testfile: &Path) -> ~[expected_error] {
     let mut error_patterns = ~[];
-    let rdr = result::get(io::file_reader(testfile));
+    let rdr = io::file_reader(testfile).get();
     let mut line_num = 1u;
     while !rdr.eof() {
         let ln = rdr.read_line();
diff --git a/src/compiletest/header.rs b/src/compiletest/header.rs
index 4ff1b8e9c78..5cd54a115ff 100644
--- a/src/compiletest/header.rs
+++ b/src/compiletest/header.rs
@@ -73,7 +73,7 @@ fn is_test_ignored(config: config, testfile: &Path) -> bool {
 }
 
 fn iter_header(testfile: &Path, it: fn(~str) -> bool) -> bool {
-    let rdr = result::get(io::file_reader(testfile));
+    let rdr = io::file_reader(testfile).get();
     while !rdr.eof() {
         let ln = rdr.read_line();
 
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
index 1c69e511137..fcb007eca8b 100644
--- a/src/compiletest/runtest.rs
+++ b/src/compiletest/runtest.rs
@@ -109,7 +109,7 @@ fn run_pretty_test(config: config, props: test_props, testfile: &Path) {
     let rounds =
         match props.pp_exact { option::Some(_) => 1, option::None => 2 };
 
-    let mut srcs = ~[result::get(io::read_whole_file_str(testfile))];
+    let mut srcs = ~[io::read_whole_file_str(testfile).get()];
 
     let mut round = 0;
     while round < rounds {
@@ -129,7 +129,7 @@ fn run_pretty_test(config: config, props: test_props, testfile: &Path) {
         match props.pp_exact {
           option::Some(file) => {
             let filepath = testfile.dir_path().push_rel(&file);
-            result::get(io::read_whole_file_str(&filepath))
+            io::read_whole_file_str(&filepath).get()
           }
           option::None => { srcs[vec::len(srcs) - 2u] }
         };
@@ -561,8 +561,8 @@ fn dump_output(config: config, testfile: &Path, out: ~str, err: ~str) {
 fn dump_output_file(config: config, testfile: &Path,
                     out: ~str, extension: ~str) {
     let outfile = make_out_name(config, testfile, extension);
-    let writer = result::get(
-        io::file_writer(&outfile, ~[io::Create, io::Truncate]));
+    let writer =
+        io::file_writer(&outfile, ~[io::Create, io::Truncate]).get();
     writer.write_str(out);
 }
 
diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs
index 5e2cf689b7c..65adbb9e09e 100644
--- a/src/fuzzer/fuzzer.rs
+++ b/src/fuzzer/fuzzer.rs
@@ -19,7 +19,7 @@ impl test_mode : cmp::Eq {
 
 fn write_file(filename: &Path, content: ~str) {
     result::get(
-        io::file_writer(filename, ~[io::Create, io::Truncate]))
+        &io::file_writer(filename, ~[io::Create, io::Truncate]))
         .write_str(content);
 }
 
@@ -543,7 +543,7 @@ fn check_convergence(files: &[Path]) {
     error!("pp convergence tests: %u files", vec::len(files));
     for files.each |file| {
         if !file_might_not_converge(file) {
-            let s = @result::get(io::read_whole_file_str(file));
+            let s = @result::get(&io::read_whole_file_str(file));
             if !content_might_not_converge(*s) {
                 error!("pp converge: %s", file.to_str());
                 // Change from 7u to 2u once
@@ -563,7 +563,7 @@ fn check_variants(files: &[Path], cx: context) {
             loop;
         }
 
-        let s = @result::get(io::read_whole_file_str(file));
+        let s = @result::get(&io::read_whole_file_str(file));
         if contains(*s, ~"#") {
             loop; // Macros are confusing
         }
diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs
index b99eec8bb5b..a32d7af2ac6 100644
--- a/src/libcore/comm.rs
+++ b/src/libcore/comm.rs
@@ -459,7 +459,7 @@ fn test_recv_chan_wrong_task() {
     let po = Port();
     let ch = Chan(po);
     send(ch, ~"flower");
-    assert result::is_err(task::try(||
+    assert result::is_err(&task::try(||
         recv_chan(ch)
     ))
 }
diff --git a/src/libcore/io.rs b/src/libcore/io.rs
index 7c08e508d51..9a2a177c196 100644
--- a/src/libcore/io.rs
+++ b/src/libcore/io.rs
@@ -645,7 +645,7 @@ impl<T: Writer> T : WriterUtil {
 
 #[allow(non_implicitly_copyable_typarams)]
 fn file_writer(path: &Path, flags: ~[FileFlag]) -> Result<Writer, ~str> {
-    result::chain(mk_file_writer(path, flags), |w| result::Ok(w))
+    mk_file_writer(path, flags).chain(|w| result::Ok(w))
 }
 
 
@@ -864,10 +864,10 @@ mod tests {
         {
             let out: io::Writer =
                 result::get(
-                    io::file_writer(tmpfile, ~[io::Create, io::Truncate]));
+                    &io::file_writer(tmpfile, ~[io::Create, io::Truncate]));
             out.write_str(frood);
         }
-        let inp: io::Reader = result::get(io::file_reader(tmpfile));
+        let inp: io::Reader = result::get(&io::file_reader(tmpfile));
         let frood2: ~str = inp.read_c_str();
         log(debug, frood2);
         assert frood == frood2;
diff --git a/src/libcore/private.rs b/src/libcore/private.rs
index 777aea7320c..9fe05723d35 100644
--- a/src/libcore/private.rs
+++ b/src/libcore/private.rs
@@ -283,7 +283,7 @@ fn test_weaken_task_fail() {
             }
         }
     };
-    assert result::is_err(res);
+    assert result::is_err(&res);
 }
 
 /****************************************************************************
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index 205d375e9db..3735d555e2d 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -1,5 +1,9 @@
 //! A type representing either success or failure
 
+// NB: transitionary, de-mode-ing.
+#[forbid(deprecated_mode)];
+#[forbid(deprecated_pattern)];
+
 use cmp::Eq;
 use either::Either;
 
@@ -18,8 +22,8 @@ enum Result<T, U> {
  *
  * If the result is an error
  */
-pure fn get<T: Copy, U>(res: Result<T, U>) -> T {
-    match res {
+pure fn get<T: Copy, U>(res: &Result<T, U>) -> T {
+    match *res {
       Ok(t) => t,
       Err(the_err) => unsafe {
         fail fmt!("get called on error result: %?", the_err)
@@ -50,23 +54,23 @@ pure fn get_ref<T, U>(res: &a/Result<T, U>) -> &a/T {
  *
  * If the result is not an error
  */
-pure fn get_err<T, U: Copy>(res: Result<T, U>) -> U {
-    match res {
+pure fn get_err<T, U: Copy>(res: &Result<T, U>) -> U {
+    match *res {
       Err(u) => u,
       Ok(_) => fail ~"get_err called on ok result"
     }
 }
 
 /// Returns true if the result is `ok`
-pure fn is_ok<T, U>(res: Result<T, U>) -> bool {
-    match res {
+pure fn is_ok<T, U>(res: &Result<T, U>) -> bool {
+    match *res {
       Ok(_) => true,
       Err(_) => false
     }
 }
 
 /// Returns true if the result is `err`
-pure fn is_err<T, U>(res: Result<T, U>) -> bool {
+pure fn is_err<T, U>(res: &Result<T, U>) -> bool {
     !is_ok(res)
 }
 
@@ -76,8 +80,8 @@ pure fn is_err<T, U>(res: Result<T, U>) -> bool {
  * `ok` result variants are converted to `either::right` variants, `err`
  * result variants are converted to `either::left`.
  */
-pure fn to_either<T: Copy, U: Copy>(res: Result<U, T>) -> Either<T, U> {
-    match res {
+pure fn to_either<T: Copy, U: Copy>(res: &Result<U, T>) -> Either<T, U> {
+    match *res {
       Ok(res) => either::Right(res),
       Err(fail_) => either::Left(fail_)
     }
@@ -97,11 +101,13 @@ pure fn to_either<T: Copy, U: Copy>(res: Result<U, T>) -> Either<T, U> {
  *         ok(parse_bytes(buf))
  *     }
  */
-fn chain<T, U: Copy, V: Copy>(res: Result<T, V>, op: fn(T) -> Result<U, V>)
+fn chain<T, U: Copy, V: Copy>(+res: Result<T, V>, op: fn(+t: T) -> Result<U, V>)
     -> Result<U, V> {
-    match res {
-      Ok(t) => op(t),
-      Err(e) => Err(e)
+    // XXX: Should be writable with move + match
+    if res.is_ok() {
+        op(unwrap(res))
+    } else {
+        Err(unwrap_err(res))
     }
 }
 
@@ -114,10 +120,10 @@ fn chain<T, U: Copy, V: Copy>(res: Result<T, V>, op: fn(T) -> Result<U, V>)
  * successful result while handling an error.
  */
 fn chain_err<T: Copy, U: Copy, V: Copy>(
-    res: Result<T, V>,
-    op: fn(V) -> Result<T, U>)
+    +res: Result<T, V>,
+    op: fn(+t: V) -> Result<T, U>)
     -> Result<T, U> {
-    match res {
+    move match res {
       Ok(t) => Ok(t),
       Err(v) => op(v)
     }
@@ -137,9 +143,9 @@ fn chain_err<T: Copy, U: Copy, V: Copy>(
  *         print_buf(buf)
  *     }
  */
-fn iter<T, E>(res: Result<T, E>, f: fn(T)) {
-    match res {
-      Ok(t) => f(t),
+fn iter<T, E>(res: &Result<T, E>, f: fn((&T))) {
+    match *res {
+      Ok(t) => f(&t),
       Err(_) => ()
     }
 }
@@ -152,10 +158,10 @@ fn iter<T, E>(res: Result<T, E>, f: fn(T)) {
  * This function can be used to pass through a successful result while
  * handling an error.
  */
-fn iter_err<T, E>(res: Result<T, E>, f: fn(E)) {
-    match res {
+fn iter_err<T, E>(res: &Result<T, E>, f: fn((&E))) {
+    match *res {
       Ok(_) => (),
-      Err(e) => f(e)
+      Err(e) => f(&e)
     }
 }
 
@@ -173,10 +179,10 @@ fn iter_err<T, E>(res: Result<T, E>, f: fn(E)) {
  *         parse_bytes(buf)
  *     }
  */
-fn map<T, E: Copy, U: Copy>(res: Result<T, E>, op: fn(T) -> U)
+fn map<T, E: Copy, U: Copy>(res: &Result<T, E>, op: fn((&T)) -> U)
   -> Result<U, E> {
-    match res {
-      Ok(t) => Ok(op(t)),
+    match *res {
+      Ok(t) => Ok(op(&t)),
       Err(e) => Err(e)
     }
 }
@@ -189,63 +195,65 @@ fn map<T, E: Copy, U: Copy>(res: Result<T, E>, op: fn(T) -> U)
  * is immediately returned.  This function can be used to pass through a
  * successful result while handling an error.
  */
-fn map_err<T: Copy, E, F: Copy>(res: Result<T, E>, op: fn(E) -> F)
+fn map_err<T: Copy, E, F: Copy>(res: &Result<T, E>, op: fn((&E)) -> F)
   -> Result<T, F> {
-    match res {
+    match *res {
       Ok(t) => Ok(t),
-      Err(e) => Err(op(e))
+      Err(e) => Err(op(&e))
     }
 }
 
 impl<T, E> Result<T, E> {
-    fn is_ok() -> bool { is_ok(self) }
+    fn is_ok() -> bool { is_ok(&self) }
 
-    fn is_err() -> bool { is_err(self) }
+    fn is_err() -> bool { is_err(&self) }
 
-    fn iter(f: fn(T)) {
+    fn iter(f: fn((&T))) {
         match self {
-          Ok(t) => f(t),
+          Ok(t) => f(&t),
           Err(_) => ()
         }
     }
 
-    fn iter_err(f: fn(E)) {
+    fn iter_err(f: fn((&E))) {
         match self {
           Ok(_) => (),
-          Err(e) => f(e)
+          Err(e) => f(&e)
         }
     }
 }
 
 impl<T: Copy, E> Result<T, E> {
-    fn get() -> T { get(self) }
+    fn get() -> T { get(&self) }
 
-    fn map_err<F:Copy>(op: fn(E) -> F) -> Result<T,F> {
+    fn map_err<F:Copy>(op: fn((&E)) -> F) -> Result<T,F> {
         match self {
           Ok(t) => Ok(t),
-          Err(e) => Err(op(e))
+          Err(e) => Err(op(&e))
         }
     }
 }
 
 impl<T, E: Copy> Result<T, E> {
-    fn get_err() -> E { get_err(self) }
+    fn get_err() -> E { get_err(&self) }
 
-    fn map<U:Copy>(op: fn(T) -> U) -> Result<U,E> {
+    fn map<U:Copy>(op: fn((&T)) -> U) -> Result<U,E> {
         match self {
-          Ok(t) => Ok(op(t)),
+          Ok(t) => Ok(op(&t)),
           Err(e) => Err(e)
         }
     }
 }
 
 impl<T: Copy, E: Copy> Result<T, E> {
-    fn chain<U:Copy>(op: fn(T) -> Result<U,E>) -> Result<U,E> {
-        chain(self, op)
+    fn chain<U:Copy>(op: fn(+t: T) -> Result<U,E>) -> Result<U,E> {
+        // XXX: Bad copy
+        chain(copy self, op)
     }
 
-    fn chain_err<F:Copy>(op: fn(E) -> Result<T,F>) -> Result<T,F> {
-        chain_err(self, op)
+    fn chain_err<F:Copy>(op: fn(+t: E) -> Result<T,F>) -> Result<T,F> {
+        // XXX: Bad copy
+        chain_err(copy self, op)
     }
 }
 
@@ -280,11 +288,11 @@ fn map_vec<T,U:Copy,V:Copy>(
 }
 
 fn map_opt<T,U:Copy,V:Copy>(
-    o_t: Option<T>, op: fn(T) -> Result<V,U>) -> Result<Option<V>,U> {
+    o_t: &Option<T>, op: fn((&T)) -> Result<V,U>) -> Result<Option<V>,U> {
 
-    match o_t {
+    match *o_t {
       None => Ok(None),
-      Some(t) => match op(t) {
+      Some(t) => match op(&t) {
         Ok(v) => Ok(Some(v)),
         Err(e) => Err(e)
       }
@@ -301,14 +309,14 @@ fn map_opt<T,U:Copy,V:Copy>(
  * to accommodate an error like the vectors being of different lengths.
  */
 fn map_vec2<S,T,U:Copy,V:Copy>(ss: &[S], ts: &[T],
-                               op: fn(S,T) -> Result<V,U>) -> Result<~[V],U> {
+                               op: fn((&S),(&T)) -> Result<V,U>) -> Result<~[V],U> {
 
     assert vec::same_length(ss, ts);
     let n = vec::len(ts);
     let mut vs = vec::with_capacity(n);
     let mut i = 0u;
     while i < n {
-        match op(ss[i],ts[i]) {
+        match op(&ss[i],&ts[i]) {
           Ok(v) => vec::push(vs, v),
           Err(u) => return Err(u)
         }
@@ -323,13 +331,13 @@ fn map_vec2<S,T,U:Copy,V:Copy>(ss: &[S], ts: &[T],
  * on its own as no result vector is built.
  */
 fn iter_vec2<S,T,U:Copy>(ss: &[S], ts: &[T],
-                         op: fn(S,T) -> Result<(),U>) -> Result<(),U> {
+                         op: fn((&S),(&T)) -> Result<(),U>) -> Result<(),U> {
 
     assert vec::same_length(ss, ts);
     let n = vec::len(ts);
     let mut i = 0u;
     while i < n {
-        match op(ss[i],ts[i]) {
+        match op(&ss[i],&ts[i]) {
           Ok(()) => (),
           Err(u) => return Err(u)
         }
@@ -380,7 +388,7 @@ mod tests {
     #[legacy_exports];
     fn op1() -> result::Result<int, ~str> { result::Ok(666) }
 
-    fn op2(&&i: int) -> result::Result<uint, ~str> {
+    fn op2(+i: int) -> result::Result<uint, ~str> {
         result::Ok(i as uint + 1u)
     }
 
@@ -388,12 +396,12 @@ mod tests {
 
     #[test]
     fn chain_success() {
-        assert get(chain(op1(), op2)) == 667u;
+        assert get(&chain(op1(), op2)) == 667u;
     }
 
     #[test]
     fn chain_failure() {
-        assert get_err(chain(op3(), op2)) == ~"sadface";
+        assert get_err(&chain(op3(), op2)) == ~"sadface";
     }
 
     #[test]
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 0f7bec6344a..2002e143ffa 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -892,7 +892,7 @@ mod tests {
             ]))
         ]);
         let astr = to_str(a);
-        let b = result::get(from_str(astr));
+        let b = result::get(&from_str(astr));
         let bstr = to_str(b);
         assert astr == bstr;
         assert a == b;
@@ -1040,24 +1040,24 @@ mod tests {
         assert from_str(~"{\"a\":1,") ==
             Err({line: 1u, col: 8u, msg: @~"EOF while parsing object"});
 
-        assert eq(result::get(from_str(~"{}")), mk_dict(~[]));
-        assert eq(result::get(from_str(~"{\"a\": 3}")),
+        assert eq(result::get(&from_str(~"{}")), mk_dict(~[]));
+        assert eq(result::get(&from_str(~"{\"a\": 3}")),
                   mk_dict(~[(~"a", Num(3.0f))]));
 
-        assert eq(result::get(from_str(~"{ \"a\": null, \"b\" : true }")),
+        assert eq(result::get(&from_str(~"{ \"a\": null, \"b\" : true }")),
                   mk_dict(~[
                       (~"a", Null),
                       (~"b", Boolean(true))]));
-        assert eq(result::get(from_str(~"\n{ \"a\": null, \"b\" : true }\n")),
+        assert eq(result::get(&from_str(~"\n{ \"a\": null, \"b\" : true }\n")),
                   mk_dict(~[
                       (~"a", Null),
                       (~"b", Boolean(true))]));
-        assert eq(result::get(from_str(~"{\"a\" : 1.0 ,\"b\": [ true ]}")),
+        assert eq(result::get(&from_str(~"{\"a\" : 1.0 ,\"b\": [ true ]}")),
                   mk_dict(~[
                       (~"a", Num(1.0)),
                       (~"b", List(@~[Boolean(true)]))
                   ]));
-        assert eq(result::get(from_str(
+        assert eq(result::get(&from_str(
                       ~"{" +
                           ~"\"a\": 1.0, " +
                           ~"\"b\": [" +
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index 3e104e259b8..445bc62e4c9 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -176,24 +176,24 @@ mod v4 {
         unsafe {
             let INADDR_NONE = ll::get_INADDR_NONE();
             let ip_rep_result = parse_to_ipv4_rep(ip);
-            if result::is_err(ip_rep_result) {
-                let err_str = result::get_err(ip_rep_result);
+            if result::is_err(&ip_rep_result) {
+                let err_str = result::get_err(&ip_rep_result);
                 return result::Err({err_msg: err_str})
             }
             // ipv4_rep.as_u32 is unsafe :/
             let input_is_inaddr_none =
-                result::get(ip_rep_result).as_u32() == INADDR_NONE;
+                result::get(&ip_rep_result).as_u32() == INADDR_NONE;
 
             let new_addr = uv_ip4_addr(str::from_slice(ip), 22);
             let reformatted_name = uv_ip4_name(&new_addr);
             log(debug, fmt!("try_parse_addr: input ip: %s reparsed ip: %s",
                             ip, reformatted_name));
             let ref_ip_rep_result = parse_to_ipv4_rep(reformatted_name);
-            if result::is_err(ref_ip_rep_result) {
-                let err_str = result::get_err(ref_ip_rep_result);
+            if result::is_err(&ref_ip_rep_result) {
+                let err_str = result::get_err(&ref_ip_rep_result);
                 return result::Err({err_msg: err_str})
             }
-            if result::get(ref_ip_rep_result).as_u32() == INADDR_NONE &&
+            if result::get(&ref_ip_rep_result).as_u32() == INADDR_NONE &&
                  !input_is_inaddr_none {
                 return result::Err(
                     {err_msg: ~"uv_ip4_name produced invalid result."})
@@ -358,7 +358,7 @@ mod test {
         let localhost_name = ~"localhost";
         let iotask = uv::global_loop::get();
         let ga_result = get_addr(localhost_name, iotask);
-        if result::is_err(ga_result) {
+        if result::is_err(&ga_result) {
             fail ~"got err result from net::ip::get_addr();"
         }
         // note really sure how to realiably test/assert
@@ -384,6 +384,6 @@ mod test {
         let localhost_name = ~"sjkl234m,./sdf";
         let iotask = uv::global_loop::get();
         let ga_result = get_addr(localhost_name, iotask);
-        assert result::is_err(ga_result);
+        assert result::is_err(&ga_result);
     }
 }
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index a0a209eae52..a1c7637dee6 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -871,17 +871,17 @@ fn read_common_impl(socket_data: *TcpSocketData, timeout_msecs: uint)
     log(debug, ~"starting tcp::read");
     let iotask = (*socket_data).iotask;
     let rs_result = read_start_common_impl(socket_data);
-    if result::is_err(rs_result) {
-        let err_data = result::get_err(rs_result);
+    if result::is_err(&rs_result) {
+        let err_data = result::get_err(&rs_result);
         result::Err(err_data)
     }
     else {
         log(debug, ~"tcp::read before recv_timeout");
         let read_result = if timeout_msecs > 0u {
             timer::recv_timeout(
-               iotask, timeout_msecs, result::get(rs_result))
+               iotask, timeout_msecs, result::get(&rs_result))
         } else {
-            Some(core::comm::recv(result::get(rs_result)))
+            Some(core::comm::recv(result::get(&rs_result)))
         };
         log(debug, ~"tcp::read after recv_timeout");
         match read_result {
@@ -1514,9 +1514,9 @@ mod test {
 
                     let accept_result = accept(new_conn);
                     log(debug, ~"SERVER: after accept()");
-                    if result::is_err(accept_result) {
+                    if result::is_err(&accept_result) {
                         log(debug, ~"SERVER: error accept connection");
-                        let err_data = result::get_err(accept_result);
+                        let err_data = result::get_err(&accept_result);
                         core::comm::send(kill_ch, Some(err_data));
                         log(debug,
                             ~"SERVER/WORKER: send on err cont ch");
@@ -1558,8 +1558,8 @@ mod test {
             log(debug, ~"SERVER: recv'd on cont_ch..leaving listen cb");
         });
         // err check on listen_result
-        if result::is_err(listen_result) {
-            match result::get_err(listen_result) {
+        if result::is_err(&listen_result) {
+            match result::get_err(&listen_result) {
               GenericListenErr(name, msg) => {
                 fail fmt!("SERVER: exited abnormally name %s msg %s",
                                 name, msg);
@@ -1592,8 +1592,8 @@ mod test {
                            new_conn, kill_ch);
         });
         // err check on listen_result
-        if result::is_err(listen_result) {
-            result::get_err(listen_result)
+        if result::is_err(&listen_result) {
+            result::get_err(&listen_result)
         }
         else {
             fail ~"SERVER: did not fail as expected"
@@ -1609,9 +1609,9 @@ mod test {
         log(debug, ~"CLIENT: starting..");
         let connect_result = connect(move server_ip_addr, server_port,
                                      iotask);
-        if result::is_err(connect_result) {
+        if result::is_err(&connect_result) {
             log(debug, ~"CLIENT: failed to connect");
-            let err_data = result::get_err(connect_result);
+            let err_data = result::get_err(&connect_result);
             Err(err_data)
         }
         else {
@@ -1636,9 +1636,9 @@ mod test {
     fn tcp_write_single(sock: &TcpSocket, val: ~[u8]) {
         let write_result_future = sock.write_future(val);
         let write_result = write_result_future.get();
-        if result::is_err(write_result) {
+        if result::is_err(&write_result) {
             log(debug, ~"tcp_write_single: write failed!");
-            let err_data = result::get_err(write_result);
+            let err_data = result::get_err(&write_result);
             log(debug, fmt!("tcp_write_single err name: %s msg: %s",
                 err_data.err_name, err_data.err_msg));
             // meh. torn on what to do here.
diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs
index 74c603e29e9..2a27aed773d 100644
--- a/src/libstd/net_url.rs
+++ b/src/libstd/net_url.rs
@@ -627,30 +627,30 @@ fn get_query_fragment(rawurl: &str) ->
 fn from_str(rawurl: &str) -> result::Result<Url, ~str> {
     // scheme
     let mut schm = get_scheme(rawurl);
-    if result::is_err(schm) {
-        return result::Err(copy *result::get_err(schm));
+    if result::is_err(&schm) {
+        return result::Err(copy *result::get_err(&schm));
     }
     let (scheme, rest) = result::unwrap(schm);
 
     // authority
     let mut auth = get_authority(rest);
-    if result::is_err(auth) {
-        return result::Err(copy *result::get_err(auth));
+    if result::is_err(&auth) {
+        return result::Err(copy *result::get_err(&auth));
     }
     let (userinfo, host, port, rest) = result::unwrap(auth);
 
     // path
     let has_authority = if host == ~"" { false } else { true };
     let mut pth = get_path(rest, has_authority);
-    if result::is_err(pth) {
-        return result::Err(copy *result::get_err(pth));
+    if result::is_err(&pth) {
+        return result::Err(copy *result::get_err(&pth));
     }
     let (path, rest) = result::unwrap(pth);
 
     // query and fragment
     let mut qry = get_query_fragment(rest);
-    if result::is_err(qry) {
-        return result::Err(copy *result::get_err(qry));
+    if result::is_err(&qry) {
+        return result::Err(copy *result::get_err(&qry));
     }
     let (query, fragment) = result::unwrap(qry);
 
@@ -796,13 +796,13 @@ mod tests {
         assert p == option::Some(~"8000");
 
         // invalid authorities;
-        assert result::is_err(get_authority(
+        assert result::is_err(&get_authority(
             ~"//user:pass@rust-lang:something"));
-        assert result::is_err(get_authority(
+        assert result::is_err(&get_authority(
             ~"//user@rust-lang:something:/path"));
-        assert result::is_err(get_authority(
+        assert result::is_err(&get_authority(
             ~"//2001:0db8:85a3:0042:0000:8a2e:0370:7334:800a"));
-        assert result::is_err(get_authority(
+        assert result::is_err(&get_authority(
             ~"//2001:0db8:85a3:0042:0000:8a2e:0370:7334:8000:00"));
 
         // these parse as empty, because they don't start with '//'
@@ -830,7 +830,7 @@ mod tests {
         assert r == ~"?q=v";
 
         //failure cases
-        assert result::is_err(get_path(~"something?q", true));
+        assert result::is_err(&get_path(~"something?q", true));
 
     }
 
@@ -877,13 +877,13 @@ mod tests {
 
     #[test]
     fn test_no_scheme() {
-        assert result::is_err(get_scheme(~"noschemehere.html"));
+        assert result::is_err(&get_scheme(~"noschemehere.html"));
     }
 
     #[test]
     fn test_invalid_scheme_errors() {
-        assert result::is_err(from_str(~"99://something"));
-        assert result::is_err(from_str(~"://something"));
+        assert result::is_err(&from_str(~"99://something"));
+        assert result::is_err(&from_str(~"://something"));
     }
 
     #[test]
diff --git a/src/rustc/middle/typeck/astconv.rs b/src/rustc/middle/typeck/astconv.rs
index 0c474994553..5434677b6fc 100644
--- a/src/rustc/middle/typeck/astconv.rs
+++ b/src/rustc/middle/typeck/astconv.rs
@@ -415,7 +415,7 @@ fn ty_of_arg<AC: ast_conv, RS: region_scope Copy Owned>(
     let mode = {
         match a.mode {
           ast::infer(_) if expected_ty.is_some() => {
-            result::get(ty::unify_mode(
+            result::get(&ty::unify_mode(
                 self.tcx(),
                 ty::expected_found {expected: expected_ty.get().mode,
                                     found: a.mode}))
@@ -434,7 +434,7 @@ fn ty_of_arg<AC: ast_conv, RS: region_scope Copy Owned>(
               _ => {
                 let m1 = ast::expl(ty::default_arg_mode_for_ty(self.tcx(),
                                                                ty));
-                result::get(ty::unify_mode(
+                result::get(&ty::unify_mode(
                     self.tcx(),
                     ty::expected_found {expected: m1,
                                         found: a.mode}))
diff --git a/src/rustc/middle/typeck/infer/combine.rs b/src/rustc/middle/typeck/infer/combine.rs
index 84791b59b32..db65bff9bfe 100644
--- a/src/rustc/middle/typeck/infer/combine.rs
+++ b/src/rustc/middle/typeck/infer/combine.rs
@@ -221,7 +221,7 @@ fn super_tps<C:combine>(
 
     if vec::same_length(as_, bs) {
         iter_vec2(as_, bs, |a, b| {
-            eq_tys(self, a, b)
+            eq_tys(self, *a, *b)
         }).then(|| Ok(as_.to_vec()) )
     } else {
         Err(ty::terr_ty_param_size(
@@ -327,7 +327,7 @@ fn super_fn_sigs<C:combine>(
                           b_args: ~[ty::arg]) -> cres<~[ty::arg]> {
 
         if vec::same_length(a_args, b_args) {
-            map_vec2(a_args, b_args, |a, b| self.args(a, b))
+            map_vec2(a_args, b_args, |a, b| self.args(*a, *b))
         } else {
             Err(ty::terr_arg_count)
         }
@@ -474,7 +474,7 @@ fn super_tys<C:combine>(
       (ty::ty_rec(as_), ty::ty_rec(bs)) => {
         if vec::same_length(as_, bs) {
             map_vec2(as_, bs, |a,b| {
-                self.flds(a, b)
+                self.flds(*a, *b)
             }).chain(|flds| Ok(ty::mk_rec(tcx, flds)) )
         } else {
             Err(ty::terr_record_size(expected_found(self, as_.len(),
@@ -484,7 +484,7 @@ fn super_tys<C:combine>(
 
       (ty::ty_tup(as_), ty::ty_tup(bs)) => {
         if vec::same_length(as_, bs) {
-            map_vec2(as_, bs, |a, b| self.tys(a, b) )
+            map_vec2(as_, bs, |a, b| self.tys(*a, *b) )
                 .chain(|ts| Ok(ty::mk_tup(tcx, ts)) )
         } else {
             Err(ty::terr_tuple_size(
diff --git a/src/rustdoc/config.rs b/src/rustdoc/config.rs
index b95e1657043..d8e79182506 100644
--- a/src/rustdoc/config.rs
+++ b/src/rustdoc/config.rs
@@ -285,20 +285,20 @@ mod test {
 #[test]
 fn should_error_with_no_crates() {
     let config = test::parse_config(~[~"rustdoc"]);
-    assert result::get_err(config) == ~"no crates specified";
+    assert config.get_err() == ~"no crates specified";
 }
 
 #[test]
 fn should_error_with_multiple_crates() {
     let config =
         test::parse_config(~[~"rustdoc", ~"crate1.rc", ~"crate2.rc"]);
-    assert result::get_err(config) == ~"multiple crates specified";
+    assert config.get_err() == ~"multiple crates specified";
 }
 
 #[test]
 fn should_set_output_dir_to_cwd_if_not_provided() {
     let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]);
-    assert result::get(config).output_dir == Path(".");
+    assert config.get().output_dir == Path(".");
 }
 
 #[test]
@@ -306,13 +306,13 @@ fn should_set_output_dir_if_provided() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--output-dir", ~"snuggles"
     ]);
-    assert result::get(config).output_dir == Path("snuggles");
+    assert config.get().output_dir == Path("snuggles");
 }
 
 #[test]
 fn should_set_output_format_to_pandoc_html_if_not_provided() {
     let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]);
-    assert result::get(config).output_format == PandocHtml;
+    assert config.get().output_format == PandocHtml;
 }
 
 #[test]
@@ -320,7 +320,7 @@ fn should_set_output_format_to_markdown_if_requested() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--output-format", ~"markdown"
     ]);
-    assert result::get(config).output_format == Markdown;
+    assert config.get().output_format == Markdown;
 }
 
 #[test]
@@ -328,7 +328,7 @@ fn should_set_output_format_to_pandoc_html_if_requested() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--output-format", ~"html"
     ]);
-    assert result::get(config).output_format == PandocHtml;
+    assert config.get().output_format == PandocHtml;
 }
 
 #[test]
@@ -336,13 +336,13 @@ fn should_error_on_bogus_format() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--output-format", ~"bogus"
     ]);
-    assert result::get_err(config) == ~"unknown output format 'bogus'";
+    assert config.get_err() == ~"unknown output format 'bogus'";
 }
 
 #[test]
 fn should_set_output_style_to_doc_per_mod_by_default() {
     let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]);
-    assert result::get(config).output_style == DocPerMod;
+    assert config.get().output_style == DocPerMod;
 }
 
 #[test]
@@ -350,7 +350,7 @@ fn should_set_output_style_to_one_doc_if_requested() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-crate"
     ]);
-    assert result::get(config).output_style == DocPerCrate;
+    assert config.get().output_style == DocPerCrate;
 }
 
 #[test]
@@ -358,7 +358,7 @@ fn should_set_output_style_to_doc_per_mod_if_requested() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-mod"
     ]);
-    assert result::get(config).output_style == DocPerMod;
+    assert config.get().output_style == DocPerMod;
 }
 
 #[test]
@@ -366,7 +366,7 @@ fn should_error_on_bogus_output_style() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--output-style", ~"bogus"
     ]);
-    assert result::get_err(config) == ~"unknown output style 'bogus'";
+    assert config.get_err() == ~"unknown output style 'bogus'";
 }
 
 #[test]
@@ -374,11 +374,11 @@ fn should_set_pandoc_command_if_requested() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--pandoc-cmd", ~"panda-bear-doc"
     ]);
-    assert result::get(config).pandoc_cmd == Some(~"panda-bear-doc");
+    assert config.get().pandoc_cmd == Some(~"panda-bear-doc");
 }
 
 #[test]
 fn should_set_pandoc_command_when_using_pandoc() {
     let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]);
-    assert result::get(config).pandoc_cmd == Some(~"pandoc");
+    assert config.get().pandoc_cmd == Some(~"pandoc");
 }
diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs
index a88793705a6..535b76bc94b 100644
--- a/src/test/bench/core-std.rs
+++ b/src/test/bench/core-std.rs
@@ -56,7 +56,7 @@ fn read_line() {
         .push_rel(&Path("src/test/bench/shootout-k-nucleotide.data"));
 
     for int::range(0, 3) |_i| {
-        let reader = result::get(io::file_reader(&path));
+        let reader = result::get(&io::file_reader(&path));
         while !reader.eof() {
             reader.read_line();
         }
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index a07b29f3dc6..0c742e16bfa 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -81,7 +81,7 @@ fn main(++args: ~[~str]) {
     };
 
     let writer = if os::getenv(~"RUST_BENCH").is_some() {
-        result::get(io::file_writer(&Path("./shootout-fasta.data"),
+        result::get(&io::file_writer(&Path("./shootout-fasta.data"),
                                     ~[io::Truncate, io::Create]))
     } else {
         io::stdout()
diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs
index dbdcf15db8a..b5dcacd76d3 100644
--- a/src/test/bench/shootout-k-nucleotide-pipes.rs
+++ b/src/test/bench/shootout-k-nucleotide-pipes.rs
@@ -134,7 +134,7 @@ fn main(++args: ~[~str]) {
        // get to this massive data set, but #include_bin chokes on it (#2598)
        let path = Path(env!("CFG_SRC_DIR"))
            .push_rel(&Path("src/test/bench/shootout-k-nucleotide.data"));
-       result::get(io::file_reader(&path))
+       result::get(&io::file_reader(&path))
    } else {
       io::stdin()
    };
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index d9d5827c56d..5f7036ed82a 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -131,7 +131,7 @@ fn main(++args: ~[~str]) {
        // get to this massive data set, but #include_bin chokes on it (#2598)
        let path = Path(env!("CFG_SRC_DIR"))
            .push_rel(&Path("src/test/bench/shootout-k-nucleotide.data"));
-       result::get(io::file_reader(&path))
+       result::get(&io::file_reader(&path))
    } else {
       io::stdin()
    };
diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs
index f6386a207b1..0cf0f0da5e5 100644
--- a/src/test/bench/shootout-mandelbrot.rs
+++ b/src/test/bench/shootout-mandelbrot.rs
@@ -114,7 +114,7 @@ fn writer(path: ~str, writech: comm::Chan<comm::Chan<line>>, size: uint)
         }
         _ => {
             result::get(
-                io::file_writer(&Path(path),
+                &io::file_writer(&Path(path),
                 ~[io::Create, io::Truncate]))
         }
     };
diff --git a/src/test/run-fail/result-get-fail.rs b/src/test/run-fail/result-get-fail.rs
index fbc8378643b..2b8712f3d59 100644
--- a/src/test/run-fail/result-get-fail.rs
+++ b/src/test/run-fail/result-get-fail.rs
@@ -1,4 +1,4 @@
 // error-pattern:get called on error result: ~"kitty"
 fn main() {
-  log(error, result::get(result::Err::<int,~str>(~"kitty")));
+  log(error, result::get(&result::Err::<int,~str>(~"kitty")));
 }
diff --git a/src/test/run-pass/cleanup-copy-mode.rs b/src/test/run-pass/cleanup-copy-mode.rs
index 2cf1276887e..e4bfa54c410 100644
--- a/src/test/run-pass/cleanup-copy-mode.rs
+++ b/src/test/run-pass/cleanup-copy-mode.rs
@@ -2,7 +2,7 @@
 fn adder(+x: @int, +y: @int) -> int { return *x + *y; }
 fn failer() -> @int { fail; }
 fn main() {
-    assert(result::is_err(task::try(|| {
+    assert(result::is_err(&task::try(|| {
         adder(@2, failer()); ()
     })));
 }
-- 
cgit 1.4.1-3-g733a5


From 7acf89c022500437e65f0f17e4ca3404fabf5f15 Mon Sep 17 00:00:00 2001
From: Tim Chevalier <chevalier@alum.wellesley.edu>
Date: Tue, 25 Sep 2012 18:19:29 -0700
Subject: Fix long line

---
 src/rustc/middle/lint.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/rustc')

diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs
index 473931d8179..ff77a598d27 100644
--- a/src/rustc/middle/lint.rs
+++ b/src/rustc/middle/lint.rs
@@ -690,7 +690,7 @@ fn check_fn_deprecated_modes(tcx: ty::ctxt, fn_ty: ty::t, decl: ast::fn_decl,
                         tcx.sess.span_lint(
                             deprecated_mode, id, id,
                             span,
-                            fmt!("argument %d uses an explicit mode", counter));
+                         fmt!("argument %d uses an explicit mode", counter));
                     }
 
                     ast::infer(_) => {
-- 
cgit 1.4.1-3-g733a5


From e19e628b19af2921fc29818009496bc430640f76 Mon Sep 17 00:00:00 2001
From: Tim Chevalier <chevalier@alum.wellesley.edu>
Date: Tue, 25 Sep 2012 17:39:22 -0700
Subject: Demode iter-trait

---
 src/libcore/iter-trait.rs                  | 12 +++++++-----
 src/libcore/iter-trait/dlist.rs            |  4 ++--
 src/libcore/iter-trait/dvec.rs             |  4 ++--
 src/libcore/iter-trait/option.rs           | 12 ++++++------
 src/libcore/iter.rs                        | 22 +++++++++++-----------
 src/libcore/str.rs                         |  4 ++--
 src/libcore/vec.rs                         |  6 +++---
 src/libstd/net_url.rs                      |  2 +-
 src/rustc/driver/rustc.rs                  |  4 ++--
 src/rustc/middle/borrowck/check_loans.rs   |  4 ++--
 src/rustc/middle/check_alt.rs              |  2 +-
 src/rustc/middle/check_const.rs            |  2 +-
 src/rustc/middle/kind.rs                   |  6 +++---
 src/rustc/middle/privacy.rs                | 14 +++++++-------
 src/rustc/middle/region.rs                 |  2 +-
 src/rustc/middle/trans/expr.rs             |  2 +-
 src/rustc/middle/typeck/check/method.rs    |  2 +-
 src/rustdoc/rustdoc.rs                     |  2 +-
 src/test/run-pass/early-vtbl-resolution.rs |  2 +-
 src/test/run-pass/iter-contains.rs         | 16 ++++++++--------
 src/test/run-pass/iter-count.rs            | 14 +++++++-------
 21 files changed, 70 insertions(+), 68 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libcore/iter-trait.rs b/src/libcore/iter-trait.rs
index b2bb53d395f..fe42fe9e36c 100644
--- a/src/libcore/iter-trait.rs
+++ b/src/libcore/iter-trait.rs
@@ -2,17 +2,19 @@
 // workaround our lack of traits and lack of macros.  See core.{rc,rs} for
 // how this file is used.
 
+#[warn(deprecated_mode)];
+
 use cmp::{Eq, Ord};
 use inst::{IMPL_T, EACH, SIZE_HINT};
 export extensions;
 
 impl<A> IMPL_T<A>: iter::BaseIter<A> {
-    pure fn each(blk: fn(v: &A) -> bool) { EACH(self, blk) }
-    pure fn size_hint() -> Option<uint> { SIZE_HINT(self) }
+    pure fn each(blk: fn(v: &A) -> bool) { EACH(&self, blk) }
+    pure fn size_hint() -> Option<uint> { SIZE_HINT(&self) }
 }
 
 impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
-    pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(self, blk) }
+    pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(&self, blk) }
     pure fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) }
     pure fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) }
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
@@ -24,8 +26,8 @@ impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
 }
 
 impl<A: Eq> IMPL_T<A>: iter::EqIter<A> {
-    pure fn contains(x: A) -> bool { iter::contains(self, x) }
-    pure fn count(x: A) -> uint { iter::count(self, x) }
+    pure fn contains(x: &A) -> bool { iter::contains(self, x) }
+    pure fn count(x: &A) -> uint { iter::count(self, x) }
 }
 
 impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {
diff --git a/src/libcore/iter-trait/dlist.rs b/src/libcore/iter-trait/dlist.rs
index b6bbc1f70c0..1cf28f81dcc 100644
--- a/src/libcore/iter-trait/dlist.rs
+++ b/src/libcore/iter-trait/dlist.rs
@@ -8,7 +8,7 @@ type IMPL_T<A> = dlist::DList<A>;
  * e.g. breadth-first search with in-place enqueues), but removing the current
  * node is forbidden.
  */
-pure fn EACH<A>(self: IMPL_T<A>, f: fn(v: &A) -> bool) {
+pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
     let mut link = self.peek_n();
     while option::is_some(&link) {
         let nobe = option::get(&link);
@@ -29,6 +29,6 @@ pure fn EACH<A>(self: IMPL_T<A>, f: fn(v: &A) -> bool) {
     }
 }
 
-pure fn SIZE_HINT<A>(self: IMPL_T<A>) -> Option<uint> {
+pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
     Some(self.len())
 }
diff --git a/src/libcore/iter-trait/dvec.rs b/src/libcore/iter-trait/dvec.rs
index 0f51df7b545..049b13da265 100644
--- a/src/libcore/iter-trait/dvec.rs
+++ b/src/libcore/iter-trait/dvec.rs
@@ -6,7 +6,7 @@ type IMPL_T<A> = dvec::DVec<A>;
  *
  * Attempts to access this dvec during iteration will fail.
  */
-pure fn EACH<A>(self: IMPL_T<A>, f: fn(v: &A) -> bool) {
+pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
     unsafe {
         do self.swap |v| {
             v.each(f);
@@ -15,6 +15,6 @@ pure fn EACH<A>(self: IMPL_T<A>, f: fn(v: &A) -> bool) {
     }
 }
 
-pure fn SIZE_HINT<A>(self: IMPL_T<A>) -> Option<uint> {
+pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
     Some(self.len())
 }
diff --git a/src/libcore/iter-trait/option.rs b/src/libcore/iter-trait/option.rs
index e1ffec0a7d7..2f7f7a4be7b 100644
--- a/src/libcore/iter-trait/option.rs
+++ b/src/libcore/iter-trait/option.rs
@@ -1,16 +1,16 @@
 #[allow(non_camel_case_types)]
 type IMPL_T<A> = Option<A>;
 
-pure fn EACH<A>(self: IMPL_T<A>, f: fn(v: &A) -> bool) {
-    match self {
+pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
+    match *self {
       None => (),
       Some(ref a) => { f(a); }
     }
 }
 
-pure fn SIZE_HINT<A>(self: IMPL_T<A>) -> Option<uint> {
-    match self {
-      None => Some(0u),
-      Some(_) => Some(1u)
+pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
+    match *self {
+      None => Some(0),
+      Some(_) => Some(1)
     }
 }
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 8af4ce3d0b1..dade851473b 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -23,8 +23,8 @@ trait ExtendedIter<A> {
 }
 
 trait EqIter<A:Eq> {
-    pure fn contains(x: A) -> bool;
-    pure fn count(x: A) -> uint;
+    pure fn contains(x: &A) -> bool;
+    pure fn count(x: &A) -> uint;
 }
 
 trait Times {
@@ -66,11 +66,11 @@ trait Buildable<A> {
                                 builder: fn(push: pure fn(+v: A))) -> self;
 }
 
-pure fn eachi<A,IA:BaseIter<A>>(self: IA, blk: fn(uint, v: &A) -> bool) {
-    let mut i = 0u;
+pure fn eachi<A,IA:BaseIter<A>>(self: &IA, blk: fn(uint, v: &A) -> bool) {
+    let mut i = 0;
     for self.each |a| {
         if !blk(i, a) { break; }
-        i += 1u;
+        i += 1;
     }
 }
 
@@ -130,17 +130,17 @@ pure fn to_vec<A:Copy,IA:BaseIter<A>>(self: IA) -> ~[A] {
     foldl::<A,~[A],IA>(self, ~[], |r, a| vec::append(copy r, ~[a]))
 }
 
-pure fn contains<A:Eq,IA:BaseIter<A>>(self: IA, x: A) -> bool {
+pure fn contains<A:Eq,IA:BaseIter<A>>(self: IA, x: &A) -> bool {
     for self.each |a| {
-        if *a == x { return true; }
+        if *a == *x { return true; }
     }
     return false;
 }
 
-pure fn count<A:Eq,IA:BaseIter<A>>(self: IA, x: A) -> uint {
-    do foldl(self, 0u) |count, value| {
-        if value == x {
-            count + 1u
+pure fn count<A:Eq,IA:BaseIter<A>>(self: IA, x: &A) -> uint {
+    do foldl(self, 0) |count, value| {
+        if value == *x {
+            count + 1
         } else {
             count
         }
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index eaaf11dab5d..13fb2260045 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -377,7 +377,7 @@ fn unshift_char(s: &mut ~str, ch: char) {
 pure fn trim_left_chars(s: &str, chars_to_trim: &[char]) -> ~str {
     if chars_to_trim.is_empty() { return from_slice(s); }
 
-    match find(s, |c| !chars_to_trim.contains(c)) {
+    match find(s, |c| !chars_to_trim.contains(&c)) {
       None => ~"",
       Some(first) => unsafe { raw::slice_bytes(s, first, s.len()) }
     }
@@ -395,7 +395,7 @@ pure fn trim_left_chars(s: &str, chars_to_trim: &[char]) -> ~str {
 pure fn trim_right_chars(s: &str, chars_to_trim: &[char]) -> ~str {
     if chars_to_trim.is_empty() { return str::from_slice(s); }
 
-    match rfind(s, |c| !chars_to_trim.contains(c)) {
+    match rfind(s, |c| !chars_to_trim.contains(&c)) {
       None => ~"",
       Some(last) => {
         let {next, _} = char_range_at(s, last);
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index e3df52b3cd6..7c5f242e8ba 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -1873,7 +1873,7 @@ impl<A> &[A]: iter::BaseIter<A> {
 }
 
 impl<A> &[A]: iter::ExtendedIter<A> {
-    pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(self, blk) }
+    pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(&self, blk) }
     pure fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) }
     pure fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) }
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
@@ -1885,8 +1885,8 @@ impl<A> &[A]: iter::ExtendedIter<A> {
 }
 
 impl<A: Eq> &[A]: iter::EqIter<A> {
-    pure fn contains(x: A) -> bool { iter::contains(self, x) }
-    pure fn count(x: A) -> uint { iter::count(self, x) }
+    pure fn contains(x: &A) -> bool { iter::contains(self, x) }
+    pure fn count(x: &A) -> uint { iter::count(self, x) }
 }
 
 impl<A: Copy> &[A]: iter::CopyableIter<A> {
diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs
index 2a27aed773d..8116bd4fb30 100644
--- a/src/libstd/net_url.rs
+++ b/src/libstd/net_url.rs
@@ -524,7 +524,7 @@ fn get_authority(rawurl: &str) ->
 
     let host_is_end_plus_one: &fn() -> bool = || {
         end+1 == len
-            && !['?', '#', '/'].contains(rawurl[end] as char)
+            && !['?', '#', '/'].contains(&(rawurl[end] as char))
     };
 
     // finish up
diff --git a/src/rustc/driver/rustc.rs b/src/rustc/driver/rustc.rs
index 1b4b47f1014..0306d0dbb18 100644
--- a/src/rustc/driver/rustc.rs
+++ b/src/rustc/driver/rustc.rs
@@ -140,12 +140,12 @@ fn run_compiler(args: ~[~str], demitter: diagnostic::emitter) {
 
     let lint_flags = vec::append(getopts::opt_strs(matches, ~"W"),
                                  getopts::opt_strs(matches, ~"warn"));
-    if lint_flags.contains(~"help") {
+    if lint_flags.contains(&~"help") {
         describe_warnings();
         return;
     }
 
-    if getopts::opt_strs(matches, ~"Z").contains(~"help") {
+    if getopts::opt_strs(matches, ~"Z").contains(&~"help") {
         describe_debug_flags();
         return;
     }
diff --git a/src/rustc/middle/borrowck/check_loans.rs b/src/rustc/middle/borrowck/check_loans.rs
index c0aaa041d18..cedab91b04e 100644
--- a/src/rustc/middle/borrowck/check_loans.rs
+++ b/src/rustc/middle/borrowck/check_loans.rs
@@ -204,7 +204,7 @@ impl check_loan_ctxt {
                 let did = ast_util::def_id_of_def(def);
                 let is_fn_arg =
                     did.crate == ast::local_crate &&
-                    (*self.fn_args).contains(did.node);
+                    (*self.fn_args).contains(&(did.node));
                 if is_fn_arg { return; } // case (a) above
               }
               ast::expr_fn_block(*) | ast::expr_fn(*) |
@@ -251,7 +251,7 @@ impl check_loan_ctxt {
             let def = self.tcx().def_map.get(expr.id);
             let did = ast_util::def_id_of_def(def);
             did.crate == ast::local_crate &&
-                (*self.fn_args).contains(did.node)
+                (*self.fn_args).contains(&(did.node))
           }
           ast::expr_fn_block(*) | ast::expr_fn(*) => {
             self.is_stack_closure(expr.id)
diff --git a/src/rustc/middle/check_alt.rs b/src/rustc/middle/check_alt.rs
index 0d8d8b8dfe0..32801ed760c 100644
--- a/src/rustc/middle/check_alt.rs
+++ b/src/rustc/middle/check_alt.rs
@@ -275,7 +275,7 @@ fn missing_ctor(tcx: ty::ctxt, m: matrix, left_ty: ty::t) -> Option<ctor> {
         let variants = ty::enum_variants(tcx, eid);
         if found.len() != (*variants).len() {
             for vec::each(*variants) |v| {
-                if !found.contains(variant(v.id)) {
+                if !found.contains(&(variant(v.id))) {
                     return Some(variant(v.id));
                 }
             }
diff --git a/src/rustc/middle/check_const.rs b/src/rustc/middle/check_const.rs
index e194a907ffd..53bdf3db868 100644
--- a/src/rustc/middle/check_const.rs
+++ b/src/rustc/middle/check_const.rs
@@ -169,7 +169,7 @@ fn check_item_recursion(sess: session, ast_map: ast_map::map,
     visitor.visit_item(it, env, visitor);
 
     fn visit_item(it: @item, &&env: env, v: visit::vt<env>) {
-        if (*env.idstack).contains(it.id) {
+        if (*env.idstack).contains(&(it.id)) {
             env.sess.span_fatal(env.root_it.span, ~"recursive constant");
         }
         (*env.idstack).push(it.id);
diff --git a/src/rustc/middle/kind.rs b/src/rustc/middle/kind.rs
index 0f918ba92a9..4f9045ec77e 100644
--- a/src/rustc/middle/kind.rs
+++ b/src/rustc/middle/kind.rs
@@ -199,13 +199,13 @@ fn check_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, sp: span,
             let id = ast_util::def_id_of_def(fv.def).node;
 
             // skip over free variables that appear in the cap clause
-            if captured_vars.contains(id) { loop; }
+            if captured_vars.contains(&id) { loop; }
 
             // if this is the last use of the variable, then it will be
             // a move and not a copy
             let is_move = {
                 match cx.last_use_map.find(fn_id) {
-                  Some(vars) => (*vars).contains(id),
+                  Some(vars) => (*vars).contains(&id),
                   None => false
                 }
             };
@@ -588,7 +588,7 @@ fn check_cast_for_escaping_regions(
     do ty::walk_ty(source_ty) |ty| {
         match ty::get(ty).sty {
           ty::ty_param(source_param) => {
-            if target_params.contains(source_param) {
+            if target_params.contains(&source_param) {
                 /* case (2) */
             } else {
                 check_owned(cx.tcx, ty, source.span); /* case (3) */
diff --git a/src/rustc/middle/privacy.rs b/src/rustc/middle/privacy.rs
index 6b0df4630da..4d291ceb590 100644
--- a/src/rustc/middle/privacy.rs
+++ b/src/rustc/middle/privacy.rs
@@ -56,7 +56,7 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
                             if method.vis == private &&
                                     (impl_id.crate != local_crate ||
                                      !privileged_items
-                                     .contains(impl_id.node)) {
+                                     .contains(&(impl_id.node))) {
                                 tcx.sess.span_err(span,
                                                   fmt!("method `%s` is \
                                                         private",
@@ -95,9 +95,9 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
                                     }
                                     match methods[method_num] {
                                         provided(method)
-                                                if method.vis == private &&
-                                                !privileged_items
-                                                .contains(trait_id.node) => {
+                                             if method.vis == private &&
+                                             !privileged_items
+                                             .contains(&(trait_id.node)) => {
                                             tcx.sess.span_err(span,
                                                               fmt!("method
                                                                     `%s` \
@@ -157,7 +157,7 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
                     match ty::get(ty::expr_ty(tcx, base)).sty {
                         ty_class(id, _)
                         if id.crate != local_crate ||
-                           !privileged_items.contains(id.node) => {
+                           !privileged_items.contains(&(id.node)) => {
                             match method_map.find(expr.id) {
                                 None => {
                                     debug!("(privacy checking) checking \
@@ -178,7 +178,7 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
                     match ty::get(ty::expr_ty(tcx, expr)).sty {
                         ty_class(id, _) => {
                             if id.crate != local_crate ||
-                                    !privileged_items.contains(id.node) {
+                                    !privileged_items.contains(&(id.node)) {
                                 for fields.each |field| {
                                         debug!("(privacy checking) checking \
                                                 field in struct literal");
@@ -205,7 +205,7 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
                     match ty::get(ty::pat_ty(tcx, pattern)).sty {
                         ty_class(id, _) => {
                             if id.crate != local_crate ||
-                                    !privileged_items.contains(id.node) {
+                                    !privileged_items.contains(&(id.node)) {
                                 for fields.each |field| {
                                         debug!("(privacy checking) checking \
                                                 struct pattern");
diff --git a/src/rustc/middle/region.rs b/src/rustc/middle/region.rs
index cf496ae6683..ae1c739b26b 100644
--- a/src/rustc/middle/region.rs
+++ b/src/rustc/middle/region.rs
@@ -485,7 +485,7 @@ impl determine_rp_ctxt {
             }
         };
         let dep = {ambient_variance: self.ambient_variance, id: self.item_id};
-        if !vec.contains(dep) { vec.push(dep); }
+        if !vec.contains(&dep) { vec.push(dep); }
     }
 
     // Determines whether a reference to a region that appears in the
diff --git a/src/rustc/middle/trans/expr.rs b/src/rustc/middle/trans/expr.rs
index 0a38e19a26c..17a1ff112cd 100644
--- a/src/rustc/middle/trans/expr.rs
+++ b/src/rustc/middle/trans/expr.rs
@@ -813,7 +813,7 @@ fn trans_local_var(bcx: block, ref_id: ast::node_id, def: ast::def) -> Datum {
                   nid: ast::node_id) -> Datum {
         let is_last_use = match bcx.ccx().maps.last_use_map.find(ref_id) {
             None => false,
-            Some(vars) => (*vars).contains(nid)
+            Some(vars) => (*vars).contains(&nid)
         };
 
         let source = if is_last_use {FromLastUseLvalue} else {FromLvalue};
diff --git a/src/rustc/middle/typeck/check/method.rs b/src/rustc/middle/typeck/check/method.rs
index 085ee51eff7..d08d3e9b847 100644
--- a/src/rustc/middle/typeck/check/method.rs
+++ b/src/rustc/middle/typeck/check/method.rs
@@ -182,7 +182,7 @@ impl LookupContext {
             ty_enum(did, _) => {
                 // Watch out for newtype'd enums like "enum t = @T".
                 // See discussion in typeck::check::do_autoderef().
-                if enum_dids.contains(did) {
+                if enum_dids.contains(&did) {
                     return None;
                 }
                 enum_dids.push(did);
diff --git a/src/rustdoc/rustdoc.rs b/src/rustdoc/rustdoc.rs
index 648d1d7a322..50ebef05afb 100755
--- a/src/rustdoc/rustdoc.rs
+++ b/src/rustdoc/rustdoc.rs
@@ -5,7 +5,7 @@ use config::Config;
 
 fn main(args: ~[~str]) {
 
-    if args.contains(~"-h") || args.contains(~"--help") {
+    if args.contains(&~"-h") || args.contains(&~"--help") {
         config::usage();
         return;
     }
diff --git a/src/test/run-pass/early-vtbl-resolution.rs b/src/test/run-pass/early-vtbl-resolution.rs
index 24faa53fda4..2bbbbf7ef17 100644
--- a/src/test/run-pass/early-vtbl-resolution.rs
+++ b/src/test/run-pass/early-vtbl-resolution.rs
@@ -9,7 +9,7 @@ fn foo_func<A, B: thing<A>>(x: B) -> Option<A> { x.foo() }
 
 fn main() {
 
-    for iter::eachi(Some({a: 0})) |i, a| { 
+    for iter::eachi(&(Some({a: 0}))) |i, a| { 
         #debug["%u %d", i, a.a];
     }
 
diff --git a/src/test/run-pass/iter-contains.rs b/src/test/run-pass/iter-contains.rs
index 43bce3e7dcb..6036b5b2d24 100644
--- a/src/test/run-pass/iter-contains.rs
+++ b/src/test/run-pass/iter-contains.rs
@@ -1,10 +1,10 @@
 fn main() {
-    assert []/_.contains(22u) == false;
-    assert [1u, 3u]/_.contains(22u) == false;
-    assert [22u, 1u, 3u]/_.contains(22u) == true;
-    assert [1u, 22u, 3u]/_.contains(22u) == true;
-    assert [1u, 3u, 22u]/_.contains(22u) == true;
-    assert None.contains(22u) == false;
-    assert Some(1u).contains(22u) == false;
-    assert Some(22u).contains(22u) == true;
+    assert []/_.contains(&22u) == false;
+    assert [1u, 3u]/_.contains(&22u) == false;
+    assert [22u, 1u, 3u]/_.contains(&22u) == true;
+    assert [1u, 22u, 3u]/_.contains(&22u) == true;
+    assert [1u, 3u, 22u]/_.contains(&22u) == true;
+    assert None.contains(&22u) == false;
+    assert Some(1u).contains(&22u) == false;
+    assert Some(22u).contains(&22u) == true;
 }
diff --git a/src/test/run-pass/iter-count.rs b/src/test/run-pass/iter-count.rs
index ba22cc7710b..0b6f94367be 100644
--- a/src/test/run-pass/iter-count.rs
+++ b/src/test/run-pass/iter-count.rs
@@ -1,9 +1,9 @@
 fn main() {
-    assert []/_.count(22u) == 0u;
-    assert [1u, 3u]/_.count(22u) == 0u;
-    assert [22u, 1u, 3u]/_.count(22u) == 1u;
-    assert [22u, 1u, 22u]/_.count(22u) == 2u;
-    assert None.count(22u) == 0u;
-    assert Some(1u).count(22u) == 0u;
-    assert Some(22u).count(22u) == 1u;
+    assert []/_.count(&22u) == 0u;
+    assert [1u, 3u]/_.count(&22u) == 0u;
+    assert [22u, 1u, 3u]/_.count(&22u) == 1u;
+    assert [22u, 1u, 22u]/_.count(&22u) == 2u;
+    assert None.count(&22u) == 0u;
+    assert Some(1u).count(&22u) == 0u;
+    assert Some(22u).count(&22u) == 1u;
 }
-- 
cgit 1.4.1-3-g733a5


From ef23d77633484e4e85f8b37431e3b08ede3e4802 Mon Sep 17 00:00:00 2001
From: Vincent Belliard <vincent@famillebelliard.fr>
Date: Wed, 26 Sep 2012 10:47:21 +0200
Subject: fix issue #3535 and add colon between mode and type when dumping
 funcion prototype

---
 src/libsyntax/parse/parser.rs                  | 45 ++++++++++++++++----------
 src/rustc/util/ppaux.rs                        |  2 +-
 src/test/compile-fail/unnamed_argument_mode.rs | 14 ++++++++
 src/test/run-pass/unnamed_argument_mode.rs     | 11 +++++++
 4 files changed, 54 insertions(+), 18 deletions(-)
 create mode 100644 src/test/compile-fail/unnamed_argument_mode.rs
 create mode 100644 src/test/run-pass/unnamed_argument_mode.rs

(limited to 'src/rustc')

diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 681d6296d4e..bc232f1259e 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -584,6 +584,29 @@ impl parser {
         } else { infer(self.get_id()) }
     }
 
+    fn is_named_argument() -> bool {
+        let offset = if self.token == token::BINOP(token::AND) {
+            1
+        } else if self.token == token::BINOP(token::MINUS) {
+            1
+        } else if self.token == token::ANDAND {
+            1
+        } else if self.token == token::BINOP(token::PLUS) {
+            if self.look_ahead(1) == token::BINOP(token::PLUS) {
+                2
+            } else {
+                1
+            }
+        } else { 0 };
+        if offset == 0 {
+            is_plain_ident(self.token)
+                && self.look_ahead(1) == token::COLON
+        } else {
+            is_plain_ident(self.look_ahead(offset))
+                && self.look_ahead(offset + 1) == token::COLON
+        }
+    }
+
     fn parse_capture_item_or(parse_arg_fn: fn(parser) -> arg_or_capture_item)
         -> arg_or_capture_item {
 
@@ -605,29 +628,17 @@ impl parser {
     // This version of parse arg doesn't necessarily require
     // identifier names.
     fn parse_arg_general(require_name: bool) -> arg {
-        let m = self.parse_arg_mode();
-        let i = if require_name {
+        let mut m;
+        let i = if require_name || self.is_named_argument() {
+            m = self.parse_arg_mode();
             let name = self.parse_value_ident();
             self.expect(token::COLON);
             name
         } else {
-            if is_plain_ident(self.token)
-                && self.look_ahead(1u) == token::COLON {
-                let name = self.parse_value_ident();
-                self.bump();
-                name
-            } else { special_idents::invalid }
+            m = infer(self.get_id());
+            special_idents::invalid
         };
 
-        match m {
-            expl(_) => {
-                if i == special_idents::invalid {
-                    self.obsolete(copy self.span, ObsoleteModeInFnType);
-                }
-            }
-            _ => {}
-        }
-
         let t = self.parse_ty(false);
 
         {mode: m, ty: t, ident: i, id: self.get_id()}
diff --git a/src/rustc/util/ppaux.rs b/src/rustc/util/ppaux.rs
index 9ade20c5568..0498a0f9541 100644
--- a/src/rustc/util/ppaux.rs
+++ b/src/rustc/util/ppaux.rs
@@ -261,7 +261,7 @@ fn ty_to_str(cx: ctxt, typ: t) -> ~str {
                 m == ty::default_arg_mode_for_ty(cx, ty) {
                 ~""
             } else {
-                mode_to_str(ast::expl(m))
+                mode_to_str(ast::expl(m)) + ":"
             }
           }
         };
diff --git a/src/test/compile-fail/unnamed_argument_mode.rs b/src/test/compile-fail/unnamed_argument_mode.rs
new file mode 100644
index 00000000000..36e6edc96f9
--- /dev/null
+++ b/src/test/compile-fail/unnamed_argument_mode.rs
@@ -0,0 +1,14 @@
+//error-pattern: mismatched types
+
+fn bad(&a: int) {
+}
+
+// unnamed argument &int is now parsed x: &int
+// it's not parsed &x: int anymore
+
+fn called(f: fn(&int)) {
+}
+
+fn main() {
+called(bad);
+}
diff --git a/src/test/run-pass/unnamed_argument_mode.rs b/src/test/run-pass/unnamed_argument_mode.rs
new file mode 100644
index 00000000000..97e7582e142
--- /dev/null
+++ b/src/test/run-pass/unnamed_argument_mode.rs
@@ -0,0 +1,11 @@
+fn good(a: &int) {
+}
+
+// unnamed argument &int is now parse x: &int
+
+fn called(f: fn(&int)) {
+}
+
+fn main() {
+called(good);
+}
-- 
cgit 1.4.1-3-g733a5


From 8b13912a839a5e0336fa285d9b62c1337e17b165 Mon Sep 17 00:00:00 2001
From: Niko Matsakis <niko@alum.mit.edu>
Date: Wed, 26 Sep 2012 14:23:27 -0700
Subject: Make impl of Add for @[] public

It's not clear that impls should have to be public to be used
from outside the crate; in particular, I don't know whether
they have to be public to be used from other modules within
the same crate.
---
 src/libcore/at_vec.rs                | 6 ++----
 src/rustc/middle/typeck/coherence.rs | 4 ++++
 2 files changed, 6 insertions(+), 4 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs
index 535aa4e37ec..2c54ed7aaf3 100644
--- a/src/libcore/at_vec.rs
+++ b/src/libcore/at_vec.rs
@@ -134,9 +134,9 @@ pub pure fn from_elem<T: Copy>(n_elts: uint, +t: T) -> @[T] {
 }
 
 #[cfg(notest)]
-mod traits {
+pub mod traits {
     #[legacy_exports];
-    impl<T: Copy> @[T] : Add<&[const T],@[T]> {
+    pub impl<T: Copy> @[T] : Add<&[const T],@[T]> {
         #[inline(always)]
         pure fn add(rhs: & &[const T]) -> @[T] {
             append(self, (*rhs))
@@ -249,9 +249,7 @@ pub fn test() {
     assert from_elem(5, 3.14) == @[3.14, 3.14, 3.14, 3.14, 3.14];
 }
 
-/*
 #[test]
 pub fn append_test() {
     assert @[1,2,3] + @[4,5,6] == @[1,2,3,4,5,6];
 }
-*/
diff --git a/src/rustc/middle/typeck/coherence.rs b/src/rustc/middle/typeck/coherence.rs
index 17d5f81993d..77c665755c3 100644
--- a/src/rustc/middle/typeck/coherence.rs
+++ b/src/rustc/middle/typeck/coherence.rs
@@ -654,6 +654,10 @@ impl CoherenceChecker {
                                                 module_def_id,
                                                 None);
         for (*implementations).each |implementation| {
+            debug!("coherence: adding impl from external crate: %s",
+                   ty::item_path_str(self.crate_context.tcx,
+                                     implementation.did));
+
             // Make sure we don't visit the same implementation
             // multiple times.
             match impls_seen.find(implementation.did) {
-- 
cgit 1.4.1-3-g733a5


From 135ebca8aa1bb546984c1915eac4e5c9bfdcf4d6 Mon Sep 17 00:00:00 2001
From: Eric Holk <eric.holk@gmail.com>
Date: Tue, 25 Sep 2012 13:16:43 -0400
Subject: Refactoring ReaderUtil trait, combining it with the traitless impl on
 Reader.

---
 src/libcore/io.rs               | 17 +++++++++++++----
 src/libstd/json.rs              |  2 +-
 src/libstd/time.rs              |  2 +-
 src/libsyntax/parse/comments.rs |  1 +
 src/rustc/driver/rustc.rs       |  1 +
 5 files changed, 17 insertions(+), 6 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libcore/io.rs b/src/libcore/io.rs
index 021aa624e06..97039800fb6 100644
--- a/src/libcore/io.rs
+++ b/src/libcore/io.rs
@@ -48,6 +48,17 @@ trait Reader {
 trait ReaderUtil {
     fn read_bytes(len: uint) -> ~[u8];
     fn read_line() -> ~str;
+
+    fn read_chars(n: uint) -> ~[char];
+    fn read_char() -> char;
+    fn read_c_str() -> ~str;
+    fn read_le_uint(size: uint) -> uint;
+    fn read_le_int(size: uint) -> int;
+    fn read_be_uint(size: uint) -> uint;
+    fn read_whole_stream() -> ~[u8];
+    fn each_byte(it: fn(int) -> bool);
+    fn each_char(it: fn(char) -> bool);
+    fn each_line(it: fn((&str)) -> bool);
 }
 
 impl<T: Reader> T : ReaderUtil {
@@ -69,12 +80,10 @@ impl<T: Reader> T : ReaderUtil {
         }
         str::from_bytes(buf)
     }
-}
 
-impl Reader {
     fn read_chars(n: uint) -> ~[char] {
         // returns the (consumed offset, n_req), appends characters to &chars
-        fn chars_from_bytes(buf: &~[u8], chars: &mut ~[char])
+        fn chars_from_bytes<T: Reader>(buf: &~[u8], chars: &mut ~[char])
             -> (uint, uint) {
             let mut i = 0;
             let buf_len = buf.len();
@@ -120,7 +129,7 @@ impl Reader {
                 break;
             }
             vec::push_all(buf, data);
-            let (offset, nbreq) = chars_from_bytes(&buf, &mut chars);
+            let (offset, nbreq) = chars_from_bytes::<T>(&buf, &mut chars);
             let ncreq = n - chars.len();
             // again we either know we need a certain number of bytes
             // to complete a character, or we make sure we don't
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index db22b9ff30b..00e09f6604d 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -8,7 +8,7 @@
 
 use core::cmp::{Eq, Ord};
 use result::{Result, Ok, Err};
-use io::WriterUtil;
+use io::{WriterUtil, ReaderUtil};
 use map::HashMap;
 use map::Map;
 use sort::Sort;
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index 64f65d15a93..890a7a0b468 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -3,7 +3,7 @@
 
 use core::cmp::Eq;
 use libc::{c_char, c_int, c_long, size_t, time_t};
-use io::Reader;
+use io::{Reader, ReaderUtil};
 use result::{Result, Ok, Err};
 
 export
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index 9c705cff7bb..ddc70a1f13e 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -1,4 +1,5 @@
 use io::println;//XXXXXXXXxxx
+use io::ReaderUtil;
 use util::interner;
 use lexer::{string_reader, bump, is_eof, nextch,
                is_whitespace, get_str_from, reader};
diff --git a/src/rustc/driver/rustc.rs b/src/rustc/driver/rustc.rs
index 0306d0dbb18..6ea5bb28023 100644
--- a/src/rustc/driver/rustc.rs
+++ b/src/rustc/driver/rustc.rs
@@ -12,6 +12,7 @@ use core::*;
 
 // -*- rust -*-
 use result::{Ok, Err};
+use io::ReaderUtil;
 use std::getopts;
 use std::map::HashMap;
 use getopts::{opt_present};
-- 
cgit 1.4.1-3-g733a5


From dd502fc6e4039e269a78be5d5cfe5b0d8899d30c Mon Sep 17 00:00:00 2001
From: Erick Tryzelaar <erick.tryzelaar@gmail.com>
Date: Wed, 19 Sep 2012 09:41:06 -0700
Subject: Allow hashmaps to infer their types

---
 src/libsyntax/ext/base.rs            |  2 +-
 src/libsyntax/ext/simplext.rs        |  2 +-
 src/libsyntax/ext/tt/macro_parser.rs |  2 +-
 src/libsyntax/ext/tt/transcribe.rs   |  2 +-
 src/libsyntax/util/interner.rs       |  2 +-
 src/rustc/metadata/creader.rs        |  2 +-
 src/rustc/metadata/cstore.rs         |  4 ++--
 src/rustc/metadata/decoder.rs        |  2 +-
 src/rustc/middle/resolve.rs          |  2 +-
 src/rustc/middle/trans/base.rs       | 26 +++++++++++++-------------
 10 files changed, 23 insertions(+), 23 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index a3ab35d77f0..acc8cf4f5d3 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -73,7 +73,7 @@ fn syntax_expander_table() -> HashMap<~str, syntax_extension> {
     fn builtin_item_tt(f: syntax_expander_tt_item_) -> syntax_extension {
         item_tt({expander: f, span: None})
     }
-    let syntax_expanders = HashMap::<~str,syntax_extension>();
+    let syntax_expanders = HashMap();
     syntax_expanders.insert(~"macro",
                             macro_defining(ext::simplext::add_new_extension));
     syntax_expanders.insert(~"macro_rules",
diff --git a/src/libsyntax/ext/simplext.rs b/src/libsyntax/ext/simplext.rs
index 3af9cfe852d..4729e7da39c 100644
--- a/src/libsyntax/ext/simplext.rs
+++ b/src/libsyntax/ext/simplext.rs
@@ -237,7 +237,7 @@ fn follow_for_trans(cx: ext_ctxt, mmaybe: Option<arb_depth<matchable>>,
 
 /* helper for transcribe_exprs: what vars from `b` occur in `e`? */
 fn free_vars(b: bindings, e: @expr, it: fn(ident)) {
-    let idents: HashMap<ident, ()> = HashMap();
+    let idents = HashMap();
     fn mark_ident(&&i: ident, _fld: ast_fold, b: bindings,
                   idents: HashMap<ident, ()>) -> ident {
         if b.contains_key(i) { idents.insert(i, ()); }
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index 74c36dcf1b7..a7a45942822 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -185,7 +185,7 @@ fn nameize(p_s: parse_sess, ms: ~[matcher], res: ~[@named_match])
           }
         }
     }
-    let ret_val = HashMap::<uint,@named_match>();
+    let ret_val = HashMap();
     for ms.each() |m| { n_rec(p_s, *m, res, ret_val) }
     return ret_val;
 }
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index 7fb910cd4b6..c42811762e4 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -47,7 +47,7 @@ fn new_tt_reader(sp_diag: span_handler, itr: ident_interner,
               mut cur: @{readme: src, mut idx: 0u, dotdotdoted: false,
                          sep: None, up: tt_frame_up(option::None)},
               interpolations: match interp { /* just a convienience */
-                None => std::map::HashMap::<uint,@named_match>(),
+                None => std::map::HashMap(),
                 Some(x) => x
               },
               mut repeat_idx: ~[],
diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs
index 15b9e34566f..021c25e3dd7 100644
--- a/src/libsyntax/util/interner.rs
+++ b/src/libsyntax/util/interner.rs
@@ -59,4 +59,4 @@ impl <T:Eq IterBytes Hash Const Copy> hash_interner<T>: interner<T> {
     pure fn get(idx: uint) -> T { self.vect.get_elt(idx) }
 
     fn len() -> uint { return self.vect.len(); }
-}
\ No newline at end of file
+}
diff --git a/src/rustc/metadata/creader.rs b/src/rustc/metadata/creader.rs
index f6c2bf7d5a1..0cd0b64a061 100644
--- a/src/rustc/metadata/creader.rs
+++ b/src/rustc/metadata/creader.rs
@@ -248,7 +248,7 @@ fn resolve_crate_deps(e: env, cdata: @~[u8]) -> cstore::cnum_map {
     debug!("resolving deps of external crate");
     // The map from crate numbers in the crate we're resolving to local crate
     // numbers
-    let cnum_map = HashMap::<int,ast::crate_num>();
+    let cnum_map = HashMap();
     for decoder::get_crate_deps(e.intr, cdata).each |dep| {
         let extrn_cnum = dep.cnum;
         let cname = dep.name;
diff --git a/src/rustc/metadata/cstore.rs b/src/rustc/metadata/cstore.rs
index cb304c419e5..7151702f25e 100644
--- a/src/rustc/metadata/cstore.rs
+++ b/src/rustc/metadata/cstore.rs
@@ -69,8 +69,8 @@ pure fn p(cstore: cstore) -> cstore_private {
 }
 
 fn mk_cstore(intr: ident_interner) -> cstore {
-    let meta_cache = map::HashMap::<int,crate_metadata>();
-    let crate_map = map::HashMap::<int,ast::crate_num>();
+    let meta_cache = map::HashMap();
+    let crate_map = map::HashMap();
     let mod_path_map = HashMap();
     return private(@{metas: meta_cache,
                      use_crate_map: crate_map,
diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs
index c631e404472..928bba5205a 100644
--- a/src/rustc/metadata/decoder.rs
+++ b/src/rustc/metadata/decoder.rs
@@ -967,7 +967,7 @@ fn get_crate_module_paths(intr: ident_interner, cdata: cmd)
     // find all module (path, def_ids), which are not
     // fowarded path due to renamed import or reexport
     let mut res = ~[];
-    let mods = map::HashMap::<~str,bool>();
+    let mods = map::HashMap();
     do iter_crate_items(intr, cdata) |path, did| {
         let m = mod_of_path(path);
         if str::is_not_empty(m) {
diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs
index afb1cbc36f4..07b5d3b4ce8 100644
--- a/src/rustc/middle/resolve.rs
+++ b/src/rustc/middle/resolve.rs
@@ -314,7 +314,7 @@ fn Atom(n: uint) -> Atom {
 
 /// Creates a hash table of atoms.
 fn atom_hashmap<V:Copy>() -> HashMap<Atom,V> {
-  HashMap::<Atom,V>()
+  HashMap()
 }
 
 /// One local scope.
diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs
index 2e2e2937cf1..b29fac0fa2f 100644
--- a/src/rustc/middle/trans/base.rs
+++ b/src/rustc/middle/trans/base.rs
@@ -1406,9 +1406,9 @@ fn new_fn_ctxt_w_id(ccx: @crate_ctxt, path: path,
           mut llself: None,
           mut personality: None,
           mut loop_ret: None,
-          llargs: HashMap::<int,local_val>(),
-          lllocals: HashMap::<int,local_val>(),
-          llupvars: HashMap::<int,ValueRef>(),
+          llargs: HashMap(),
+          lllocals: HashMap(),
+          llupvars: HashMap(),
           id: id,
           param_substs: param_substs,
           span: sp,
@@ -2315,7 +2315,7 @@ fn declare_intrinsics(llmod: ModuleRef) -> HashMap<~str, ValueRef> {
     let frameaddress = decl_cdecl_fn(llmod, ~"llvm.frameaddress",
                                      T_fn(T_frameaddress_args,
                                           T_ptr(T_i8())));
-    let intrinsics = HashMap::<~str,ValueRef>();
+    let intrinsics = HashMap();
     intrinsics.insert(~"llvm.gcroot", gcroot);
     intrinsics.insert(~"llvm.gcread", gcread);
     intrinsics.insert(~"llvm.memmove.p0i8.p0i8.i32", memmove32);
@@ -2627,17 +2627,17 @@ fn trans_crate(sess: session::session,
           llmod: llmod,
           td: td,
           tn: tn,
-          externs: HashMap::<~str,ValueRef>(),
+          externs: HashMap(),
           intrinsics: intrinsics,
-          item_vals: HashMap::<int,ValueRef>(),
+          item_vals: HashMap(),
           exp_map2: emap2,
           reachable: reachable,
-          item_symbols: HashMap::<int,~str>(),
+          item_symbols: HashMap(),
           mut main_fn: None::<ValueRef>,
           link_meta: link_meta,
           enum_sizes: ty::new_ty_hash(),
           discrims: HashMap(),
-          discrim_symbols: HashMap::<int,~str>(),
+          discrim_symbols: HashMap(),
           tydescs: ty::new_ty_hash(),
           mut finished_tydescs: false,
           external: HashMap(),
@@ -2646,15 +2646,15 @@ fn trans_crate(sess: session::session,
           type_use_cache: HashMap(),
           vtables: map::HashMap(),
           const_cstr_cache: HashMap(),
-          const_globals: HashMap::<int,ValueRef>(),
-          module_data: HashMap::<~str,ValueRef>(),
+          const_globals: HashMap(),
+          module_data: HashMap(),
           lltypes: ty::new_ty_hash(),
           names: new_namegen(sess.parse_sess.interner),
           next_addrspace: new_addrspace_gen(),
           symbol_hasher: symbol_hasher,
           type_hashcodes: ty::new_ty_hash(),
           type_short_names: ty::new_ty_hash(),
-          all_llvm_symbols: HashMap::<~str,()>(),
+          all_llvm_symbols: HashMap(),
           tcx: tcx,
           maps: maps,
           stats:
@@ -2672,7 +2672,7 @@ fn trans_crate(sess: session::session,
           upcalls:
               upcall::declare_upcalls(targ_cfg, tn, tydesc_type,
                                       llmod),
-          rtcalls: HashMap::<~str,ast::def_id>(),
+          rtcalls: HashMap(),
           tydesc_type: tydesc_type,
           int_type: int_type,
           float_type: float_type,
@@ -2683,7 +2683,7 @@ fn trans_crate(sess: session::session,
           crate_map: crate_map,
           mut uses_gc: false,
           dbg_cx: dbg_cx,
-          class_ctors: HashMap::<int,ast::def_id>(),
+          class_ctors: HashMap(),
           mut do_not_commit_warning_issued: false};
 
 
-- 
cgit 1.4.1-3-g733a5


From b96af7315951dcc69567c2f3432a46ff71ecddf3 Mon Sep 17 00:00:00 2001
From: Erick Tryzelaar <erick.tryzelaar@gmail.com>
Date: Wed, 19 Sep 2012 18:50:24 -0700
Subject: turn ast::ident into a struct

This will help with the auto_serialize2 migration. We have to change
ident from a type alias to uint into a unique type. We need to use
a struct instead of a "enum ident = token::str_num" because structs
support constants, but newtypes do not.
---
 src/fuzzer/fuzzer.rs                |   2 +-
 src/libsyntax/ast.rs                |  15 ++++-
 src/libsyntax/ast_map.rs            |   8 +--
 src/libsyntax/ast_util.rs           |   2 +-
 src/libsyntax/ext/tt/transcribe.rs  |   4 +-
 src/libsyntax/parse.rs              |   2 +-
 src/libsyntax/parse/lexer.rs        |  12 ++--
 src/libsyntax/parse/parser.rs       |   2 +-
 src/libsyntax/parse/token.rs        | 118 ++++++++++++++++++++----------------
 src/libsyntax/print/pprust.rs       |  34 +++++------
 src/rustc/back/link.rs              |   2 +-
 src/rustc/driver/session.rs         |   2 +-
 src/rustc/metadata/creader.rs       |   4 +-
 src/rustc/metadata/cstore.rs        |   4 +-
 src/rustc/metadata/decoder.rs       |  42 ++++++-------
 src/rustc/metadata/loader.rs        |   6 +-
 src/rustc/middle/resolve.rs         |   6 +-
 src/rustc/middle/trans/common.rs    |   9 +--
 src/rustc/middle/trans/debuginfo.rs |   2 +-
 src/rustdoc/extract.rs              |   2 +-
 20 files changed, 154 insertions(+), 124 deletions(-)

(limited to 'src/rustc')

diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs
index 65adbb9e09e..9f1cc419d15 100644
--- a/src/fuzzer/fuzzer.rs
+++ b/src/fuzzer/fuzzer.rs
@@ -243,7 +243,7 @@ fn check_variants_T<T: Copy>(
   filename: &Path,
   thing_label: ~str,
   things: ~[T],
-  stringifier: fn@(@T, syntax::parse::token::ident_interner) -> ~str,
+  stringifier: fn@(@T, @syntax::parse::token::ident_interner) -> ~str,
   replacer: fn@(ast::crate, uint, T, test_mode) -> ast::crate,
   cx: context
   ) {
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 75a2081bc14..24dc3660faf 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -38,6 +38,10 @@ macro_rules! interner_key (
         (-3 as uint, 0u)))
 )
 
+// FIXME(#3534): Replace with the struct-based newtype when it's been
+// implemented.
+struct ident { repr: uint }
+
 fn serialize_ident<S: Serializer>(s: S, i: ident) {
     let intr = match unsafe{
         task::local_data::local_data_get(interner_key!())
@@ -59,7 +63,16 @@ fn deserialize_ident<D: Deserializer>(d: D) -> ident  {
     (*intr).intern(@d.read_str())
 }
 
-type ident = token::str_num;
+impl ident: cmp::Eq {
+    pure fn eq(other: &ident) -> bool { self.repr == other.repr }
+    pure fn ne(other: &ident) -> bool { !self.eq(other) }
+}
+
+impl ident: to_bytes::IterBytes {
+    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+        self.repr.iter_bytes(lsb0, f)
+    }
+}
 
 // Functions may or may not have names.
 #[auto_serialize]
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index 9a3e94b737f..09922ade073 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -34,7 +34,7 @@ impl path_elt : cmp::Eq {
 type path = ~[path_elt];
 
 /* FIXMEs that say "bad" are as per #2543 */
-fn path_to_str_with_sep(p: path, sep: ~str, itr: ident_interner) -> ~str {
+fn path_to_str_with_sep(p: path, sep: ~str, itr: @ident_interner) -> ~str {
     let strs = do vec::map(p) |e| {
         match *e {
           path_mod(s) => *itr.get(s),
@@ -44,7 +44,7 @@ fn path_to_str_with_sep(p: path, sep: ~str, itr: ident_interner) -> ~str {
     str::connect(strs, sep)
 }
 
-fn path_ident_to_str(p: path, i: ident, itr: ident_interner) -> ~str {
+fn path_ident_to_str(p: path, i: ident, itr: @ident_interner) -> ~str {
     if vec::is_empty(p) {
         //FIXME /* FIXME (#2543) */ copy *i
         *itr.get(i)
@@ -53,7 +53,7 @@ fn path_ident_to_str(p: path, i: ident, itr: ident_interner) -> ~str {
     }
 }
 
-fn path_to_str(p: path, itr: ident_interner) -> ~str {
+fn path_to_str(p: path, itr: @ident_interner) -> ~str {
     path_to_str_with_sep(p, ~"::", itr)
 }
 
@@ -326,7 +326,7 @@ fn map_stmt(stmt: @stmt, cx: ctx, v: vt) {
     visit::visit_stmt(stmt, cx, v);
 }
 
-fn node_id_to_str(map: map, id: node_id, itr: ident_interner) -> ~str {
+fn node_id_to_str(map: map, id: node_id, itr: @ident_interner) -> ~str {
     match map.find(id) {
       None => {
         fmt!("unknown node (id=%d)", id)
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index b0df0ea1c8d..98a471bd54c 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -23,7 +23,7 @@ pure fn dummy_sp() -> span { return mk_sp(0u, 0u); }
 
 
 
-pure fn path_name_i(idents: ~[ident], intr: token::ident_interner) -> ~str {
+pure fn path_name_i(idents: ~[ident], intr: @token::ident_interner) -> ~str {
     // FIXME: Bad copies (#2543 -- same for everything else that says "bad")
     str::connect(idents.map(|i| *intr.get(*i)), ~"::")
 }
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index c42811762e4..b208e4f8c6f 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -25,7 +25,7 @@ type tt_frame = @{
 
 type tt_reader = @{
     sp_diag: span_handler,
-    interner: ident_interner,
+    interner: @ident_interner,
     mut cur: tt_frame,
     /* for MBE-style macro transcription */
     interpolations: std::map::HashMap<ident, @named_match>,
@@ -39,7 +39,7 @@ type tt_reader = @{
 /** This can do Macro-By-Example transcription. On the other hand, if
  *  `src` contains no `tt_seq`s and `tt_nonterminal`s, `interp` can (and
  *  should) be none. */
-fn new_tt_reader(sp_diag: span_handler, itr: ident_interner,
+fn new_tt_reader(sp_diag: span_handler, itr: @ident_interner,
                  interp: Option<std::map::HashMap<ident,@named_match>>,
                  src: ~[ast::token_tree])
     -> tt_reader {
diff --git a/src/libsyntax/parse.rs b/src/libsyntax/parse.rs
index 312c78085ac..751b3ce62b9 100644
--- a/src/libsyntax/parse.rs
+++ b/src/libsyntax/parse.rs
@@ -25,7 +25,7 @@ type parse_sess = @{
     cm: codemap::codemap,
     mut next_id: node_id,
     span_diagnostic: span_handler,
-    interner: ident_interner,
+    interner: @ident_interner,
     // these two must be kept up to date
     mut chpos: uint,
     mut byte_pos: uint
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
index c9b10c7b754..06fcc1cf958 100644
--- a/src/libsyntax/parse/lexer.rs
+++ b/src/libsyntax/parse/lexer.rs
@@ -13,7 +13,7 @@ trait reader {
     fn next_token() -> {tok: token::token, sp: span};
     fn fatal(~str) -> !;
     fn span_diag() -> span_handler;
-    pure fn interner() -> token::ident_interner;
+    pure fn interner() -> @token::ident_interner;
     fn peek() -> {tok: token::token, sp: span};
     fn dup() -> reader;
 }
@@ -26,7 +26,7 @@ type string_reader = @{
     mut curr: char,
     mut chpos: uint,
     filemap: codemap::filemap,
-    interner: token::ident_interner,
+    interner: @token::ident_interner,
     /* cached: */
     mut peek_tok: token::token,
     mut peek_span: span
@@ -34,7 +34,7 @@ type string_reader = @{
 
 fn new_string_reader(span_diagnostic: span_handler,
                      filemap: codemap::filemap,
-                     itr: token::ident_interner) -> string_reader {
+                     itr: @token::ident_interner) -> string_reader {
     let r = new_low_level_string_reader(span_diagnostic, filemap, itr);
     string_advance_token(r); /* fill in peek_* */
     return r;
@@ -43,7 +43,7 @@ fn new_string_reader(span_diagnostic: span_handler,
 /* For comments.rs, which hackily pokes into 'pos' and 'curr' */
 fn new_low_level_string_reader(span_diagnostic: span_handler,
                                filemap: codemap::filemap,
-                               itr: token::ident_interner)
+                               itr: @token::ident_interner)
     -> string_reader {
     let r = @{span_diagnostic: span_diagnostic, src: filemap.src,
               mut col: 0u, mut pos: 0u, mut curr: -1 as char,
@@ -78,7 +78,7 @@ impl string_reader: reader {
         self.span_diagnostic.span_fatal(copy self.peek_span, m)
     }
     fn span_diag() -> span_handler { self.span_diagnostic }
-    pure fn interner() -> token::ident_interner { self.interner }
+    pure fn interner() -> @token::ident_interner { self.interner }
     fn peek() -> {tok: token::token, sp: span} {
         {tok: self.peek_tok, sp: self.peek_span}
     }
@@ -100,7 +100,7 @@ impl tt_reader: reader {
         self.sp_diag.span_fatal(copy self.cur_span, m);
     }
     fn span_diag() -> span_handler { self.sp_diag }
-    pure fn interner() -> token::ident_interner { self.interner }
+    pure fn interner() -> @token::ident_interner { self.interner }
     fn peek() -> {tok: token::token, sp: span} {
         { tok: self.cur_tok, sp: self.cur_span }
     }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index bc232f1259e..9d970e23f68 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -237,7 +237,7 @@ struct parser {
     mut restriction: restriction,
     mut quote_depth: uint, // not (yet) related to the quasiquoter
     reader: reader,
-    interner: interner<@~str>,
+    interner: @token::ident_interner,
     keywords: HashMap<~str, ()>,
     strict_keywords: HashMap<~str, ()>,
     reserved_keywords: HashMap<~str, ()>,
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 0f9041a2fcd..a328ff1bdf6 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -12,9 +12,6 @@ use std::serialization::{Serializer,
                             serialize_bool,
                             deserialize_bool};
 
-#[auto_serialize]
-type str_num = uint;
-
 #[auto_serialize]
 enum binop {
     PLUS,
@@ -72,17 +69,17 @@ enum token {
     LIT_INT(i64, ast::int_ty),
     LIT_UINT(u64, ast::uint_ty),
     LIT_INT_UNSUFFIXED(i64),
-    LIT_FLOAT(str_num, ast::float_ty),
-    LIT_STR(str_num),
+    LIT_FLOAT(ast::ident, ast::float_ty),
+    LIT_STR(ast::ident),
 
     /* Name components */
-    IDENT(str_num, bool),
+    IDENT(ast::ident, bool),
     UNDERSCORE,
 
     /* For interpolation */
     INTERPOLATED(nonterminal),
 
-    DOC_COMMENT(str_num),
+    DOC_COMMENT(ast::ident),
     EOF,
 }
 
@@ -95,7 +92,7 @@ enum nonterminal {
     nt_pat( @ast::pat),
     nt_expr(@ast::expr),
     nt_ty(  @ast::ty),
-    nt_ident(str_num, bool),
+    nt_ident(ast::ident, bool),
     nt_path(@ast::path),
     nt_tt(  @ast::token_tree), //needs @ed to break a circularity
     nt_matchers(~[ast::matcher])
@@ -116,7 +113,7 @@ fn binop_to_str(o: binop) -> ~str {
     }
 }
 
-fn to_str(in: interner<@~str>, t: token) -> ~str {
+fn to_str(in: @ident_interner, t: token) -> ~str {
     match t {
       EQ => ~"=",
       LT => ~"<",
@@ -174,7 +171,7 @@ fn to_str(in: interner<@~str>, t: token) -> ~str {
         }
         body + ast_util::float_ty_to_str(t)
       }
-      LIT_STR(s) => { ~"\"" + str::escape_default( *in.get(s)) + ~"\"" }
+      LIT_STR(s) => { ~"\"" + str::escape_default(*in.get(s)) + ~"\"" }
 
       /* Name components */
       IDENT(s, _) => *in.get(s),
@@ -281,49 +278,66 @@ pure fn is_bar(t: token) -> bool {
 mod special_idents {
     #[legacy_exports];
     use ast::ident;
-    const underscore : ident = 0u;
-    const anon : ident = 1u;
-    const dtor : ident = 2u; // 'drop', but that's reserved
-    const invalid : ident = 3u; // ''
-    const unary : ident = 4u;
-    const not_fn : ident = 5u;
-    const idx_fn : ident = 6u;
-    const unary_minus_fn : ident = 7u;
-    const clownshoes_extensions : ident = 8u;
-
-    const self_ : ident = 9u; // 'self'
+    const underscore : ident = ident { repr: 0u };
+    const anon : ident = ident { repr: 1u };
+    const dtor : ident = ident { repr: 2u }; // 'drop', but that's reserved
+    const invalid : ident = ident { repr: 3u }; // ''
+    const unary : ident = ident { repr: 4u };
+    const not_fn : ident = ident { repr: 5u };
+    const idx_fn : ident = ident { repr: 6u };
+    const unary_minus_fn : ident = ident { repr: 7u };
+    const clownshoes_extensions : ident = ident { repr: 8u };
+
+    const self_ : ident = ident { repr: 9u }; // 'self'
 
     /* for matcher NTs */
-    const item : ident = 10u;
-    const block : ident = 11u;
-    const stmt : ident = 12u;
-    const pat : ident = 13u;
-    const expr : ident = 14u;
-    const ty : ident = 15u;
-    const ident : ident = 16u;
-    const path : ident = 17u;
-    const tt : ident = 18u;
-    const matchers : ident = 19u;
-
-    const str : ident = 20u; // for the type
+    const item : ident = ident { repr: 10u };
+    const block : ident = ident { repr: 11u };
+    const stmt : ident = ident { repr: 12u };
+    const pat : ident = ident { repr: 13u };
+    const expr : ident = ident { repr: 14u };
+    const ty : ident = ident { repr: 15u };
+    const ident : ident = ident { repr: 16u };
+    const path : ident = ident { repr: 17u };
+    const tt : ident = ident { repr: 18u };
+    const matchers : ident = ident { repr: 19u };
+
+    const str : ident = ident { repr: 20u }; // for the type
 
     /* outside of libsyntax */
-    const ty_visitor : ident = 21u;
-    const arg : ident = 22u;
-    const descrim : ident = 23u;
-    const clownshoe_abi : ident = 24u;
-    const clownshoe_stack_shim : ident = 25u;
-    const tydesc : ident = 26u;
-    const literally_dtor : ident = 27u;
-    const main : ident = 28u;
-    const opaque : ident = 29u;
-    const blk : ident = 30u;
-    const static : ident = 31u;
-    const intrinsic : ident = 32u;
-    const clownshoes_foreign_mod: ident = 33;
+    const ty_visitor : ident = ident { repr: 21u };
+    const arg : ident = ident { repr: 22u };
+    const descrim : ident = ident { repr: 23u };
+    const clownshoe_abi : ident = ident { repr: 24u };
+    const clownshoe_stack_shim : ident = ident { repr: 25u };
+    const tydesc : ident = ident { repr: 26u };
+    const literally_dtor : ident = ident { repr: 27u };
+    const main : ident = ident { repr: 28u };
+    const opaque : ident = ident { repr: 29u };
+    const blk : ident = ident { repr: 30u };
+    const static : ident = ident { repr: 31u };
+    const intrinsic : ident = ident { repr: 32u };
+    const clownshoes_foreign_mod: ident = ident { repr: 33 };
 }
 
-type ident_interner = util::interner::interner<@~str>;
+struct ident_interner {
+    priv interner: util::interner::interner<@~str>,
+}
+
+impl ident_interner {
+    fn intern(val: @~str) -> ast::ident {
+        ast::ident { repr: self.interner.intern(val) }
+    }
+    fn gensym(val: @~str) -> ast::ident {
+        ast::ident { repr: self.interner.gensym(val) }
+    }
+    pure fn get(idx: ast::ident) -> @~str {
+        self.interner.get(idx.repr)
+    }
+    fn len() -> uint {
+        self.interner.len()
+    }
+}
 
 /** Key for thread-local data for sneaking interner information to the
  * serializer/deserializer. It sounds like a hack because it is one.
@@ -335,7 +349,7 @@ macro_rules! interner_key (
         (-3 as uint, 0u)))
 )
 
-fn mk_ident_interner() -> ident_interner {
+fn mk_ident_interner() -> @ident_interner {
     /* the indices here must correspond to the numbers in special_idents */
     let init_vec = ~[@~"_", @~"anon", @~"drop", @~"", @~"unary", @~"!",
                      @~"[]", @~"unary-", @~"__extensions__", @~"self",
@@ -346,7 +360,9 @@ fn mk_ident_interner() -> ident_interner {
                      @~"dtor", @~"main", @~"<opaque>", @~"blk", @~"static",
                      @~"intrinsic", @~"__foreign_mod__"];
 
-    let rv = interner::mk_prefill::<@~str>(init_vec);
+    let rv = @ident_interner {
+        interner: interner::mk_prefill::<@~str>(init_vec)
+    };
 
     /* having multiple interners will just confuse the serializer */
     unsafe {
@@ -360,8 +376,8 @@ fn mk_ident_interner() -> ident_interner {
 
 /* for when we don't care about the contents; doesn't interact with TLD or
    serialization */
-fn mk_fake_ident_interner() -> ident_interner {
-    interner::mk::<@~str>()
+fn mk_fake_ident_interner() -> @ident_interner {
+    @ident_interner { interner: interner::mk::<@~str>() }
 }
 
 /**
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 3630ba8c5c6..00652346e10 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -25,7 +25,7 @@ fn no_ann() -> pp_ann {
 type ps =
     @{s: pp::printer,
       cm: Option<codemap>,
-      intr: token::ident_interner,
+      intr: @token::ident_interner,
       comments: Option<~[comments::cmnt]>,
       literals: Option<~[comments::lit]>,
       mut cur_cmnt: uint,
@@ -43,7 +43,7 @@ fn end(s: ps) {
     pp::end(s.s);
 }
 
-fn rust_printer(writer: io::Writer, intr: ident_interner) -> ps {
+fn rust_printer(writer: io::Writer, intr: @ident_interner) -> ps {
     return @{s: pp::mk_printer(writer, default_columns),
              cm: None::<codemap>,
              intr: intr,
@@ -63,7 +63,7 @@ const default_columns: uint = 78u;
 // Requires you to pass an input filename and reader so that
 // it can scan the input text for comments and literals to
 // copy forward.
-fn print_crate(cm: codemap, intr: ident_interner,
+fn print_crate(cm: codemap, intr: @ident_interner,
                span_diagnostic: diagnostic::span_handler,
                crate: @ast::crate, filename: ~str, in: io::Reader,
                out: io::Writer, ann: pp_ann, is_expanded: bool) {
@@ -91,40 +91,40 @@ fn print_crate_(s: ps, &&crate: @ast::crate) {
     eof(s.s);
 }
 
-fn ty_to_str(ty: @ast::ty, intr: ident_interner) -> ~str {
+fn ty_to_str(ty: @ast::ty, intr: @ident_interner) -> ~str {
     to_str(ty, print_type, intr)
 }
 
-fn pat_to_str(pat: @ast::pat, intr: ident_interner) -> ~str {
+fn pat_to_str(pat: @ast::pat, intr: @ident_interner) -> ~str {
     to_str(pat, print_pat, intr)
 }
 
-fn expr_to_str(e: @ast::expr, intr: ident_interner) -> ~str {
+fn expr_to_str(e: @ast::expr, intr: @ident_interner) -> ~str {
     to_str(e, print_expr, intr)
 }
 
-fn tt_to_str(tt: ast::token_tree, intr: ident_interner) -> ~str {
+fn tt_to_str(tt: ast::token_tree, intr: @ident_interner) -> ~str {
     to_str(tt, print_tt, intr)
 }
 
-fn stmt_to_str(s: ast::stmt, intr: ident_interner) -> ~str {
+fn stmt_to_str(s: ast::stmt, intr: @ident_interner) -> ~str {
     to_str(s, print_stmt, intr)
 }
 
-fn item_to_str(i: @ast::item, intr: ident_interner) -> ~str {
+fn item_to_str(i: @ast::item, intr: @ident_interner) -> ~str {
     to_str(i, print_item, intr)
 }
 
-fn typarams_to_str(tps: ~[ast::ty_param], intr: ident_interner) -> ~str {
+fn typarams_to_str(tps: ~[ast::ty_param], intr: @ident_interner) -> ~str {
     to_str(tps, print_type_params, intr)
 }
 
-fn path_to_str(&&p: @ast::path, intr: ident_interner) -> ~str {
+fn path_to_str(&&p: @ast::path, intr: @ident_interner) -> ~str {
     to_str(p, |a,b| print_path(a, b, false), intr)
 }
 
 fn fun_to_str(decl: ast::fn_decl, name: ast::ident,
-              params: ~[ast::ty_param], intr: ident_interner) -> ~str {
+              params: ~[ast::ty_param], intr: @ident_interner) -> ~str {
     do io::with_str_writer |wr| {
         let s = rust_printer(wr, intr);
         print_fn(s, decl, None, name, params, None, ast::inherited);
@@ -147,7 +147,7 @@ fn test_fun_to_str() {
     assert fun_to_str(decl, "a", ~[]) == "fn a()";
 }
 
-fn block_to_str(blk: ast::blk, intr: ident_interner) -> ~str {
+fn block_to_str(blk: ast::blk, intr: @ident_interner) -> ~str {
     do io::with_str_writer |wr| {
         let s = rust_printer(wr, intr);
         // containing cbox, will be closed by print-block at }
@@ -159,15 +159,15 @@ fn block_to_str(blk: ast::blk, intr: ident_interner) -> ~str {
     }
 }
 
-fn meta_item_to_str(mi: @ast::meta_item, intr: ident_interner) -> ~str {
+fn meta_item_to_str(mi: @ast::meta_item, intr: @ident_interner) -> ~str {
     to_str(mi, print_meta_item, intr)
 }
 
-fn attribute_to_str(attr: ast::attribute, intr: ident_interner) -> ~str {
+fn attribute_to_str(attr: ast::attribute, intr: @ident_interner) -> ~str {
     to_str(attr, print_attribute, intr)
 }
 
-fn variant_to_str(var: ast::variant, intr: ident_interner) -> ~str {
+fn variant_to_str(var: ast::variant, intr: @ident_interner) -> ~str {
     to_str(var, print_variant, intr)
 }
 
@@ -2059,7 +2059,7 @@ fn print_string(s: ps, st: ~str) {
     word(s.s, ~"\"");
 }
 
-fn to_str<T>(t: T, f: fn@(ps, T), intr: ident_interner) -> ~str {
+fn to_str<T>(t: T, f: fn@(ps, T), intr: @ident_interner) -> ~str {
     do io::with_str_writer |wr| {
         let s = rust_printer(wr, intr);
         f(s, t);
diff --git a/src/rustc/back/link.rs b/src/rustc/back/link.rs
index fb3d749673c..c8f5871333f 100644
--- a/src/rustc/back/link.rs
+++ b/src/rustc/back/link.rs
@@ -607,7 +607,7 @@ fn mangle_internal_name_by_path(ccx: @crate_ctxt, path: path) -> ~str {
 }
 
 fn mangle_internal_name_by_seq(ccx: @crate_ctxt, flav: ~str) -> ~str {
-    return fmt!("%s_%u", flav, ccx.names(flav));
+    return fmt!("%s_%u", flav, ccx.names(flav).repr);
 }
 
 // If the user wants an exe generated we need to invoke
diff --git a/src/rustc/driver/session.rs b/src/rustc/driver/session.rs
index 335e1004078..c6c0ff2826a 100644
--- a/src/rustc/driver/session.rs
+++ b/src/rustc/driver/session.rs
@@ -243,7 +243,7 @@ impl session {
     fn ident_of(st: ~str) -> ast::ident {
         self.parse_sess.interner.intern(@st)
     }
-    fn intr() -> syntax::parse::token::ident_interner {
+    fn intr() -> @syntax::parse::token::ident_interner {
         self.parse_sess.interner
     }
 }
diff --git a/src/rustc/metadata/creader.rs b/src/rustc/metadata/creader.rs
index 0cd0b64a061..0d19fe796e1 100644
--- a/src/rustc/metadata/creader.rs
+++ b/src/rustc/metadata/creader.rs
@@ -18,7 +18,7 @@ export read_crates;
 // libraries necessary for later resolving, typechecking, linking, etc.
 fn read_crates(diag: span_handler, crate: ast::crate,
                cstore: cstore::cstore, filesearch: filesearch,
-               os: loader::os, static: bool, intr: ident_interner) {
+               os: loader::os, static: bool, intr: @ident_interner) {
     let e = @{diag: diag,
               filesearch: filesearch,
               cstore: cstore,
@@ -94,7 +94,7 @@ type env = @{diag: span_handler,
              static: bool,
              crate_cache: DVec<cache_entry>,
              mut next_crate_num: ast::crate_num,
-             intr: ident_interner};
+             intr: @ident_interner};
 
 fn visit_view_item(e: env, i: @ast::view_item) {
     match i.node {
diff --git a/src/rustc/metadata/cstore.rs b/src/rustc/metadata/cstore.rs
index 7151702f25e..8a982eaf497 100644
--- a/src/rustc/metadata/cstore.rs
+++ b/src/rustc/metadata/cstore.rs
@@ -58,7 +58,7 @@ type cstore_private =
       mut used_crate_files: ~[Path],
       mut used_libraries: ~[~str],
       mut used_link_args: ~[~str],
-      intr: ident_interner};
+      intr: @ident_interner};
 
 // Map from node_id's of local use statements to crate numbers
 type use_crate_map = map::HashMap<ast::node_id, ast::crate_num>;
@@ -68,7 +68,7 @@ pure fn p(cstore: cstore) -> cstore_private {
     match cstore { private(p) => p }
 }
 
-fn mk_cstore(intr: ident_interner) -> cstore {
+fn mk_cstore(intr: @ident_interner) -> cstore {
     let meta_cache = map::HashMap();
     let crate_map = map::HashMap();
     let mod_path_map = HashMap();
diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs
index 928bba5205a..4a72867eb85 100644
--- a/src/rustc/metadata/decoder.rs
+++ b/src/rustc/metadata/decoder.rs
@@ -268,7 +268,7 @@ fn enum_variant_ids(item: ebml::Doc, cdata: cmd) -> ~[ast::def_id] {
     return ids;
 }
 
-fn item_path(intr: ident_interner, item_doc: ebml::Doc) -> ast_map::path {
+fn item_path(intr: @ident_interner, item_doc: ebml::Doc) -> ast_map::path {
     let path_doc = ebml::get_doc(item_doc, tag_path);
 
     let len_doc = ebml::get_doc(path_doc, tag_path_len);
@@ -290,7 +290,7 @@ fn item_path(intr: ident_interner, item_doc: ebml::Doc) -> ast_map::path {
     return result;
 }
 
-fn item_name(intr: ident_interner, item: ebml::Doc) -> ast::ident {
+fn item_name(intr: @ident_interner, item: ebml::Doc) -> ast::ident {
     let name = ebml::get_doc(item, tag_paths_data_name);
     intr.intern(@str::from_bytes(ebml::doc_data(name)))
 }
@@ -365,7 +365,7 @@ fn get_impl_traits(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) -> ~[ty::t] {
     item_impl_traits(lookup_item(id, cdata.data), tcx, cdata)
 }
 
-fn get_impl_method(intr: ident_interner, cdata: cmd, id: ast::node_id,
+fn get_impl_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
                    name: ast::ident) -> ast::def_id {
     let items = ebml::get_doc(ebml::Doc(cdata.data), tag_items);
     let mut found = None;
@@ -378,7 +378,7 @@ fn get_impl_method(intr: ident_interner, cdata: cmd, id: ast::node_id,
     found.get()
 }
 
-fn get_class_method(intr: ident_interner, cdata: cmd, id: ast::node_id,
+fn get_class_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
                     name: ast::ident) -> ast::def_id {
     let items = ebml::get_doc(ebml::Doc(cdata.data), tag_items);
     let mut found = None;
@@ -451,7 +451,7 @@ fn path_entry(path_string: ~str, def_like: def_like) -> path_entry {
 }
 
 /// Iterates over all the paths in the given crate.
-fn each_path(intr: ident_interner, cdata: cmd, f: fn(path_entry) -> bool) {
+fn each_path(intr: @ident_interner, cdata: cmd, f: fn(path_entry) -> bool) {
     let root = ebml::Doc(cdata.data);
     let items = ebml::get_doc(root, tag_items);
     let items_data = ebml::get_doc(items, tag_items_data);
@@ -531,7 +531,7 @@ fn each_path(intr: ident_interner, cdata: cmd, f: fn(path_entry) -> bool) {
     }
 }
 
-fn get_item_path(intr: ident_interner, cdata: cmd, id: ast::node_id)
+fn get_item_path(intr: @ident_interner, cdata: cmd, id: ast::node_id)
     -> ast_map::path {
     item_path(intr, lookup_item(id, cdata.data))
 }
@@ -542,7 +542,7 @@ type decode_inlined_item = fn(
     path: ast_map::path,
     par_doc: ebml::Doc) -> Option<ast::inlined_item>;
 
-fn maybe_get_item_ast(intr: ident_interner, cdata: cmd, tcx: ty::ctxt,
+fn maybe_get_item_ast(intr: @ident_interner, cdata: cmd, tcx: ty::ctxt,
                       id: ast::node_id,
                       decode_inlined_item: decode_inlined_item
                      ) -> csearch::found_ast {
@@ -568,7 +568,7 @@ fn maybe_get_item_ast(intr: ident_interner, cdata: cmd, tcx: ty::ctxt,
     }
 }
 
-fn get_enum_variants(intr: ident_interner, cdata: cmd, id: ast::node_id,
+fn get_enum_variants(intr: @ident_interner, cdata: cmd, id: ast::node_id,
                      tcx: ty::ctxt) -> ~[ty::variant_info] {
     let data = cdata.data;
     let items = ebml::get_doc(ebml::Doc(data), tag_items);
@@ -638,7 +638,7 @@ fn get_self_ty(item: ebml::Doc) -> ast::self_ty_ {
     }
 }
 
-fn item_impl_methods(intr: ident_interner, cdata: cmd, item: ebml::Doc,
+fn item_impl_methods(intr: @ident_interner, cdata: cmd, item: ebml::Doc,
                      base_tps: uint) -> ~[@method_info] {
     let mut rslt = ~[];
     for ebml::tagged_docs(item, tag_item_impl_method) |doc| {
@@ -654,7 +654,7 @@ fn item_impl_methods(intr: ident_interner, cdata: cmd, item: ebml::Doc,
     rslt
 }
 
-fn get_impls_for_mod(intr: ident_interner, cdata: cmd,
+fn get_impls_for_mod(intr: @ident_interner, cdata: cmd,
                      m_id: ast::node_id, name: Option<ast::ident>,
                      get_cdata: fn(ast::crate_num) -> cmd)
                   -> @~[@_impl] {
@@ -685,7 +685,7 @@ fn get_impls_for_mod(intr: ident_interner, cdata: cmd,
 }
 
 /* Works for both classes and traits */
-fn get_trait_methods(intr: ident_interner, cdata: cmd, id: ast::node_id,
+fn get_trait_methods(intr: @ident_interner, cdata: cmd, id: ast::node_id,
                      tcx: ty::ctxt) -> @~[ty::method] {
     let data = cdata.data;
     let item = lookup_item(id, data);
@@ -712,7 +712,7 @@ fn get_trait_methods(intr: ident_interner, cdata: cmd, id: ast::node_id,
 // If the item in question is a trait, returns its set of methods and
 // their self types. Otherwise, returns none. This overlaps in an
 // annoying way with get_trait_methods.
-fn get_method_names_if_trait(intr: ident_interner, cdata: cmd,
+fn get_method_names_if_trait(intr: @ident_interner, cdata: cmd,
                              node_id: ast::node_id)
                           -> Option<@DVec<(ast::ident, ast::self_ty_)>> {
 
@@ -742,7 +742,7 @@ fn get_item_attrs(cdata: cmd,
 }
 
 // Helper function that gets either fields or methods
-fn get_class_members(intr: ident_interner, cdata: cmd, id: ast::node_id,
+fn get_class_members(intr: @ident_interner, cdata: cmd, id: ast::node_id,
                      p: fn(Family) -> bool) -> ~[ty::field_ty] {
     let data = cdata.data;
     let item = lookup_item(id, data);
@@ -769,7 +769,7 @@ pure fn family_to_visibility(family: Family) -> ast::visibility {
     }
 }
 
-fn get_class_fields(intr: ident_interner, cdata: cmd, id: ast::node_id)
+fn get_class_fields(intr: @ident_interner, cdata: cmd, id: ast::node_id)
     -> ~[ty::field_ty] {
     get_class_members(intr, cdata, id, |f| f == PublicField
                       || f == PrivateField || f == InheritedField)
@@ -876,14 +876,14 @@ fn get_attributes(md: ebml::Doc) -> ~[ast::attribute] {
     return attrs;
 }
 
-fn list_meta_items(intr: ident_interner,
+fn list_meta_items(intr: @ident_interner,
                    meta_items: ebml::Doc, out: io::Writer) {
     for get_meta_items(meta_items).each |mi| {
         out.write_str(fmt!("%s\n", pprust::meta_item_to_str(*mi, intr)));
     }
 }
 
-fn list_crate_attributes(intr: ident_interner, md: ebml::Doc, hash: ~str,
+fn list_crate_attributes(intr: @ident_interner, md: ebml::Doc, hash: ~str,
                          out: io::Writer) {
     out.write_str(fmt!("=Crate Attributes (%s)=\n", hash));
 
@@ -901,7 +901,7 @@ fn get_crate_attributes(data: @~[u8]) -> ~[ast::attribute] {
 type crate_dep = {cnum: ast::crate_num, name: ast::ident,
                   vers: ~str, hash: ~str};
 
-fn get_crate_deps(intr: ident_interner, data: @~[u8]) -> ~[crate_dep] {
+fn get_crate_deps(intr: @ident_interner, data: @~[u8]) -> ~[crate_dep] {
     let mut deps: ~[crate_dep] = ~[];
     let cratedoc = ebml::Doc(data);
     let depsdoc = ebml::get_doc(cratedoc, tag_crate_deps);
@@ -919,7 +919,7 @@ fn get_crate_deps(intr: ident_interner, data: @~[u8]) -> ~[crate_dep] {
     return deps;
 }
 
-fn list_crate_deps(intr: ident_interner, data: @~[u8], out: io::Writer) {
+fn list_crate_deps(intr: @ident_interner, data: @~[u8], out: io::Writer) {
     out.write_str(~"=External Dependencies=\n");
 
     for get_crate_deps(intr, data).each |dep| {
@@ -946,7 +946,7 @@ fn get_crate_vers(data: @~[u8]) -> ~str {
     };
 }
 
-fn iter_crate_items(intr: ident_interner,
+fn iter_crate_items(intr: @ident_interner,
                     cdata: cmd, proc: fn(~str, ast::def_id)) {
     for each_path(intr, cdata) |path_entry| {
         match path_entry.def_like {
@@ -958,7 +958,7 @@ fn iter_crate_items(intr: ident_interner,
     }
 }
 
-fn get_crate_module_paths(intr: ident_interner, cdata: cmd)
+fn get_crate_module_paths(intr: @ident_interner, cdata: cmd)
                                     -> ~[(ast::def_id, ~str)] {
     fn mod_of_path(p: ~str) -> ~str {
         str::connect(vec::init(str::split_str(p, ~"::")), ~"::")
@@ -985,7 +985,7 @@ fn get_crate_module_paths(intr: ident_interner, cdata: cmd)
     }
 }
 
-fn list_crate_metadata(intr: ident_interner, bytes: @~[u8],
+fn list_crate_metadata(intr: @ident_interner, bytes: @~[u8],
                        out: io::Writer) {
     let hash = get_crate_hash(bytes);
     let md = ebml::Doc(bytes);
diff --git a/src/rustc/metadata/loader.rs b/src/rustc/metadata/loader.rs
index e11793a36d0..b2c28fafd4c 100644
--- a/src/rustc/metadata/loader.rs
+++ b/src/rustc/metadata/loader.rs
@@ -35,7 +35,7 @@ type ctxt = {
     hash: ~str,
     os: os,
     static: bool,
-    intr: ident_interner
+    intr: @ident_interner
 };
 
 fn load_library_crate(cx: ctxt) -> {ident: ~str, data: @~[u8]} {
@@ -135,7 +135,7 @@ fn crate_name_from_metas(metas: ~[@ast::meta_item]) -> ~str {
     }
 }
 
-fn note_linkage_attrs(intr: ident_interner, diag: span_handler,
+fn note_linkage_attrs(intr: @ident_interner, diag: span_handler,
                       attrs: ~[ast::attribute]) {
     for attr::find_linkage_metas(attrs).each |mi| {
         diag.handler().note(fmt!("meta: %s",
@@ -226,7 +226,7 @@ fn meta_section_name(os: os) -> ~str {
 }
 
 // A diagnostic function for dumping crate metadata to an output stream
-fn list_file_metadata(intr: ident_interner,
+fn list_file_metadata(intr: @ident_interner,
                       os: os, path: &Path, out: io::Writer) {
     match get_metadata_section(os, path) {
       option::Some(bytes) => decoder::list_crate_metadata(intr, bytes, out),
diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs
index 07b5d3b4ce8..3e216c4eacc 100644
--- a/src/rustc/middle/resolve.rs
+++ b/src/rustc/middle/resolve.rs
@@ -652,14 +652,14 @@ struct PrimitiveTypeTable {
 }
 
 impl PrimitiveTypeTable {
-    fn intern(intr: ident_interner, string: @~str,
+    fn intern(intr: @ident_interner, string: @~str,
               primitive_type: prim_ty) {
         let atom = intr.intern(string);
         self.primitive_types.insert(atom, primitive_type);
     }
 }
 
-fn PrimitiveTypeTable(intr: ident_interner) -> PrimitiveTypeTable {
+fn PrimitiveTypeTable(intr: @ident_interner) -> PrimitiveTypeTable {
     let table = PrimitiveTypeTable {
         primitive_types: atom_hashmap()
     };
@@ -765,7 +765,7 @@ struct Resolver {
     lang_items: LanguageItems,
     crate: @crate,
 
-    intr: ident_interner,
+    intr: @ident_interner,
 
     graph_root: @NameBindings,
 
diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs
index a1ca4287f0e..fc74e5e0e4d 100644
--- a/src/rustc/middle/trans/common.rs
+++ b/src/rustc/middle/trans/common.rs
@@ -25,9 +25,9 @@ use syntax::parse::token::ident_interner;
 use syntax::ast::ident;
 
 type namegen = fn@(~str) -> ident;
-fn new_namegen(intr: ident_interner) -> namegen {
+fn new_namegen(intr: @ident_interner) -> namegen {
     return fn@(prefix: ~str) -> ident {
-        return intr.gensym(@fmt!("%s_%u", prefix, intr.gensym(@prefix)))
+        return intr.gensym(@fmt!("%s_%u", prefix, intr.gensym(@prefix).repr))
     };
 }
 
@@ -1024,7 +1024,7 @@ fn C_cstr(cx: @crate_ctxt, s: ~str) -> ValueRef {
         llvm::LLVMConstString(buf, str::len(s) as c_uint, False)
     };
     let g =
-        str::as_c_str(fmt!("str%u", cx.names(~"str")),
+        str::as_c_str(fmt!("str%u", cx.names(~"str").repr),
                     |buf| llvm::LLVMAddGlobal(cx.llmod, val_ty(sc), buf));
     llvm::LLVMSetInitializer(g, sc);
     llvm::LLVMSetGlobalConstant(g, True);
@@ -1086,7 +1086,8 @@ fn C_bytes_plus_null(bytes: ~[u8]) -> ValueRef unsafe {
 
 fn C_shape(ccx: @crate_ctxt, bytes: ~[u8]) -> ValueRef {
     let llshape = C_bytes_plus_null(bytes);
-    let llglobal = str::as_c_str(fmt!("shape%u", ccx.names(~"shape")), |buf| {
+    let name = fmt!("shape%u", ccx.names(~"shape").repr);
+    let llglobal = str::as_c_str(name, |buf| {
         llvm::LLVMAddGlobal(ccx.llmod, val_ty(llshape), buf)
     });
     llvm::LLVMSetInitializer(llglobal, llshape);
diff --git a/src/rustc/middle/trans/debuginfo.rs b/src/rustc/middle/trans/debuginfo.rs
index 9944daefea4..26a83951c01 100644
--- a/src/rustc/middle/trans/debuginfo.rs
+++ b/src/rustc/middle/trans/debuginfo.rs
@@ -90,7 +90,7 @@ type debug_ctxt = {
     crate_file: ~str
 };
 
-fn mk_ctxt(crate: ~str, intr: ident_interner) -> debug_ctxt {
+fn mk_ctxt(crate: ~str, intr: @ident_interner) -> debug_ctxt {
     {llmetadata: map::HashMap(),
      names: new_namegen(intr),
      crate_file: crate}
diff --git a/src/rustdoc/extract.rs b/src/rustdoc/extract.rs
index b8a13b712e5..448e699fc8d 100644
--- a/src/rustdoc/extract.rs
+++ b/src/rustdoc/extract.rs
@@ -21,7 +21,7 @@ fn to_str(id: ast::ident) -> ~str {
     return *(*intr.get()).get(id);
 }
 
-fn interner() -> syntax::parse::token::ident_interner {
+fn interner() -> @syntax::parse::token::ident_interner {
     return *(unsafe{ local_data_get(interner_key!()) }).get();
 }
 
-- 
cgit 1.4.1-3-g733a5


From 79131ecfd33c1f5782a0f9f61aa764717e4a2ddd Mon Sep 17 00:00:00 2001
From: Erick Tryzelaar <erick.tryzelaar@gmail.com>
Date: Wed, 19 Sep 2012 18:52:49 -0700
Subject: replace resolve::Atom with ast::ident.

---
 src/rustc/middle/resolve.rs | 271 +++++++++++++++++++++-----------------------
 1 file changed, 129 insertions(+), 142 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs
index 3e216c4eacc..7380a217ebe 100644
--- a/src/rustc/middle/resolve.rs
+++ b/src/rustc/middle/resolve.rs
@@ -191,7 +191,7 @@ impl ImportDirectiveNS : cmp::Eq {
 
 /// Contains data for specific types of import directives.
 enum ImportDirectiveSubclass {
-    SingleImport(Atom /* target */, Atom /* source */, ImportDirectiveNS),
+    SingleImport(ident /* target */, ident /* source */, ImportDirectiveNS),
     GlobImport
 }
 
@@ -303,29 +303,15 @@ enum EnumVariantOrConstResolution {
     EnumVariantOrConstNotFound
 }
 
-// FIXME (issue #2550): Should be a class but then it becomes not implicitly
-// copyable due to a kind bug.
-
-type Atom = uint;
-
-fn Atom(n: uint) -> Atom {
-    return n;
-}
-
-/// Creates a hash table of atoms.
-fn atom_hashmap<V:Copy>() -> HashMap<Atom,V> {
-  HashMap()
-}
-
 /// One local scope.
 struct Rib {
-    bindings: HashMap<Atom,def_like>,
+    bindings: HashMap<ident,def_like>,
     kind: RibKind,
 }
 
 fn Rib(kind: RibKind) -> Rib {
     Rib {
-        bindings: atom_hashmap(),
+        bindings: HashMap(),
         kind: kind
     }
 }
@@ -334,13 +320,13 @@ fn Rib(kind: RibKind) -> Rib {
 /// One import directive.
 struct ImportDirective {
     privacy: Privacy,
-    module_path: @DVec<Atom>,
+    module_path: @DVec<ident>,
     subclass: @ImportDirectiveSubclass,
     span: span,
 }
 
 fn ImportDirective(privacy: Privacy,
-                   module_path: @DVec<Atom>,
+                   module_path: @DVec<ident>,
                    subclass: @ImportDirectiveSubclass,
                    span: span) -> ImportDirective {
     ImportDirective {
@@ -407,7 +393,7 @@ impl ImportResolution {
 /// The link from a module up to its nearest parent node.
 enum ParentLink {
     NoParentLink,
-    ModuleParentLink(@Module, Atom),
+    ModuleParentLink(@Module, ident),
     BlockParentLink(@Module, node_id)
 }
 
@@ -416,7 +402,7 @@ struct Module {
     parent_link: ParentLink,
     mut def_id: Option<def_id>,
 
-    children: HashMap<Atom,@NameBindings>,
+    children: HashMap<ident,@NameBindings>,
     imports: DVec<@ImportDirective>,
 
     // The anonymous children of this node. Anonymous children are pseudo-
@@ -439,10 +425,10 @@ struct Module {
     // XXX: This is about to be reworked so that exports are on individual
     // items, not names.
     //
-    // The atom is the name of the exported item, while the node ID is the
+    // The ident is the name of the exported item, while the node ID is the
     // ID of the export path.
 
-    exported_names: HashMap<Atom,node_id>,
+    exported_names: HashMap<ident,node_id>,
 
     // XXX: This is a transition measure to let us switch export-evaluation
     // logic when compiling modules that have transitioned to listing their
@@ -452,7 +438,7 @@ struct Module {
     legacy_exports: bool,
 
     // The status of resolving each import in this module.
-    import_resolutions: HashMap<Atom,@ImportResolution>,
+    import_resolutions: HashMap<ident,@ImportResolution>,
 
     // The number of unresolved globs that this module exports.
     mut glob_count: uint,
@@ -467,12 +453,12 @@ fn Module(parent_link: ParentLink,
     Module {
         parent_link: parent_link,
         def_id: def_id,
-        children: atom_hashmap(),
+        children: HashMap(),
         imports: DVec(),
         anonymous_children: HashMap(),
-        exported_names: atom_hashmap(),
+        exported_names: HashMap(),
         legacy_exports: legacy_exports,
-        import_resolutions: atom_hashmap(),
+        import_resolutions: HashMap(),
         glob_count: 0u,
         resolved_import_count: 0u
     }
@@ -648,20 +634,20 @@ fn NameBindings() -> NameBindings {
 
 /// Interns the names of the primitive types.
 struct PrimitiveTypeTable {
-    primitive_types: HashMap<Atom,prim_ty>,
+    primitive_types: HashMap<ident,prim_ty>,
 }
 
 impl PrimitiveTypeTable {
     fn intern(intr: @ident_interner, string: @~str,
               primitive_type: prim_ty) {
-        let atom = intr.intern(string);
-        self.primitive_types.insert(atom, primitive_type);
+        let ident = intr.intern(string);
+        self.primitive_types.insert(ident, primitive_type);
     }
 }
 
 fn PrimitiveTypeTable(intr: @ident_interner) -> PrimitiveTypeTable {
     let table = PrimitiveTypeTable {
-        primitive_types: atom_hashmap()
+        primitive_types: HashMap()
     };
 
     table.intern(intr, @~"bool",    ty_bool);
@@ -743,7 +729,7 @@ fn Resolver(session: session, lang_items: LanguageItems,
         xray_context: NoXray,
         current_trait_refs: None,
 
-        self_atom: syntax::parse::token::special_idents::self_,
+        self_ident: syntax::parse::token::special_idents::self_,
         primitive_type_table: @PrimitiveTypeTable(session.
                                                   parse_sess.interner),
 
@@ -771,7 +757,7 @@ struct Resolver {
 
     unused_import_lint_level: level,
 
-    trait_info: HashMap<def_id,@HashMap<Atom,()>>,
+    trait_info: HashMap<def_id,@HashMap<ident,()>>,
     structs: HashMap<def_id,bool>,
 
     // The number of imports that are currently unresolved.
@@ -797,10 +783,10 @@ struct Resolver {
     // The trait that the current context can refer to.
     mut current_trait_refs: Option<@DVec<def_id>>,
 
-    // The atom for the keyword "self".
-    self_atom: Atom,
+    // The ident for the keyword "self".
+    self_ident: ident,
 
-    // The atoms for the primitive types.
+    // The idents for the primitive types.
     primitive_type_table: @PrimitiveTypeTable,
 
     // The four namespaces.
@@ -899,7 +885,7 @@ impl Resolver {
      * If this node does not have a module definition and we are not inside
      * a block, fails.
      */
-    fn add_child(name: Atom,
+    fn add_child(name: ident,
                  reduced_graph_parent: ReducedGraphParent,
                  // Pass in the namespaces for the child item so that we can
                  // check for duplicate items in the same namespace
@@ -981,7 +967,8 @@ impl Resolver {
         return false;
     }
 
-    fn get_parent_link(parent: ReducedGraphParent, name: Atom) -> ParentLink {
+    fn get_parent_link(parent: ReducedGraphParent,
+                       name: ident) -> ParentLink {
         match parent {
             ModuleReducedGraphParent(module_) => {
                 return ModuleParentLink(module_, name);
@@ -994,7 +981,7 @@ impl Resolver {
                                     parent: ReducedGraphParent,
                                     &&visitor: vt<ReducedGraphParent>) {
 
-        let atom = item.ident;
+        let ident = item.ident;
         let sp = item.span;
         let legacy = match parent {
           ModuleReducedGraphParent(m) => m.legacy_exports
@@ -1004,10 +991,10 @@ impl Resolver {
         match item.node {
             item_mod(module_) => {
               let legacy = has_legacy_export_attr(item.attrs);
-              let (name_bindings, new_parent) = self.add_child(atom, parent,
+              let (name_bindings, new_parent) = self.add_child(ident, parent,
                                                        ~[ModuleNS], sp);
 
-                let parent_link = self.get_parent_link(new_parent, atom);
+                let parent_link = self.get_parent_link(new_parent, ident);
                 let def_id = { crate: 0, node: item.id };
               (*name_bindings).define_module(privacy, parent_link,
                                              Some(def_id), legacy, sp);
@@ -1021,10 +1008,10 @@ impl Resolver {
               let legacy = has_legacy_export_attr(item.attrs);
               let new_parent = match fm.sort {
                 named => {
-                  let (name_bindings, new_parent) = self.add_child(atom,
+                  let (name_bindings, new_parent) = self.add_child(ident,
                      parent, ~[ModuleNS], sp);
 
-                  let parent_link = self.get_parent_link(new_parent, atom);
+                  let parent_link = self.get_parent_link(new_parent, ident);
                   let def_id = { crate: 0, node: item.id };
                   (*name_bindings).define_module(privacy, parent_link,
                                                  Some(def_id), legacy, sp);
@@ -1041,14 +1028,14 @@ impl Resolver {
 
             // These items live in the value namespace.
             item_const(*) => {
-              let (name_bindings, _) = self.add_child(atom, parent,
+              let (name_bindings, _) = self.add_child(ident, parent,
                                                       ~[ValueNS], sp);
 
                 (*name_bindings).define_value
                     (privacy, def_const(local_def(item.id)), sp);
             }
             item_fn(_, purity, _, _) => {
-              let (name_bindings, new_parent) = self.add_child(atom, parent,
+              let (name_bindings, new_parent) = self.add_child(ident, parent,
                                                         ~[ValueNS], sp);
 
                 let def = def_fn(local_def(item.id), purity);
@@ -1058,7 +1045,7 @@ impl Resolver {
 
             // These items live in the type namespace.
             item_ty(*) => {
-              let (name_bindings, _) = self.add_child(atom, parent,
+              let (name_bindings, _) = self.add_child(ident, parent,
                                                       ~[TypeNS], sp);
 
                 (*name_bindings).define_type
@@ -1067,7 +1054,7 @@ impl Resolver {
 
             item_enum(enum_definition, _) => {
 
-              let (name_bindings, new_parent) = self.add_child(atom, parent,
+              let (name_bindings, new_parent) = self.add_child(ident, parent,
                                                                ~[TypeNS], sp);
 
                 (*name_bindings).define_type
@@ -1087,7 +1074,7 @@ impl Resolver {
                     match struct_definition.ctor {
                     None => {
                         let (name_bindings, new_parent) =
-                            self.add_child(atom, parent, ~[TypeNS], sp);
+                            self.add_child(ident, parent, ~[TypeNS], sp);
 
                         (*name_bindings).define_type
                             (privacy, def_ty(local_def(item.id)), sp);
@@ -1095,7 +1082,7 @@ impl Resolver {
                     }
                     Some(ctor) => {
                         let (name_bindings, new_parent) =
-                            self.add_child(atom, parent, ~[ValueNS, TypeNS],
+                            self.add_child(ident, parent, ~[ValueNS, TypeNS],
                                            sp);
 
                         (*name_bindings).define_type
@@ -1121,22 +1108,22 @@ impl Resolver {
             }
 
             item_trait(_, _, methods) => {
-              let (name_bindings, new_parent) = self.add_child(atom, parent,
+              let (name_bindings, new_parent) = self.add_child(ident, parent,
                                                                ~[TypeNS], sp);
 
                 // Add the names of all the methods to the trait info.
-                let method_names = @atom_hashmap();
+                let method_names = @HashMap();
                 for methods.each |method| {
                     let ty_m = trait_method_to_ty_method(*method);
 
-                    let atom = ty_m.ident;
+                    let ident = ty_m.ident;
                     // Add it to the trait info if not static,
                     // add it as a name in the enclosing module otherwise.
                     match ty_m.self_ty.node {
                       sty_static => {
                         // which parent to use??
                         let (method_name_bindings, _) =
-                            self.add_child(atom, new_parent, ~[ValueNS],
+                            self.add_child(ident, new_parent, ~[ValueNS],
                                            ty_m.span);
                         let def = def_static_method(local_def(ty_m.id),
                                                     ty_m.purity);
@@ -1144,7 +1131,7 @@ impl Resolver {
                             (Public, def, ty_m.span);
                       }
                       _ => {
-                        (*method_names).insert(atom, ());
+                        (*method_names).insert(ident, ());
                       }
                     }
                 }
@@ -1176,8 +1163,8 @@ impl Resolver {
           ModuleReducedGraphParent(m) => m.legacy_exports
         };
 
-        let atom = variant.node.name;
-        let (child, _) = self.add_child(atom, parent, ~[ValueNS],
+        let ident = variant.node.name;
+        let (child, _) = self.add_child(ident, parent, ~[ValueNS],
                                         variant.span);
         let privacy = self.visibility_to_privacy(variant.node.vis, legacy);
 
@@ -1338,9 +1325,9 @@ impl Resolver {
                                 }
 
                                 for path_list_idents.each |path_list_ident| {
-                                    let atom = path_list_ident.node.name;
+                                    let ident = path_list_ident.node.name;
                                     let id = path_list_ident.node.id;
-                                    module_.exported_names.insert(atom, id);
+                                    module_.exported_names.insert(ident, id);
                                 }
                             }
                         }
@@ -1433,7 +1420,7 @@ impl Resolver {
     fn handle_external_def(def: def, modules: HashMap<def_id, @Module>,
                            child_name_bindings: @NameBindings,
                            final_ident: ~str,
-                           atom: Atom, new_parent: ReducedGraphParent) {
+                           ident: ident, new_parent: ReducedGraphParent) {
         match def {
           def_mod(def_id) | def_foreign_mod(def_id) => {
             match copy child_name_bindings.module_def {
@@ -1441,7 +1428,7 @@ impl Resolver {
                 debug!("(building reduced graph for \
                         external crate) building module \
                         %s", final_ident);
-                let parent_link = self.get_parent_link(new_parent, atom);
+                let parent_link = self.get_parent_link(new_parent, ident);
 
                 match modules.find(def_id) {
                   None => {
@@ -1466,9 +1453,9 @@ impl Resolver {
                       BlockParentLink(*) => {
                         fail ~"can't happen";
                       }
-                      ModuleParentLink(parent_module, atom) => {
+                      ModuleParentLink(parent_module, ident) => {
 
-                        let name_bindings = parent_module.children.get(atom);
+                        let name_bindings = parent_module.children.get(ident);
 
                         resolution.module_target =
                             Some(Target(parent_module, name_bindings));
@@ -1478,7 +1465,7 @@ impl Resolver {
                     debug!("(building reduced graph for external crate) \
                             ... creating import resolution");
 
-                    new_parent.import_resolutions.insert(atom, resolution);
+                    new_parent.import_resolutions.insert(ident, resolution);
                   }
                 }
               }
@@ -1510,7 +1497,7 @@ impl Resolver {
                 // Nothing to do.
               }
               Some(method_names) => {
-                let interned_method_names = @atom_hashmap();
+                let interned_method_names = @HashMap();
                 for method_names.each |method_data| {
                     let (method_name, self_ty) = *method_data;
                     debug!("(building reduced graph for \
@@ -1634,7 +1621,7 @@ impl Resolver {
     /// Creates and adds an import directive to the given module.
     fn build_import_directive(privacy: Privacy,
                               module_: @Module,
-                              module_path: @DVec<Atom>,
+                              module_path: @DVec<ident>,
                               subclass: @ImportDirectiveSubclass,
                               span: span) {
 
@@ -1764,17 +1751,17 @@ impl Resolver {
         }
     }
 
-    fn atoms_to_str(atoms: ~[Atom]) -> ~str {
+    fn idents_to_str(idents: ~[ident]) -> ~str {
         // XXX: str::connect should do this.
         let mut result = ~"";
         let mut first = true;
-        for atoms.each() |atom| {
+        for idents.each() |ident| {
             if first {
                 first = false;
             } else {
                 result += ~"::";
             }
-            result += self.session.str_of(*atom);
+            result += self.session.str_of(*ident);
         }
         // XXX: Shouldn't copy here. We need string builder functionality.
         return result;
@@ -1795,7 +1782,7 @@ impl Resolver {
 
         debug!("(resolving import for module) resolving import `%s::...` in \
                 `%s`",
-               self.atoms_to_str((*module_path).get()),
+               self.idents_to_str((*module_path).get()),
                self.module_to_str(module_));
 
         // One-level renaming imports of the form `import foo = bar;` are
@@ -1882,8 +1869,8 @@ impl Resolver {
 
     fn resolve_single_import(module_: @Module,
                              containing_module: @Module,
-                             target: Atom,
-                             source: Atom)
+                             target: ident,
+                             source: ident)
                           -> ResolveResult<()> {
 
         debug!("(resolving single import) resolving `%s` = `%s::%s` from \
@@ -2072,8 +2059,8 @@ impl Resolver {
 
     fn resolve_single_module_import(module_: @Module,
                                     containing_module: @Module,
-                                    target: Atom,
-                                    source: Atom)
+                                    target: ident,
+                                    source: ident)
                                  -> ResolveResult<()> {
 
         debug!("(resolving single module import) resolving `%s` = `%s::%s` \
@@ -2229,11 +2216,11 @@ impl Resolver {
 
         // Add all resolved imports from the containing module.
         for containing_module.import_resolutions.each
-                |atom, target_import_resolution| {
+                |ident, target_import_resolution| {
 
-            if !self.name_is_exported(containing_module, atom) {
+            if !self.name_is_exported(containing_module, ident) {
                 debug!("(resolving glob import) name `%s` is unexported",
-                       self.session.str_of(atom));
+                       self.session.str_of(ident));
                 loop;
             }
 
@@ -2243,7 +2230,7 @@ impl Resolver {
                    self.module_to_str(module_));
 
             // Here we merge two import resolutions.
-            match module_.import_resolutions.find(atom) {
+            match module_.import_resolutions.find(ident) {
                 None => {
                     // Simple: just copy the old import resolution.
                     let new_import_resolution =
@@ -2257,7 +2244,7 @@ impl Resolver {
                         copy target_import_resolution.type_target;
 
                     module_.import_resolutions.insert
-                        (atom, new_import_resolution);
+                        (ident, new_import_resolution);
                 }
                 Some(dest_import_resolution) => {
                     // Merge the two import resolutions at a finer-grained
@@ -2295,21 +2282,21 @@ impl Resolver {
         }
 
         // Add all children from the containing module.
-        for containing_module.children.each |atom, name_bindings| {
-            if !self.name_is_exported(containing_module, atom) {
+        for containing_module.children.each |ident, name_bindings| {
+            if !self.name_is_exported(containing_module, ident) {
                 debug!("(resolving glob import) name `%s` is unexported",
-                       self.session.str_of(atom));
+                       self.session.str_of(ident));
                 loop;
             }
 
             let mut dest_import_resolution;
-            match module_.import_resolutions.find(atom) {
+            match module_.import_resolutions.find(ident) {
                 None => {
                     // Create a new import resolution from this child.
                     dest_import_resolution = @ImportResolution(privacy,
                                                                span);
                     module_.import_resolutions.insert
-                        (atom, dest_import_resolution);
+                        (ident, dest_import_resolution);
                 }
                 Some(existing_import_resolution) => {
                     dest_import_resolution = existing_import_resolution;
@@ -2319,7 +2306,7 @@ impl Resolver {
 
             debug!("(resolving glob import) writing resolution `%s` in `%s` \
                     to `%s`",
-                   self.session.str_of(atom),
+                   self.session.str_of(ident),
                    self.module_to_str(containing_module),
                    self.module_to_str(module_));
 
@@ -2346,7 +2333,7 @@ impl Resolver {
     }
 
     fn resolve_module_path_from_root(module_: @Module,
-                                     module_path: @DVec<Atom>,
+                                     module_path: @DVec<ident>,
                                      index: uint,
                                      xray: XrayFlag,
                                      span: span)
@@ -2403,7 +2390,7 @@ impl Resolver {
      * the given module.
      */
     fn resolve_module_path_for_import(module_: @Module,
-                                      module_path: @DVec<Atom>,
+                                      module_path: @DVec<ident>,
                                       xray: XrayFlag,
                                       span: span)
                                    -> ResolveResult<@Module> {
@@ -2413,7 +2400,7 @@ impl Resolver {
 
         debug!("(resolving module path for import) processing `%s` rooted at \
                `%s`",
-               self.atoms_to_str((*module_path).get()),
+               self.idents_to_str((*module_path).get()),
                self.module_to_str(module_));
 
         // The first element of the module path must be in the current scope
@@ -2444,7 +2431,7 @@ impl Resolver {
     }
 
     fn resolve_item_in_lexical_scope(module_: @Module,
-                                     name: Atom,
+                                     name: ident,
                                      namespace: Namespace)
                                   -> ResolveResult<Target> {
 
@@ -2530,7 +2517,7 @@ impl Resolver {
         }
     }
 
-    fn resolve_module_in_lexical_scope(module_: @Module, name: Atom)
+    fn resolve_module_in_lexical_scope(module_: @Module, name: ident)
                                     -> ResolveResult<@Module> {
 
         match self.resolve_item_in_lexical_scope(module_, name, ModuleNS) {
@@ -2559,7 +2546,7 @@ impl Resolver {
         }
     }
 
-    fn name_is_exported(module_: @Module, name: Atom) -> bool {
+    fn name_is_exported(module_: @Module, name: ident) -> bool {
         return !module_.legacy_exports ||
             module_.exported_names.size() == 0u ||
             module_.exported_names.contains_key(name);
@@ -2571,7 +2558,7 @@ impl Resolver {
      * the name.
      */
     fn resolve_name_in_module(module_: @Module,
-                              name: Atom,
+                              name: ident,
                               namespace: Namespace,
                               xray: XrayFlag)
                            -> ResolveResult<Target> {
@@ -2863,7 +2850,7 @@ impl Resolver {
 
         self.record_exports_for_module(module_);
 
-        for module_.children.each |_atom, child_name_bindings| {
+        for module_.children.each |_ident, child_name_bindings| {
             match child_name_bindings.get_module_if_available() {
                 None => {
                     // Nothing to do.
@@ -2899,7 +2886,7 @@ impl Resolver {
 
 
     fn add_exports_of_namebindings(exports2: &mut ~[Export2],
-                                   atom: Atom,
+                                   ident: ident,
                                    namebindings: @NameBindings,
                                    reexport: bool) {
         for [ModuleNS, TypeNS, ValueNS].each |ns| {
@@ -2908,11 +2895,11 @@ impl Resolver {
                     debug!("(computing exports) YES: %s '%s' \
                             => %?",
                            if reexport { ~"reexport" } else { ~"export"},
-                           self.session.str_of(atom),
+                           self.session.str_of(ident),
                            def_id_of_def(d.def));
                     vec::push(*exports2,  Export2 {
                         reexport: reexport,
-                        name: self.session.str_of(atom),
+                        name: self.session.str_of(ident),
                         def_id: def_id_of_def(d.def)
                     });
                 }
@@ -2923,20 +2910,20 @@ impl Resolver {
 
     fn add_exports_for_module(exports2: &mut ~[Export2], module_: @Module) {
 
-        for module_.children.each_ref |atom, namebindings| {
+        for module_.children.each_ref |ident, namebindings| {
             debug!("(computing exports) maybe export '%s'",
-                   self.session.str_of(*atom));
-            self.add_exports_of_namebindings(exports2, *atom,
+                   self.session.str_of(*ident));
+            self.add_exports_of_namebindings(exports2, *ident,
                                              *namebindings, false)
         }
 
-        for module_.import_resolutions.each_ref |atom, importresolution| {
+        for module_.import_resolutions.each_ref |ident, importresolution| {
             for [ModuleNS, TypeNS, ValueNS].each |ns| {
                 match importresolution.target_for_namespace(*ns) {
                     Some(target) => {
                         debug!("(computing exports) maybe reexport '%s'",
-                               self.session.str_of(*atom));
-                        self.add_exports_of_namebindings(exports2, *atom,
+                               self.session.str_of(*ident));
+                        self.add_exports_of_namebindings(exports2, *ident,
                                                          target.bindings,
                                                          true)
                     }
@@ -3002,7 +2989,7 @@ impl Resolver {
     // generate a fake "implementation scope" containing all the
     // implementations thus found, for compatibility with old resolve pass.
 
-    fn with_scope(name: Option<Atom>, f: fn()) {
+    fn with_scope(name: Option<ident>, f: fn()) {
         let orig_module = self.current_module;
 
         // Move down in the graph.
@@ -3142,7 +3129,7 @@ impl Resolver {
         return Some(dl_def(def));
     }
 
-    fn search_ribs(ribs: @DVec<@Rib>, name: Atom, span: span,
+    fn search_ribs(ribs: @DVec<@Rib>, name: ident, span: span,
                    allow_capturing_self: AllowCapturingSelfFlag)
                 -> Option<def_like> {
 
@@ -3223,7 +3210,7 @@ impl Resolver {
                 // Create a new rib for the self type.
                 let self_type_rib = @Rib(NormalRibKind);
                 (*self.type_ribs).push(self_type_rib);
-                self_type_rib.bindings.insert(self.self_atom,
+                self_type_rib.bindings.insert(self.self_ident,
                                               dl_def(def_self(item.id)));
 
                 // Create a new rib for the trait-wide type parameters.
@@ -3483,7 +3470,7 @@ impl Resolver {
                 }
                 HasSelfBinding(self_node_id) => {
                     let def_like = dl_def(def_self(self_node_id));
-                    (*function_value_rib).bindings.insert(self.self_atom,
+                    (*function_value_rib).bindings.insert(self.self_ident,
                                                           def_like);
                 }
             }
@@ -3818,7 +3805,7 @@ impl Resolver {
     fn resolve_arm(arm: arm, visitor: ResolveVisitor) {
         (*self.value_ribs).push(@Rib(NormalRibKind));
 
-        let bindings_list = atom_hashmap();
+        let bindings_list = HashMap();
         for arm.pats.each |pattern| {
             self.resolve_pattern(*pattern, RefutableMode, Immutable,
                                  Some(bindings_list), visitor);
@@ -3937,7 +3924,7 @@ impl Resolver {
                        mutability: Mutability,
                        // Maps idents to the node ID for the (outermost)
                        // pattern that binds them
-                       bindings_list: Option<HashMap<Atom,node_id>>,
+                       bindings_list: Option<HashMap<ident,node_id>>,
                        visitor: ResolveVisitor) {
 
         let pat_id = pattern.id;
@@ -3954,13 +3941,13 @@ impl Resolver {
                     // matching such a variant is simply disallowed (since
                     // it's rarely what you want).
 
-                    let atom = path.idents[0];
+                    let ident = path.idents[0];
 
-                    match self.resolve_enum_variant_or_const(atom) {
+                    match self.resolve_enum_variant_or_const(ident) {
                         FoundEnumVariant(def) if mode == RefutableMode => {
                             debug!("(resolving pattern) resolving `%s` to \
                                     enum variant",
-                                    self.session.str_of(atom));
+                                    self.session.str_of(ident));
 
                             self.record_def(pattern.id, def);
                         }
@@ -3970,7 +3957,7 @@ impl Resolver {
                                                         shadows an enum \
                                                         that's in scope",
                                                         self.session
-                                                        .str_of(atom)));
+                                                        .str_of(ident)));
                         }
                         FoundConst => {
                             self.session.span_err(pattern.span,
@@ -3980,7 +3967,7 @@ impl Resolver {
                         }
                         EnumVariantOrConstNotFound => {
                             debug!("(resolving pattern) binding `%s`",
-                                   self.session.str_of(atom));
+                                   self.session.str_of(ident));
 
                             let is_mutable = mutability == Mutable;
 
@@ -4011,14 +3998,14 @@ impl Resolver {
 
                             match bindings_list {
                                 Some(bindings_list)
-                                if !bindings_list.contains_key(atom) => {
+                                if !bindings_list.contains_key(ident) => {
                                     let last_rib = (*self.value_ribs).last();
-                                    last_rib.bindings.insert(atom,
+                                    last_rib.bindings.insert(ident,
                                                              dl_def(def));
-                                    bindings_list.insert(atom, pat_id);
+                                    bindings_list.insert(ident, pat_id);
                                 }
                                 Some(b) => {
-                                  if b.find(atom) == Some(pat_id) {
+                                  if b.find(ident) == Some(pat_id) {
                                       // Then this is a duplicate variable
                                       // in the same disjunct, which is an
                                       // error
@@ -4032,7 +4019,7 @@ impl Resolver {
                                 }
                                 None => {
                                     let last_rib = (*self.value_ribs).last();
-                                    last_rib.bindings.insert(atom,
+                                    last_rib.bindings.insert(ident,
                                                              dl_def(def));
                                 }
                             }
@@ -4110,7 +4097,7 @@ impl Resolver {
         }
     }
 
-    fn resolve_enum_variant_or_const(name: Atom)
+    fn resolve_enum_variant_or_const(name: ident)
                                   -> EnumVariantOrConstResolution {
 
         match self.resolve_item_in_lexical_scope(self.current_module,
@@ -4205,7 +4192,7 @@ impl Resolver {
 
     // XXX: Merge me with resolve_name_in_module?
     fn resolve_definition_of_name_in_module(containing_module: @Module,
-                                            name: Atom,
+                                            name: ident,
                                             namespace: Namespace,
                                             xray: XrayFlag)
                                          -> NameDefinition {
@@ -4266,17 +4253,17 @@ impl Resolver {
         }
     }
 
-    fn intern_module_part_of_path(path: @path) -> @DVec<Atom> {
-        let module_path_atoms = @DVec();
+    fn intern_module_part_of_path(path: @path) -> @DVec<ident> {
+        let module_path_idents = @DVec();
         for path.idents.eachi |index, ident| {
             if index == path.idents.len() - 1u {
                 break;
             }
 
-            (*module_path_atoms).push(*ident);
+            (*module_path_idents).push(*ident);
         }
 
-        return module_path_atoms;
+        return module_path_idents;
     }
 
     fn resolve_module_relative_path(path: @path,
@@ -4284,19 +4271,19 @@ impl Resolver {
                                     namespace: Namespace)
                                  -> Option<def> {
 
-        let module_path_atoms = self.intern_module_part_of_path(path);
+        let module_path_idents = self.intern_module_part_of_path(path);
 
         let mut containing_module;
         match self.resolve_module_path_for_import(self.current_module,
-                                                module_path_atoms,
+                                                module_path_idents,
                                                 xray,
                                                 path.span) {
 
             Failed => {
                 self.session.span_err(path.span,
                                       fmt!("use of undeclared module `%s`",
-                                           self.atoms_to_str(
-                                               (*module_path_atoms).get())));
+                                           self.idents_to_str(
+                                               (*module_path_idents).get())));
                 return None;
             }
 
@@ -4329,13 +4316,13 @@ impl Resolver {
                                    namespace: Namespace)
                                 -> Option<def> {
 
-        let module_path_atoms = self.intern_module_part_of_path(path);
+        let module_path_idents = self.intern_module_part_of_path(path);
 
         let root_module = (*self.graph_root).get_module();
 
         let mut containing_module;
         match self.resolve_module_path_from_root(root_module,
-                                               module_path_atoms,
+                                               module_path_idents,
                                                0u,
                                                xray,
                                                path.span) {
@@ -4343,8 +4330,8 @@ impl Resolver {
             Failed => {
                 self.session.span_err(path.span,
                                       fmt!("use of undeclared module `::%s`",
-                                            self.atoms_to_str
-                                              ((*module_path_atoms).get())));
+                                            self.idents_to_str
+                                              ((*module_path_idents).get())));
                 return None;
             }
 
@@ -4676,7 +4663,7 @@ impl Resolver {
         }
     }
 
-    fn search_for_traits_containing_method(name: Atom) -> @DVec<def_id> {
+    fn search_for_traits_containing_method(name: ident) -> @DVec<def_id> {
         let found_traits = @DVec();
         let mut search_module = self.current_module;
         loop {
@@ -4715,7 +4702,7 @@ impl Resolver {
 
             // Look for imports.
             for search_module.import_resolutions.each
-                    |_atom, import_resolution| {
+                    |_ident, import_resolution| {
 
                 match import_resolution.target_for_namespace(TypeNS) {
                     None => {
@@ -4761,7 +4748,7 @@ impl Resolver {
 
     fn add_trait_info_if_containing_method(found_traits: @DVec<def_id>,
                                            trait_def_id: def_id,
-                                           name: Atom) {
+                                           name: ident) {
 
         match self.trait_info.find(trait_def_id) {
             Some(trait_info) if trait_info.contains_key(name) => {
@@ -4827,7 +4814,7 @@ impl Resolver {
 
         self.check_for_unused_imports_in_module(module_);
 
-        for module_.children.each |_atom, child_name_bindings| {
+        for module_.children.each |_ident, child_name_bindings| {
             match (*child_name_bindings).get_module_if_available() {
                 None => {
                     // Nothing to do.
@@ -4876,7 +4863,7 @@ impl Resolver {
 
     /// A somewhat inefficient routine to print out the name of a module.
     fn module_to_str(module_: @Module) -> ~str {
-        let atoms = DVec();
+        let idents = DVec();
         let mut current_module = module_;
         loop {
             match current_module.parent_link {
@@ -4884,27 +4871,27 @@ impl Resolver {
                     break;
                 }
                 ModuleParentLink(module_, name) => {
-                    atoms.push(name);
+                    idents.push(name);
                     current_module = module_;
                 }
                 BlockParentLink(module_, _) => {
-                    atoms.push(syntax::parse::token::special_idents::opaque);
+                    idents.push(syntax::parse::token::special_idents::opaque);
                     current_module = module_;
                 }
             }
         }
 
-        if atoms.len() == 0u {
+        if idents.len() == 0u {
             return ~"???";
         }
 
         let mut string = ~"";
-        let mut i = atoms.len() - 1u;
+        let mut i = idents.len() - 1u;
         loop {
-            if i < atoms.len() - 1u {
+            if i < idents.len() - 1u {
                 string += ~"::";
             }
-            string += self.session.str_of(atoms.get_elt(i));
+            string += self.session.str_of(idents.get_elt(i));
 
             if i == 0u {
                 break;
-- 
cgit 1.4.1-3-g733a5


From 67a8e7128aea292445b763b47b04bc5f4fd43cb2 Mon Sep 17 00:00:00 2001
From: Niko Matsakis <niko@alum.mit.edu>
Date: Wed, 26 Sep 2012 17:33:34 -0700
Subject: Demode vec::push (and convert to method)

---
 doc/rust.md                                        |   2 +-
 doc/tutorial.md                                    |   2 +-
 src/cargo/cargo.rs                                 |   4 +-
 src/compiletest/compiletest.rs                     |   2 +-
 src/compiletest/header.rs                          |   6 +-
 src/compiletest/procsrv.rs                         |   2 +-
 src/compiletest/runtest.rs                         |   2 +-
 src/fuzzer/cycles.rs                               |   4 +-
 src/fuzzer/fuzzer.rs                               |   4 +-
 src/fuzzer/ivec_fuzz.rs                            |   8 +-
 src/fuzzer/rand_util.rs                            |   2 +-
 src/libcore/core.rs                                |   2 +
 src/libcore/dvec.rs                                |   8 +-
 src/libcore/either.rs                              |  28 +--
 src/libcore/extfmt.rs                              |   4 +-
 src/libcore/flate.rs                               |   4 +-
 src/libcore/float.rs                               |   2 +-
 src/libcore/io.rs                                  |  18 +-
 src/libcore/os.rs                                  |   2 +-
 src/libcore/path.rs                                |  10 +-
 src/libcore/pipes.rs                               |   2 +-
 src/libcore/private.rs                             |   2 +-
 src/libcore/rand.rs                                |   2 +-
 src/libcore/result.rs                              |   4 +-
 src/libcore/run.rs                                 |  12 +-
 src/libcore/send_map.rs                            |  15 +-
 src/libcore/str.rs                                 |  23 ++-
 src/libcore/vec.rs                                 | 189 ++++++++++++---------
 src/libstd/arc.rs                                  |   4 +-
 src/libstd/base64.rs                               |  12 +-
 src/libstd/deque.rs                                |   4 +-
 src/libstd/ebml.rs                                 |   2 +-
 src/libstd/ebml2.rs                                |   2 +-
 src/libstd/getopts.rs                              |  21 ++-
 src/libstd/json.rs                                 |  29 ++--
 src/libstd/md4.rs                                  |   4 +-
 src/libstd/net_ip.rs                               |   2 +-
 src/libstd/net_tcp.rs                              |   4 +-
 src/libstd/net_url.rs                              |   2 +-
 src/libstd/par.rs                                  |   2 +-
 src/libstd/rope.rs                                 |   2 +-
 src/libstd/sort.rs                                 |   4 +-
 src/libstd/sync.rs                                 |   8 +-
 src/libstd/test.rs                                 |   4 +-
 src/libsyntax/ast_map.rs                           |   4 +-
 src/libsyntax/ast_util.rs                          |   4 +-
 src/libsyntax/attr.rs                              |   2 +-
 src/libsyntax/codemap.rs                           |   4 +-
 src/libsyntax/ext/auto_serialize2.rs               |   2 +-
 src/libsyntax/ext/base.rs                          |   2 +-
 src/libsyntax/ext/build.rs                         |   2 +-
 src/libsyntax/ext/fmt.rs                           |   4 +-
 src/libsyntax/ext/pipes/liveness.rs                |   2 +-
 src/libsyntax/ext/pipes/pipec.rs                   |  86 +++++-----
 src/libsyntax/ext/simplext.rs                      |  13 +-
 src/libsyntax/ext/tt/macro_parser.rs               |  24 +--
 src/libsyntax/ext/tt/transcribe.rs                 |   4 +-
 src/libsyntax/fold.rs                              |  10 +-
 src/libsyntax/parse/comments.rs                    |  14 +-
 src/libsyntax/parse/common.rs                      |   4 +-
 src/libsyntax/parse/eval.rs                        |   6 +-
 src/libsyntax/parse/parser.rs                      | 136 +++++++--------
 src/rustc/back/link.rs                             |  42 ++---
 src/rustc/back/rpath.rs                            |  10 +-
 src/rustc/back/upcall.rs                           |   2 +-
 src/rustc/driver/driver.rs                         |   4 +-
 src/rustc/front/test.rs                            |   4 +-
 src/rustc/metadata/cstore.rs                       |   8 +-
 src/rustc/metadata/decoder.rs                      |  40 ++---
 src/rustc/metadata/encoder.rs                      |  55 +++---
 src/rustc/metadata/filesearch.rs                   |  10 +-
 src/rustc/metadata/loader.rs                       |   2 +-
 src/rustc/metadata/tydecode.rs                     |  16 +-
 src/rustc/middle/capture.rs                        |   2 +-
 src/rustc/middle/check_alt.rs                      |   4 +-
 src/rustc/middle/freevars.rs                       |   2 +-
 src/rustc/middle/kind.rs                           |   8 +-
 src/rustc/middle/lint.rs                           |   2 +-
 src/rustc/middle/liveness.rs                       |   6 +-
 src/rustc/middle/pat_util.rs                       |   2 +-
 src/rustc/middle/region.rs                         |   2 +-
 src/rustc/middle/resolve.rs                        |   6 +-
 src/rustc/middle/trans/alt.rs                      |  12 +-
 src/rustc/middle/trans/base.rs                     |  16 +-
 src/rustc/middle/trans/build.rs                    |   2 +-
 src/rustc/middle/trans/callee.rs                   |  10 +-
 src/rustc/middle/trans/closure.rs                  |  20 +--
 src/rustc/middle/trans/common.rs                   |  24 +--
 src/rustc/middle/trans/debuginfo.rs                |   4 +-
 src/rustc/middle/trans/expr.rs                     |   4 +-
 src/rustc/middle/trans/foreign.rs                  |  22 +--
 src/rustc/middle/trans/monomorphize.rs             |   2 +-
 src/rustc/middle/trans/tvec.rs                     |   4 +-
 src/rustc/middle/trans/type_of.rs                  |  10 +-
 src/rustc/middle/ty.rs                             |  46 ++---
 src/rustc/middle/typeck/check.rs                   |  11 +-
 src/rustc/middle/typeck/check/regionmanip.rs       |   4 +-
 src/rustc/middle/typeck/check/vtable.rs            |  10 +-
 src/rustc/middle/typeck/check/writeback.rs         |   2 +-
 src/rustc/middle/typeck/coherence.rs               |   9 +-
 .../middle/typeck/infer/region_var_bindings.rs     |   8 +-
 src/rustc/middle/typeck/infer/resolve.rs           |   2 +-
 src/rustc/middle/typeck/infer/unify.rs             |   2 +-
 src/rustc/util/common.rs                           |   2 +-
 src/rustc/util/ppaux.rs                            |   6 +-
 src/rustdoc/extract.rs                             |   2 +-
 src/rustdoc/path_pass.rs                           |   4 +-
 src/test/bench/core-std.rs                         |   6 +-
 src/test/bench/core-vec-append.rs                  |   2 +-
 src/test/bench/graph500-bfs.rs                     |   2 +-
 src/test/bench/msgsend-pipes-shared.rs             |   2 +-
 src/test/bench/msgsend-pipes.rs                    |   2 +-
 src/test/bench/msgsend-ring-mutex-arcs.rs          |   4 +-
 src/test/bench/msgsend-ring-pipes.rs               |   2 +-
 src/test/bench/msgsend-ring-rw-arcs.rs             |   4 +-
 src/test/bench/msgsend-ring.rs                     |   2 +-
 src/test/bench/msgsend.rs                          |   2 +-
 src/test/bench/shootout-chameneos-redux.rs         |   2 +-
 src/test/bench/shootout-k-nucleotide-pipes.rs      |   4 +-
 src/test/bench/shootout-k-nucleotide.rs            |   2 +-
 src/test/bench/shootout-mandelbrot.rs              |   2 +-
 src/test/bench/shootout-pfib.rs                    |   2 +-
 src/test/bench/task-perf-one-million.rs            |   2 +-
 src/test/bench/task-perf-word-count-generic.rs     |   7 +-
 src/test/compile-fail/purity-infer-fail.rs         |   2 +-
 src/test/run-fail/zip-different-lengths.rs         |   4 +-
 src/test/run-pass/auto-ref-sliceable.rs            |   2 +-
 src/test/run-pass/autoref-vec-push.rs              |  17 --
 src/test/run-pass/borrowck-mut-uniq.rs             |   2 +-
 src/test/run-pass/issue-2904.rs                    |   7 +-
 src/test/run-pass/task-comm-3.rs                   |   2 +-
 src/test/run-pass/task-comm.rs                     |   4 +-
 src/test/run-pass/vec-push.rs                      |   2 +-
 src/test/run-pass/zip-same-length.rs               |   4 +-
 134 files changed, 684 insertions(+), 670 deletions(-)
 delete mode 100644 src/test/run-pass/autoref-vec-push.rs

(limited to 'src/rustc')

diff --git a/doc/rust.md b/doc/rust.md
index ccc5a532cdd..6f6a7bb86b6 100644
--- a/doc/rust.md
+++ b/doc/rust.md
@@ -1016,7 +1016,7 @@ fn iter<T>(seq: ~[T], f: fn(T)) {
 }
 fn map<T, U>(seq: ~[T], f: fn(T) -> U) -> ~[U] {
     let mut acc = ~[];
-    for seq.each |elt| { vec::push(acc, f(elt)); }
+    for seq.each |elt| { acc.push(f(elt)); }
     acc
 }
 ~~~~
diff --git a/doc/tutorial.md b/doc/tutorial.md
index 7244206b2eb..4b76152cdb0 100644
--- a/doc/tutorial.md
+++ b/doc/tutorial.md
@@ -1651,7 +1651,7 @@ may be invoked on multiple types.
 fn map<T, U>(vector: &[T], function: fn(v: &T) -> U) -> ~[U] {
     let mut accumulator = ~[];
     for vec::each(vector) |element| {
-        vec::push(accumulator, function(element));
+        accumulator.push(function(element));
     }
     return accumulator;
 }
diff --git a/src/cargo/cargo.rs b/src/cargo/cargo.rs
index b5c9fc17416..853060ea571 100644
--- a/src/cargo/cargo.rs
+++ b/src/cargo/cargo.rs
@@ -345,7 +345,7 @@ fn load_crate(filename: &Path) -> Option<Crate> {
 
                 match *ps.interner.get(attr_name) {
                     ~"std" | ~"core" => (),
-                    _ => vec::push(e.deps, query)
+                    _ => e.deps.push(query)
                 }
             }
             _ => ()
@@ -801,7 +801,7 @@ fn install_source(c: &Cargo, path: &Path) {
     let mut cratefiles = ~[];
     for os::walk_dir(&Path(".")) |p| {
         if p.filetype() == Some(~".rc") {
-            vec::push(cratefiles, *p);
+            cratefiles.push(*p);
         }
     }
 
diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs
index 5bee7fb255d..8d48669ab17 100644
--- a/src/compiletest/compiletest.rs
+++ b/src/compiletest/compiletest.rs
@@ -141,7 +141,7 @@ fn make_tests(config: config) -> ~[test::TestDesc] {
         let file = copy *file;
         debug!("inspecting file %s", file.to_str());
         if is_test(config, file) {
-            vec::push(tests, make_test(config, file))
+            tests.push(make_test(config, file))
         }
     }
     return tests;
diff --git a/src/compiletest/header.rs b/src/compiletest/header.rs
index 5cd54a115ff..19a3c621d27 100644
--- a/src/compiletest/header.rs
+++ b/src/compiletest/header.rs
@@ -28,7 +28,7 @@ fn load_props(testfile: &Path) -> test_props {
     let mut pp_exact = option::None;
     for iter_header(testfile) |ln| {
         match parse_error_pattern(ln) {
-          option::Some(ep) => vec::push(error_patterns, ep),
+          option::Some(ep) => error_patterns.push(ep),
           option::None => ()
         };
 
@@ -41,11 +41,11 @@ fn load_props(testfile: &Path) -> test_props {
         }
 
         do parse_aux_build(ln).iter |ab| {
-            vec::push(aux_builds, ab);
+            aux_builds.push(ab);
         }
 
         do parse_exec_env(ln).iter |ee| {
-            vec::push(exec_env, ee);
+            exec_env.push(ee);
         }
     };
     return {
diff --git a/src/compiletest/procsrv.rs b/src/compiletest/procsrv.rs
index d62f2fe5837..641425f2b8e 100644
--- a/src/compiletest/procsrv.rs
+++ b/src/compiletest/procsrv.rs
@@ -19,7 +19,7 @@ fn target_env(lib_path: ~str, prog: ~str) -> ~[(~str,~str)] {
         else { (k,v) }
     };
     if str::ends_with(prog, ~"rustc.exe") {
-        vec::push(env, (~"RUST_THREADS", ~"1"));
+        env.push((~"RUST_THREADS", ~"1"));
     }
     return env;
 }
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
index fcb007eca8b..dae5105ce71 100644
--- a/src/compiletest/runtest.rs
+++ b/src/compiletest/runtest.rs
@@ -121,7 +121,7 @@ fn run_pretty_test(config: config, props: test_props, testfile: &Path) {
                           procres);
         }
 
-        vec::push(srcs, procres.stdout);
+        srcs.push(procres.stdout);
         round += 1;
     }
 
diff --git a/src/fuzzer/cycles.rs b/src/fuzzer/cycles.rs
index 17ed1c0fb96..ec263ead954 100644
--- a/src/fuzzer/cycles.rs
+++ b/src/fuzzer/cycles.rs
@@ -62,7 +62,7 @@ fn test_cycles(r : rand::rng, k: uint, n: uint)
 
     // Create a graph with no edges
     range(0u, vlen) {|_i|
-        vec::push(v, empty_pointy());
+        v.push(empty_pointy());
     }
 
     // Fill in the graph with random edges, with density k/n
@@ -77,7 +77,7 @@ fn test_cycles(r : rand::rng, k: uint, n: uint)
           // https://github.com/mozilla/rust/issues/1899
 
         if (likelihood(r, k, n)) { v[i].m = [p(choice(r, v))]; }
-        if (likelihood(r, k, n)) { vec::push(v[i].n, mut p(choice(r, v))); }
+        if (likelihood(r, k, n)) { v[i].n.push(mut p(choice(r, v))); }
         if (likelihood(r, k, n)) { v[i].o = {x: 0, y: p(choice(r, v))}; }
     }
 
diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs
index 9f1cc419d15..5329d3c14dc 100644
--- a/src/fuzzer/fuzzer.rs
+++ b/src/fuzzer/fuzzer.rs
@@ -30,7 +30,7 @@ fn contains(haystack: ~str, needle: ~str) -> bool {
 fn find_rust_files(files: &mut ~[Path], path: &Path) {
     if path.filetype() == Some(~".rs") && !contains(path.to_str(), ~"utf8") {
         // ignoring "utf8" tests because something is broken
-        vec::push(*files, *path);
+        files.push(*path);
     } else if os::path_is_dir(path)
         && !contains(path.to_str(), ~"compile-fail")
         && !contains(path.to_str(), ~"build") {
@@ -124,7 +124,7 @@ fn stash_ty_if(c: fn@(@ast::ty, test_mode)->bool,
                e: @ast::ty,
                tm: test_mode) {
     if c(e, tm) {
-        vec::push(*es,*e);
+        es.push(e);
     } else {/* now my indices are wrong :( */ }
 }
 
diff --git a/src/fuzzer/ivec_fuzz.rs b/src/fuzzer/ivec_fuzz.rs
index 9351e23acf0..49d34e76992 100644
--- a/src/fuzzer/ivec_fuzz.rs
+++ b/src/fuzzer/ivec_fuzz.rs
@@ -55,11 +55,11 @@ fn vec_edits<T: copy>(v: ~[T], xs: ~[T]) -> ~[~[T]] {
 
     if Lv != 1u {
         // When Lv == 1u, this is redundant with omit.
-        vec::push(edits, ~[]);
+        edits.push(~[]);
     }
     if Lv >= 3u {
         // When Lv == 2u, this is redundant with swap.
-        vec::push(edits, vec::reversed(v));
+        edits.push(vec::reversed(v));
     }
     ix(0u, 1u, Lv) {|i| edits += ~[vec_omit(v, i)]; }
     ix(0u, 1u, Lv) {|i| edits += ~[vec_dup(v, i)]; }
@@ -69,10 +69,10 @@ fn vec_edits<T: copy>(v: ~[T], xs: ~[T]) -> ~[~[T]] {
 
     ix(0u, 1u, len(xs)) {|j|
         ix(0u, 1u, Lv) {|i|
-            vec::push(edits, vec_poke(v, i, xs[j]));
+            edits.push(vec_poke(v, i, xs[j]));
         }
         ix(0u, 0u, Lv) {|i|
-            vec::push(edits, vec_insert(v, i, xs[j]));
+            edits.push(vec_insert(v, i, xs[j]));
         }
     }
 
diff --git a/src/fuzzer/rand_util.rs b/src/fuzzer/rand_util.rs
index 39301d17a45..6745805e2d8 100644
--- a/src/fuzzer/rand_util.rs
+++ b/src/fuzzer/rand_util.rs
@@ -61,7 +61,7 @@ fn weighted_vec<T: copy>(v : ~[weighted<T>]) -> ~[T] {
     for {weight: weight, item: item} in v {
         let i = 0u;
         while i < weight {
-            vec::push(r, item);
+            r.push(item);
             i += 1u;
         }
     }
diff --git a/src/libcore/core.rs b/src/libcore/core.rs
index 8806131c9fb..dae77d66f25 100644
--- a/src/libcore/core.rs
+++ b/src/libcore/core.rs
@@ -17,6 +17,7 @@ use tuple::{TupleOps, ExtendedTupleOps};
 use str::{StrSlice, UniqueStr};
 use vec::{ConstVector, CopyableVector, ImmutableVector};
 use vec::{ImmutableEqVector, ImmutableCopyableVector};
+use vec::{MutableVector, MutableCopyableVector};
 use iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};
 use iter::{CopyableOrderedIter, Times, TimesIx};
 use num::Num;
@@ -33,6 +34,7 @@ export Num, Times, TimesIx;
 export StrSlice, UniqueStr;
 export ConstVector, CopyableVector, ImmutableVector;
 export ImmutableEqVector, ImmutableCopyableVector, IterTraitExtensions;
+export MutableVector, MutableCopyableVector;
 export BaseIter, CopyableIter, CopyableOrderedIter, ExtendedIter, EqIter;
 export TupleOps, ExtendedTupleOps;
 export Ptr;
diff --git a/src/libcore/dvec.rs b/src/libcore/dvec.rs
index 9d3d2e97f9a..eb221926fc1 100644
--- a/src/libcore/dvec.rs
+++ b/src/libcore/dvec.rs
@@ -172,7 +172,7 @@ impl<A> DVec<A> {
             if data_ptr.is_null() { fail ~"Recursive use of dvec"; }
             log(error, ~"a");
             self.data <- ~[move t];
-            vec::push_all_move(self.data, move data);
+            self.data.push_all_move(move data);
             log(error, ~"b");
         }
     }
@@ -180,7 +180,7 @@ impl<A> DVec<A> {
     /// Append a single item to the end of the list
     fn push(+t: A) {
         self.check_not_borrowed();
-        vec::push(self.data, move t);
+        self.data.push(move t);
     }
 
     /// Remove and return the first element
@@ -240,7 +240,7 @@ impl<A: Copy> DVec<A> {
             vec::reserve(&mut v, new_len);
             let mut i = from_idx;
             while i < to_idx {
-                vec::push(v, ts[i]);
+                v.push(ts[i]);
                 i += 1u;
             }
             move v
@@ -266,7 +266,7 @@ impl<A: Copy> DVec<A> {
             }
            };
 
-        for ts.each |t| { vec::push(v, *t) };
+        for ts.each |t| { v.push(*t) };
            v
         }
     }
diff --git a/src/libcore/either.rs b/src/libcore/either.rs
index 55e22f7cfe9..d93074e4a40 100644
--- a/src/libcore/either.rs
+++ b/src/libcore/either.rs
@@ -32,27 +32,27 @@ fn either<T, U, V>(f_left: fn((&T)) -> V,
 fn lefts<T: Copy, U>(eithers: &[Either<T, U>]) -> ~[T] {
     //! Extracts from a vector of either all the left values
 
-    let mut result: ~[T] = ~[];
-    for vec::each(eithers) |elt| {
-        match *elt {
-          Left(l) => vec::push(result, l),
-          _ => { /* fallthrough */ }
+    do vec::build_sized(eithers.len()) |push| {
+        for vec::each(eithers) |elt| {
+            match *elt {
+                Left(ref l) => { push(*l); }
+                _ => { /* fallthrough */ }
+            }
         }
     }
-    move result
 }
 
 fn rights<T, U: Copy>(eithers: &[Either<T, U>]) -> ~[U] {
     //! Extracts from a vector of either all the right values
 
-    let mut result: ~[U] = ~[];
-    for vec::each(eithers) |elt| {
-        match *elt {
-          Right(r) => vec::push(result, r),
-          _ => { /* fallthrough */ }
+    do vec::build_sized(eithers.len()) |push| {
+        for vec::each(eithers) |elt| {
+            match *elt {
+                Right(ref r) => { push(*r); }
+                _ => { /* fallthrough */ }
+            }
         }
     }
-    move result
 }
 
 fn partition<T: Copy, U: Copy>(eithers: &[Either<T, U>])
@@ -68,8 +68,8 @@ fn partition<T: Copy, U: Copy>(eithers: &[Either<T, U>])
     let mut rights: ~[U] = ~[];
     for vec::each(eithers) |elt| {
         match *elt {
-          Left(l) => vec::push(lefts, l),
-          Right(r) => vec::push(rights, r)
+          Left(l) => lefts.push(l),
+          Right(r) => rights.push(r)
         }
     }
     return {lefts: move lefts, rights: move rights};
diff --git a/src/libcore/extfmt.rs b/src/libcore/extfmt.rs
index 9a992143a11..fda3f50ca29 100644
--- a/src/libcore/extfmt.rs
+++ b/src/libcore/extfmt.rs
@@ -90,7 +90,7 @@ mod ct {
         fn flush_buf(+buf: ~str, &pieces: ~[Piece]) -> ~str {
             if str::len(buf) > 0 {
                 let piece = PieceString(move buf);
-                vec::push(pieces, move piece);
+                pieces.push(move piece);
             }
             return ~"";
         }
@@ -110,7 +110,7 @@ mod ct {
                 } else {
                     buf = flush_buf(move buf, pieces);
                     let rs = parse_conversion(s, i, lim, error);
-                    vec::push(pieces, copy rs.piece);
+                    pieces.push(copy rs.piece);
                     i = rs.next;
                 }
             } else { buf += curr; i += size; }
diff --git a/src/libcore/flate.rs b/src/libcore/flate.rs
index b75894e0c1b..6b4c93949e5 100644
--- a/src/libcore/flate.rs
+++ b/src/libcore/flate.rs
@@ -71,12 +71,12 @@ fn test_flate_round_trip() {
     let r = rand::Rng();
     let mut words = ~[];
     for 20.times {
-        vec::push(words, r.gen_bytes(r.gen_uint_range(1, 10)));
+        words.push(r.gen_bytes(r.gen_uint_range(1, 10)));
     }
     for 20.times {
         let mut in = ~[];
         for 2000.times {
-            vec::push_all(in, r.choose(words));
+            in.push_all(r.choose(words));
         }
         debug!("de/inflate of %u bytes of random word-sequences",
                in.len());
diff --git a/src/libcore/float.rs b/src/libcore/float.rs
index eaa51814056..cf8a10b9c7b 100644
--- a/src/libcore/float.rs
+++ b/src/libcore/float.rs
@@ -143,7 +143,7 @@ fn to_str_common(num: float, digits: uint, exact: bool) -> ~str {
         // store the next digit
         frac *= 10.0;
         let digit = frac as uint;
-        vec::push(fractionalParts, digit);
+        fractionalParts.push(digit);
 
         // calculate the next frac
         frac -= digit as float;
diff --git a/src/libcore/io.rs b/src/libcore/io.rs
index 97039800fb6..385df30e824 100644
--- a/src/libcore/io.rs
+++ b/src/libcore/io.rs
@@ -76,7 +76,7 @@ impl<T: Reader> T : ReaderUtil {
         loop {
             let ch = self.read_byte();
             if ch == -1 || ch == 10 { break; }
-            vec::push(buf, ch as u8);
+            buf.push(ch as u8);
         }
         str::from_bytes(buf)
     }
@@ -94,7 +94,7 @@ impl<T: Reader> T : ReaderUtil {
                 i += 1;
                 assert (w > 0);
                 if w == 1 {
-                    vec::push(*chars, b0 as char);
+                    chars.push(b0 as char);
                     loop;
                 }
                 // can't satisfy this char with the existing data
@@ -113,7 +113,7 @@ impl<T: Reader> T : ReaderUtil {
                 // See str::char_at
                 val += ((b0 << ((w + 1) as u8)) as uint)
                     << (w - 1) * 6 - w - 1u;
-                vec::push(*chars, val as char);
+                chars.push(val as char);
             }
             return (i, 0);
         }
@@ -128,7 +128,7 @@ impl<T: Reader> T : ReaderUtil {
                 // we're split in a unicode char?
                 break;
             }
-            vec::push_all(buf, data);
+            buf.push_all(data);
             let (offset, nbreq) = chars_from_bytes::<T>(&buf, &mut chars);
             let ncreq = n - chars.len();
             // again we either know we need a certain number of bytes
@@ -155,7 +155,7 @@ impl<T: Reader> T : ReaderUtil {
         let mut buf: ~[u8] = ~[];
         loop {
             let ch = self.read_byte();
-            if ch < 1 { break; } else { vec::push(buf, ch as u8); }
+            if ch < 1 { break; } else { buf.push(ch as u8); }
         }
         str::from_bytes(buf)
     }
@@ -190,7 +190,7 @@ impl<T: Reader> T : ReaderUtil {
 
     fn read_whole_stream() -> ~[u8] {
         let mut buf: ~[u8] = ~[];
-        while !self.eof() { vec::push_all(buf, self.read_bytes(2048u)); }
+        while !self.eof() { buf.push_all(self.read_bytes(2048u)); }
         move buf
     }
 
@@ -503,7 +503,7 @@ fn u64_to_le_bytes<T>(n: u64, size: uint, f: fn(v: &[u8]) -> T) -> T {
 
         let mut bytes: ~[u8] = ~[], i = size, n = n;
         while i > 0u {
-            vec::push(bytes, (n & 255_u64) as u8);
+            bytes.push((n & 255_u64) as u8);
             n >>= 8_u64;
             i -= 1u;
         }
@@ -535,7 +535,7 @@ fn u64_to_be_bytes<T>(n: u64, size: uint, f: fn(v: &[u8]) -> T) -> T {
         let mut i = size;
         while i > 0u {
             let shift = ((i - 1u) * 8u) as u64;
-            vec::push(bytes, (n >> shift) as u8);
+            bytes.push((n >> shift) as u8);
             i -= 1u;
         }
         f(bytes)
@@ -737,7 +737,7 @@ fn with_str_writer(f: fn(Writer)) -> ~str {
     let mut v = with_bytes_writer(f);
 
     // Make sure the vector has a trailing null and is proper utf8.
-    vec::push(v, 0);
+    v.push(0);
     assert str::is_utf8(v);
 
     unsafe { move ::cast::transmute(v) }
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
index b4c284cbd82..0a2f00e3f2b 100644
--- a/src/libcore/os.rs
+++ b/src/libcore/os.rs
@@ -219,7 +219,7 @@ mod global_env {
             for vec::each(rustrt::rust_env_pairs()) |p| {
                 let vs = str::splitn_char(*p, '=', 1u);
                 assert vec::len(vs) == 2u;
-                vec::push(pairs, (copy vs[0], copy vs[1]));
+                pairs.push((copy vs[0], copy vs[1]));
             }
             move pairs
         }
diff --git a/src/libcore/path.rs b/src/libcore/path.rs
index ab847702d68..505ecff2bcf 100644
--- a/src/libcore/path.rs
+++ b/src/libcore/path.rs
@@ -206,7 +206,7 @@ impl PosixPath : GenericPath {
             let mut ss = str::split_nonempty(
                 *e,
                 |c| windows::is_sep(c as u8));
-            unsafe { vec::push_all_move(v, move ss); }
+            unsafe { v.push_all_move(move ss); }
         }
         PosixPath { components: move v, ..self }
     }
@@ -214,7 +214,7 @@ impl PosixPath : GenericPath {
     pure fn push(s: &str) -> PosixPath {
         let mut v = copy self.components;
         let mut ss = str::split_nonempty(s, |c| windows::is_sep(c as u8));
-        unsafe { vec::push_all_move(v, move ss); }
+        unsafe { v.push_all_move(move ss); }
         PosixPath { components: move v, ..self }
     }
 
@@ -400,7 +400,7 @@ impl WindowsPath : GenericPath {
             let mut ss = str::split_nonempty(
                 *e,
                 |c| windows::is_sep(c as u8));
-            unsafe { vec::push_all_move(v, move ss); }
+            unsafe { v.push_all_move(move ss); }
         }
         return WindowsPath { components: move v, ..self }
     }
@@ -408,7 +408,7 @@ impl WindowsPath : GenericPath {
     pure fn push(s: &str) -> WindowsPath {
         let mut v = copy self.components;
         let mut ss = str::split_nonempty(s, |c| windows::is_sep(c as u8));
-        unsafe { vec::push_all_move(v, move ss); }
+        unsafe { v.push_all_move(move ss); }
         return WindowsPath { components: move v, ..self }
     }
 
@@ -440,7 +440,7 @@ pure fn normalize(components: &[~str]) -> ~[~str] {
                     vec::pop(cs);
                     loop;
                 }
-                vec::push(cs, copy *c);
+                cs.push(copy *c);
             }
         }
     }
diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs
index bbabceafe8e..c4a7fa1437a 100644
--- a/src/libcore/pipes.rs
+++ b/src/libcore/pipes.rs
@@ -1059,7 +1059,7 @@ pub fn PortSet<T: Send>() -> PortSet<T>{
 impl<T: Send> PortSet<T> : Recv<T> {
 
     fn add(+port: pipes::Port<T>) {
-        vec::push(self.ports, move port)
+        self.ports.push(move port)
     }
 
     fn chan() -> Chan<T> {
diff --git a/src/libcore/private.rs b/src/libcore/private.rs
index 4021ad5e88f..7eba81803b3 100644
--- a/src/libcore/private.rs
+++ b/src/libcore/private.rs
@@ -564,7 +564,7 @@ pub mod tests {
 
         for uint::range(0u, num_tasks) |_i| {
             let total = total.clone();
-            vec::push(futures, future::spawn(|| {
+            futures.push(future::spawn(|| {
                 for uint::range(0u, count) |_i| {
                     do total.with |count| {
                         **count += 1u;
diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs
index 02aa8530072..d68bd97ae5d 100644
--- a/src/libcore/rand.rs
+++ b/src/libcore/rand.rs
@@ -215,7 +215,7 @@ impl Rng {
         let mut r = ~[];
         for v.each |item| {
             for uint::range(0u, item.weight) |_i| {
-                vec::push(r, item.item);
+                r.push(item.item);
             }
         }
         move r
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index 7644175f93c..3968b0264d9 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -280,7 +280,7 @@ fn map_vec<T,U:Copy,V:Copy>(
     let mut vs: ~[V] = vec::with_capacity(vec::len(ts));
     for vec::each(ts) |t| {
         match op(t) {
-          Ok(v) => vec::push(vs, v),
+          Ok(v) => vs.push(v),
           Err(u) => return Err(u)
         }
     }
@@ -317,7 +317,7 @@ fn map_vec2<S,T,U:Copy,V:Copy>(ss: &[S], ts: &[T],
     let mut i = 0u;
     while i < n {
         match op(&ss[i],&ts[i]) {
-          Ok(v) => vec::push(vs, v),
+          Ok(v) => vs.push(v),
           Err(u) => return Err(u)
         }
         i += 1u;
diff --git a/src/libcore/run.rs b/src/libcore/run.rs
index e3e8491e15a..abeff1bd1d6 100644
--- a/src/libcore/run.rs
+++ b/src/libcore/run.rs
@@ -82,10 +82,10 @@ fn with_argv<T>(prog: &str, args: &[~str],
     let mut tmps = ~[];
     for vec::each(args) |arg| {
         let t = @copy *arg;
-        vec::push(tmps, t);
-        vec::push_all(argptrs, str::as_c_str(*t, |b| ~[b]));
+        tmps.push(t);
+        argptrs.push_all(str::as_c_str(*t, |b| ~[b]));
     }
-    vec::push(argptrs, ptr::null());
+    argptrs.push(ptr::null());
     vec::as_imm_buf(argptrs, |buf, _len| cb(buf))
 }
 
@@ -102,10 +102,10 @@ fn with_envp<T>(env: &Option<~[(~str,~str)]>,
         for vec::each(es) |e| {
             let (k,v) = copy *e;
             let t = @(fmt!("%s=%s", k, v));
-            vec::push(tmps, t);
-            vec::push_all(ptrs, str::as_c_str(*t, |b| ~[b]));
+            tmps.push(t);
+            ptrs.push_all(str::as_c_str(*t, |b| ~[b]));
         }
-        vec::push(ptrs, ptr::null());
+        ptrs.push(ptr::null());
         vec::as_imm_buf(ptrs, |p, _len|
             unsafe { cb(::cast::reinterpret_cast(&p)) }
         )
diff --git a/src/libcore/send_map.rs b/src/libcore/send_map.rs
index ac9a012c373..7ed962b4a90 100644
--- a/src/libcore/send_map.rs
+++ b/src/libcore/send_map.rs
@@ -283,18 +283,9 @@ pub mod linear {
                 FoundEntry(idx) => {
                     match self.buckets[idx] {
                         Some(ref bkt) => {
-                            let ptr = unsafe {
-                                // FIXME(#3148)--region inference
-                                // fails to capture needed deps.
-                                // Here, the bucket value is known to
-                                // live as long as self, because self
-                                // is immutable.  But the region
-                                // inference stupidly infers a
-                                // lifetime for `ref bkt` that is
-                                // shorter than it needs to be.
-                                cast::copy_lifetime(self, &bkt.value)
-                            };
-                            Some(ptr)
+                            // FIXME(#3148)---should be inferred
+                            let bkt: &self/Bucket<K,V> = bkt;
+                            Some(&bkt.value)
                         }
                         None => {
                             fail ~"LinearMap::find: internal logic error"
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index 13fb2260045..0993d1df63f 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -468,7 +468,7 @@ pure fn chars(s: &str) -> ~[char] {
     let len = len(s);
     while i < len {
         let {ch, next} = char_range_at(s, i);
-        unsafe { vec::push(buf, ch); }
+        unsafe { buf.push(ch); }
         i = next;
     }
     move buf
@@ -537,8 +537,7 @@ pure fn split_char_inner(s: &str, sep: char, count: uint, allow_empty: bool)
         while i < l && done < count {
             if s[i] == b {
                 if allow_empty || start < i unsafe {
-                    vec::push(result,
-                              unsafe { raw::slice_bytes(s, start, i) });
+                    result.push(unsafe { raw::slice_bytes(s, start, i) });
                 }
                 start = i + 1u;
                 done += 1u;
@@ -546,7 +545,7 @@ pure fn split_char_inner(s: &str, sep: char, count: uint, allow_empty: bool)
             i += 1u;
         }
         if allow_empty || start < l {
-            unsafe { vec::push(result, raw::slice_bytes(s, start, l) ) };
+            unsafe { result.push(raw::slice_bytes(s, start, l) ) };
         }
         move result
     } else {
@@ -581,7 +580,7 @@ pure fn split_inner(s: &str, sepfn: fn(cc: char) -> bool, count: uint,
         let {ch, next} = char_range_at(s, i);
         if sepfn(ch) {
             if allow_empty || start < i unsafe {
-                vec::push(result, unsafe { raw::slice_bytes(s, start, i)});
+                result.push(unsafe { raw::slice_bytes(s, start, i)});
             }
             start = next;
             done += 1u;
@@ -589,7 +588,7 @@ pure fn split_inner(s: &str, sepfn: fn(cc: char) -> bool, count: uint,
         i = next;
     }
     if allow_empty || start < l unsafe {
-        vec::push(result, unsafe { raw::slice_bytes(s, start, l) });
+        result.push(unsafe { raw::slice_bytes(s, start, l) });
     }
     move result
 }
@@ -643,7 +642,7 @@ pure fn iter_between_matches(s: &a/str, sep: &b/str, f: fn(uint, uint)) {
 pure fn split_str(s: &a/str, sep: &b/str) -> ~[~str] {
     let mut result = ~[];
     do iter_between_matches(s, sep) |from, to| {
-        unsafe { vec::push(result, raw::slice_bytes(s, from, to)); }
+        unsafe { result.push(raw::slice_bytes(s, from, to)); }
     }
     move result
 }
@@ -652,7 +651,7 @@ pure fn split_str_nonempty(s: &a/str, sep: &b/str) -> ~[~str] {
     let mut result = ~[];
     do iter_between_matches(s, sep) |from, to| {
         if to > from {
-            unsafe { vec::push(result, raw::slice_bytes(s, from, to)); }
+            unsafe { result.push(raw::slice_bytes(s, from, to)); }
         }
     }
     move result
@@ -1535,14 +1534,14 @@ pure fn to_utf16(s: &str) -> ~[u16] {
         if (ch & 0xFFFF_u32) == ch unsafe {
             // The BMP falls through (assuming non-surrogate, as it should)
             assert ch <= 0xD7FF_u32 || ch >= 0xE000_u32;
-            vec::push(u, ch as u16)
+            u.push(ch as u16)
         } else unsafe {
             // Supplementary planes break into surrogates.
             assert ch >= 0x1_0000_u32 && ch <= 0x10_FFFF_u32;
             ch -= 0x1_0000_u32;
             let w1 = 0xD800_u16 | ((ch >> 10) as u16);
             let w2 = 0xDC00_u16 | ((ch as u16) & 0x3FF_u16);
-            vec::push_all(u, ~[w1, w2])
+            u.push_all(~[w1, w2])
         }
     }
     move u
@@ -2010,7 +2009,7 @@ mod raw {
             ptr::memcpy(vbuf, buf as *u8, len)
         });
         vec::raw::set_len(v, len);
-        vec::push(v, 0u8);
+        v.push(0u8);
 
         assert is_utf8(v);
         return ::cast::transmute(move v);
@@ -2067,7 +2066,7 @@ mod raw {
                     ptr::memcpy(vbuf, src, end - begin);
                 }
                 vec::raw::set_len(v, end - begin);
-                vec::push(v, 0u8);
+                v.push(0u8);
                 ::cast::transmute(move v)
             }
         }
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index 7c5f242e8ba..50011dbacec 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -92,6 +92,8 @@ export CopyableVector;
 export ImmutableVector;
 export ImmutableEqVector;
 export ImmutableCopyableVector;
+export MutableVector;
+export MutableCopyableVector;
 export IterTraitExtensions;
 export vec_concat;
 export traits;
@@ -238,7 +240,7 @@ pure fn with_capacity<T>(capacity: uint) -> ~[T] {
 pure fn build_sized<A>(size: uint,
                        builder: fn(push: pure fn(+v: A))) -> ~[A] {
     let mut vec = with_capacity(size);
-    builder(|+x| unsafe { push(vec, move x) });
+    builder(|+x| unsafe { vec.push(move x) });
     move vec
 }
 
@@ -330,7 +332,7 @@ pure fn slice<T: Copy>(v: &[const T], start: uint, end: uint) -> ~[T] {
     assert (end <= len(v));
     let mut result = ~[];
     unsafe {
-        for uint::range(start, end) |i| { vec::push(result, v[i]) }
+        for uint::range(start, end) |i| { result.push(v[i]) }
     }
     move result
 }
@@ -383,14 +385,14 @@ fn split<T: Copy>(v: &[T], f: fn(T) -> bool) -> ~[~[T]] {
     let mut result = ~[];
     while start < ln {
         match position_between(v, start, ln, f) {
-          None => break,
-          Some(i) => {
-            push(result, slice(v, start, i));
-            start = i + 1u;
-          }
+            None => break,
+            Some(i) => {
+                result.push(slice(v, start, i));
+                start = i + 1u;
+            }
         }
     }
-    push(result, slice(v, start, ln));
+    result.push(slice(v, start, ln));
     move result
 }
 
@@ -407,16 +409,16 @@ fn splitn<T: Copy>(v: &[T], n: uint, f: fn(T) -> bool) -> ~[~[T]] {
     let mut result = ~[];
     while start < ln && count > 0u {
         match position_between(v, start, ln, f) {
-          None => break,
-          Some(i) => {
-            push(result, slice(v, start, i));
-            // Make sure to skip the separator.
-            start = i + 1u;
-            count -= 1u;
-          }
+            None => break,
+            Some(i) => {
+                result.push(slice(v, start, i));
+                // Make sure to skip the separator.
+                start = i + 1u;
+                count -= 1u;
+            }
         }
     }
-    push(result, slice(v, start, ln));
+    result.push(slice(v, start, ln));
     move result
 }
 
@@ -432,14 +434,14 @@ fn rsplit<T: Copy>(v: &[T], f: fn(T) -> bool) -> ~[~[T]] {
     let mut result = ~[];
     while end > 0u {
         match rposition_between(v, 0u, end, f) {
-          None => break,
-          Some(i) => {
-            push(result, slice(v, i + 1u, end));
-            end = i;
-          }
+            None => break,
+            Some(i) => {
+                result.push(slice(v, i + 1u, end));
+                end = i;
+            }
         }
     }
-    push(result, slice(v, 0u, end));
+    result.push(slice(v, 0u, end));
     reverse(result);
     return move result;
 }
@@ -457,16 +459,16 @@ fn rsplitn<T: Copy>(v: &[T], n: uint, f: fn(T) -> bool) -> ~[~[T]] {
     let mut result = ~[];
     while end > 0u && count > 0u {
         match rposition_between(v, 0u, end, f) {
-          None => break,
-          Some(i) => {
-            push(result, slice(v, i + 1u, end));
-            // Make sure to skip the separator.
-            end = i;
-            count -= 1u;
-          }
+            None => break,
+            Some(i) => {
+                result.push(slice(v, i + 1u, end));
+                // Make sure to skip the separator.
+                end = i;
+                count -= 1u;
+            }
         }
     }
-    push(result, slice(v, 0u, end));
+    result.push(slice(v, 0u, end));
     reverse(result);
     move result
 }
@@ -489,7 +491,7 @@ fn shift<T>(&v: ~[T]) -> T {
 
             for uint::range(1, ln) |i| {
                 let r <- *ptr::offset(vv, i);
-                push(v, move r);
+                v.push(move r);
             }
         }
         raw::set_len(vv, 0);
@@ -503,7 +505,7 @@ fn unshift<T>(&v: ~[T], +x: T) {
     let mut vv = ~[move x];
     v <-> vv;
     while len(vv) > 0 {
-        push(v, shift(vv));
+        v.push(shift(vv));
     }
 }
 
@@ -568,9 +570,9 @@ fn swap_remove<T>(&v: ~[const T], index: uint) -> T {
 
 /// Append an element to a vector
 #[inline(always)]
-fn push<T>(&v: ~[T], +initval: T) {
+fn push<T>(v: &mut ~[T], +initval: T) {
     unsafe {
-        let repr: **raw::VecRepr = ::cast::reinterpret_cast(&addr_of(v));
+        let repr: **raw::VecRepr = ::cast::transmute(copy v);
         let fill = (**repr).unboxed.fill;
         if (**repr).unboxed.alloc > fill {
             push_fast(v, move initval);
@@ -583,8 +585,8 @@ fn push<T>(&v: ~[T], +initval: T) {
 
 // This doesn't bother to make sure we have space.
 #[inline(always)] // really pretty please
-unsafe fn push_fast<T>(&v: ~[T], +initval: T) {
-    let repr: **raw::VecRepr = ::cast::reinterpret_cast(&addr_of(v));
+unsafe fn push_fast<T>(+v: &mut ~[T], +initval: T) {
+    let repr: **raw::VecRepr = ::cast::transmute(v);
     let fill = (**repr).unboxed.fill;
     (**repr).unboxed.fill += sys::size_of::<T>();
     let p = ptr::addr_of((**repr).unboxed.data);
@@ -593,14 +595,14 @@ unsafe fn push_fast<T>(&v: ~[T], +initval: T) {
 }
 
 #[inline(never)]
-fn push_slow<T>(&v: ~[T], +initval: T) {
-    reserve_at_least(&mut v, v.len() + 1u);
+fn push_slow<T>(+v: &mut ~[T], +initval: T) {
+    reserve_at_least(v, v.len() + 1u);
     unsafe { push_fast(v, move initval) }
 }
 
 #[inline(always)]
-fn push_all<T: Copy>(&v: ~[T], rhs: &[const T]) {
-    reserve(&mut v, v.len() + rhs.len());
+fn push_all<T: Copy>(+v: &mut ~[T], rhs: &[const T]) {
+    reserve(v, v.len() + rhs.len());
 
     for uint::range(0u, rhs.len()) |i| {
         push(v, unsafe { raw::get(rhs, i) })
@@ -608,8 +610,8 @@ fn push_all<T: Copy>(&v: ~[T], rhs: &[const T]) {
 }
 
 #[inline(always)]
-fn push_all_move<T>(&v: ~[T], -rhs: ~[const T]) {
-    reserve(&mut v, v.len() + rhs.len());
+fn push_all_move<T>(v: &mut ~[T], -rhs: ~[const T]) {
+    reserve(v, v.len() + rhs.len());
     unsafe {
         do as_imm_buf(rhs) |p, len| {
             for uint::range(0, len) |i| {
@@ -675,7 +677,7 @@ fn dedup<T: Eq>(&v: ~[const T]) unsafe {
 pure fn append<T: Copy>(+lhs: ~[T], rhs: &[const T]) -> ~[T] {
     let mut v <- lhs;
     unsafe {
-        push_all(v, rhs);
+        v.push_all(rhs);
     }
     move v
 }
@@ -683,7 +685,7 @@ pure fn append<T: Copy>(+lhs: ~[T], rhs: &[const T]) -> ~[T] {
 #[inline(always)]
 pure fn append_one<T>(+lhs: ~[T], +x: T) -> ~[T] {
     let mut v <- lhs;
-    unsafe { push(v, move x); }
+    unsafe { v.push(move x); }
     move v
 }
 
@@ -705,7 +707,10 @@ fn grow<T: Copy>(&v: ~[T], n: uint, initval: T) {
     reserve_at_least(&mut v, len(v) + n);
     let mut i: uint = 0u;
 
-    while i < n { push(v, initval); i += 1u; }
+    while i < n {
+        v.push(initval);
+        i += 1u;
+    }
 }
 
 /**
@@ -724,7 +729,10 @@ fn grow<T: Copy>(&v: ~[T], n: uint, initval: T) {
 fn grow_fn<T>(&v: ~[T], n: uint, op: iter::InitOp<T>) {
     reserve_at_least(&mut v, len(v) + n);
     let mut i: uint = 0u;
-    while i < n { push(v, op(i)); i += 1u; }
+    while i < n {
+        v.push(op(i));
+        i += 1u;
+    }
 }
 
 /**
@@ -745,14 +753,18 @@ fn grow_set<T: Copy>(&v: ~[T], index: uint, initval: T, val: T) {
 /// Apply a function to each element of a vector and return the results
 pure fn map<T, U>(v: &[T], f: fn(v: &T) -> U) -> ~[U] {
     let mut result = with_capacity(len(v));
-    for each(v) |elem| { unsafe { push(result, f(elem)); } }
+    for each(v) |elem| {
+        unsafe {
+            result.push(f(elem));
+        }
+    }
     move result
 }
 
 fn map_consume<T, U>(+v: ~[T], f: fn(+v: T) -> U) -> ~[U] {
     let mut result = ~[];
     do consume(move v) |_i, x| {
-        vec::push(result, f(move x));
+        result.push(f(move x));
     }
     move result
 }
@@ -772,7 +784,7 @@ pure fn mapi<T, U>(v: &[T], f: fn(uint, v: &T) -> U) -> ~[U] {
  */
 pure fn flat_map<T, U>(v: &[T], f: fn(T) -> ~[U]) -> ~[U] {
     let mut result = ~[];
-    for each(v) |elem| { unsafe{ push_all_move(result, f(*elem)); } }
+    for each(v) |elem| { unsafe{ result.push_all_move(f(*elem)); } }
     move result
 }
 
@@ -784,7 +796,7 @@ pure fn map2<T: Copy, U: Copy, V>(v0: &[T], v1: &[U],
     let mut u: ~[V] = ~[];
     let mut i = 0u;
     while i < v0_len {
-        unsafe { push(u, f(copy v0[i], copy v1[i])) };
+        unsafe { u.push(f(copy v0[i], copy v1[i])) };
         i += 1u;
     }
     move u
@@ -802,7 +814,7 @@ pure fn filter_map<T, U: Copy>(v: &[T], f: fn(T) -> Option<U>)
     for each(v) |elem| {
         match f(*elem) {
           None => {/* no-op */ }
-          Some(result_elem) => unsafe { push(result, result_elem); }
+          Some(result_elem) => unsafe { result.push(result_elem); }
         }
     }
     move result
@@ -818,7 +830,7 @@ pure fn filter_map<T, U: Copy>(v: &[T], f: fn(T) -> Option<U>)
 pure fn filter<T: Copy>(v: &[T], f: fn(T) -> bool) -> ~[T] {
     let mut result = ~[];
     for each(v) |elem| {
-        if f(*elem) { unsafe { push(result, *elem); } }
+        if f(*elem) { unsafe { result.push(*elem); } }
     }
     move result
 }
@@ -830,7 +842,7 @@ pure fn filter<T: Copy>(v: &[T], f: fn(T) -> bool) -> ~[T] {
  */
 pure fn concat<T: Copy>(v: &[~[T]]) -> ~[T] {
     let mut r = ~[];
-    for each(v) |inner| { unsafe { push_all(r, *inner); } }
+    for each(v) |inner| { unsafe { r.push_all(*inner); } }
     move r
 }
 
@@ -839,8 +851,8 @@ pure fn connect<T: Copy>(v: &[~[T]], sep: T) -> ~[T] {
     let mut r: ~[T] = ~[];
     let mut first = true;
     for each(v) |inner| {
-        if first { first = false; } else { unsafe { push(r, sep); } }
-        unsafe { push_all(r, *inner) };
+        if first { first = false; } else { unsafe { r.push(sep); } }
+        unsafe { r.push_all(*inner) };
     }
     move r
 }
@@ -1059,15 +1071,15 @@ pure fn rposition_between<T>(v: &[T], start: uint, end: uint,
  * Convert a vector of pairs into a pair of vectors, by reference. As unzip().
  */
 pure fn unzip_slice<T: Copy, U: Copy>(v: &[(T, U)]) -> (~[T], ~[U]) {
-    let mut as_ = ~[], bs = ~[];
+    let mut ts = ~[], us = ~[];
     for each(v) |p| {
-        let (a, b) = *p;
+        let (t, u) = *p;
         unsafe {
-            vec::push(as_, a);
-            vec::push(bs, b);
+            ts.push(t);
+            us.push(u);
         }
     }
-    return (move as_, move bs);
+    return (move ts, move us);
 }
 
 /**
@@ -1082,9 +1094,9 @@ pure fn unzip<T,U>(+v: ~[(T, U)]) -> (~[T], ~[U]) {
     let mut ts = ~[], us = ~[];
     unsafe {
         do consume(move v) |_i, p| {
-            let (a,b) = move p;
-            push(ts, move a);
-            push(us, move b);
+            let (t, u) = move p;
+            ts.push(move t);
+            us.push(move u);
         }
     }
     (move ts, move us)
@@ -1099,7 +1111,7 @@ pure fn zip_slice<T: Copy, U: Copy>(v: &[const T], u: &[const U])
     let sz = len(v);
     let mut i = 0u;
     assert sz == len(u);
-    while i < sz unsafe { vec::push(zipped, (v[i], u[i])); i += 1u; }
+    while i < sz unsafe { zipped.push((v[i], u[i])); i += 1u; }
     move zipped
 }
 
@@ -1114,7 +1126,7 @@ pure fn zip<T, U>(+v: ~[const T], +u: ~[const U]) -> ~[(T, U)] {
     assert i == len(u);
     let mut w = with_capacity(i);
     while i > 0 {
-        unsafe { push(w, (pop(v),pop(u))); }
+        unsafe { w.push((pop(v),pop(u))); }
         i -= 1;
     }
     unsafe { reverse(w); }
@@ -1147,8 +1159,8 @@ pure fn reversed<T: Copy>(v: &[const T]) -> ~[T] {
     let mut i = len::<T>(v);
     if i == 0 { return (move rs); } else { i -= 1; }
     unsafe {
-        while i != 0 { vec::push(rs, v[i]); i -= 1; }
-        vec::push(rs, v[0]);
+        while i != 0 { rs.push(v[i]); i -= 1; }
+        rs.push(v[0]);
     }
     move rs
 }
@@ -1283,7 +1295,7 @@ pure fn permute<T: Copy>(v: &[const T], put: fn(~[T])) {
             let elt = v[i];
             let mut rest = slice(v, 0u, i);
             unsafe {
-                push_all(rest, const_view(v, i+1u, ln));
+                rest.push_all(const_view(v, i+1u, ln));
                 permute(rest, |permutation| {
                     put(append(~[elt], permutation))
                 })
@@ -1299,7 +1311,7 @@ pure fn windowed<TT: Copy>(nn: uint, xx: &[TT]) -> ~[~[TT]] {
     for vec::eachi (xx) |ii, _x| {
         let len = vec::len(xx);
         if ii+nn <= len unsafe {
-            vec::push(ww, vec::slice(xx, ii, ii+nn));
+            ww.push(vec::slice(xx, ii, ii+nn));
         }
     }
     move ww
@@ -1551,7 +1563,7 @@ impl<T> &[T]: ImmutableVector<T> {
         let mut r = ~[];
         let mut i = 0;
         while i < self.len() {
-            push(r, f(&self[i]));
+            r.push(f(&self[i]));
             i += 1;
         }
         move r
@@ -1637,6 +1649,31 @@ impl<T: Copy> &[T]: ImmutableCopyableVector<T> {
     pure fn rfind(f: fn(T) -> bool) -> Option<T> { rfind(self, f) }
 }
 
+trait MutableVector<T> {
+    fn push(&mut self, +t: T);
+    fn push_all_move(&mut self, -rhs: ~[const T]);
+}
+
+trait MutableCopyableVector<T: Copy> {
+    fn push_all(&mut self, rhs: &[const T]);
+}
+
+impl<T> ~[T]: MutableVector<T> {
+    fn push(&mut self, +t: T) {
+        push(self, move t);
+    }
+
+    fn push_all_move(&mut self, -rhs: ~[const T]) {
+        push_all_move(self, move rhs);
+    }
+}
+
+impl<T: Copy> ~[T]: MutableCopyableVector<T> {
+    fn push_all(&mut self, rhs: &[const T]) {
+        push_all(self, rhs);
+    }
+}
+
 /// Unsafe operations
 mod raw {
     #[legacy_exports];
@@ -2109,12 +2146,12 @@ mod tests {
     fn test_push() {
         // Test on-stack push().
         let mut v = ~[];
-        push(v, 1);
+        v.push(1);
         assert (len(v) == 1u);
         assert (v[0] == 1);
 
         // Test on-heap push().
-        push(v, 2);
+        v.push(2);
         assert (len(v) == 2u);
         assert (v[0] == 1);
         assert (v[1] == 2);
@@ -2380,19 +2417,19 @@ mod tests {
         let mut results: ~[~[int]];
 
         results = ~[];
-        permute(~[], |v| vec::push(results, copy v));
+        permute(~[], |v| results.push(copy v));
         assert results == ~[~[]];
 
         results = ~[];
-        permute(~[7], |v| push(results, copy v));
+        permute(~[7], |v| results.push(copy v));
         assert results == ~[~[7]];
 
         results = ~[];
-        permute(~[1,1], |v| push(results, copy v));
+        permute(~[1,1], |v| results.push(copy v));
         assert results == ~[~[1,1],~[1,1]];
 
         results = ~[];
-        permute(~[5,2,0], |v| push(results, copy v));
+        permute(~[5,2,0], |v| results.push(copy v));
         assert results ==
             ~[~[5,2,0],~[5,0,2],~[2,5,0],~[2,0,5],~[0,5,2],~[0,2,5]];
     }
diff --git a/src/libstd/arc.rs b/src/libstd/arc.rs
index 4ffe7245113..1f26822ed9f 100644
--- a/src/libstd/arc.rs
+++ b/src/libstd/arc.rs
@@ -648,7 +648,7 @@ mod tests {
         let mut children = ~[];
         for 5.times {
             let arc3 = ~arc.clone();
-            do task::task().future_result(|+r| vec::push(children, r)).spawn {
+            do task::task().future_result(|+r| children.push(r)).spawn {
                 do arc3.read |num| {
                     assert *num >= 0;
                 }
@@ -676,7 +676,7 @@ mod tests {
         let mut reader_convos = ~[];
         for 10.times {
             let ((rc1,rp1),(rc2,rp2)) = (pipes::stream(),pipes::stream());
-            vec::push(reader_convos, (rc1,rp2));
+            reader_convos.push((rc1,rp2));
             let arcn = ~arc.clone();
             do task::spawn {
                 rp1.recv(); // wait for downgrader to give go-ahead
diff --git a/src/libstd/base64.rs b/src/libstd/base64.rs
index 0da23db7291..e5eacd5c440 100644
--- a/src/libstd/base64.rs
+++ b/src/libstd/base64.rs
@@ -102,12 +102,12 @@ impl ~[u8]: FromBase64 {
                 } else if ch == '=' {
                     match len - i {
                       1u => {
-                        vec::push(r, ((n >> 16u) & 0xFFu) as u8);
-                        vec::push(r, ((n >> 8u ) & 0xFFu) as u8);
+                        r.push(((n >> 16u) & 0xFFu) as u8);
+                        r.push(((n >> 8u ) & 0xFFu) as u8);
                         return copy r;
                       }
                       2u => {
-                        vec::push(r, ((n >> 10u) & 0xFFu) as u8);
+                        r.push(((n >> 10u) & 0xFFu) as u8);
                         return copy r;
                       }
                       _ => fail ~"invalid base64 padding"
@@ -119,9 +119,9 @@ impl ~[u8]: FromBase64 {
                 i += 1u;
             };
 
-            vec::push(r, ((n >> 16u) & 0xFFu) as u8);
-            vec::push(r, ((n >> 8u ) & 0xFFu) as u8);
-            vec::push(r, ((n       ) & 0xFFu) as u8);
+            r.push(((n >> 16u) & 0xFFu) as u8);
+            r.push(((n >> 8u ) & 0xFFu) as u8);
+            r.push(((n       ) & 0xFFu) as u8);
         }
 
         r
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index 17d4b39b01e..8506bd5f6fc 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -38,8 +38,8 @@ fn create<T: Copy>() -> Deque<T> {
         let nalloc = uint::next_power_of_two(nelts + 1u);
         while i < nalloc {
             if i < nelts {
-                vec::push(rv, elts[(lo + i) % nelts]);
-            } else { vec::push(rv, None); }
+                rv.push(elts[(lo + i) % nelts]);
+            } else { rv.push(None); }
             i += 1u;
         }
 
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 9b7f7a79f22..3f6bcd31a73 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -211,7 +211,7 @@ impl Writer {
         write_vuint(self.writer, tag_id);
 
         // Write a placeholder four-byte size.
-        vec::push(self.size_positions, self.writer.tell());
+        self.size_positions.push(self.writer.tell());
         let zeroes: &[u8] = &[0u8, 0u8, 0u8, 0u8];
         self.writer.write(zeroes);
     }
diff --git a/src/libstd/ebml2.rs b/src/libstd/ebml2.rs
index 8b37dea6210..496010d579e 100644
--- a/src/libstd/ebml2.rs
+++ b/src/libstd/ebml2.rs
@@ -220,7 +220,7 @@ impl Serializer {
         write_vuint(self.writer, tag_id);
 
         // Write a placeholder four-byte size.
-        vec::push(self.size_positions, self.writer.tell());
+        self.size_positions.push(self.writer.tell());
         let zeroes: &[u8] = &[0u8, 0u8, 0u8, 0u8];
         self.writer.write(zeroes);
     }
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index f8b86d80061..7a47db8a7f0 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -234,10 +234,10 @@ fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
         let cur = args[i];
         let curlen = str::len(cur);
         if !is_arg(cur) {
-            vec::push(free, cur);
+            free.push(cur);
         } else if cur == ~"--" {
             let mut j = i + 1u;
-            while j < l { vec::push(free, args[j]); j += 1u; }
+            while j < l { free.push(args[j]); j += 1u; }
             break;
         } else {
             let mut names;
@@ -287,7 +287,7 @@ fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
                         }
                       }
                     }
-                    vec::push(names, opt);
+                    names.push(opt);
                     j = range.next;
                 }
             }
@@ -303,23 +303,22 @@ fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
                     if !i_arg.is_none() {
                         return Err(UnexpectedArgument(name_str(nm)));
                     }
-                    vec::push(vals[optid], Given);
+                    vals[optid].push(Given);
                   }
                   Maybe => {
                     if !i_arg.is_none() {
-                        vec::push(vals[optid], Val(i_arg.get()));
+                        vals[optid].push(Val(i_arg.get()));
                     } else if name_pos < vec::len::<Name>(names) ||
                                   i + 1u == l || is_arg(args[i + 1u]) {
-                        vec::push(vals[optid], Given);
-                    } else { i += 1u; vec::push(vals[optid], Val(args[i])); }
+                        vals[optid].push(Given);
+                    } else { i += 1u; vals[optid].push(Val(args[i])); }
                   }
                   Yes => {
                     if !i_arg.is_none() {
-                        vec::push(vals[optid],
-                                  Val(i_arg.get()));
+                        vals[optid].push(Val(i_arg.get()));
                     } else if i + 1u == l {
                         return Err(ArgumentMissing(name_str(nm)));
-                    } else { i += 1u; vec::push(vals[optid], Val(args[i])); }
+                    } else { i += 1u; vals[optid].push(Val(args[i])); }
                   }
                 }
             }
@@ -412,7 +411,7 @@ fn opts_str(+mm: Matches, names: &[~str]) -> ~str {
 fn opt_strs(+mm: Matches, nm: &str) -> ~[~str] {
     let mut acc: ~[~str] = ~[];
     for vec::each(opt_vals(mm, nm)) |v| {
-        match *v { Val(s) => vec::push(acc, s), _ => () }
+        match *v { Val(s) => acc.push(s), _ => () }
     }
     return acc;
 }
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index f75f033bb8e..29535c62b5e 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -594,7 +594,7 @@ priv impl Parser {
 
         loop {
             match move self.parse_value() {
-              Ok(move v) => vec::push(values, v),
+              Ok(move v) => values.push(v),
               Err(move e) => return Err(e)
             }
 
@@ -690,13 +690,13 @@ pub fn Deserializer(rdr: io::Reader) -> Result<Deserializer, Error> {
 }
 
 priv impl Deserializer {
-    fn peek() -> &self/Json {
-        if self.stack.len() == 0 { vec::push(self.stack, &self.json); }
+    fn peek(&self) -> &self/Json {
+        if self.stack.len() == 0 { self.stack.push(&self.json); }
         vec::last(self.stack)
     }
 
-    fn pop() -> &self/Json {
-        if self.stack.len() == 0 { vec::push(self.stack, &self.json); }
+    fn pop(&self) -> &self/Json {
+        if self.stack.len() == 0 { self.stack.push(&self.json); }
         vec::pop(self.stack)
     }
 }
@@ -772,7 +772,7 @@ pub impl Deserializer: serialization2::Deserializer {
     fn read_vec<T>(&self, f: fn(uint) -> T) -> T {
         debug!("read_vec()");
         let len = match *self.peek() {
-            List(list) => list.len(),
+            List(ref list) => list.len(),
             _ => fail ~"not a list",
         };
         let res = f(len);
@@ -784,7 +784,10 @@ pub impl Deserializer: serialization2::Deserializer {
         debug!("read_vec_elt(idx=%u)", idx);
         match *self.peek() {
             List(ref list) => {
-                vec::push(self.stack, &list[idx]);
+                // FIXME(#3148)---should be inferred
+                let list: &self/~[Json] = list;
+
+                self.stack.push(&list[idx]);
                 f()
             }
             _ => fail ~"not a list",
@@ -820,7 +823,7 @@ pub impl Deserializer: serialization2::Deserializer {
                 match obj.find_ref(&f_name) {
                     None => fail fmt!("no such field: %s", f_name),
                     Some(json) => {
-                        vec::push(self.stack, json);
+                        self.stack.push(json);
                         f()
                     }
                 }
@@ -845,8 +848,10 @@ pub impl Deserializer: serialization2::Deserializer {
     fn read_tup_elt<T>(&self, idx: uint, f: fn() -> T) -> T {
         debug!("read_tup_elt(idx=%u)", idx);
         match *self.peek() {
-            List(list) => {
-                vec::push(self.stack, &list[idx]);
+            List(ref list) => {
+                // FIXME(#3148)---should be inferred
+                let list: &self/~[Json] = list;
+                self.stack.push(&list[idx]);
                 f()
             }
             _ => fail ~"not a list"
@@ -939,12 +944,12 @@ impl Json : Ord {
 
                             // XXX: this is horribly inefficient...
                             for d0.each |k, v| {
-                                 vec::push(d0_flat, (@copy *k, @copy *v));
+                                 d0_flat.push((@copy *k, @copy *v));
                             }
                             d0_flat.qsort();
 
                             for d1.each |k, v| {
-                                vec::push(d1_flat, (@copy *k, @copy *v));
+                                d1_flat.push((@copy *k, @copy *v));
                             }
                             d1_flat.qsort();
 
diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs
index a4272324670..0bf4f6f8610 100644
--- a/src/libstd/md4.rs
+++ b/src/libstd/md4.rs
@@ -11,14 +11,14 @@ fn md4(msg: &[u8]) -> {a: u32, b: u32, c: u32, d: u32} {
     let mut msg = vec::append(vec::from_slice(msg), ~[0x80u8]);
     let mut bitlen = orig_len + 8u64;
     while (bitlen + 64u64) % 512u64 > 0u64 {
-        vec::push(msg, 0u8);
+        msg.push(0u8);
         bitlen += 8u64;
     }
 
     // append length
     let mut i = 0u64;
     while i < 8u64 {
-        vec::push(msg, (orig_len >> (i * 8u64)) as u8);
+        msg.push((orig_len >> (i * 8u64)) as u8);
         i += 1u64;
     }
 
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index 445bc62e4c9..347f2b271a1 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -277,7 +277,7 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
                         result::Err(GetAddrUnknownError));
                     break;
                 };
-                vec::push(out_vec, move new_ip_addr);
+                out_vec.push(move new_ip_addr);
 
                 let next_addr = ll::get_next_addrinfo(curr_addr);
                 if next_addr == ptr::null::<addrinfo>() as *addrinfo {
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index a1c7637dee6..a0ba8aae3f1 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -779,7 +779,7 @@ impl TcpSocketBuf: io::Reader {
                 }
             }
             else {
-                vec::push_all(self.data.buf, result::unwrap(read_result));
+                self.data.buf.push_all(result::unwrap(read_result));
             }
         }
 
@@ -790,7 +790,7 @@ impl TcpSocketBuf: io::Reader {
 
         vec::bytes::memcpy(buf, vec::view(data, 0, data.len()), count);
 
-        vec::push_all(self.data.buf, vec::view(data, count, data.len()));
+        self.data.buf.push_all(vec::view(data, count, data.len()));
 
         count
     }
diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs
index 8116bd4fb30..33e657c390b 100644
--- a/src/libstd/net_url.rs
+++ b/src/libstd/net_url.rs
@@ -329,7 +329,7 @@ fn query_from_str(rawquery: &str) -> Query {
     if str::len(rawquery) != 0 {
         for str::split_char(rawquery, '&').each |p| {
             let (k, v) = split_char_first(*p, '=');
-            vec::push(query, (decode_component(k), decode_component(v)));
+            query.push((decode_component(k), decode_component(v)));
         };
     }
     return query;
diff --git a/src/libstd/par.rs b/src/libstd/par.rs
index 38a814b22e0..2f98c4bad34 100644
--- a/src/libstd/par.rs
+++ b/src/libstd/par.rs
@@ -55,7 +55,7 @@ fn map_slices<A: Copy Send, B: Copy Send>(
                         f(base, slice)
                     }
                 };
-                vec::push(futures, move f);
+                futures.push(move f);
             };
             base += items_per_task;
         }
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index 2d49ede3507..4680448e275 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -869,7 +869,7 @@ mod node {
         loop {
             match (leaf_iterator::next(&it)) {
               option::None    => break,
-              option::Some(x) => vec::push(forest, @Leaf(x))
+              option::Some(x) => forest.push(@Leaf(x))
             }
         }
         //2. Rebuild tree from forest
diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index 46f79c01948..f1abe5be5a5 100644
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -47,9 +47,9 @@ fn merge_sort<T: Copy>(le: Le<T>, v: &[const T]) -> ~[T] {
         let mut b_ix = 0u;
         while a_ix < a_len && b_ix < b_len {
             if le(&a[a_ix], &b[b_ix]) {
-                vec::push(rs, a[a_ix]);
+                rs.push(a[a_ix]);
                 a_ix += 1u;
-            } else { vec::push(rs, b[b_ix]); b_ix += 1u; }
+            } else { rs.push(b[b_ix]); b_ix += 1u; }
         }
         rs = vec::append(rs, vec::slice(a, a_ix, a_len));
         rs = vec::append(rs, vec::slice(b, b_ix, b_len));
diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs
index 8fdcc22b4c1..7638b43ad86 100644
--- a/src/libstd/sync.rs
+++ b/src/libstd/sync.rs
@@ -82,7 +82,7 @@ fn new_sem_and_signal(count: int, num_condvars: uint)
         -> Sem<~[mut Waitqueue]> {
     let mut queues = ~[];
     for num_condvars.times {
-        vec::push(queues, new_waitqueue());
+        queues.push(new_waitqueue());
     }
     new_sem(count, vec::to_mut(move queues))
 }
@@ -840,7 +840,7 @@ mod tests {
         for num_waiters.times {
             let mi = ~m.clone();
             let (chan, port) = pipes::stream();
-            vec::push(ports, port);
+            ports.push(port);
             do task::spawn {
                 do mi.lock_cond |cond| {
                     chan.send(());
@@ -930,7 +930,7 @@ mod tests {
             for 2.times {
                 let (c,p) = pipes::stream();
                 let c = ~mut Some(c);
-                vec::push(sibling_convos, p);
+                sibling_convos.push(p);
                 let mi = ~m2.clone();
                 // spawn sibling task
                 do task::spawn { // linked
@@ -1194,7 +1194,7 @@ mod tests {
         for num_waiters.times {
             let xi = ~x.clone();
             let (chan, port) = pipes::stream();
-            vec::push(ports, port);
+            ports.push(port);
             do task::spawn {
                 do lock_cond(xi, dg1) |cond| {
                     chan.send(());
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index e872cba5dc9..facc43f6273 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -141,7 +141,7 @@ fn run_tests_console(opts: &TestOpts,
                 st.failed += 1u;
                 write_failed(st.out, st.use_color);
                 st.out.write_line(~"");
-                vec::push(st.failures, copy test);
+                st.failures.push(copy test);
               }
               TrIgnored => {
                 st.ignored += 1u;
@@ -545,7 +545,7 @@ mod tests {
             for vec::each(names) |name| {
                 let test = {name: *name, testfn: copy testfn, ignore: false,
                             should_fail: false};
-                vec::push(tests, test);
+                tests.push(test);
             }
             tests
         };
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index 09922ade073..b6d4c2d0fe3 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -273,9 +273,9 @@ fn map_item(i: @item, cx: ctx, v: vt) {
     }
     match i.node {
       item_mod(_) | item_foreign_mod(_) => {
-        vec::push(cx.path, path_mod(i.ident));
+        cx.path.push(path_mod(i.ident));
       }
-      _ => vec::push(cx.path, path_name(i.ident))
+      _ => cx.path.push(path_name(i.ident))
     }
     visit::visit_item(i, cx, v);
     vec::pop(cx.path);
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 98a471bd54c..329c9f362a4 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -313,8 +313,8 @@ fn split_trait_methods(trait_methods: ~[trait_method])
     let mut reqd = ~[], provd = ~[];
     for trait_methods.each |trt_method| {
         match *trt_method {
-          required(tm) => vec::push(reqd, tm),
-          provided(m) => vec::push(provd, m)
+          required(tm) => reqd.push(tm),
+          provided(m) => provd.push(m)
         }
     };
     (reqd, provd)
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index eb4ffb26fb1..7ef34d8eb0b 100644
--- a/src/libsyntax/attr.rs
+++ b/src/libsyntax/attr.rs
@@ -91,7 +91,7 @@ fn attr_meta(attr: ast::attribute) -> @ast::meta_item { @attr.node.value }
 // Get the meta_items from inside a vector of attributes
 fn attr_metas(attrs: ~[ast::attribute]) -> ~[@ast::meta_item] {
     let mut mitems = ~[];
-    for attrs.each |a| { vec::push(mitems, attr_meta(*a)); }
+    for attrs.each |a| { mitems.push(attr_meta(*a)); }
     return mitems;
 }
 
diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs
index ae49e19c862..e07985119ec 100644
--- a/src/libsyntax/codemap.rs
+++ b/src/libsyntax/codemap.rs
@@ -84,7 +84,7 @@ fn mk_substr_filename(cm: codemap, sp: span) -> ~str
 }
 
 fn next_line(file: filemap, chpos: uint, byte_pos: uint) {
-    vec::push(file.lines, {ch: chpos, byte: byte_pos + file.start_pos.byte});
+    file.lines.push({ch: chpos, byte: byte_pos + file.start_pos.byte});
 }
 
 type lookup_fn = pure fn(file_pos) -> uint;
@@ -204,7 +204,7 @@ fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines {
     let hi = lookup_char_pos(cm, sp.hi);
     let mut lines = ~[];
     for uint::range(lo.line - 1u, hi.line as uint) |i| {
-        vec::push(lines, i);
+        lines.push(i);
     };
     return @{file: lo.file, lines: lines};
 }
diff --git a/src/libsyntax/ext/auto_serialize2.rs b/src/libsyntax/ext/auto_serialize2.rs
index 264711584fc..b51184eefd8 100644
--- a/src/libsyntax/ext/auto_serialize2.rs
+++ b/src/libsyntax/ext/auto_serialize2.rs
@@ -750,7 +750,7 @@ fn mk_enum_deser_body(
         body: cx.expr_blk(cx.expr(span, ast::expr_fail(None))),
     };
 
-    vec::push(arms, impossible_case);
+    arms.push(impossible_case);
 
     // ast for `|i| { match i { $(arms) } }`
     let expr_lambda = cx.expr(
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 1cbcd0f6ddb..566cdc4fa21 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -160,7 +160,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
         fn cfg() -> ast::crate_cfg { self.cfg }
         fn print_backtrace() { }
         fn backtrace() -> expn_info { self.backtrace }
-        fn mod_push(i: ast::ident) { vec::push(self.mod_path, i); }
+        fn mod_push(i: ast::ident) { self.mod_path.push(i); }
         fn mod_pop() { vec::pop(self.mod_path); }
         fn mod_path() -> ~[ast::ident] { return self.mod_path; }
         fn bt_push(ei: codemap::expn_info_) {
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 8574c0c9082..8ce426f0357 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -96,7 +96,7 @@ fn mk_rec_e(cx: ext_ctxt, sp: span,
         let val = field.ex;
         let astfield =
             {node: {mutbl: ast::m_imm, ident: ident, expr: val}, span: sp};
-        vec::push(astfields, astfield);
+        astfields.push(astfield);
     }
     let recexpr = ast::expr_rec(astfields, option::None::<@ast::expr>);
     mk_expr(cx, sp, recexpr)
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
index 3ea0493239f..e4f197801c2 100644
--- a/src/libsyntax/ext/fmt.rs
+++ b/src/libsyntax/ext/fmt.rs
@@ -245,7 +245,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
     for pieces.each |pc| {
         match *pc {
           PieceString(s) => {
-            vec::push(piece_exprs, mk_uniq_str(cx, fmt_sp, s))
+            piece_exprs.push(mk_uniq_str(cx, fmt_sp, s))
           }
           PieceConv(conv) => {
             n += 1u;
@@ -258,7 +258,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
             log_conv(conv);
             let arg_expr = args[n];
             let c_expr = make_new_conv(cx, fmt_sp, conv, arg_expr);
-            vec::push(piece_exprs, c_expr);
+            piece_exprs.push(c_expr);
           }
         }
     }
diff --git a/src/libsyntax/ext/pipes/liveness.rs b/src/libsyntax/ext/pipes/liveness.rs
index 8b17ffc1104..a9bfd87ab0e 100644
--- a/src/libsyntax/ext/pipes/liveness.rs
+++ b/src/libsyntax/ext/pipes/liveness.rs
@@ -65,7 +65,7 @@ fn analyze(proto: protocol, _cx: ext_ctxt) {
     let mut self_live = ~[];
     for colive.eachi |i, bv| {
         if bv.get(i) {
-            vec::push(self_live, proto.get_state_by_id(i))
+            self_live.push(proto.get_state_by_id(i))
         }
     }
 
diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs
index 11250cfbf38..f93fa830f92 100644
--- a/src/libsyntax/ext/pipes/pipec.rs
+++ b/src/libsyntax/ext/pipes/pipec.rs
@@ -226,7 +226,7 @@ impl state: to_type_decls {
 
             let v = cx.variant(cx.ident_of(name), span, tys);
 
-            vec::push(items_msg, v);
+            items_msg.push(v);
         }
 
         ~[cx.item_enum_poly(name,
@@ -245,44 +245,44 @@ impl state: to_type_decls {
         let mut items = ~[];
         for self.messages.each |m| {
             if dir == send {
-                vec::push(items, m.gen_send(cx, true));
-                vec::push(items, m.gen_send(cx, false));
+                items.push(m.gen_send(cx, true));
+                items.push(m.gen_send(cx, false));
             }
         }
 
         if !self.proto.is_bounded() {
-            vec::push(items,
-                      cx.item_ty_poly(
-                          self.data_name(),
-                          self.span,
-                          cx.ty_path_ast_builder(
-                              path(~[cx.ident_of(~"pipes"),
-                                     cx.ident_of(dir.to_str() + ~"Packet")],
-                                   empty_span())
-                              .add_ty(cx.ty_path_ast_builder(
-                                  path(~[cx.ident_of(self.proto.name),
-                                         self.data_name()],
-                                       empty_span())
-                                  .add_tys(cx.ty_vars(self.ty_params))))),
-                          self.ty_params));
+            items.push(
+                cx.item_ty_poly(
+                    self.data_name(),
+                    self.span,
+                    cx.ty_path_ast_builder(
+                        path(~[cx.ident_of(~"pipes"),
+                               cx.ident_of(dir.to_str() + ~"Packet")],
+                             empty_span())
+                        .add_ty(cx.ty_path_ast_builder(
+                            path(~[cx.ident_of(self.proto.name),
+                                   self.data_name()],
+                                 empty_span())
+                            .add_tys(cx.ty_vars(self.ty_params))))),
+                    self.ty_params));
         }
         else {
-            vec::push(items,
-                      cx.item_ty_poly(
-                          self.data_name(),
-                          self.span,
-                          cx.ty_path_ast_builder(
-                              path(~[cx.ident_of(~"pipes"),
-                                     cx.ident_of(dir.to_str()
-                                                 + ~"PacketBuffered")],
-                                  empty_span())
-                              .add_tys(~[cx.ty_path_ast_builder(
-                                  path(~[cx.ident_of(self.proto.name),
-                                         self.data_name()],
-                                       empty_span())
-                                  .add_tys(cx.ty_vars(self.ty_params))),
-                                         self.proto.buffer_ty_path(cx)])),
-                          self.ty_params));
+            items.push(
+                cx.item_ty_poly(
+                    self.data_name(),
+                    self.span,
+                    cx.ty_path_ast_builder(
+                        path(~[cx.ident_of(~"pipes"),
+                               cx.ident_of(dir.to_str()
+                                           + ~"PacketBuffered")],
+                             empty_span())
+                        .add_tys(~[cx.ty_path_ast_builder(
+                            path(~[cx.ident_of(self.proto.name),
+                                   self.data_name()],
+                                 empty_span())
+                            .add_tys(cx.ty_vars(self.ty_params))),
+                                   self.proto.buffer_ty_path(cx)])),
+                    self.ty_params));
         };
         items
     }
@@ -367,7 +367,7 @@ impl protocol: gen_init {
         for (copy self.states).each |s| {
             for s.ty_params.each |tp| {
                 match params.find(|tpp| tp.ident == tpp.ident) {
-                  None => vec::push(params, *tp),
+                  None => params.push(*tp),
                   _ => ()
                 }
             }
@@ -383,7 +383,7 @@ impl protocol: gen_init {
         let fields = do (copy self.states).map_to_vec |s| {
             for s.ty_params.each |tp| {
                 match params.find(|tpp| tp.ident == tpp.ident) {
-                  None => vec::push(params, *tp),
+                  None => params.push(*tp),
                   _ => ()
                 }
             }
@@ -415,17 +415,15 @@ impl protocol: gen_init {
         }
 
         if self.is_bounded() {
-            vec::push(items, self.gen_buffer_type(cx))
+            items.push(self.gen_buffer_type(cx))
         }
 
-        vec::push(items,
-                  cx.item_mod(cx.ident_of(~"client"),
-                              self.span,
-                              client_states));
-        vec::push(items,
-                  cx.item_mod(cx.ident_of(~"server"),
-                              self.span,
-                              server_states));
+        items.push(cx.item_mod(cx.ident_of(~"client"),
+                               self.span,
+                               client_states));
+        items.push(cx.item_mod(cx.ident_of(~"server"),
+                               self.span,
+                               server_states));
 
         cx.item_mod(cx.ident_of(self.name), self.span, items)
     }
diff --git a/src/libsyntax/ext/simplext.rs b/src/libsyntax/ext/simplext.rs
index 4729e7da39c..51239754635 100644
--- a/src/libsyntax/ext/simplext.rs
+++ b/src/libsyntax/ext/simplext.rs
@@ -94,7 +94,7 @@ fn option_flatten_map<T: Copy, U: Copy>(f: fn@(T) -> Option<U>, v: ~[T]) ->
     for v.each |elem| {
         match f(*elem) {
           None => return None,
-          Some(fv) => vec::push(res, fv)
+          Some(fv) => res.push(fv)
         }
     }
     return Some(res);
@@ -305,8 +305,8 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
                 /* Whew, we now know how how many times to repeat */
                 let mut idx: uint = 0u;
                 while idx < rc {
-                    vec::push(*idx_path, idx);
-                    vec::push(res, recur(repeat_me)); // whew!
+                    idx_path.push(idx);
+                    res.push(recur(repeat_me)); // whew!
                     vec::pop(*idx_path);
                     idx += 1u;
                 }
@@ -567,7 +567,7 @@ fn p_t_s_r_ellipses(cx: ext_ctxt, repeat_me: @expr, offset: uint, s: selector,
                     let mut elts = ~[];
                     let mut idx = offset;
                     while idx < vec::len(arg_elts) {
-                        vec::push(elts, leaf(match_expr(arg_elts[idx])));
+                        elts.push(leaf(match_expr(arg_elts[idx])));
                         idx += 1u;
                     }
 
@@ -672,9 +672,8 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
                       None => cx.span_fatal(mac.span,
                                            ~"macro must have arguments")
                     };
-                    vec::push(clauses,
-                              @{params: pattern_to_selectors(cx, arg),
-                                body: elts[1u]});
+                    clauses.push(@{params: pattern_to_selectors(cx, arg),
+                                   body: elts[1u]});
 
                     // FIXME (#2251): check duplicates (or just simplify
                     // the macro arg situation)
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index a7a45942822..737694337e3 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -208,7 +208,7 @@ fn parse_or_else(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader,
 fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
     -> parse_result {
     let mut cur_eis = ~[];
-    vec::push(cur_eis, initial_matcher_pos(ms, None, rdr.peek().sp.lo));
+    cur_eis.push(initial_matcher_pos(ms, None, rdr.peek().sp.lo));
 
     loop {
         let mut bb_eis = ~[]; // black-box parsed by parser.rs
@@ -256,7 +256,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
                         }
 
                         new_pos.idx += 1;
-                        vec::push(cur_eis, move new_pos);
+                        cur_eis.push(move new_pos);
                     }
 
                     // can we go around again?
@@ -267,17 +267,17 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
                         if tok == t { //pass the separator
                             let ei_t <- ei;
                             ei_t.idx += 1;
-                            vec::push(next_eis, move ei_t);
+                            next_eis.push(move ei_t);
                         }
                       }
                       _ => { // we don't need a separator
                         let ei_t <- ei;
                         ei_t.idx = 0;
-                        vec::push(cur_eis, move ei_t);
+                        cur_eis.push(move ei_t);
                       }
                     }
                 } else {
-                    vec::push(eof_eis, move ei);
+                    eof_eis.push(move ei);
                 }
             } else {
                 match copy ei.elts[idx].node {
@@ -292,13 +292,13 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
                             new_ei.matches[idx].push(@matched_seq(~[], sp));
                         }
 
-                        vec::push(cur_eis, move new_ei);
+                        cur_eis.push(move new_ei);
                     }
 
                     let matches = vec::map(ei.matches, // fresh, same size:
                                            |_m| DVec::<@named_match>());
                     let ei_t <- ei;
-                    vec::push(cur_eis, ~{
+                    cur_eis.push(~{
                         elts: matchers, sep: sep, mut idx: 0u,
                         mut up: matcher_pos_up(Some(move ei_t)),
                         matches: move matches,
@@ -306,12 +306,12 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
                         sp_lo: sp.lo
                     });
                   }
-                  match_nonterminal(_,_,_) => { vec::push(bb_eis, move ei) }
+                  match_nonterminal(_,_,_) => { bb_eis.push(move ei) }
                   match_tok(t) => {
                     let ei_t <- ei;
                     if t == tok {
                         ei_t.idx += 1;
-                        vec::push(next_eis, move ei_t);
+                        next_eis.push(move ei_t);
                     }
                   }
                 }
@@ -323,7 +323,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
             if eof_eis.len() == 1u {
                 return success(
                     nameize(sess, ms,
-                            vec::map(eof_eis[0u].matches, |dv| dv.pop())));
+                            eof_eis[0u].matches.map(|dv| dv.pop())));
             } else if eof_eis.len() > 1u {
                 return error(sp, ~"Ambiguity: multiple successful parses");
             } else {
@@ -350,7 +350,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
             } else if (next_eis.len() > 0u) {
                 /* Now process the next token */
                 while(next_eis.len() > 0u) {
-                    vec::push(cur_eis, vec::pop(next_eis));
+                    cur_eis.push(vec::pop(next_eis));
                 }
                 rdr.next_token();
             } else /* bb_eis.len() == 1 */ {
@@ -365,7 +365,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
                   }
                   _ => fail
                 }
-                vec::push(cur_eis, move ei);
+                cur_eis.push(move ei);
 
                 /* this would fail if zero-length tokens existed */
                 while rdr.peek().sp.lo < rust_parser.span.lo {
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index b208e4f8c6f..558593579bf 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -205,8 +205,8 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} {
                     r.cur.idx += 1u;
                     return tt_next_token(r);
                 } else {
-                    vec::push(r.repeat_len, len);
-                    vec::push(r.repeat_idx, 0u);
+                    r.repeat_len.push(len);
+                    r.repeat_idx.push(0u);
                     r.cur = @{readme: tts, mut idx: 0u, dotdotdoted: true,
                               sep: sep, up: tt_frame_up(option::Some(r.cur))};
                 }
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index f8f481c8f66..12c8dc2f7bb 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -367,9 +367,8 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
           pat_rec(fields, etc) => {
             let mut fs = ~[];
             for fields.each |f| {
-                vec::push(fs,
-                          {ident: /* FIXME (#2543) */ copy f.ident,
-                           pat: fld.fold_pat(f.pat)});
+                fs.push({ident: /* FIXME (#2543) */ copy f.ident,
+                         pat: fld.fold_pat(f.pat)});
             }
             pat_rec(fs, etc)
           }
@@ -377,9 +376,8 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
             let pth_ = fld.fold_path(pth);
             let mut fs = ~[];
             for fields.each |f| {
-                vec::push(fs,
-                          {ident: /* FIXME (#2543) */ copy f.ident,
-                           pat: fld.fold_pat(f.pat)});
+                fs.push({ident: /* FIXME (#2543) */ copy f.ident,
+                         pat: fld.fold_pat(f.pat)});
             }
             pat_struct(pth_, fs, etc)
           }
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index ddc70a1f13e..cb8416501b3 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -130,7 +130,7 @@ fn consume_non_eol_whitespace(rdr: string_reader) {
 fn push_blank_line_comment(rdr: string_reader, &comments: ~[cmnt]) {
     debug!(">>> blank-line comment");
     let v: ~[~str] = ~[];
-    vec::push(comments, {style: blank_line, lines: v, pos: rdr.chpos});
+    comments.push({style: blank_line, lines: v, pos: rdr.chpos});
 }
 
 fn consume_whitespace_counting_blank_lines(rdr: string_reader,
@@ -149,7 +149,7 @@ fn read_shebang_comment(rdr: string_reader, code_to_the_left: bool,
     debug!(">>> shebang comment");
     let p = rdr.chpos;
     debug!("<<< shebang comment");
-    vec::push(comments, {
+    comments.push({
         style: if code_to_the_left { trailing } else { isolated },
         lines: ~[read_one_line_comment(rdr)],
         pos: p
@@ -167,12 +167,12 @@ fn read_line_comments(rdr: string_reader, code_to_the_left: bool,
         if is_doc_comment(line) { // doc-comments are not put in comments
             break;
         }
-        vec::push(lines, line);
+        lines.push(line);
         consume_non_eol_whitespace(rdr);
     }
     debug!("<<< line comments");
     if !lines.is_empty() {
-        vec::push(comments, {
+        comments.push({
             style: if code_to_the_left { trailing } else { isolated },
             lines: lines,
             pos: p
@@ -198,7 +198,7 @@ fn trim_whitespace_prefix_and_push_line(&lines: ~[~str],
         } else { s1 = ~""; }
     } else { s1 = s; }
     log(debug, ~"pushing line: " + s1);
-    vec::push(lines, s1);
+    lines.push(s1);
 }
 
 fn read_block_comment(rdr: string_reader, code_to_the_left: bool,
@@ -257,7 +257,7 @@ fn read_block_comment(rdr: string_reader, code_to_the_left: bool,
         style = mixed;
     }
     debug!("<<< block comment");
-    vec::push(comments, {style: style, lines: lines, pos: p});
+    comments.push({style: style, lines: lines, pos: p});
 }
 
 fn peeking_at_comment(rdr: string_reader) -> bool {
@@ -315,7 +315,7 @@ fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler,
         let {tok: tok, sp: sp} = rdr.peek();
         if token::is_lit(tok) {
             let s = get_str_from(rdr, bstart);
-            vec::push(literals, {lit: s, pos: sp.lo});
+            literals.push({lit: s, pos: sp.lo});
             log(debug, ~"tok lit: " + s);
         } else {
             log(debug, ~"tok: " + token::to_str(rdr.interner, tok));
diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs
index 4b8bfcda848..c8c30ee7fa9 100644
--- a/src/libsyntax/parse/common.rs
+++ b/src/libsyntax/parse/common.rs
@@ -229,7 +229,7 @@ impl parser: parser_common {
               }
               _ => ()
             }
-            vec::push(v, f(self));
+            v.push(f(self));
         }
 
         return v;
@@ -274,7 +274,7 @@ impl parser: parser_common {
               _ => ()
             }
             if sep.trailing_sep_allowed && self.token == ket { break; }
-            vec::push(v, f(self));
+            v.push(f(self));
         }
         return v;
     }
diff --git a/src/libsyntax/parse/eval.rs b/src/libsyntax/parse/eval.rs
index 7127e2747eb..14dc490346e 100644
--- a/src/libsyntax/parse/eval.rs
+++ b/src/libsyntax/parse/eval.rs
@@ -107,7 +107,7 @@ fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: &Path,
         // Thread defids, chpos and byte_pos through the parsers
         cx.sess.chpos = r0.chpos;
         cx.sess.byte_pos = cx.sess.byte_pos + r0.pos;
-        vec::push(items, i);
+        items.push(i);
       }
       ast::cdir_dir_mod(vis, id, cdirs, attrs) => {
         let path = Path(cdir_path_opt(*cx.sess.interner.get(id), attrs));
@@ -126,9 +126,9 @@ fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: &Path,
               vis: vis,
               span: cdir.span};
         cx.sess.next_id += 1;
-        vec::push(items, i);
+        items.push(i);
       }
-      ast::cdir_view_item(vi) => vec::push(view_items, vi),
+      ast::cdir_view_item(vi) => view_items.push(vi),
       ast::cdir_syntax(*) => ()
     }
 }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 9d970e23f68..10981c5c708 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -496,7 +496,7 @@ impl parser {
                 let mut ts = ~[self.parse_ty(false)];
                 while self.token == token::COMMA {
                     self.bump();
-                    vec::push(ts, self.parse_ty(false));
+                    ts.push(self.parse_ty(false));
                 }
                 let t = if vec::len(ts) == 1u { ts[0].node }
                 else { ty_tup(ts) };
@@ -771,10 +771,10 @@ impl parser {
                 && self.look_ahead(1u) == token::MOD_SEP;
 
             if is_not_last {
-                vec::push(ids, parse_ident(self));
+                ids.push(parse_ident(self));
                 self.expect(token::MOD_SEP);
             } else {
-                vec::push(ids, parse_last_ident(self));
+                ids.push(parse_last_ident(self));
                 break;
             }
         }
@@ -903,7 +903,7 @@ impl parser {
             }
             let mut es = ~[self.parse_expr()];
             while self.token == token::COMMA {
-                self.bump(); vec::push(es, self.parse_expr());
+                self.bump(); es.push(self.parse_expr());
             }
             hi = self.span.hi;
             self.expect(token::RPAREN);
@@ -1049,7 +1049,7 @@ impl parser {
                     self.bump();
                     let mut fields = ~[];
                     let mut base = None;
-                    vec::push(fields, self.parse_field(token::COLON));
+                    fields.push(self.parse_field(token::COLON));
                     while self.token != token::RBRACE {
 
                         if self.try_parse_obsolete_with() {
@@ -1067,7 +1067,7 @@ impl parser {
                             // Accept an optional trailing comma.
                             break;
                         }
-                        vec::push(fields, self.parse_field(token::COLON));
+                        fields.push(self.parse_field(token::COLON));
                     }
 
                     hi = pth.span.hi;
@@ -1316,7 +1316,7 @@ impl parser {
         while self.token != ket || lparens > 0u {
             if self.token == token::LPAREN { lparens += 1u; }
             if self.token == token::RPAREN { lparens -= 1u; }
-            vec::push(ret_val, self.parse_matcher(name_idx));
+            ret_val.push(self.parse_matcher(name_idx));
         }
 
         self.bump();
@@ -1722,7 +1722,7 @@ impl parser {
                 // record ends by an optional trailing comma
                 break;
             }
-            vec::push(fields, self.parse_field(token::COLON));
+            fields.push(self.parse_field(token::COLON));
         }
         self.expect(token::RBRACE);
         return expr_rec(fields, base);
@@ -1757,7 +1757,7 @@ impl parser {
                               rules: default_blk},
                        span: expr.span};
 
-            vec::push(arms, {pats: pats, guard: guard, body: blk});
+            arms.push({pats: pats, guard: guard, body: blk});
         }
         let mut hi = self.span.hi;
         self.bump();
@@ -1802,7 +1802,7 @@ impl parser {
     fn parse_pats() -> ~[@pat] {
         let mut pats = ~[];
         loop {
-            vec::push(pats, self.parse_pat(true));
+            pats.push(self.parse_pat(true));
             if self.token == token::BINOP(token::OR) { self.bump(); }
             else { return pats; }
         };
@@ -1849,7 +1849,7 @@ impl parser {
                     span: self.last_span
                 };
             }
-            vec::push(fields, {ident: fieldname, pat: subpat});
+            fields.push({ident: fieldname, pat: subpat});
         }
         return (fields, etc);
     }
@@ -1937,7 +1937,7 @@ impl parser {
                 let mut fields = ~[self.parse_pat(refutable)];
                 while self.token == token::COMMA {
                     self.bump();
-                    vec::push(fields, self.parse_pat(refutable));
+                    fields.push(self.parse_pat(refutable));
                 }
                 if vec::len(fields) == 1u { self.expect(token::COMMA); }
                 hi = self.span.hi;
@@ -2126,7 +2126,7 @@ impl parser {
         let lo = self.span.lo;
         let mut locals = ~[self.parse_local(is_mutbl, true)];
         while self.eat(token::COMMA) {
-            vec::push(locals, self.parse_local(is_mutbl, true));
+            locals.push(self.parse_local(is_mutbl, true));
         }
         return @spanned(lo, self.last_span.hi, decl_local(locals));
     }
@@ -2266,8 +2266,8 @@ impl parser {
 
         for items.each |item| {
             let decl = @spanned(item.span.lo, item.span.hi, decl_item(*item));
-            push(stmts, @spanned(item.span.lo, item.span.hi,
-                                 stmt_decl(decl, self.get_id())));
+            stmts.push(@spanned(item.span.lo, item.span.hi,
+                                stmt_decl(decl, self.get_id())));
         }
 
         let mut initial_attrs = attrs_remaining;
@@ -2278,43 +2278,43 @@ impl parser {
 
         while self.token != token::RBRACE {
             match self.token {
-              token::SEMI => {
-                self.bump(); // empty
-              }
-              _ => {
-                let stmt = self.parse_stmt(initial_attrs);
-                initial_attrs = ~[];
-                match stmt.node {
-                  stmt_expr(e, stmt_id) => { // Expression without semicolon:
-                    match self.token {
-                      token::SEMI => {
-                        self.bump();
-                        push(stmts,
-                             @{node: stmt_semi(e, stmt_id),.. *stmt});
-                      }
-                      token::RBRACE => {
-                        expr = Some(e);
-                      }
-                      t => {
-                        if classify::stmt_ends_with_semi(*stmt) {
-                            self.fatal(~"expected `;` or `}` after \
-                                         expression but found `"
-                                       + token_to_str(self.reader, t) + ~"`");
+                token::SEMI => {
+                    self.bump(); // empty
+                }
+                _ => {
+                    let stmt = self.parse_stmt(initial_attrs);
+                    initial_attrs = ~[];
+                    match stmt.node {
+                        stmt_expr(e, stmt_id) => { // Expression without semicolon:
+                            match self.token {
+                                token::SEMI => {
+                                    self.bump();
+                                    stmts.push(@{node: stmt_semi(e, stmt_id),
+                                                 ..*stmt});
+                                }
+                                token::RBRACE => {
+                                    expr = Some(e);
+                                }
+                                t => {
+                                    if classify::stmt_ends_with_semi(*stmt) {
+                                        self.fatal(~"expected `;` or `}` after \
+                                                     expression but found `"
+                                                   + token_to_str(self.reader, t) + ~"`");
+                                    }
+                                    stmts.push(stmt);
+                                }
+                            }
                         }
-                        vec::push(stmts, stmt);
-                      }
-                    }
-                  }
 
-                  _ => { // All other kinds of statements:
-                    vec::push(stmts, stmt);
+                        _ => { // All other kinds of statements:
+                            stmts.push(stmt);
 
-                    if classify::stmt_ends_with_semi(*stmt) {
-                        self.expect(token::SEMI);
+                            if classify::stmt_ends_with_semi(*stmt) {
+                                self.expect(token::SEMI);
+                            }
+                        }
                     }
-                  }
                 }
-              }
             }
         }
         let mut hi = self.span.hi;
@@ -2356,16 +2356,16 @@ impl parser {
                     };
 
                     match maybe_bound {
-                      Some(bound) => {
-                        self.bump();
-                        push(bounds, bound);
-                      }
-                      None => {
-                        push(bounds, bound_trait(self.parse_ty(false)));
-                      }
+                        Some(bound) => {
+                            self.bump();
+                            bounds.push(bound);
+                        }
+                        None => {
+                            bounds.push(bound_trait(self.parse_ty(false)));
+                        }
                     }
                 } else {
-                    push(bounds, bound_trait(self.parse_ty(false)));
+                    bounds.push(bound_trait(self.parse_ty(false)));
                 }
             }
         }
@@ -2636,7 +2636,7 @@ impl parser {
         self.expect(token::LBRACE);
         while !self.eat(token::RBRACE) {
             let vis = self.parse_visibility();
-            vec::push(meths, self.parse_method(vis));
+            meths.push(self.parse_method(vis));
         }
         (ident, item_impl(tps, opt_trait, ty, meths), None)
     }
@@ -2722,9 +2722,9 @@ impl parser {
                     for mms.each |mm| {
                         match *mm {
                             @field_member(struct_field) =>
-                                vec::push(fields, struct_field),
+                                fields.push(struct_field),
                             @method_member(the_method_member) =>
-                                vec::push(methods, the_method_member)
+                                methods.push(the_method_member)
                         }
                     }
                   }
@@ -2896,7 +2896,7 @@ impl parser {
             debug!("parse_mod_items: parse_item_or_view_item(attrs=%?)",
                    attrs);
             match self.parse_item_or_view_item(attrs, true) {
-              iovi_item(item) => vec::push(items, item),
+              iovi_item(item) => items.push(item),
               iovi_view_item(view_item) => {
                 self.span_fatal(view_item.span, ~"view items must be \
                                                   declared at the top of the \
@@ -3000,7 +3000,7 @@ impl parser {
             let attrs = vec::append(initial_attrs,
                                     self.parse_outer_attributes());
             initial_attrs = ~[];
-            vec::push(items, self.parse_foreign_item(attrs));
+            items.push(self.parse_foreign_item(attrs));
         }
         return {sort: sort, view_items: view_items,
              items: items};
@@ -3113,9 +3113,9 @@ impl parser {
                     for mms.each |mm| {
                         match *mm {
                             @field_member(struct_field) =>
-                                vec::push(fields, struct_field),
+                                fields.push(struct_field),
                             @method_member(the_method_member) =>
-                                vec::push(methods, the_method_member)
+                                methods.push(the_method_member)
                         }
                     }
                 }
@@ -3184,7 +3184,7 @@ impl parser {
                         seq_sep_trailing_disallowed(token::COMMA),
                         |p| p.parse_ty(false));
                     for arg_tys.each |ty| {
-                        vec::push(args, {ty: *ty, id: self.get_id()});
+                        args.push({ty: *ty, id: self.get_id()});
                     }
                     kind = tuple_variant_kind(args);
                 } else if self.eat(token::EQ) {
@@ -3200,7 +3200,7 @@ impl parser {
             let vr = {name: ident, attrs: variant_attrs,
                       kind: kind, id: self.get_id(),
                       disr_expr: disr_expr, vis: vis};
-            vec::push(variants, spanned(vlo, self.last_span.hi, vr));
+            variants.push(spanned(vlo, self.last_span.hi, vr));
 
             if needs_comma && !self.eat(token::COMMA) { break; }
         }
@@ -3427,7 +3427,7 @@ impl parser {
             while self.token == token::MOD_SEP {
                 self.bump();
                 let id = self.parse_ident();
-                vec::push(path, id);
+                path.push(id);
             }
             let path = @{span: mk_sp(lo, self.span.hi), global: false,
                          idents: path, rp: None, types: ~[]};
@@ -3445,7 +3445,7 @@ impl parser {
 
                   token::IDENT(i, _) => {
                     self.bump();
-                    vec::push(path, i);
+                    path.push(i);
                   }
 
                   // foo::bar::{a,b,c}
@@ -3488,7 +3488,7 @@ impl parser {
         let mut vp = ~[self.parse_view_path()];
         while self.token == token::COMMA {
             self.bump();
-            vec::push(vp, self.parse_view_path());
+            vp.push(self.parse_view_path());
         }
         return vp;
     }
@@ -3662,7 +3662,7 @@ impl parser {
         let mut first_outer_attr = first_outer_attr;
         while self.token != term {
             let cdir = @self.parse_crate_directive(first_outer_attr);
-            vec::push(cdirs, cdir);
+            cdirs.push(cdir);
             first_outer_attr = ~[];
         }
         return cdirs;
diff --git a/src/rustc/back/link.rs b/src/rustc/back/link.rs
index c8f5871333f..4bbd51524c4 100644
--- a/src/rustc/back/link.rs
+++ b/src/rustc/back/link.rs
@@ -392,14 +392,14 @@ fn build_link_meta(sess: session, c: ast::crate, output: &Path,
             if attr::get_meta_item_name(*meta) == ~"name" {
                 match attr::get_meta_item_value_str(*meta) {
                   Some(v) => { name = Some(v); }
-                  None => vec::push(cmh_items, *meta)
+                  None => cmh_items.push(*meta)
                 }
             } else if attr::get_meta_item_name(*meta) == ~"vers" {
                 match attr::get_meta_item_value_str(*meta) {
                   Some(v) => { vers = Some(v); }
-                  None => vec::push(cmh_items, *meta)
+                  None => cmh_items.push(*meta)
                 }
-            } else { vec::push(cmh_items, *meta); }
+            } else { cmh_items.push(*meta); }
         }
         return {name: name, vers: vers, cmh_items: cmh_items};
     }
@@ -657,9 +657,9 @@ fn link_binary(sess: session,
 
     let mut cc_args =
         vec::append(~[stage], sess.targ_cfg.target_strs.cc_args);
-    vec::push(cc_args, ~"-o");
-    vec::push(cc_args, output.to_str());
-    vec::push(cc_args, obj_filename.to_str());
+    cc_args.push(~"-o");
+    cc_args.push(output.to_str());
+    cc_args.push(obj_filename.to_str());
 
     let mut lib_cmd;
     let os = sess.targ_cfg.os;
@@ -674,17 +674,17 @@ fn link_binary(sess: session,
     let cstore = sess.cstore;
     for cstore::get_used_crate_files(cstore).each |cratepath| {
         if cratepath.filetype() == Some(~".rlib") {
-            vec::push(cc_args, cratepath.to_str());
+            cc_args.push(cratepath.to_str());
             loop;
         }
         let dir = cratepath.dirname();
-        if dir != ~"" { vec::push(cc_args, ~"-L" + dir); }
+        if dir != ~"" { cc_args.push(~"-L" + dir); }
         let libarg = unlib(sess.targ_cfg, cratepath.filestem().get());
-        vec::push(cc_args, ~"-l" + libarg);
+        cc_args.push(~"-l" + libarg);
     }
 
     let ula = cstore::get_used_link_args(cstore);
-    for ula.each |arg| { vec::push(cc_args, *arg); }
+    for ula.each |arg| { cc_args.push(*arg); }
 
     // # Extern library linking
 
@@ -695,41 +695,41 @@ fn link_binary(sess: session,
     // forces to make sure that library can be found at runtime.
 
     let addl_paths = sess.opts.addl_lib_search_paths;
-    for addl_paths.each |path| { vec::push(cc_args, ~"-L" + path.to_str()); }
+    for addl_paths.each |path| { cc_args.push(~"-L" + path.to_str()); }
 
     // The names of the extern libraries
     let used_libs = cstore::get_used_libraries(cstore);
-    for used_libs.each |l| { vec::push(cc_args, ~"-l" + *l); }
+    for used_libs.each |l| { cc_args.push(~"-l" + *l); }
 
     if sess.building_library {
-        vec::push(cc_args, lib_cmd);
+        cc_args.push(lib_cmd);
 
         // On mac we need to tell the linker to let this library
         // be rpathed
         if sess.targ_cfg.os == session::os_macos {
-            vec::push(cc_args, ~"-Wl,-install_name,@rpath/"
+            cc_args.push(~"-Wl,-install_name,@rpath/"
                       + output.filename().get());
         }
     }
 
     if !sess.debugging_opt(session::no_rt) {
         // Always want the runtime linked in
-        vec::push(cc_args, ~"-lrustrt");
+        cc_args.push(~"-lrustrt");
     }
 
     // On linux librt and libdl are an indirect dependencies via rustrt,
     // and binutils 2.22+ won't add them automatically
     if sess.targ_cfg.os == session::os_linux {
-        vec::push_all(cc_args, ~[~"-lrt", ~"-ldl"]);
+        cc_args.push_all(~[~"-lrt", ~"-ldl"]);
 
         // LLVM implements the `frem` instruction as a call to `fmod`,
         // which lives in libm. Similar to above, on some linuxes we
         // have to be explicit about linking to it. See #2510
-        vec::push(cc_args, ~"-lm");
+        cc_args.push(~"-lm");
     }
 
     if sess.targ_cfg.os == session::os_freebsd {
-        vec::push_all(cc_args, ~[~"-pthread", ~"-lrt",
+        cc_args.push_all(~[~"-pthread", ~"-lrt",
                                 ~"-L/usr/local/lib", ~"-lexecinfo",
                                 ~"-L/usr/local/lib/gcc46",
                                 ~"-L/usr/local/lib/gcc44", ~"-lstdc++",
@@ -743,15 +743,15 @@ fn link_binary(sess: session,
     // understand how to unwind our __morestack frame, so we have to turn it
     // off. This has impacted some other projects like GHC.
     if sess.targ_cfg.os == session::os_macos {
-        vec::push(cc_args, ~"-Wl,-no_compact_unwind");
+        cc_args.push(~"-Wl,-no_compact_unwind");
     }
 
     // Stack growth requires statically linking a __morestack function
-    vec::push(cc_args, ~"-lmorestack");
+    cc_args.push(~"-lmorestack");
 
     // FIXME (#2397): At some point we want to rpath our guesses as to where
     // extern libraries might live, based on the addl_lib_search_paths
-    vec::push_all(cc_args, rpath::get_rpath_flags(sess, &output));
+    cc_args.push_all(rpath::get_rpath_flags(sess, &output));
 
     debug!("%s link args: %s", cc_prog, str::connect(cc_args, ~" "));
     // We run 'cc' here
diff --git a/src/rustc/back/rpath.rs b/src/rustc/back/rpath.rs
index 132bbc96344..8aa7caefc7a 100644
--- a/src/rustc/back/rpath.rs
+++ b/src/rustc/back/rpath.rs
@@ -81,8 +81,8 @@ fn get_rpaths(os: session::os,
     log_rpaths(~"fallback", fallback_rpaths);
 
     let mut rpaths = rel_rpaths;
-    vec::push_all(rpaths, abs_rpaths);
-    vec::push_all(rpaths, fallback_rpaths);
+    rpaths.push_all(abs_rpaths);
+    rpaths.push_all(fallback_rpaths);
 
     // Remove duplicates
     let rpaths = minimize_rpaths(rpaths);
@@ -136,9 +136,9 @@ fn get_relative_to(abs1: &Path, abs2: &Path) -> Path {
     }
 
     let mut path = ~[];
-    for uint::range(start_idx, len1 - 1) |_i| { vec::push(path, ~".."); };
+    for uint::range(start_idx, len1 - 1) |_i| { path.push(~".."); };
 
-    vec::push_all(path, vec::view(split2, start_idx, len2 - 1));
+    path.push_all(vec::view(split2, start_idx, len2 - 1));
 
     if vec::is_not_empty(path) {
         return Path("").push_many(path);
@@ -172,7 +172,7 @@ fn minimize_rpaths(rpaths: &[Path]) -> ~[Path] {
     for rpaths.each |rpath| {
         let s = rpath.to_str();
         if !set.contains_key(s) {
-            vec::push(minimized, *rpath);
+            minimized.push(*rpath);
             set.insert(s, ());
         }
     }
diff --git a/src/rustc/back/upcall.rs b/src/rustc/back/upcall.rs
index f289a0bdf27..a2c864f6f46 100644
--- a/src/rustc/back/upcall.rs
+++ b/src/rustc/back/upcall.rs
@@ -28,7 +28,7 @@ fn declare_upcalls(targ_cfg: @session::config,
             tys: ~[TypeRef], rv: TypeRef) ->
        ValueRef {
         let mut arg_tys: ~[TypeRef] = ~[];
-        for tys.each |t| { vec::push(arg_tys, *t); }
+        for tys.each |t| { arg_tys.push(*t); }
         let fn_ty = T_fn(arg_tys, rv);
         return base::decl_cdecl_fn(llmod, prefix + name, fn_ty);
     }
diff --git a/src/rustc/driver/driver.rs b/src/rustc/driver/driver.rs
index f890fa85eb3..3acacd3c0a5 100644
--- a/src/rustc/driver/driver.rs
+++ b/src/rustc/driver/driver.rs
@@ -94,7 +94,7 @@ fn parse_cfgspecs(cfgspecs: ~[~str]) -> ast::crate_cfg {
     // meta_word variant.
     let mut words = ~[];
     for cfgspecs.each |s| {
-        vec::push(words, attr::mk_word_item(*s));
+        words.push(attr::mk_word_item(*s));
     }
     return words;
 }
@@ -466,7 +466,7 @@ fn build_session_options(binary: ~str,
                                            level_name, lint_name));
               }
               Some(lint) => {
-                vec::push(lint_opts, (lint.lint, *level));
+                lint_opts.push((lint.lint, *level));
               }
             }
         }
diff --git a/src/rustc/front/test.rs b/src/rustc/front/test.rs
index e1441d9ee5e..55d71ab6950 100644
--- a/src/rustc/front/test.rs
+++ b/src/rustc/front/test.rs
@@ -99,7 +99,7 @@ fn fold_crate(cx: test_ctxt, c: ast::crate_, fld: fold::ast_fold) ->
 fn fold_item(cx: test_ctxt, &&i: @ast::item, fld: fold::ast_fold) ->
    Option<@ast::item> {
 
-    vec::push(cx.path, i.ident);
+    cx.path.push(i.ident);
     debug!("current path: %s",
            ast_util::path_name_i(cx.path, cx.sess.parse_sess.interner));
 
@@ -286,7 +286,7 @@ fn mk_test_desc_vec(cx: test_ctxt) -> @ast::expr {
     debug!("building test vector from %u tests", cx.testfns.len());
     let mut descs = ~[];
     for cx.testfns.each |test| {
-        vec::push(descs, mk_test_desc_rec(cx, *test));
+        descs.push(mk_test_desc_rec(cx, *test));
     }
 
     let inner_expr = @{id: cx.sess.next_node_id(),
diff --git a/src/rustc/metadata/cstore.rs b/src/rustc/metadata/cstore.rs
index 8a982eaf497..edf6a9612c7 100644
--- a/src/rustc/metadata/cstore.rs
+++ b/src/rustc/metadata/cstore.rs
@@ -115,7 +115,7 @@ fn iter_crate_data(cstore: cstore, i: fn(ast::crate_num, crate_metadata)) {
 
 fn add_used_crate_file(cstore: cstore, lib: &Path) {
     if !vec::contains(p(cstore).used_crate_files, copy *lib) {
-        vec::push(p(cstore).used_crate_files, copy *lib);
+        p(cstore).used_crate_files.push(copy *lib);
     }
 }
 
@@ -127,7 +127,7 @@ fn add_used_library(cstore: cstore, lib: ~str) -> bool {
     assert lib != ~"";
 
     if vec::contains(p(cstore).used_libraries, lib) { return false; }
-    vec::push(p(cstore).used_libraries, lib);
+    p(cstore).used_libraries.push(lib);
     return true;
 }
 
@@ -136,7 +136,7 @@ fn get_used_libraries(cstore: cstore) -> ~[~str] {
 }
 
 fn add_used_link_args(cstore: cstore, args: ~str) {
-    vec::push_all(p(cstore).used_link_args, str::split_char(args, ' '));
+    p(cstore).used_link_args.push_all(str::split_char(args, ' '));
 }
 
 fn get_used_link_args(cstore: cstore) -> ~[~str] {
@@ -163,7 +163,7 @@ fn get_dep_hashes(cstore: cstore) -> ~[~str] {
         let cdata = cstore::get_crate_data(cstore, cnum);
         let hash = decoder::get_crate_hash(cdata.data);
         debug!("Add hash[%s]: %s", cdata.name, hash);
-        vec::push(result, {name: cdata.name, hash: hash});
+        result.push({name: cdata.name, hash: hash});
     };
     pure fn lteq(a: &crate_hash, b: &crate_hash) -> bool {a.name <= b.name}
     let sorted = std::sort::merge_sort(lteq, result);
diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs
index 4a72867eb85..a6bb681bc16 100644
--- a/src/rustc/metadata/decoder.rs
+++ b/src/rustc/metadata/decoder.rs
@@ -227,7 +227,7 @@ fn item_type(item_id: ast::def_id, item: ebml::Doc,
 fn item_impl_traits(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd) -> ~[ty::t] {
     let mut results = ~[];
     for ebml::tagged_docs(item, tag_impl_trait) |ity| {
-        vec::push(results, doc_type(ity, tcx, cdata));
+        results.push(doc_type(ity, tcx, cdata));
     };
     results
 }
@@ -239,7 +239,7 @@ fn item_ty_param_bounds(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd)
         let bd = parse_bounds_data(p.data, p.start, cdata.cnum, tcx, |did| {
             translate_def_id(cdata, did)
         });
-        vec::push(bounds, bd);
+        bounds.push(bd);
     }
     @bounds
 }
@@ -263,7 +263,7 @@ fn enum_variant_ids(item: ebml::Doc, cdata: cmd) -> ~[ast::def_id] {
     let v = tag_items_data_item_variant;
     for ebml::tagged_docs(item, v) |p| {
         let ext = ebml::with_doc_data(p, |d| parse_def_id(d));
-        vec::push(ids, {crate: cdata.cnum, node: ext.node});
+        ids.push({crate: cdata.cnum, node: ext.node});
     };
     return ids;
 }
@@ -278,10 +278,10 @@ fn item_path(intr: @ident_interner, item_doc: ebml::Doc) -> ast_map::path {
     for ebml::docs(path_doc) |tag, elt_doc| {
         if tag == tag_path_elt_mod {
             let str = ebml::doc_as_str(elt_doc);
-            vec::push(result, ast_map::path_mod(intr.intern(@str)));
+            result.push(ast_map::path_mod(intr.intern(@str)));
         } else if tag == tag_path_elt_name {
             let str = ebml::doc_as_str(elt_doc);
-            vec::push(result, ast_map::path_name(intr.intern(@str)));
+            result.push(ast_map::path_name(intr.intern(@str)));
         } else {
             // ignore tag_path_len element
         }
@@ -584,7 +584,7 @@ fn get_enum_variants(intr: @ident_interner, cdata: cmd, id: ast::node_id,
         let mut arg_tys: ~[ty::t] = ~[];
         match ty::get(ctor_ty).sty {
           ty::ty_fn(f) => {
-            for f.sig.inputs.each |a| { vec::push(arg_tys, a.ty); }
+            for f.sig.inputs.each |a| { arg_tys.push(a.ty); }
           }
           _ => { /* Nullary enum variant. */ }
         }
@@ -592,7 +592,7 @@ fn get_enum_variants(intr: @ident_interner, cdata: cmd, id: ast::node_id,
           Some(val) => { disr_val = val; }
           _         => { /* empty */ }
         }
-        vec::push(infos, @{args: arg_tys, ctor_ty: ctor_ty, name: name,
+        infos.push(@{args: arg_tys, ctor_ty: ctor_ty, name: name,
                            id: *did, disr_val: disr_val});
         disr_val += 1;
     }
@@ -645,7 +645,7 @@ fn item_impl_methods(intr: @ident_interner, cdata: cmd, item: ebml::Doc,
         let m_did = ebml::with_doc_data(doc, |d| parse_def_id(d));
         let mth_item = lookup_item(m_did.node, cdata.data);
         let self_ty = get_self_ty(mth_item);
-        vec::push(rslt, @{did: translate_def_id(cdata, m_did),
+        rslt.push(@{did: translate_def_id(cdata, m_did),
                     /* FIXME (maybe #2323) tjc: take a look at this. */
                    n_tps: item_ty_param_count(mth_item) - base_tps,
                    ident: item_name(intr, mth_item),
@@ -675,7 +675,7 @@ fn get_impls_for_mod(intr: @ident_interner, cdata: cmd,
         let nm = item_name(intr, item);
         if match name { Some(n) => { n == nm } None => { true } } {
            let base_tps = item_ty_param_count(item);
-           vec::push(result, @{
+           result.push(@{
                 did: local_did, ident: nm,
                 methods: item_impl_methods(intr, impl_cdata, item, base_tps)
             });
@@ -701,7 +701,7 @@ fn get_trait_methods(intr: @ident_interner, cdata: cmd, id: ast::node_id,
                 ~"get_trait_methods: id has non-function type");
         } };
         let self_ty = get_self_ty(mth);
-        vec::push(result, {ident: name, tps: bounds, fty: fty,
+        result.push({ident: name, tps: bounds, fty: fty,
                            self_ty: self_ty,
                            vis: ast::public});
     }
@@ -753,7 +753,7 @@ fn get_class_members(intr: @ident_interner, cdata: cmd, id: ast::node_id,
           let name = item_name(intr, an_item);
           let did = item_def_id(an_item, cdata);
           let mt = field_mutability(an_item);
-          vec::push(result, {ident: name, id: did, vis:
+          result.push({ident: name, id: did, vis:
                   family_to_visibility(f), mutability: mt});
        }
     }
@@ -835,7 +835,7 @@ fn get_meta_items(md: ebml::Doc) -> ~[@ast::meta_item] {
     for ebml::tagged_docs(md, tag_meta_item_word) |meta_item_doc| {
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
         let n = str::from_bytes(ebml::doc_data(nd));
-        vec::push(items, attr::mk_word_item(n));
+        items.push(attr::mk_word_item(n));
     };
     for ebml::tagged_docs(md, tag_meta_item_name_value) |meta_item_doc| {
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
@@ -844,13 +844,13 @@ fn get_meta_items(md: ebml::Doc) -> ~[@ast::meta_item] {
         let v = str::from_bytes(ebml::doc_data(vd));
         // FIXME (#623): Should be able to decode meta_name_value variants,
         // but currently the encoder just drops them
-        vec::push(items, attr::mk_name_value_item_str(n, v));
+        items.push(attr::mk_name_value_item_str(n, v));
     };
     for ebml::tagged_docs(md, tag_meta_item_list) |meta_item_doc| {
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
         let n = str::from_bytes(ebml::doc_data(nd));
         let subitems = get_meta_items(meta_item_doc);
-        vec::push(items, attr::mk_list_item(n, subitems));
+        items.push(attr::mk_list_item(n, subitems));
     };
     return items;
 }
@@ -865,10 +865,10 @@ fn get_attributes(md: ebml::Doc) -> ~[ast::attribute] {
             // an attribute
             assert (vec::len(meta_items) == 1u);
             let meta_item = meta_items[0];
-            vec::push(attrs,
-                      {node: {style: ast::attr_outer, value: *meta_item,
-                              is_sugared_doc: false},
-                       span: ast_util::dummy_sp()});
+            attrs.push(
+                {node: {style: ast::attr_outer, value: *meta_item,
+                        is_sugared_doc: false},
+                 span: ast_util::dummy_sp()});
         };
       }
       option::None => ()
@@ -910,7 +910,7 @@ fn get_crate_deps(intr: @ident_interner, data: @~[u8]) -> ~[crate_dep] {
         str::from_bytes(ebml::doc_data(ebml::get_doc(doc, tag_)))
     }
     for ebml::tagged_docs(depsdoc, tag_crate_dep) |depdoc| {
-        vec::push(deps, {cnum: crate_num,
+        deps.push({cnum: crate_num,
                   name: intr.intern(@docstr(depdoc, tag_crate_dep_name)),
                   vers: docstr(depdoc, tag_crate_dep_vers),
                   hash: docstr(depdoc, tag_crate_dep_hash)});
@@ -977,7 +977,7 @@ fn get_crate_module_paths(intr: @ident_interner, cdata: cmd)
         // Collect everything by now. There might be multiple
         // paths pointing to the same did. Those will be
         // unified later by using the mods map
-        vec::push(res, (did, path));
+        res.push((did, path));
     }
     return do vec::filter(res) |x| {
         let (_, xp) = x;
diff --git a/src/rustc/metadata/encoder.rs b/src/rustc/metadata/encoder.rs
index 3424ea8dd57..81ad9dfc3a5 100644
--- a/src/rustc/metadata/encoder.rs
+++ b/src/rustc/metadata/encoder.rs
@@ -118,12 +118,12 @@ type entry<T> = {val: T, pos: uint};
 fn add_to_index(ecx: @encode_ctxt, ebml_w: ebml::Writer, path: &[ident],
                 &index: ~[entry<~str>], name: ident) {
     let mut full_path = ~[];
-    vec::push_all(full_path, path);
-    vec::push(full_path, name);
-    vec::push(index,
-              {val: ast_util::path_name_i(full_path,
-                                          ecx.tcx.sess.parse_sess.interner),
-               pos: ebml_w.writer.tell()});
+    full_path.push_all(path);
+    full_path.push(name);
+    index.push(
+        {val: ast_util::path_name_i(full_path,
+                                    ecx.tcx.sess.parse_sess.interner),
+         pos: ebml_w.writer.tell()});
 }
 
 fn encode_trait_ref(ebml_w: ebml::Writer, ecx: @encode_ctxt, t: @trait_ref) {
@@ -225,7 +225,7 @@ fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml::Writer,
     let mut i = 0;
     let vi = ty::enum_variants(ecx.tcx, {crate: local_crate, node: id});
     for variants.each |variant| {
-        vec::push(*index, {val: variant.node.id, pos: ebml_w.writer.tell()});
+        index.push({val: variant.node.id, pos: ebml_w.writer.tell()});
         ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, local_def(variant.node.id));
         encode_family(ebml_w, 'v');
@@ -390,9 +390,9 @@ fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::Writer,
         match field.node.kind {
             named_field(nm, mt, vis) => {
                 let id = field.node.id;
-                vec::push(*index, {val: id, pos: ebml_w.writer.tell()});
-                vec::push(*global_index, {val: id,
-                                          pos: ebml_w.writer.tell()});
+                index.push({val: id, pos: ebml_w.writer.tell()});
+                global_index.push({val: id,
+                                    pos: ebml_w.writer.tell()});
                 ebml_w.start_tag(tag_items_data_item);
                 debug!("encode_info_for_class: doing %s %d",
                        tcx.sess.str_of(nm), id);
@@ -411,9 +411,9 @@ fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::Writer,
     for methods.each |m| {
         match m.vis {
             public | inherited => {
-                vec::push(*index, {val: m.id, pos: ebml_w.writer.tell()});
-                vec::push(*global_index,
-                          {val: m.id, pos: ebml_w.writer.tell()});
+                index.push({val: m.id, pos: ebml_w.writer.tell()});
+                global_index.push(
+                    {val: m.id, pos: ebml_w.writer.tell()});
                 let impl_path = vec::append_one(path,
                                                 ast_map::path_name(m.ident));
                 debug!("encode_info_for_class: doing %s %d",
@@ -519,7 +519,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::Writer, item: @item,
 
     fn add_to_index_(item: @item, ebml_w: ebml::Writer,
                      index: @mut ~[entry<int>]) {
-        vec::push(*index, {val: item.id, pos: ebml_w.writer.tell()});
+        index.push({val: item.id, pos: ebml_w.writer.tell()});
     }
     let add_to_index = |copy ebml_w| add_to_index_(item, ebml_w, index);
 
@@ -603,7 +603,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::Writer, item: @item,
                                         index);
         /* Encode the dtor */
         do struct_def.dtor.iter |dtor| {
-            vec::push(*index, {val: dtor.node.id, pos: ebml_w.writer.tell()});
+            index.push({val: dtor.node.id, pos: ebml_w.writer.tell()});
           encode_info_for_ctor(ecx, ebml_w, dtor.node.id,
                                ecx.tcx.sess.ident_of(
                                    ecx.tcx.sess.str_of(item.ident) +
@@ -688,7 +688,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::Writer, item: @item,
         for struct_def.ctor.each |ctor| {
             debug!("encoding info for ctor %s %d",
                    ecx.tcx.sess.str_of(item.ident), ctor.node.id);
-            vec::push(*index, {
+            index.push({
                 val: ctor.node.id,
                 pos: ebml_w.writer.tell()
             });
@@ -723,7 +723,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::Writer, item: @item,
         let impl_path = vec::append_one(path,
                                         ast_map::path_name(item.ident));
         for methods.each |m| {
-            vec::push(*index, {val: m.id, pos: ebml_w.writer.tell()});
+            index.push({val: m.id, pos: ebml_w.writer.tell()});
             encode_info_for_method(ecx, ebml_w, impl_path,
                                    should_inline(m.attrs), item.id, *m,
                                    vec::append(tps, m.tps));
@@ -774,7 +774,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::Writer, item: @item,
             let ty_m = ast_util::trait_method_to_ty_method(*m);
             if ty_m.self_ty.node != ast::sty_static { loop; }
 
-            vec::push(*index, {val: ty_m.id, pos: ebml_w.writer.tell()});
+            index.push({val: ty_m.id, pos: ebml_w.writer.tell()});
 
             ebml_w.start_tag(tag_items_data_item);
             encode_def_id(ebml_w, local_def(ty_m.id));
@@ -799,7 +799,7 @@ fn encode_info_for_foreign_item(ecx: @encode_ctxt, ebml_w: ebml::Writer,
                                 index: @mut ~[entry<int>],
                                 path: ast_map::path, abi: foreign_abi) {
     if !reachable(ecx, nitem.id) { return; }
-    vec::push(*index, {val: nitem.id, pos: ebml_w.writer.tell()});
+    index.push({val: nitem.id, pos: ebml_w.writer.tell()});
 
     ebml_w.start_tag(tag_items_data_item);
     match nitem.node {
@@ -831,7 +831,7 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::Writer,
                          crate: @crate) -> ~[entry<int>] {
     let index = @mut ~[];
     ebml_w.start_tag(tag_items_data);
-    vec::push(*index, {val: crate_node_id, pos: ebml_w.writer.tell()});
+    index.push({val: crate_node_id, pos: ebml_w.writer.tell()});
     encode_info_for_mod(ecx, ebml_w, crate.node.module,
                         crate_node_id, ~[],
                         syntax::parse::token::special_idents::invalid);
@@ -869,15 +869,15 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::Writer,
 fn create_index<T: Copy Hash IterBytes>(index: ~[entry<T>]) ->
    ~[@~[entry<T>]] {
     let mut buckets: ~[@mut ~[entry<T>]] = ~[];
-    for uint::range(0u, 256u) |_i| { vec::push(buckets, @mut ~[]); };
+    for uint::range(0u, 256u) |_i| { buckets.push(@mut ~[]); };
     for index.each |elt| {
         let h = elt.val.hash() as uint;
-        vec::push(*buckets[h % 256], *elt);
+        buckets[h % 256].push(*elt);
     }
 
     let mut buckets_frozen = ~[];
     for buckets.each |bucket| {
-        vec::push(buckets_frozen, @**bucket);
+        buckets_frozen.push(@**bucket);
     }
     return buckets_frozen;
 }
@@ -889,7 +889,7 @@ fn encode_index<T>(ebml_w: ebml::Writer, buckets: ~[@~[entry<T>]],
     let mut bucket_locs: ~[uint] = ~[];
     ebml_w.start_tag(tag_index_buckets);
     for buckets.each |bucket| {
-        vec::push(bucket_locs, ebml_w.writer.tell());
+        bucket_locs.push(ebml_w.writer.tell());
         ebml_w.start_tag(tag_index_buckets_bucket);
         for vec::each(**bucket) |elt| {
             ebml_w.start_tag(tag_index_buckets_bucket_elt);
@@ -996,8 +996,7 @@ fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> ~[attribute] {
     let mut attrs: ~[attribute] = ~[];
     let mut found_link_attr = false;
     for crate.node.attrs.each |attr| {
-        vec::push(
-            attrs,
+        attrs.push(
             if attr::get_attr_name(*attr) != ~"link" {
                 *attr
             } else {
@@ -1011,7 +1010,7 @@ fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> ~[attribute] {
             });
     }
 
-    if !found_link_attr { vec::push(attrs, synthesize_link_attr(ecx, ~[])); }
+    if !found_link_attr { attrs.push(synthesize_link_attr(ecx, ~[])); }
 
     return attrs;
 }
@@ -1031,7 +1030,7 @@ fn encode_crate_deps(ecx: @encode_ctxt, ebml_w: ebml::Writer,
             let dep = {cnum: key, name: ecx.tcx.sess.ident_of(val.name),
                        vers: decoder::get_crate_vers(val.data),
                        hash: decoder::get_crate_hash(val.data)};
-            vec::push(deps, dep);
+            deps.push(dep);
         };
 
         // Sort by cnum
diff --git a/src/rustc/metadata/filesearch.rs b/src/rustc/metadata/filesearch.rs
index 77d06bd2d29..63370b09321 100644
--- a/src/rustc/metadata/filesearch.rs
+++ b/src/rustc/metadata/filesearch.rs
@@ -39,15 +39,15 @@ fn mk_filesearch(maybe_sysroot: Option<Path>,
         fn lib_search_paths() -> ~[Path] {
             let mut paths = self.addl_lib_search_paths;
 
-            vec::push(paths,
-                      make_target_lib_path(&self.sysroot,
-                                           self.target_triple));
+            paths.push(
+                make_target_lib_path(&self.sysroot,
+                                     self.target_triple));
             match get_cargo_lib_path_nearest() {
-              result::Ok(p) => vec::push(paths, p),
+              result::Ok(p) => paths.push(p),
               result::Err(_) => ()
             }
             match get_cargo_lib_path() {
-              result::Ok(p) => vec::push(paths, p),
+              result::Ok(p) => paths.push(p),
               result::Err(_) => ()
             }
             paths
diff --git a/src/rustc/metadata/loader.rs b/src/rustc/metadata/loader.rs
index b2c28fafd4c..2ccaccf17a5 100644
--- a/src/rustc/metadata/loader.rs
+++ b/src/rustc/metadata/loader.rs
@@ -90,7 +90,7 @@ fn find_library_crate_aux(cx: ctxt,
                     option::None::<()>
                 } else {
                     debug!("found %s with matching metadata", path.to_str());
-                    vec::push(matches, {ident: path.to_str(), data: cvec});
+                    matches.push({ident: path.to_str(), data: cvec});
                     option::None::<()>
                 }
               }
diff --git a/src/rustc/metadata/tydecode.rs b/src/rustc/metadata/tydecode.rs
index 5cf24aef558..f3fa0e3f350 100644
--- a/src/rustc/metadata/tydecode.rs
+++ b/src/rustc/metadata/tydecode.rs
@@ -84,7 +84,7 @@ fn parse_ret_ty(st: @pstate, conv: conv_did) -> (ast::ret_style, ty::t) {
 fn parse_path(st: @pstate) -> @ast::path {
     let mut idents: ~[ast::ident] = ~[];
     fn is_last(c: char) -> bool { return c == '(' || c == ':'; }
-    vec::push(idents, parse_ident_(st, is_last));
+    idents.push(parse_ident_(st, is_last));
     loop {
         match peek(st) {
           ':' => { next(st); next(st); }
@@ -93,7 +93,7 @@ fn parse_path(st: @pstate) -> @ast::path {
                 return @{span: ast_util::dummy_sp(),
                       global: false, idents: idents,
                       rp: None, types: ~[]};
-            } else { vec::push(idents, parse_ident_(st, is_last)); }
+            } else { idents.push(parse_ident_(st, is_last)); }
           }
         }
     };
@@ -136,7 +136,7 @@ fn parse_substs(st: @pstate, conv: conv_did) -> ty::substs {
 
     assert next(st) == '[';
     let mut params: ~[ty::t] = ~[];
-    while peek(st) != ']' { vec::push(params, parse_ty(st, conv)); }
+    while peek(st) != ']' { params.push(parse_ty(st, conv)); }
     st.pos = st.pos + 1u;
 
     return {self_r: self_r,
@@ -273,7 +273,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
         let mut fields: ~[ty::field] = ~[];
         while peek(st) != ']' {
             let name = st.tcx.sess.ident_of(parse_str(st, '='));
-            vec::push(fields, {ident: name, mt: parse_mt(st, conv)});
+            fields.push({ident: name, mt: parse_mt(st, conv)});
         }
         st.pos = st.pos + 1u;
         return ty::mk_rec(st.tcx, fields);
@@ -281,7 +281,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
       'T' => {
         assert (next(st) == '[');
         let mut params = ~[];
-        while peek(st) != ']' { vec::push(params, parse_ty(st, conv)); }
+        while peek(st) != ']' { params.push(parse_ty(st, conv)); }
         st.pos = st.pos + 1u;
         return ty::mk_tup(st.tcx, params);
       }
@@ -348,7 +348,7 @@ fn parse_mt(st: @pstate, conv: conv_did) -> ty::mt {
 
 fn parse_def(st: @pstate, conv: conv_did) -> ast::def_id {
     let mut def = ~[];
-    while peek(st) != '|' { vec::push(def, next_byte(st)); }
+    while peek(st) != '|' { def.push(next_byte(st)); }
     st.pos = st.pos + 1u;
     return conv(parse_def_id(def));
 }
@@ -412,7 +412,7 @@ fn parse_ty_fn(st: @pstate, conv: conv_did) -> ty::FnTy {
     let mut inputs: ~[ty::arg] = ~[];
     while peek(st) != ']' {
         let mode = parse_mode(st);
-        vec::push(inputs, {mode: mode, ty: parse_ty(st, conv)});
+        inputs.push({mode: mode, ty: parse_ty(st, conv)});
     }
     st.pos += 1u; // eat the ']'
     let (ret_style, ret_ty) = parse_ret_ty(st, conv);
@@ -464,7 +464,7 @@ fn parse_bounds_data(data: @~[u8], start: uint,
 fn parse_bounds(st: @pstate, conv: conv_did) -> @~[ty::param_bound] {
     let mut bounds = ~[];
     loop {
-        vec::push(bounds, match next(st) {
+        bounds.push(match next(st) {
           'S' => ty::bound_send,
           'C' => ty::bound_copy,
           'K' => ty::bound_const,
diff --git a/src/rustc/middle/capture.rs b/src/rustc/middle/capture.rs
index 1e885605171..618d43e121a 100644
--- a/src/rustc/middle/capture.rs
+++ b/src/rustc/middle/capture.rs
@@ -122,6 +122,6 @@ fn compute_capture_vars(tcx: ty::ctxt,
     }
 
     let mut result = ~[];
-    for cap_map.each_value |cap_var| { vec::push(result, cap_var); }
+    for cap_map.each_value |cap_var| { result.push(cap_var); }
     return result;
 }
diff --git a/src/rustc/middle/check_alt.rs b/src/rustc/middle/check_alt.rs
index 32801ed760c..54f415857ba 100644
--- a/src/rustc/middle/check_alt.rs
+++ b/src/rustc/middle/check_alt.rs
@@ -67,7 +67,7 @@ fn check_arms(tcx: ty::ctxt, arms: ~[arm]) {
               }
               _ => ()
             }
-            if arm.guard.is_none() { vec::push(seen, v); }
+            if arm.guard.is_none() { seen.push(v); }
         }
     }
 }
@@ -269,7 +269,7 @@ fn missing_ctor(tcx: ty::ctxt, m: matrix, left_ty: ty::t) -> Option<ctor> {
         let mut found = ~[];
         for m.each |r| {
             do option::iter(&pat_ctor_id(tcx, r[0])) |id| {
-                if !vec::contains(found, id) { vec::push(found, id); }
+                if !vec::contains(found, id) { found.push(id); }
             }
         }
         let variants = ty::enum_variants(tcx, eid);
diff --git a/src/rustc/middle/freevars.rs b/src/rustc/middle/freevars.rs
index 251ef2c89b7..7e925d7d8d8 100644
--- a/src/rustc/middle/freevars.rs
+++ b/src/rustc/middle/freevars.rs
@@ -63,7 +63,7 @@ fn collect_freevars(def_map: resolve::DefMap, blk: ast::blk)
                       if i == depth { // Made it to end of loop
                         let dnum = ast_util::def_id_of_def(def).node;
                         if !seen.contains_key(dnum) {
-                            vec::push(*refs, @{def:def, span:expr.span});
+                            refs.push(@{def:def, span:expr.span});
                             seen.insert(dnum, ());
                         }
                       }
diff --git a/src/rustc/middle/kind.rs b/src/rustc/middle/kind.rs
index 4f9045ec77e..7d911f7d05a 100644
--- a/src/rustc/middle/kind.rs
+++ b/src/rustc/middle/kind.rs
@@ -42,17 +42,17 @@ fn kind_to_str(k: kind) -> ~str {
     let mut kinds = ~[];
 
     if ty::kind_lteq(kind_const(), k) {
-        vec::push(kinds, ~"const");
+        kinds.push(~"const");
     }
 
     if ty::kind_can_be_copied(k) {
-        vec::push(kinds, ~"copy");
+        kinds.push(~"copy");
     }
 
     if ty::kind_can_be_sent(k) {
-        vec::push(kinds, ~"send");
+        kinds.push(~"send");
     } else if ty::kind_is_owned(k) {
-        vec::push(kinds, ~"owned");
+        kinds.push(~"owned");
     }
 
     str::connect(kinds, ~" ")
diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs
index ff77a598d27..b92f8e8441f 100644
--- a/src/rustc/middle/lint.rs
+++ b/src/rustc/middle/lint.rs
@@ -288,7 +288,7 @@ impl ctxt {
                     for metas.each |meta| {
                         match meta.node {
                           ast::meta_word(lintname) => {
-                            vec::push(triples, (*meta, *level, lintname));
+                            triples.push((*meta, *level, lintname));
                           }
                           _ => {
                             self.sess.span_err(
diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs
index a4c9b5f4b35..b39b7914905 100644
--- a/src/rustc/middle/liveness.rs
+++ b/src/rustc/middle/liveness.rs
@@ -302,7 +302,7 @@ fn IrMaps(tcx: ty::ctxt, method_map: typeck::method_map,
 impl IrMaps {
     fn add_live_node(lnk: LiveNodeKind) -> LiveNode {
         let ln = LiveNode(self.num_live_nodes);
-        vec::push(self.lnks, lnk);
+        self.lnks.push(lnk);
         self.num_live_nodes += 1u;
 
         debug!("%s is of kind %?", ln.to_str(), lnk);
@@ -319,7 +319,7 @@ impl IrMaps {
 
     fn add_variable(vk: VarKind) -> Variable {
         let v = Variable(self.num_vars);
-        vec::push(self.var_kinds, vk);
+        self.var_kinds.push(vk);
         self.num_vars += 1u;
 
         match vk {
@@ -540,7 +540,7 @@ fn visit_expr(expr: @expr, &&self: @IrMaps, vt: vt<@IrMaps>) {
                   cap_move | cap_drop => true, // var must be dead afterwards
                   cap_copy | cap_ref => false // var can still be used
                 };
-                vec::push(call_caps, {ln: cv_ln, is_move: is_move, rv: rv});
+                call_caps.push({ln: cv_ln, is_move: is_move, rv: rv});
               }
               None => {}
             }
diff --git a/src/rustc/middle/pat_util.rs b/src/rustc/middle/pat_util.rs
index e67b85b869c..006065988b9 100644
--- a/src/rustc/middle/pat_util.rs
+++ b/src/rustc/middle/pat_util.rs
@@ -54,6 +54,6 @@ fn pat_bindings(dm: resolve::DefMap, pat: @pat,
 
 fn pat_binding_ids(dm: resolve::DefMap, pat: @pat) -> ~[node_id] {
     let mut found = ~[];
-    pat_bindings(dm, pat, |_bm, b_id, _sp, _pt| vec::push(found, b_id) );
+    pat_bindings(dm, pat, |_bm, b_id, _sp, _pt| found.push(b_id) );
     return found;
 }
diff --git a/src/rustc/middle/region.rs b/src/rustc/middle/region.rs
index ae1c739b26b..ff708b7f4ef 100644
--- a/src/rustc/middle/region.rs
+++ b/src/rustc/middle/region.rs
@@ -141,7 +141,7 @@ fn nearest_common_ancestor(region_map: region_map, scope_a: ast::node_id,
             match region_map.find(scope) {
                 None => return result,
                 Some(superscope) => {
-                    vec::push(result, superscope);
+                    result.push(superscope);
                     scope = superscope;
                 }
             }
diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs
index 7380a217ebe..99d98c52f95 100644
--- a/src/rustc/middle/resolve.rs
+++ b/src/rustc/middle/resolve.rs
@@ -2897,7 +2897,7 @@ impl Resolver {
                            if reexport { ~"reexport" } else { ~"export"},
                            self.session.str_of(ident),
                            def_id_of_def(d.def));
-                    vec::push(*exports2,  Export2 {
+                    exports2.push(Export2 {
                         reexport: reexport,
                         name: self.session.str_of(ident),
                         def_id: def_id_of_def(d.def)
@@ -2949,7 +2949,7 @@ impl Resolver {
                                 for %?",
                                self.session.str_of(name),
                                module_.def_id);
-                        vec::push(*exports2, Export2 {
+                        exports2.push(Export2 {
                             reexport: false,
                             name: self.session.str_of(name),
                             def_id: def_id_of_def(target_def)
@@ -2960,7 +2960,7 @@ impl Resolver {
                                 %?",
                                self.session.str_of(name),
                                module_.def_id);
-                        vec::push(*exports2, Export2 {
+                        exports2.push(Export2 {
                             reexport: true,
                             name: self.session.str_of(name),
                             def_id: def_id_of_def(target_def)
diff --git a/src/rustc/middle/trans/alt.rs b/src/rustc/middle/trans/alt.rs
index 11b694bcb1d..165ca8e2fc4 100644
--- a/src/rustc/middle/trans/alt.rs
+++ b/src/rustc/middle/trans/alt.rs
@@ -305,7 +305,7 @@ fn enter_match(bcx: block, dm: DefMap, m: &[@Match/&r],
                     _ => {}
                 }
 
-                vec::push(result, @Match {pats: pats, data: br.data});
+                result.push(@Match {pats: pats, data: br.data});
             }
             None => ()
         }
@@ -398,8 +398,8 @@ fn enter_rec_or_struct(bcx: block, dm: DefMap, m: &[@Match/&r], col: uint,
                 let mut pats = ~[];
                 for vec::each(fields) |fname| {
                     match fpats.find(|p| p.ident == *fname) {
-                        None => vec::push(pats, dummy),
-                        Some(pat) => vec::push(pats, pat.pat)
+                        None => pats.push(dummy),
+                        Some(pat) => pats.push(pat.pat)
                     }
                 }
                 Some(pats)
@@ -582,7 +582,7 @@ fn collect_record_or_struct_fields(m: &[@Match], col: uint) -> ~[ast::ident] {
         for field_pats.each |field_pat| {
             let field_ident = field_pat.ident;
             if !vec::any(*idents, |x| x == field_ident) {
-                vec::push(*idents, field_ident);
+                idents.push(field_ident);
             }
         }
     }
@@ -1162,9 +1162,9 @@ fn trans_alt_inner(scope_cx: block,
         let arm_data = @ArmData {bodycx: body,
                                  arm: arm,
                                  bindings_map: bindings_map};
-        vec::push(arm_datas, arm_data);
+        arm_datas.push(arm_data);
         for vec::each(arm.pats) |p| {
-            vec::push(matches, @Match {pats: ~[*p], data: arm_data});
+            matches.push(@Match {pats: ~[*p], data: arm_data});
         }
     }
 
diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs
index b29fac0fa2f..94b09a30e4b 100644
--- a/src/rustc/middle/trans/base.rs
+++ b/src/rustc/middle/trans/base.rs
@@ -76,7 +76,7 @@ impl @crate_ctxt: get_insn_ctxt {
     fn insn_ctxt(s: &str) -> icx_popper {
         debug!("new insn_ctxt: %s", s);
         if self.sess.count_llvm_insns() {
-            vec::push(*self.stats.llvm_insn_ctxt, str::from_slice(s));
+            self.stats.llvm_insn_ctxt.push(str::from_slice(s));
         }
         icx_popper(self)
     }
@@ -98,7 +98,7 @@ fn log_fn_time(ccx: @crate_ctxt, name: ~str, start: time::Timespec,
                end: time::Timespec) {
     let elapsed = 1000 * ((end.sec - start.sec) as int) +
         ((end.nsec as int) - (start.nsec as int)) / 1000000;
-    vec::push(*ccx.stats.fn_times, {ident: name, time: elapsed});
+    ccx.stats.fn_times.push({ident: name, time: elapsed});
 }
 
 fn decl_fn(llmod: ModuleRef, name: ~str, cc: lib::llvm::CallConv,
@@ -1153,7 +1153,7 @@ fn cleanup_and_leave(bcx: block, upto: Option<BasicBlockRef>,
             }
             let sub_cx = sub_block(bcx, ~"cleanup");
             Br(bcx, sub_cx.llbb);
-            vec::push(inf.cleanup_paths, {target: leave, dest: sub_cx.llbb});
+            inf.cleanup_paths.push({target: leave, dest: sub_cx.llbb});
             bcx = trans_block_cleanups_(sub_cx, block_cleanups(cur), is_lpad);
           }
           _ => ()
@@ -2001,7 +2001,7 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef,
         let llenvarg = llvm::LLVMGetParam(llfdecl, 1 as c_uint);
         let mut args = ~[lloutputarg, llenvarg];
         if takes_argv {
-            vec::push(args, llvm::LLVMGetParam(llfdecl, 2 as c_uint));
+            args.push(llvm::LLVMGetParam(llfdecl, 2 as c_uint));
         }
         Call(bcx, main_llfn, args);
 
@@ -2451,10 +2451,10 @@ fn create_module_map(ccx: @crate_ctxt) -> ValueRef {
     for ccx.module_data.each |key, val| {
         let elt = C_struct(~[p2i(ccx, C_cstr(ccx, key)),
                             p2i(ccx, val)]);
-        vec::push(elts, elt);
+        elts.push(elt);
     }
     let term = C_struct(~[C_int(ccx, 0), C_int(ccx, 0)]);
-    vec::push(elts, term);
+    elts.push(term);
     llvm::LLVMSetInitializer(map, C_array(elttype, elts));
     return map;
 }
@@ -2492,10 +2492,10 @@ fn fill_crate_map(ccx: @crate_ctxt, map: ValueRef) {
         let cr = str::as_c_str(nm, |buf| {
             llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type, buf)
         });
-        vec::push(subcrates, p2i(ccx, cr));
+        subcrates.push(p2i(ccx, cr));
         i += 1;
     }
-    vec::push(subcrates, C_int(ccx, 0));
+    subcrates.push(C_int(ccx, 0));
 
     let llannihilatefn;
     let annihilate_def_id = ccx.tcx.lang_items.annihilate_fn.get();
diff --git a/src/rustc/middle/trans/build.rs b/src/rustc/middle/trans/build.rs
index 865374054e6..070132b4b18 100644
--- a/src/rustc/middle/trans/build.rs
+++ b/src/rustc/middle/trans/build.rs
@@ -435,7 +435,7 @@ fn GEP(cx: block, Pointer: ValueRef, Indices: ~[ValueRef]) -> ValueRef {
 // XXX: Use a small-vector optimization to avoid allocations here.
 fn GEPi(cx: block, base: ValueRef, ixs: &[uint]) -> ValueRef {
     let mut v: ~[ValueRef] = ~[];
-    for vec::each(ixs) |i| { vec::push(v, C_i32(*i as i32)); }
+    for vec::each(ixs) |i| { v.push(C_i32(*i as i32)); }
     count_insn(cx, "gepi");
     return InBoundsGEP(cx, base, v);
 }
diff --git a/src/rustc/middle/trans/callee.rs b/src/rustc/middle/trans/callee.rs
index 3050297b360..470d4dbb4ab 100644
--- a/src/rustc/middle/trans/callee.rs
+++ b/src/rustc/middle/trans/callee.rs
@@ -478,10 +478,10 @@ fn trans_args(cx: block, llenv: ValueRef, args: CallArgs, fn_ty: ty::t,
             }
         }
     };
-    vec::push(llargs, llretslot);
+    llargs.push(llretslot);
 
     // Arg 1: Env (closure-bindings / self value)
-    vec::push(llargs, llenv);
+    llargs.push(llenv);
 
     // ... then explicit args.
 
@@ -497,11 +497,11 @@ fn trans_args(cx: block, llenv: ValueRef, args: CallArgs, fn_ty: ty::t,
                                if i == last { ret_flag } else { None },
                                autoref_arg)
             });
-            vec::push(llargs, arg_val);
+            llargs.push(arg_val);
         }
       }
       ArgVals(vs) => {
-        vec::push_all(llargs, vs);
+        llargs.push_all(vs);
       }
     }
 
@@ -622,7 +622,7 @@ fn trans_arg_expr(bcx: block,
                         // However, we must cleanup should we fail before the
                         // callee is actually invoked.
                         scratch.add_clean(bcx);
-                        vec::push(*temp_cleanups, scratch.val);
+                        temp_cleanups.push(scratch.val);
 
                         match arg_datum.appropriate_mode() {
                             ByValue => {
diff --git a/src/rustc/middle/trans/closure.rs b/src/rustc/middle/trans/closure.rs
index 38526c223a1..7b071866136 100644
--- a/src/rustc/middle/trans/closure.rs
+++ b/src/rustc/middle/trans/closure.rs
@@ -259,16 +259,16 @@ fn build_closure(bcx0: block,
         match cap_var.mode {
             capture::cap_ref => {
                 assert ck == ty::ck_block;
-                vec::push(env_vals, EnvValue {action: EnvRef,
-                                              datum: datum});
+                env_vals.push(EnvValue {action: EnvRef,
+                                        datum: datum});
             }
             capture::cap_copy => {
-                vec::push(env_vals, EnvValue {action: EnvStore,
-                                              datum: datum});
+                env_vals.push(EnvValue {action: EnvStore,
+                                        datum: datum});
             }
             capture::cap_move => {
-                vec::push(env_vals, EnvValue {action: EnvMove,
-                                              datum: datum});
+                env_vals.push(EnvValue {action: EnvMove,
+                                        datum: datum});
             }
             capture::cap_drop => {
                 bcx = datum.drop_val(bcx);
@@ -283,8 +283,8 @@ fn build_closure(bcx0: block,
         // Flag indicating we have returned (a by-ref bool):
         let flag_datum = Datum {val: flagptr, ty: ty::mk_bool(tcx),
                                 mode: ByRef, source: FromLvalue};
-        vec::push(env_vals, EnvValue {action: EnvRef,
-                                      datum: flag_datum});
+        env_vals.push(EnvValue {action: EnvRef,
+                                datum: flag_datum});
 
         // Return value (we just pass a by-ref () and cast it later to
         // the right thing):
@@ -295,8 +295,8 @@ fn build_closure(bcx0: block,
         let ret_casted = PointerCast(bcx, ret_true, T_ptr(T_nil()));
         let ret_datum = Datum {val: ret_casted, ty: ty::mk_nil(tcx),
                                mode: ByRef, source: FromLvalue};
-        vec::push(env_vals, EnvValue {action: EnvRef,
-                                      datum: ret_datum});
+        env_vals.push(EnvValue {action: EnvRef,
+                                datum: ret_datum});
     }
 
     return store_environment(bcx, env_vals, ck);
diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs
index fc74e5e0e4d..0df63e40acf 100644
--- a/src/rustc/middle/trans/common.rs
+++ b/src/rustc/middle/trans/common.rs
@@ -348,9 +348,9 @@ fn add_clean(bcx: block, val: ValueRef, t: ty::t) {
     let {root, rooted} = root_for_cleanup(bcx, val, t);
     let cleanup_type = cleanup_type(bcx.tcx(), t);
     do in_scope_cx(bcx) |info| {
-        vec::push(info.cleanups,
-                  clean(|a| glue::drop_ty_root(a, root, rooted, t),
-                        cleanup_type));
+        info.cleanups.push(
+            clean(|a| glue::drop_ty_root(a, root, rooted, t),
+                  cleanup_type));
         scope_clean_changed(info);
     }
 }
@@ -362,9 +362,9 @@ fn add_clean_temp_immediate(cx: block, val: ValueRef, ty: ty::t) {
            ty_to_str(cx.ccx().tcx, ty));
     let cleanup_type = cleanup_type(cx.tcx(), ty);
     do in_scope_cx(cx) |info| {
-        vec::push(info.cleanups,
-                  clean_temp(val, |a| glue::drop_ty_immediate(a, val, ty),
-                             cleanup_type));
+        info.cleanups.push(
+            clean_temp(val, |a| glue::drop_ty_immediate(a, val, ty),
+                       cleanup_type));
         scope_clean_changed(info);
     }
 }
@@ -376,9 +376,9 @@ fn add_clean_temp_mem(bcx: block, val: ValueRef, t: ty::t) {
     let {root, rooted} = root_for_cleanup(bcx, val, t);
     let cleanup_type = cleanup_type(bcx.tcx(), t);
     do in_scope_cx(bcx) |info| {
-        vec::push(info.cleanups,
-                  clean_temp(val, |a| glue::drop_ty_root(a, root, rooted, t),
-                             cleanup_type));
+        info.cleanups.push(
+            clean_temp(val, |a| glue::drop_ty_root(a, root, rooted, t),
+                       cleanup_type));
         scope_clean_changed(info);
     }
 }
@@ -388,8 +388,8 @@ fn add_clean_free(cx: block, ptr: ValueRef, heap: heap) {
       heap_exchange => |a| glue::trans_unique_free(a, ptr)
     };
     do in_scope_cx(cx) |info| {
-        vec::push(info.cleanups, clean_temp(ptr, free_fn,
-                                     normal_exit_and_unwind));
+        info.cleanups.push(clean_temp(ptr, free_fn,
+                                      normal_exit_and_unwind));
         scope_clean_changed(info);
     }
 }
@@ -1050,7 +1050,7 @@ fn C_postr(s: ~str) -> ValueRef {
 fn C_zero_byte_arr(size: uint) -> ValueRef unsafe {
     let mut i = 0u;
     let mut elts: ~[ValueRef] = ~[];
-    while i < size { vec::push(elts, C_u8(0u)); i += 1u; }
+    while i < size { elts.push(C_u8(0u)); i += 1u; }
     return llvm::LLVMConstArray(T_i8(), vec::raw::to_ptr(elts),
                              elts.len() as c_uint);
 }
diff --git a/src/rustc/middle/trans/debuginfo.rs b/src/rustc/middle/trans/debuginfo.rs
index 26a83951c01..6cd4b49fa3b 100644
--- a/src/rustc/middle/trans/debuginfo.rs
+++ b/src/rustc/middle/trans/debuginfo.rs
@@ -383,7 +383,7 @@ fn create_derived_type(type_tag: int, file: ValueRef, name: ~str, line: int,
 
 fn add_member(cx: @struct_ctxt, name: ~str, line: int, size: int, align: int,
               ty: ValueRef) {
-    vec::push(cx.members, create_derived_type(MemberTag, cx.file, name, line,
+    cx.members.push(create_derived_type(MemberTag, cx.file, name, line,
                                        size * 8, align * 8, cx.total_size,
                                        ty));
     cx.total_size += size * 8;
@@ -529,7 +529,7 @@ fn create_ty(_cx: @crate_ctxt, _t: ty::t, _ty: @ast::ty)
           ty::ty_rec(fields) {
             let fs = ~[];
             for field in fields {
-                vec::push(fs, {node: {ident: field.ident,
+                fs.push({node: {ident: field.ident,
                                mt: {ty: t_to_ty(cx, field.mt.ty, span),
                                     mutbl: field.mt.mutbl}},
                         span: span});
diff --git a/src/rustc/middle/trans/expr.rs b/src/rustc/middle/trans/expr.rs
index 17a1ff112cd..dafaebef9e0 100644
--- a/src/rustc/middle/trans/expr.rs
+++ b/src/rustc/middle/trans/expr.rs
@@ -993,7 +993,7 @@ fn trans_rec_or_struct(bcx: block,
             let dest = GEPi(bcx, addr, struct_field(ix));
             bcx = trans_into(bcx, field.node.expr, SaveIn(dest));
             add_clean_temp_mem(bcx, dest, field_tys[ix].mt.ty);
-            vec::push(temp_cleanups, dest);
+            temp_cleanups.push(dest);
         }
 
         // copy over any remaining fields from the base (for
@@ -1046,7 +1046,7 @@ fn trans_tup(bcx: block, elts: ~[@ast::expr], dest: Dest) -> block {
         let e_ty = expr_ty(bcx, *e);
         bcx = trans_into(bcx, *e, SaveIn(dest));
         add_clean_temp_mem(bcx, dest, e_ty);
-        vec::push(temp_cleanups, dest);
+        temp_cleanups.push(dest);
     }
     for vec::each(temp_cleanups) |cleanup| {
         revoke_clean(bcx, *cleanup);
diff --git a/src/rustc/middle/trans/foreign.rs b/src/rustc/middle/trans/foreign.rs
index e775b3fd746..f1077912fec 100644
--- a/src/rustc/middle/trans/foreign.rs
+++ b/src/rustc/middle/trans/foreign.rs
@@ -297,21 +297,21 @@ fn llreg_ty(cls: ~[x86_64_reg_class]) -> TypeRef {
     while i < e {
         match cls[i] {
             integer_class => {
-                vec::push(tys, T_i64());
+                tys.push(T_i64());
             }
             sse_fv_class => {
                 let vec_len = llvec_len(vec::tailn(cls, i + 1u)) * 2u;
                 let vec_ty = llvm::LLVMVectorType(T_f32(),
                                                   vec_len as c_uint);
-                vec::push(tys, vec_ty);
+                tys.push(vec_ty);
                 i += vec_len;
                 loop;
             }
             sse_fs_class => {
-                vec::push(tys, T_f32());
+                tys.push(T_f32());
             }
             sse_ds_class => {
-                vec::push(tys, T_f64());
+                tys.push(T_f64());
             }
             _ => fail ~"llregtype: unhandled class"
         }
@@ -378,8 +378,8 @@ fn x86_64_tys(atys: ~[TypeRef],
     let mut attrs = ~[];
     for vec::each(atys) |t| {
         let (ty, attr) = x86_64_ty(*t, is_pass_byval, ByValAttribute);
-        vec::push(arg_tys, ty);
-        vec::push(attrs, attr);
+        arg_tys.push(ty);
+        attrs.push(attr);
     }
     let mut (ret_ty, ret_attr) = x86_64_ty(rty, is_ret_bysret,
                                        StructRetAttribute);
@@ -619,7 +619,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt,
                         } else {
                             load_inbounds(bcx, llargbundle, [0u, i])
                         };
-                        vec::push(llargvals, llargval);
+                        llargvals.push(llargval);
                         i += 1u;
                     }
                 }
@@ -627,7 +627,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt,
                     while i < n {
                         let llargval = load_inbounds(bcx, llargbundle,
                                                           [0u, i]);
-                        vec::push(llargvals, llargval);
+                        llargvals.push(llargval);
                         i += 1u;
                     }
                 }
@@ -1041,12 +1041,12 @@ fn trans_foreign_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl,
             let mut i = 0u;
             let n = vec::len(tys.arg_tys);
             let llretptr = load_inbounds(bcx, llargbundle, ~[0u, n]);
-            vec::push(llargvals, llretptr);
+            llargvals.push(llretptr);
             let llenvptr = C_null(T_opaque_box_ptr(bcx.ccx()));
-            vec::push(llargvals, llenvptr);
+            llargvals.push(llenvptr);
             while i < n {
                 let llargval = load_inbounds(bcx, llargbundle, ~[0u, i]);
-                vec::push(llargvals, llargval);
+                llargvals.push(llargval);
                 i += 1u;
             }
             return llargvals;
diff --git a/src/rustc/middle/trans/monomorphize.rs b/src/rustc/middle/trans/monomorphize.rs
index 8a68ef4823b..40558e72c80 100644
--- a/src/rustc/middle/trans/monomorphize.rs
+++ b/src/rustc/middle/trans/monomorphize.rs
@@ -246,7 +246,7 @@ fn make_mono_id(ccx: @crate_ctxt, item: ast::def_id, substs: ~[ty::t],
             for vec::each(*bounds) |bound| {
                 match *bound {
                   ty::bound_trait(_) => {
-                    vec::push(v, meth::vtable_id(ccx, vts[i]));
+                    v.push(meth::vtable_id(ccx, vts[i]));
                     i += 1u;
                   }
                   _ => ()
diff --git a/src/rustc/middle/trans/tvec.rs b/src/rustc/middle/trans/tvec.rs
index 10f93626280..e1eae115694 100644
--- a/src/rustc/middle/trans/tvec.rs
+++ b/src/rustc/middle/trans/tvec.rs
@@ -332,7 +332,7 @@ fn write_content(bcx: block,
                         bcx = expr::trans_into(bcx, *element,
                                                SaveIn(lleltptr));
                         add_clean_temp_mem(bcx, lleltptr, vt.unit_ty);
-                        vec::push(temp_cleanups, lleltptr);
+                        temp_cleanups.push(lleltptr);
                     }
                     for vec::each(temp_cleanups) |cleanup| {
                         revoke_clean(bcx, *cleanup);
@@ -369,7 +369,7 @@ fn write_content(bcx: block,
                             bcx = tmpdatum.move_to(bcx, INIT, lleltptr);
                         }
                         add_clean_temp_mem(bcx, lleltptr, vt.unit_ty);
-                        vec::push(temp_cleanups, lleltptr);
+                        temp_cleanups.push(lleltptr);
                     }
 
                     for vec::each(temp_cleanups) |cleanup| {
diff --git a/src/rustc/middle/trans/type_of.rs b/src/rustc/middle/trans/type_of.rs
index d9032f8ce90..99555d5b294 100644
--- a/src/rustc/middle/trans/type_of.rs
+++ b/src/rustc/middle/trans/type_of.rs
@@ -39,13 +39,13 @@ fn type_of_fn(cx: @crate_ctxt, inputs: ~[ty::arg],
     let mut atys: ~[TypeRef] = ~[];
 
     // Arg 0: Output pointer.
-    vec::push(atys, T_ptr(type_of(cx, output)));
+    atys.push(T_ptr(type_of(cx, output)));
 
     // Arg 1: Environment
-    vec::push(atys, T_opaque_box_ptr(cx));
+    atys.push(T_opaque_box_ptr(cx));
 
     // ... then explicit args.
-    vec::push_all(atys, type_of_explicit_args(cx, inputs));
+    atys.push_all(type_of_explicit_args(cx, inputs));
     return T_fn(atys, llvm::LLVMVoidType());
 }
 
@@ -151,7 +151,7 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
         let mut tys: ~[TypeRef] = ~[];
         for vec::each(fields) |f| {
             let mt_ty = f.mt.ty;
-            vec::push(tys, type_of(cx, mt_ty));
+            tys.push(type_of(cx, mt_ty));
         }
 
         // n.b.: introduce an extra layer of indirection to match
@@ -164,7 +164,7 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
       ty::ty_tup(elts) => {
         let mut tys = ~[];
         for vec::each(elts) |elt| {
-            vec::push(tys, type_of(cx, *elt));
+            tys.push(type_of(cx, *elt));
         }
         T_struct(tys)
       }
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index f256b4b76cd..ed71d27451c 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -2243,10 +2243,10 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
           }
 
           ty_class(did, ref substs) => {
-            vec::push(*seen, did);
-            let r = vec::any(class_items_as_fields(cx, did, substs),
-                             |f| type_requires(cx, seen, r_ty, f.mt.ty));
-            vec::pop(*seen);
+              seen.push(did);
+              let r = vec::any(class_items_as_fields(cx, did, substs),
+                               |f| type_requires(cx, seen, r_ty, f.mt.ty));
+              vec::pop(*seen);
             r
           }
 
@@ -2258,18 +2258,18 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
             false
           }
 
-          ty_enum(did, ref substs) => {
-            vec::push(*seen, did);
-            let vs = enum_variants(cx, did);
-            let r = vec::len(*vs) > 0u && vec::all(*vs, |variant| {
-                vec::any(variant.args, |aty| {
-                    let sty = subst(cx, substs, aty);
-                    type_requires(cx, seen, r_ty, sty)
-                })
-            });
-            vec::pop(*seen);
-            r
-          }
+            ty_enum(did, ref substs) => {
+                seen.push(did);
+                let vs = enum_variants(cx, did);
+                let r = vec::len(*vs) > 0u && vec::all(*vs, |variant| {
+                    vec::any(variant.args, |aty| {
+                        let sty = subst(cx, substs, aty);
+                        type_requires(cx, seen, r_ty, sty)
+                    })
+                });
+                vec::pop(*seen);
+                r
+            }
         };
 
         debug!("subtypes_require(%s, %s)? %b",
@@ -3036,7 +3036,7 @@ fn param_tys_in_type(ty: t) -> ~[param_ty] {
     do walk_ty(ty) |ty| {
         match get(ty).sty {
           ty_param(p) => {
-            vec::push(rslt, p);
+            rslt.push(p);
           }
           _ => ()
         }
@@ -3052,7 +3052,7 @@ fn occurs_check(tcx: ctxt, sp: span, vid: TyVid, rt: t) {
         let mut rslt = ~[];
         do walk_ty(ty) |ty| {
             match get(ty).sty {
-              ty_infer(TyVar(v)) => vec::push(rslt, v),
+              ty_infer(TyVar(v)) => rslt.push(v),
               _ => ()
             }
         }
@@ -3704,10 +3704,10 @@ fn class_field_tys(fields: ~[@struct_field]) -> ~[field_ty] {
     for fields.each |field| {
         match field.node.kind {
             named_field(ident, mutability, visibility) => {
-                vec::push(rslt, {ident: ident,
-                                 id: ast_util::local_def(field.node.id),
-                                 vis: visibility,
-                                 mutability: mutability});
+                rslt.push({ident: ident,
+                           id: ast_util::local_def(field.node.id),
+                           vis: visibility,
+                           mutability: mutability});
             }
             unnamed_field => {}
        }
@@ -3747,7 +3747,7 @@ fn class_item_fields(cx:ctxt,
     for lookup_class_fields(cx, did).each |f| {
        // consider all instance vars mut, because the
        // constructor may mutate all vars
-       vec::push(rslt, {ident: f.ident, mt:
+       rslt.push({ident: f.ident, mt:
                {ty: lookup_field_type(cx, did, f.id, substs),
                     mutbl: frob_mutability(f.mutability)}});
     }
diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs
index 8d2384cd530..bc7711c059b 100644
--- a/src/rustc/middle/typeck/check.rs
+++ b/src/rustc/middle/typeck/check.rs
@@ -818,7 +818,7 @@ fn do_autoderef(fcx: @fn_ctxt, sp: span, t: ty::t) -> (ty::t, uint) {
                 if vec::contains(enum_dids, did) {
                     return (t1, autoderefs);
                 }
-                vec::push(enum_dids, did);
+                enum_dids.push(did);
             }
             _ => { /*ok*/ }
         }
@@ -2029,8 +2029,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
                         let name = class_field.ident;
                         let (_, seen) = class_field_map.get(name);
                         if !seen {
-                            vec::push(missing_fields,
-                                      ~"`" + tcx.sess.str_of(name) + ~"`");
+                            missing_fields.push(
+                                ~"`" + tcx.sess.str_of(name) + ~"`");
                         }
                     }
 
@@ -2298,7 +2298,7 @@ fn check_enum_variants(ccx: @crate_ctxt,
                 ccx.tcx.sess.span_err(v.span,
                                       ~"discriminator value already exists");
             }
-            vec::push(*disr_vals, *disr_val);
+            disr_vals.push(*disr_val);
             let ctor_ty = ty::node_id_to_type(ccx.tcx, v.node.id);
             let arg_tys;
 
@@ -2321,7 +2321,8 @@ fn check_enum_variants(ccx: @crate_ctxt,
             match arg_tys {
                 None => {}
                 Some(arg_tys) => {
-                    vec::push(*variants, @{args: arg_tys, ctor_ty: ctor_ty,
+                    variants.push(
+                        @{args: arg_tys, ctor_ty: ctor_ty,
                           name: v.node.name, id: local_def(v.node.id),
                           disr_val: this_disr_val});
                 }
diff --git a/src/rustc/middle/typeck/check/regionmanip.rs b/src/rustc/middle/typeck/check/regionmanip.rs
index d969ce908f0..aec42f77048 100644
--- a/src/rustc/middle/typeck/check/regionmanip.rs
+++ b/src/rustc/middle/typeck/check/regionmanip.rs
@@ -27,13 +27,13 @@ fn replace_bound_regions_in_fn_ty(
         let region = ty::re_bound(ty::br_self);
         let ty = ty::mk_rptr(tcx, region,
                              { ty: ty::mk_self(tcx), mutbl: m });
-        vec::push(all_tys, ty);
+        all_tys.push(ty);
       }
       _ => {}
     }
 
 
-    for self_ty.each |t| { vec::push(all_tys, *t) }
+    for self_ty.each |t| { all_tys.push(*t) }
 
     debug!("replace_bound_regions_in_fn_ty(self_info.self_ty=%?, fn_ty=%s, \
                 all_tys=%?)",
diff --git a/src/rustc/middle/typeck/check/vtable.rs b/src/rustc/middle/typeck/check/vtable.rs
index d48f5b9c070..453559e5e42 100644
--- a/src/rustc/middle/typeck/check/vtable.rs
+++ b/src/rustc/middle/typeck/check/vtable.rs
@@ -51,8 +51,8 @@ fn lookup_vtables(fcx: @fn_ctxt,
             match *bound {
               ty::bound_trait(i_ty) => {
                 let i_ty = ty::subst(tcx, substs, i_ty);
-                vec::push(result, lookup_vtable(fcx, expr, *ty, i_ty,
-                                                allow_unsafe, is_early));
+                result.push(lookup_vtable(fcx, expr, *ty, i_ty,
+                                          allow_unsafe, is_early));
               }
               _ => ()
             }
@@ -331,9 +331,9 @@ fn lookup_vtable(fcx: @fn_ctxt,
                             // the impl as well as the resolved list
                             // of type substitutions for the target
                             // trait.
-                            vec::push(found,
-                                      vtable_static(im.did, substs_f.tps,
-                                                    subres));
+                            found.push(
+                                vtable_static(im.did, substs_f.tps,
+                                              subres));
                         }
                     }
                 }
diff --git a/src/rustc/middle/typeck/check/writeback.rs b/src/rustc/middle/typeck/check/writeback.rs
index a70e5f600d3..33a26c8daf4 100644
--- a/src/rustc/middle/typeck/check/writeback.rs
+++ b/src/rustc/middle/typeck/check/writeback.rs
@@ -94,7 +94,7 @@ fn resolve_type_vars_for_node(wbcx: wb_ctxt, sp: span, id: ast::node_id)
             let mut new_tps = ~[];
             for substs.tps.each |subst| {
                 match resolve_type_vars_in_type(fcx, sp, *subst) {
-                  Some(t) => vec::push(new_tps, t),
+                  Some(t) => new_tps.push(t),
                   None => { wbcx.success = false; return None; }
                 }
             }
diff --git a/src/rustc/middle/typeck/coherence.rs b/src/rustc/middle/typeck/coherence.rs
index 77c665755c3..907cdb4f5ec 100644
--- a/src/rustc/middle/typeck/coherence.rs
+++ b/src/rustc/middle/typeck/coherence.rs
@@ -198,7 +198,7 @@ impl CoherenceChecker {
                                               existing trait",
                                               sess.str_of(mi.ident));
                                       let mut method_infos = mis;
-                                      push(method_infos, mi);
+                                      method_infos.push(mi);
                                       pmm.insert(item.id, method_infos);
                                     }
                                     None => {
@@ -547,7 +547,7 @@ impl CoherenceChecker {
                     debug!(
                         "(creating impl) adding provided method `%s` to impl",
                         sess.str_of(provided_method.ident));
-                    push(methods, *provided_method);
+                    methods.push(*provided_method);
                 }
             }
 
@@ -559,8 +559,7 @@ impl CoherenceChecker {
                 let mut methods = ~[];
 
                 for ast_methods.each |ast_method| {
-                    push(methods,
-                         method_to_MethodInfo(*ast_method));
+                    methods.push(method_to_MethodInfo(*ast_method));
                 }
 
                 // For each trait that the impl implements, see what
@@ -619,7 +618,7 @@ impl CoherenceChecker {
                             -> @Impl {
         let mut methods = ~[];
         for struct_def.methods.each |ast_method| {
-            push(methods, @{
+            methods.push(@{
                 did: local_def(ast_method.id),
                 n_tps: ast_method.tps.len(),
                 ident: ast_method.ident,
diff --git a/src/rustc/middle/typeck/infer/region_var_bindings.rs b/src/rustc/middle/typeck/infer/region_var_bindings.rs
index c0312872488..8eabb2c0787 100644
--- a/src/rustc/middle/typeck/infer/region_var_bindings.rs
+++ b/src/rustc/middle/typeck/infer/region_var_bindings.rs
@@ -830,7 +830,7 @@ impl RegionVarBindings {
         // It would be nice to write this using map():
         let mut edges = vec::with_capacity(num_edges);
         for self.constraints.each_ref |constraint, span| {
-            vec::push(edges, GraphEdge {
+            edges.push(GraphEdge {
                 next_edge: [mut uint::max_value, uint::max_value],
                 constraint: *constraint,
                 span: *span
@@ -1201,13 +1201,13 @@ impl RegionVarBindings {
                       Outgoing => to_vid
                     };
                     if set.insert(*vid, ()) {
-                        vec::push(stack, vid);
+                        stack.push(vid);
                     }
                   }
 
                   ConstrainRegSubVar(region, _) => {
                     assert dir == Incoming;
-                    vec::push(result, SpannedRegion {
+                    result.push(SpannedRegion {
                         region: region,
                         span: edge.span
                     });
@@ -1215,7 +1215,7 @@ impl RegionVarBindings {
 
                   ConstrainVarSubReg(_, region) => {
                     assert dir == Outgoing;
-                    vec::push(result, SpannedRegion {
+                    result.push(SpannedRegion {
                         region: region,
                         span: edge.span
                     });
diff --git a/src/rustc/middle/typeck/infer/resolve.rs b/src/rustc/middle/typeck/infer/resolve.rs
index 5d748efc332..a366a2ef1c7 100644
--- a/src/rustc/middle/typeck/infer/resolve.rs
+++ b/src/rustc/middle/typeck/infer/resolve.rs
@@ -174,7 +174,7 @@ impl resolve_state {
             self.err = Some(cyclic_ty(vid));
             return ty::mk_var(self.infcx.tcx, vid);
         } else {
-            vec::push(self.v_seen, vid);
+            self.v_seen.push(vid);
             let tcx = self.infcx.tcx;
 
             // Nonobvious: prefer the most specific type
diff --git a/src/rustc/middle/typeck/infer/unify.rs b/src/rustc/middle/typeck/infer/unify.rs
index 500a4d5b419..7ccbaa40ada 100644
--- a/src/rustc/middle/typeck/infer/unify.rs
+++ b/src/rustc/middle/typeck/infer/unify.rs
@@ -51,7 +51,7 @@ impl infer_ctxt {
         +new_v: var_value<V, T>) {
 
         let old_v = vb.vals.get(vid.to_uint());
-        vec::push(vb.bindings, (vid, old_v));
+        vb.bindings.push((vid, old_v));
         vb.vals.insert(vid.to_uint(), new_v);
 
         debug!("Updating variable %s from %s to %s",
diff --git a/src/rustc/util/common.rs b/src/rustc/util/common.rs
index 4c033515b9a..37cc016e8ea 100644
--- a/src/rustc/util/common.rs
+++ b/src/rustc/util/common.rs
@@ -36,7 +36,7 @@ fn field_expr(f: ast::field) -> @ast::expr { return f.node.expr; }
 
 fn field_exprs(fields: ~[ast::field]) -> ~[@ast::expr] {
     let mut es = ~[];
-    for fields.each |f| { vec::push(es, f.node.expr); }
+    for fields.each |f| { es.push(f.node.expr); }
     return es;
 }
 
diff --git a/src/rustc/util/ppaux.rs b/src/rustc/util/ppaux.rs
index 0498a0f9541..0df5827ed3d 100644
--- a/src/rustc/util/ppaux.rs
+++ b/src/rustc/util/ppaux.rs
@@ -286,7 +286,7 @@ fn ty_to_str(cx: ctxt, typ: t) -> ~str {
         }
         s += ~"(";
         let mut strs = ~[];
-        for inputs.each |a| { vec::push(strs, fn_input_to_str(cx, *a)); }
+        for inputs.each |a| { strs.push(fn_input_to_str(cx, *a)); }
         s += str::connect(strs, ~", ");
         s += ~")";
         if ty::get(output).sty != ty_nil {
@@ -342,12 +342,12 @@ fn ty_to_str(cx: ctxt, typ: t) -> ~str {
       ty_type => ~"type",
       ty_rec(elems) => {
         let mut strs: ~[~str] = ~[];
-        for elems.each |fld| { vec::push(strs, field_to_str(cx, *fld)); }
+        for elems.each |fld| { strs.push(field_to_str(cx, *fld)); }
         ~"{" + str::connect(strs, ~",") + ~"}"
       }
       ty_tup(elems) => {
         let mut strs = ~[];
-        for elems.each |elem| { vec::push(strs, ty_to_str(cx, *elem)); }
+        for elems.each |elem| { strs.push(ty_to_str(cx, *elem)); }
         ~"(" + str::connect(strs, ~",") + ~")"
       }
       ty_fn(ref f) => {
diff --git a/src/rustdoc/extract.rs b/src/rustdoc/extract.rs
index 448e699fc8d..7b34a327bee 100644
--- a/src/rustdoc/extract.rs
+++ b/src/rustdoc/extract.rs
@@ -140,7 +140,7 @@ fn nmoddoc_from_mod(
         let ItemDoc = mk_itemdoc(item.id, to_str(item.ident));
         match item.node {
           ast::foreign_item_fn(*) => {
-            vec::push(fns, fndoc_from_fn(ItemDoc));
+            fns.push(fndoc_from_fn(ItemDoc));
           }
           ast::foreign_item_const(*) => {} // XXX: Not implemented.
         }
diff --git a/src/rustdoc/path_pass.rs b/src/rustdoc/path_pass.rs
index 84b542f6bf0..96ed269a7e9 100644
--- a/src/rustdoc/path_pass.rs
+++ b/src/rustdoc/path_pass.rs
@@ -43,7 +43,7 @@ fn fold_item(fold: fold::Fold<Ctxt>, doc: doc::ItemDoc) -> doc::ItemDoc {
 fn fold_mod(fold: fold::Fold<Ctxt>, doc: doc::ModDoc) -> doc::ModDoc {
     let is_topmod = doc.id() == ast::crate_node_id;
 
-    if !is_topmod { vec::push(fold.ctxt.path, doc.name()); }
+    if !is_topmod { fold.ctxt.path.push(doc.name()); }
     let doc = fold::default_any_fold_mod(fold, doc);
     if !is_topmod { vec::pop(fold.ctxt.path); }
 
@@ -54,7 +54,7 @@ fn fold_mod(fold: fold::Fold<Ctxt>, doc: doc::ModDoc) -> doc::ModDoc {
 }
 
 fn fold_nmod(fold: fold::Fold<Ctxt>, doc: doc::NmodDoc) -> doc::NmodDoc {
-    vec::push(fold.ctxt.path, doc.name());
+    fold.ctxt.path.push(doc.name());
     let doc = fold::default_seq_fold_nmod(fold, doc);
     vec::pop(fold.ctxt.path);
 
diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs
index a7312cc8320..9454ef7aec7 100644
--- a/src/test/bench/core-std.rs
+++ b/src/test/bench/core-std.rs
@@ -47,7 +47,7 @@ fn shift_push() {
     let mut v2 = ~[];
 
     while v1.len() > 0 {
-        vec::push(v2, vec::shift(v1));
+        v2.push(vec::shift(v1));
     }
 }
 
@@ -122,11 +122,11 @@ fn vec_push_all() {
     for uint::range(0, 1500) |i| {
         let mut rv = vec::from_elem(r.gen_uint_range(0, i + 1), i);
         if r.gen_bool() {
-            vec::push_all(v, rv);
+            v.push_all(rv);
         }
         else {
             v <-> rv;
-            vec::push_all(v, rv);
+            v.push_all(rv);
         }
     }
 }
diff --git a/src/test/bench/core-vec-append.rs b/src/test/bench/core-vec-append.rs
index d708ac9eaa7..2b9216876b4 100644
--- a/src/test/bench/core-vec-append.rs
+++ b/src/test/bench/core-vec-append.rs
@@ -7,7 +7,7 @@ use io::WriterUtil;
 fn collect_raw(num: uint) -> ~[uint] {
     let mut result = ~[];
     for uint::range(0u, num) |i| {
-        vec::push(result, i);
+        result.push(i);
     }
     return result;
 }
diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs
index 61d556b4613..ef2fa8dfa9e 100644
--- a/src/test/bench/graph500-bfs.rs
+++ b/src/test/bench/graph500-bfs.rs
@@ -318,7 +318,7 @@ fn validate(edges: ~[(node_id, node_id)],
                     status = false;
                 }
 
-                vec::push(path, parent);
+                path.push(parent);
                 parent = tree[parent];
             }
 
diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs
index 89d339b7a76..392f67d6714 100644
--- a/src/test/bench/msgsend-pipes-shared.rs
+++ b/src/test/bench/msgsend-pipes-shared.rs
@@ -60,7 +60,7 @@ fn run(args: &[~str]) {
     for uint::range(0u, workers) |i| {
         let to_child = to_child.clone();
         do task::task().future_result(|+r| {
-            vec::push(worker_results, r);
+            worker_results.push(r);
         }).spawn {
             for uint::range(0u, size / workers) |_i| {
                 //error!("worker %?: sending %? bytes", i, num_bytes);
diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs
index babc97694a5..6ba8b71d8c4 100644
--- a/src/test/bench/msgsend-pipes.rs
+++ b/src/test/bench/msgsend-pipes.rs
@@ -57,7 +57,7 @@ fn run(args: &[~str]) {
         let (to_child, from_parent_) = pipes::stream();
         from_parent.add(from_parent_);
         do task::task().future_result(|+r| {
-            vec::push(worker_results, r);
+            worker_results.push(r);
         }).spawn {
             for uint::range(0u, size / workers) |_i| {
                 //error!("worker %?: sending %? bytes", i, num_bytes);
diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs
index e3d8afce1bf..2931cab248f 100644
--- a/src/test/bench/msgsend-ring-mutex-arcs.rs
+++ b/src/test/bench/msgsend-ring-mutex-arcs.rs
@@ -18,7 +18,7 @@ type pipe = arc::MutexARC<~[uint]>;
 
 fn send(p: &pipe, msg: uint) {
     do p.access_cond |state, cond| {
-        vec::push(*state, msg);
+        state.push(msg);
         cond.signal();
     }
 }
@@ -91,7 +91,7 @@ fn main(++args: ~[~str]) {
                         option::unwrap(num_chan),
                         option::unwrap(num_port1))
         });
-        vec::push(futures, new_future);
+        futures.push(new_future);
         num_chan = Some(new_chan);
     };
 
diff --git a/src/test/bench/msgsend-ring-pipes.rs b/src/test/bench/msgsend-ring-pipes.rs
index 645aa654700..3c888fd0c8d 100644
--- a/src/test/bench/msgsend-ring-pipes.rs
+++ b/src/test/bench/msgsend-ring-pipes.rs
@@ -88,7 +88,7 @@ fn main(++args: ~[~str]) {
                         option::unwrap(num_chan),
                         option::unwrap(num_port1))
         };
-        vec::push(futures, new_future);
+        futures.push(new_future);
         num_chan = Some(new_chan);
     };
 
diff --git a/src/test/bench/msgsend-ring-rw-arcs.rs b/src/test/bench/msgsend-ring-rw-arcs.rs
index b4b75adc3b5..525cf8f1c50 100644
--- a/src/test/bench/msgsend-ring-rw-arcs.rs
+++ b/src/test/bench/msgsend-ring-rw-arcs.rs
@@ -18,7 +18,7 @@ type pipe = arc::RWARC<~[uint]>;
 
 fn send(p: &pipe, msg: uint) {
     do p.write_cond |state, cond| {
-        vec::push(*state, msg);
+        state.push(msg);
         cond.signal();
     }
 }
@@ -92,7 +92,7 @@ fn main(++args: ~[~str]) {
                         option::unwrap(num_chan),
                         option::unwrap(num_port1))
         };
-        vec::push(futures, new_future);
+        futures.push(new_future);
         num_chan = Some(new_chan);
     };
 
diff --git a/src/test/bench/msgsend-ring.rs b/src/test/bench/msgsend-ring.rs
index 47ce0d2b91f..5533aeeeb41 100644
--- a/src/test/bench/msgsend-ring.rs
+++ b/src/test/bench/msgsend-ring.rs
@@ -51,7 +51,7 @@ fn main(++args: ~[~str]) {
             get_chan_chan.send(Chan(p));
             thread_ring(i, msg_per_task, num_chan,  p)
         };
-        vec::push(futures, new_future);
+        futures.push(new_future);
         
         num_chan = get_chan.recv();
     };
diff --git a/src/test/bench/msgsend.rs b/src/test/bench/msgsend.rs
index 2790f00d40d..fb1e3ae9226 100644
--- a/src/test/bench/msgsend.rs
+++ b/src/test/bench/msgsend.rs
@@ -37,7 +37,7 @@ fn run(args: ~[~str]) {
     let mut worker_results = ~[];
     for uint::range(0u, workers) |_i| {
         do task::task().future_result(|+r| {
-            vec::push(worker_results, r);
+            worker_results.push(r);
         }).spawn {
             for uint::range(0u, size / workers) |_i| {
                 comm::send(to_child, bytes(100u));
diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs
index bdfe4b7b727..5c7827f5106 100644
--- a/src/test/bench/shootout-chameneos-redux.rs
+++ b/src/test/bench/shootout-chameneos-redux.rs
@@ -163,7 +163,7 @@ fn rendezvous(nn: uint, set: ~[color]) {
     // save each creature's meeting stats
     let mut report = ~[];
     for vec::each(to_creature) |_to_one| {
-        vec::push(report, comm::recv(from_creatures_log));
+        report.push(comm::recv(from_creatures_log));
     }
 
     // print each color in the set
diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs
index b5dcacd76d3..4f821a534ab 100644
--- a/src/test/bench/shootout-k-nucleotide-pipes.rs
+++ b/src/test/bench/shootout-k-nucleotide-pipes.rs
@@ -41,7 +41,7 @@ fn sort_and_fmt(mm: HashMap<~[u8], uint>, total: uint) -> ~str {
 
    // map -> [(k,%)]
    mm.each(fn&(key: ~[u8], val: uint) -> bool {
-      vec::push(pairs, (key, pct(val, total)));
+      pairs.push((key, pct(val, total)));
       return true;
    });
 
@@ -152,7 +152,7 @@ fn main(++args: ~[~str]) {
         stream <-> streams[ii];
         let (to_parent_, from_child_) = option::unwrap(stream);
 
-        vec::push(from_child, from_child_);
+        from_child.push(from_child_);
 
         let (to_child, from_parent) = pipes::stream();
 
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index 5f7036ed82a..3b00fd99a55 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -38,7 +38,7 @@ fn sort_and_fmt(mm: HashMap<~[u8], uint>, total: uint) -> ~str {
 
    // map -> [(k,%)]
    mm.each(fn&(key: ~[u8], val: uint) -> bool {
-      vec::push(pairs, (key, pct(val, total)));
+      pairs.push((key, pct(val, total)));
       return true;
    });
 
diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs
index 0cf0f0da5e5..d9859d54648 100644
--- a/src/test/bench/shootout-mandelbrot.rs
+++ b/src/test/bench/shootout-mandelbrot.rs
@@ -85,7 +85,7 @@ fn chanmb(i: uint, size: uint, ch: comm::Chan<line>) -> ()
     let xincr = 8f64*incr;
     for uint::range(0_u, size/8_u) |j| {
         let x = cmplx {re: xincr*(j as f64) - 1.5f64, im: y};
-        vec::push(crv, fillbyte(x, incr));
+        crv.push(fillbyte(x, incr));
     };
     comm::send(ch, {i:i, b:crv});
 }
diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 705679bd403..90224645f84 100644
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -73,7 +73,7 @@ fn stress(num_tasks: int) {
     let mut results = ~[];
     for range(0, num_tasks) |i| {
         do task::task().future_result(|+r| {
-            vec::push(results, r);
+            results.push(r);
         }).spawn {
             stress_task(i);
         }
diff --git a/src/test/bench/task-perf-one-million.rs b/src/test/bench/task-perf-one-million.rs
index da8b1932f65..c9d4fb6b4d8 100644
--- a/src/test/bench/task-perf-one-million.rs
+++ b/src/test/bench/task-perf-one-million.rs
@@ -21,7 +21,7 @@ fn calc(children: uint, parent_ch: comm::Chan<msg>) {
     for iter::repeat (children) {
         match comm::recv(port) {
           ready(child_ch) => {
-            vec::push(child_chs, child_ch);
+            child_chs.push(child_ch);
           }
           _ => fail ~"task-perf-one-million failed (port not ready)"
         }
diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs
index 73c5dab16d8..efb795a76af 100644
--- a/src/test/bench/task-perf-word-count-generic.rs
+++ b/src/test/bench/task-perf-word-count-generic.rs
@@ -155,8 +155,8 @@ mod map_reduce {
             let (ctrl, ctrl_server) = ctrl_proto::init();
             let ctrl = box(ctrl);
             let i = copy *i;
-            vec::push(tasks, spawn_joinable(|move i| map_task(map, ctrl, i)));
-            vec::push(ctrls, ctrl_server);
+            tasks.push(spawn_joinable(|move i| map_task(map, ctrl, i)));
+            ctrls.push(ctrl_server);
         }
         return tasks;
     }
@@ -270,8 +270,7 @@ mod map_reduce {
                     let p = Port();
                     let ch = Chan(p);
                     let r = reduce, kk = k;
-                    vec::push(tasks,
-                              spawn_joinable(|| reduce_task(r, kk, ch) ));
+                    tasks.push(spawn_joinable(|| reduce_task(r, kk, ch) ));
                     c = recv(p);
                     reducers.insert(k, c);
                   }
diff --git a/src/test/compile-fail/purity-infer-fail.rs b/src/test/compile-fail/purity-infer-fail.rs
index 691829edf59..b7666fa8650 100644
--- a/src/test/compile-fail/purity-infer-fail.rs
+++ b/src/test/compile-fail/purity-infer-fail.rs
@@ -2,5 +2,5 @@ fn something(f: pure fn()) { f(); }
 
 fn main() {
     let mut x = ~[];
-    something(|| vec::push(x, 0) ); //~ ERROR access to impure function prohibited in pure context
+    something(|| x.push(0) ); //~ ERROR access to impure function prohibited in pure context
 }
diff --git a/src/test/run-fail/zip-different-lengths.rs b/src/test/run-fail/zip-different-lengths.rs
index 4e97d2f903f..c6239c1f657 100644
--- a/src/test/run-fail/zip-different-lengths.rs
+++ b/src/test/run-fail/zip-different-lengths.rs
@@ -8,7 +8,7 @@ fn enum_chars(start: u8, end: u8) -> ~[char] {
     assert start < end;
     let mut i = start;
     let mut r = ~[];
-    while i <= end { vec::push(r, i as char); i += 1u as u8; }
+    while i <= end { r.push(i as char); i += 1u as u8; }
     return r;
 }
 
@@ -16,7 +16,7 @@ fn enum_uints(start: uint, end: uint) -> ~[uint] {
     assert start < end;
     let mut i = start;
     let mut r = ~[];
-    while i <= end { vec::push(r, i); i += 1u; }
+    while i <= end { r.push(i); i += 1u; }
     return r;
 }
 
diff --git a/src/test/run-pass/auto-ref-sliceable.rs b/src/test/run-pass/auto-ref-sliceable.rs
index 43d9fa5b14b..48d83da74ad 100644
--- a/src/test/run-pass/auto-ref-sliceable.rs
+++ b/src/test/run-pass/auto-ref-sliceable.rs
@@ -4,7 +4,7 @@ trait Pushable<T> {
 
 impl<T> ~[T]: Pushable<T> {
     fn push_val(&mut self, +t: T) {
-        vec::push(*self, t);
+        self.push(t);
     }
 }
 
diff --git a/src/test/run-pass/autoref-vec-push.rs b/src/test/run-pass/autoref-vec-push.rs
deleted file mode 100644
index cb70a1810b7..00000000000
--- a/src/test/run-pass/autoref-vec-push.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-trait VecPush<T> {
-    fn push(&mut self, +t: T);
-}
-
-impl<T> ~[T]: VecPush<T> {
-    fn push(&mut self, +t: T) {
-        vec::push(*self, t);
-    }
-}
-
-fn main() {
-    let mut x = ~[];
-    x.push(1);
-    x.push(2);
-    x.push(3);
-    assert x == ~[1, 2, 3];
-}
\ No newline at end of file
diff --git a/src/test/run-pass/borrowck-mut-uniq.rs b/src/test/run-pass/borrowck-mut-uniq.rs
index 6db380735cb..2d1833c0736 100644
--- a/src/test/run-pass/borrowck-mut-uniq.rs
+++ b/src/test/run-pass/borrowck-mut-uniq.rs
@@ -4,7 +4,7 @@ fn add_int(x: &mut ints, v: int) {
     *x.sum += v;
     let mut values = ~[];
     x.values <-> values;
-    vec::push(values, v);
+    values.push(v);
     x.values <- values;
 }
 
diff --git a/src/test/run-pass/issue-2904.rs b/src/test/run-pass/issue-2904.rs
index 3eb6561eb96..fc637429cd0 100644
--- a/src/test/run-pass/issue-2904.rs
+++ b/src/test/run-pass/issue-2904.rs
@@ -52,10 +52,15 @@ fn read_board_grid<rdr: Owned io::Reader>(+in: rdr) -> ~[~[square]] {
     let mut grid = ~[];
     for in.each_line |line| {
         let mut row = ~[];
+<<<<<<< HEAD
         for str::each_char(line) |c| {
             vec::push(row, square_from_char(c))
+=======
+        for line.each_char |c| {
+            row.push(square_from_char(c))
+>>>>>>> Demode vec::push (and convert to method)
         }
-        vec::push(grid, row)
+        grid.push(row)
     }
     let width = grid[0].len();
     for grid.each |row| { assert row.len() == width }
diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs
index dd2dd5e54d4..4faac4fdac1 100644
--- a/src/test/run-pass/task-comm-3.rs
+++ b/src/test/run-pass/task-comm-3.rs
@@ -34,7 +34,7 @@ fn test00() {
     while i < number_of_tasks {
         let ch = po.chan();
         do task::task().future_result(|+r| {
-            vec::push(results, r);
+            results.push(r);
         }).spawn |copy i| {
             test00_start(ch, i, number_of_messages)
         }
diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs
index a3a6b6efd7f..8d144b1a399 100644
--- a/src/test/run-pass/task-comm.rs
+++ b/src/test/run-pass/task-comm.rs
@@ -40,7 +40,7 @@ fn test00() {
     while i < number_of_tasks {
         i = i + 1;
         do task::task().future_result(|+r| {
-            vec::push(results, r);
+            results.push(r);
         }).spawn |copy i| {
             test00_start(ch, i, number_of_messages);
         }
@@ -127,7 +127,7 @@ fn test06() {
     while i < number_of_tasks {
         i = i + 1;
         do task::task().future_result(|+r| {
-            vec::push(results, r);
+            results.push(r);
         }).spawn |copy i| {
             test06_start(i);
         };
diff --git a/src/test/run-pass/vec-push.rs b/src/test/run-pass/vec-push.rs
index 3e47f7e0a3b..d4190d41386 100644
--- a/src/test/run-pass/vec-push.rs
+++ b/src/test/run-pass/vec-push.rs
@@ -1 +1 @@
-fn main() { let mut v = ~[1, 2, 3]; vec::push(v, 1); }
+fn main() { let mut v = ~[1, 2, 3]; v.push(1); }
diff --git a/src/test/run-pass/zip-same-length.rs b/src/test/run-pass/zip-same-length.rs
index 61e359129fe..9b8304792fa 100644
--- a/src/test/run-pass/zip-same-length.rs
+++ b/src/test/run-pass/zip-same-length.rs
@@ -7,7 +7,7 @@ fn enum_chars(start: u8, end: u8) -> ~[char] {
     assert start < end;
     let mut i = start;
     let mut r = ~[];
-    while i <= end { vec::push(r, i as char); i += 1u as u8; }
+    while i <= end { r.push(i as char); i += 1u as u8; }
     return r;
 }
 
@@ -15,7 +15,7 @@ fn enum_uints(start: uint, end: uint) -> ~[uint] {
     assert start < end;
     let mut i = start;
     let mut r = ~[];
-    while i <= end { vec::push(r, i); i += 1u; }
+    while i <= end { r.push(i); i += 1u; }
     return r;
 }
 
-- 
cgit 1.4.1-3-g733a5


From 0ec267b276d85786f4529e3d9717c6594bbf2f1d Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Wed, 26 Sep 2012 18:12:07 -0700
Subject: std: Demode more of list and treemap

---
 src/libstd/arena.rs              | 2 +-
 src/libstd/list.rs               | 6 +++---
 src/libstd/treemap.rs            | 6 +++---
 src/rustc/middle/typeck/check.rs | 2 +-
 4 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libstd/arena.rs b/src/libstd/arena.rs
index f9c023597c4..fbe9a2ddae6 100644
--- a/src/libstd/arena.rs
+++ b/src/libstd/arena.rs
@@ -63,7 +63,7 @@ struct Arena {
         unsafe {
             destroy_chunk(&self.head);
             for list::each(self.chunks) |chunk| {
-                if !chunk.is_pod { destroy_chunk(&chunk); }
+                if !chunk.is_pod { destroy_chunk(chunk); }
             }
         }
     }
diff --git a/src/libstd/list.rs b/src/libstd/list.rs
index 297720cbde9..d8f7edada6a 100644
--- a/src/libstd/list.rs
+++ b/src/libstd/list.rs
@@ -59,7 +59,7 @@ fn find<T: Copy>(ls: @List<T>, f: fn((&T)) -> bool) -> Option<T> {
 /// Returns true if a list contains an element with the given value
 fn has<T: Copy Eq>(ls: @List<T>, +elt: T) -> bool {
     for each(ls) |e| {
-        if e == elt { return true; }
+        if *e == elt { return true; }
     }
     return false;
 }
@@ -135,11 +135,11 @@ fn iter<T>(l: @List<T>, f: fn((&T))) {
 }
 
 /// Iterate over a list
-fn each<T>(l: @List<T>, f: fn(T) -> bool) {
+fn each<T>(l: @List<T>, f: fn((&T)) -> bool) {
     let mut cur = l;
     loop {
         cur = match *cur {
-          Cons(hd, tl) => {
+          Cons(ref hd, tl) => {
             if !f(hd) { return; }
             tl
           }
diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs
index d6946590d80..7fe8b145ed7 100644
--- a/src/libstd/treemap.rs
+++ b/src/libstd/treemap.rs
@@ -73,13 +73,13 @@ fn find<K: Copy Eq Ord, V: Copy>(m: &const TreeEdge<K, V>, +k: K)
 }
 
 /// Visit all pairs in the map in order.
-fn traverse<K, V: Copy>(m: &const TreeEdge<K, V>, f: fn(K, V)) {
+fn traverse<K, V: Copy>(m: &const TreeEdge<K, V>, f: fn((&K), (&V))) {
     match copy *m {
       None => (),
       Some(node) => {
         traverse(&const node.left, f);
         // copy of value is req'd as f() requires an immutable ptr
-        f(node.key, copy node.value);
+        f(&node.key, &copy node.value);
         traverse(&const node.right, f);
       }
     }
@@ -130,7 +130,7 @@ mod tests {
         fn t(n: @mut int, +k: int, +_v: ()) {
             assert (*n == k); *n += 1;
         }
-        traverse(m, |x,y| t(n, x, y));
+        traverse(m, |x,y| t(n, *x, *y));
     }
 
     #[test]
diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs
index bc7711c059b..c642f12cf62 100644
--- a/src/rustc/middle/typeck/check.rs
+++ b/src/rustc/middle/typeck/check.rs
@@ -181,7 +181,7 @@ impl isr_alist: get_and_find_region {
 
     fn find(br: ty::bound_region) -> Option<ty::region> {
         for list::each(self) |isr| {
-            let (isr_br, isr_r) = isr;
+            let (isr_br, isr_r) = *isr;
             if isr_br == br { return Some(isr_r); }
         }
         return None;
-- 
cgit 1.4.1-3-g733a5


From 996ec62cbfce9f25ecc8b573a0b9eb7f4a1b6db9 Mon Sep 17 00:00:00 2001
From: Tim Chevalier <chevalier@alum.wellesley.edu>
Date: Wed, 26 Sep 2012 19:40:05 -0700
Subject: Remove spurious by-ref argument to destructors

Destructors were internally declared with an extra (hidden) nil-typed
argument that was passed in by-ref mode. This was causing spurious
mode warnings. Deleted it. Also some misc. cleanup because I
couldn't help myself.
---
 src/libsyntax/ast_util.rs              |  6 ++----
 src/rustc/middle/trans/base.rs         | 10 ++++------
 src/rustc/middle/trans/datum.rs        |  2 +-
 src/rustc/middle/trans/glue.rs         |  6 +++---
 src/rustc/middle/trans/monomorphize.rs |  4 ++--
 src/rustc/middle/trans/type_of.rs      |  4 ++--
 6 files changed, 14 insertions(+), 18 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 329c9f362a4..a2c935ea6f4 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -398,10 +398,8 @@ fn operator_prec(op: ast::binop) -> uint {
 
 fn dtor_dec() -> fn_decl {
     let nil_t = @{id: 0, node: ty_nil, span: dummy_sp()};
-    // dtor has one argument, of type ()
-    {inputs: ~[{mode: ast::expl(ast::by_ref),
-                ty: nil_t, ident: parse::token::special_idents::underscore,
-                id: 0}],
+    // dtor has no args
+    {inputs: ~[],
      output: nil_t, cf: return_val}
 }
 
diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs
index 94b09a30e4b..47ac8e9ef6a 100644
--- a/src/rustc/middle/trans/base.rs
+++ b/src/rustc/middle/trans/base.rs
@@ -383,7 +383,7 @@ fn get_res_dtor(ccx: @crate_ctxt, did: ast::def_id,
                 parent_id: ast::def_id, substs: ~[ty::t])
    -> ValueRef {
     let _icx = ccx.insn_ctxt("trans_res_dtor");
-    if (substs.len() > 0u) {
+    if (substs.is_not_empty()) {
         let did = if did.crate != ast::local_crate {
             inline::maybe_instantiate_inline(ccx, did)
         } else { did };
@@ -1496,7 +1496,7 @@ fn copy_args_to_allocas(fcx: fn_ctxt,
 
         // For certain mode/type combinations, the raw llarg values are passed
         // by value.  However, within the fn body itself, we want to always
-        // have all locals and argumenst be by-ref so that we can cancel the
+        // have all locals and arguments be by-ref so that we can cancel the
         // cleanup and for better interaction with LLVM's debug info.  So, if
         // the argument would be passed by value, we store it into an alloca.
         // This alloca should be optimized away by LLVM's mem-to-reg pass in
@@ -1767,9 +1767,7 @@ fn trans_class_dtor(ccx: @crate_ctxt, path: path,
 
   /* The dtor takes a (null) output pointer, and a self argument,
      and returns () */
-  let lldty = T_fn(~[T_ptr(type_of(ccx, ty::mk_nil(tcx))),
-                    T_ptr(type_of(ccx, class_ty))],
-                   llvm::LLVMVoidType());
+  let lldty = type_of_dtor(ccx, class_ty);
 
   let s = get_dtor_symbol(ccx, path, dtor_id, psubsts);
 
@@ -1833,7 +1831,7 @@ fn trans_item(ccx: @crate_ctxt, item: ast::item) {
                                          *path,
                                          ~[path_name(item.ident)]),
                                      decl, body, llfndecl, item.id);
-        } else if tps.len() == 0u {
+        } else if tps.is_empty() {
             let llfndecl = get_item_val(ccx, item.id);
             trans_fn(ccx,
                      vec::append(*path, ~[path_name(item.ident)]),
diff --git a/src/rustc/middle/trans/datum.rs b/src/rustc/middle/trans/datum.rs
index 3f2705a9bcc..59e8cd72025 100644
--- a/src/rustc/middle/trans/datum.rs
+++ b/src/rustc/middle/trans/datum.rs
@@ -204,7 +204,7 @@ fn appropriate_mode(ty: ty::t) -> DatumMode {
     *
     * Indicates the "appropriate" mode for this value,
     * which is either by ref or by value, depending
-    * on whether type is iimmediate or what. */
+    * on whether type is immediate or not. */
 
     if ty::type_is_nil(ty) || ty::type_is_bot(ty) {
         ByValue
diff --git a/src/rustc/middle/trans/glue.rs b/src/rustc/middle/trans/glue.rs
index 0fc72e8dc15..50a24a1a825 100644
--- a/src/rustc/middle/trans/glue.rs
+++ b/src/rustc/middle/trans/glue.rs
@@ -426,8 +426,8 @@ fn trans_class_drop(bcx: block,
         // Class dtors have no explicit args, so the params should
         // just consist of the output pointer and the environment
         // (self)
-        assert(params.len() == 2u);
-        let self_arg = PointerCast(bcx, v0, params[1u]);
+        assert(params.len() == 2);
+        let self_arg = PointerCast(bcx, v0, params[1]);
         let args = ~[bcx.fcx.llretptr, self_arg];
         Call(bcx, dtor_addr, args);
 
@@ -440,7 +440,7 @@ fn trans_class_drop(bcx: block,
             bcx = drop_ty(bcx, llfld_a, fld.mt.ty);
         }
 
-        Store(bcx, C_u8(0u), drop_flag);
+        Store(bcx, C_u8(0), drop_flag);
         bcx
     }
 }
diff --git a/src/rustc/middle/trans/monomorphize.rs b/src/rustc/middle/trans/monomorphize.rs
index 40558e72c80..bbcacec052e 100644
--- a/src/rustc/middle/trans/monomorphize.rs
+++ b/src/rustc/middle/trans/monomorphize.rs
@@ -103,11 +103,11 @@ fn monomorphic_fn(ccx: @crate_ctxt,
     // Random cut-off -- code that needs to instantiate the same function
     // recursively more than ten times can probably safely be assumed to be
     // causing an infinite expansion.
-    if depth > 10u {
+    if depth > 10 {
         ccx.sess.span_fatal(
             span, ~"overly deep expansion of inlined function");
     }
-    ccx.monomorphizing.insert(fn_id, depth + 1u);
+    ccx.monomorphizing.insert(fn_id, depth + 1);
 
     let pt = vec::append(*pt,
                          ~[path_name(ccx.names(ccx.sess.str_of(name)))]);
diff --git a/src/rustc/middle/trans/type_of.rs b/src/rustc/middle/trans/type_of.rs
index 99555d5b294..b45da3b2700 100644
--- a/src/rustc/middle/trans/type_of.rs
+++ b/src/rustc/middle/trans/type_of.rs
@@ -254,8 +254,8 @@ fn llvm_type_name(cx: @crate_ctxt,
 }
 
 fn type_of_dtor(ccx: @crate_ctxt, self_ty: ty::t) -> TypeRef {
-    T_fn(~[T_ptr(type_of(ccx, ty::mk_nil(ccx.tcx))),
-          T_ptr(type_of(ccx, self_ty))],
+    T_fn(~[T_ptr(type_of(ccx, ty::mk_nil(ccx.tcx))), // output pointer
+           T_ptr(type_of(ccx, self_ty))],            // self arg
          llvm::LLVMVoidType())
 }
 
-- 
cgit 1.4.1-3-g733a5


From 887b59b7bea4d795ebe30655ac051f7872aa6a44 Mon Sep 17 00:00:00 2001
From: Zack Corr <zack@z0w0.me>
Date: Tue, 11 Sep 2012 16:05:51 +1000
Subject: jit: Separate JIT execution into two functions and load crates before
 main lookup

---
 src/rustc/back/link.rs       | 38 ++++++++++++++++++---
 src/rustc/lib/llvm.rs        | 22 +++++++-----
 src/rustllvm/RustWrapper.cpp | 81 +++++++++++++++++++++++++++++++++-----------
 src/rustllvm/rustllvm.def.in |  5 +--
 4 files changed, 112 insertions(+), 34 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/back/link.rs b/src/rustc/back/link.rs
index 4bbd51524c4..751f0369141 100644
--- a/src/rustc/back/link.rs
+++ b/src/rustc/back/link.rs
@@ -74,14 +74,44 @@ mod jit {
             m: ModuleRef,
             opt: c_int,
             stacks: bool) unsafe {
-        let ptr = llvm::LLVMRustJIT(rusti::morestack_addr(),
-                                    pm, m, opt, stacks);
+        let manager = llvm::LLVMRustPrepareJIT(rusti::morestack_addr());
+
+        // We need to tell JIT where to resolve all linked
+        // symbols from. The equivalent of -lstd, -lcore, etc.
+        // By default the JIT will resolve symbols from the std and
+        // core linked into rustc. We don't want that,
+        // incase the user wants to use an older std library.
+
+        let cstore = sess.cstore;
+        for cstore::get_used_crate_files(cstore).each |cratepath| {
+            let path = cratepath.to_str();
+
+            debug!("linking: %s", path);
+
+            let _: () = str::as_c_str(
+                path,
+                |buf_t| {
+                    if !llvm::LLVMRustLoadCrate(manager, buf_t) {
+                        llvm_err(sess, ~"Could not link");
+                    }
+                    debug!("linked: %s", path);
+                });
+        }
+
+        // The execute function will return a void pointer
+        // to the _rust_main function. We can do closure
+        // magic here to turn it straight into a callable rust
+        // closure. It will also cleanup the memory manager
+        // for us.
+
+        let entry = llvm::LLVMRustExecuteJIT(manager,
+                                      pm, m, opt, stacks);
 
-        if ptr::is_null(ptr) {
+        if ptr::is_null(entry) {
             llvm_err(sess, ~"Could not JIT");
         } else {
             let closure = Closure {
-                code: ptr,
+                code: entry,
                 env: ptr::null()
             };
             let func: fn(~[~str]) = cast::transmute(move closure);
diff --git a/src/rustc/lib/llvm.rs b/src/rustc/lib/llvm.rs
index 031ce219308..c16fe31f933 100644
--- a/src/rustc/lib/llvm.rs
+++ b/src/rustc/lib/llvm.rs
@@ -990,15 +990,19 @@ extern mod llvm {
         call. */
     fn LLVMRustGetLastError() -> *c_char;
 
-    /** Load a shared library to resolve symbols against. */
-    fn LLVMRustLoadLibrary(Filename: *c_char) -> bool;
-
-    /** Create and execute the JIT engine. */
-    fn LLVMRustJIT(__morestack: *(),
-                   PM: PassManagerRef,
-                   M: ModuleRef,
-                   OptLevel: c_int,
-                   EnableSegmentedStacks: bool) -> *();
+    /** Prepare the JIT. Returns a memory manager that can load crates. */
+    fn LLVMRustPrepareJIT(__morestack: *()) -> *();
+
+    /** Load a crate into the memory manager. */
+    fn LLVMRustLoadCrate(MM: *(),
+                         Filename: *c_char) -> bool;
+
+    /** Execute the JIT engine. */
+    fn LLVMRustExecuteJIT(MM: *(),
+                          PM: PassManagerRef,
+                          M: ModuleRef,
+                          OptLevel: c_int,
+                          EnableSegmentedStacks: bool) -> *();
 
     /** Parses the bitcode in the given memory buffer. */
     fn LLVMRustParseBitcode(MemBuf: MemoryBufferRef) -> ModuleRef;
diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp
index 6ea433e6f1f..2def9c1c030 100644
--- a/src/rustllvm/RustWrapper.cpp
+++ b/src/rustllvm/RustWrapper.cpp
@@ -20,6 +20,7 @@
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/Assembly/Parser.h"
 #include "llvm/Assembly/PrintModulePass.h"
 #include "llvm/Support/FormattedStream.h"
@@ -42,7 +43,6 @@
 #include "llvm-c/Core.h"
 #include "llvm-c/BitReader.h"
 #include "llvm-c/Object.h"
-#include <cstdlib>
 
 // Used by RustMCJITMemoryManager::getPointerToNamedFunction()
 // to get around glibc issues. See the function for more information.
@@ -53,6 +53,7 @@
 #endif
 
 using namespace llvm;
+using namespace llvm::sys;
 
 static const char *LLVMRustError;
 
@@ -100,18 +101,6 @@ void LLVMRustInitializeTargets() {
   LLVMInitializeX86AsmParser();
 }
 
-extern "C" bool
-LLVMRustLoadLibrary(const char* file) {
-  std::string err;
-
-  if(llvm::sys::DynamicLibrary::LoadLibraryPermanently(file, &err)) {
-    LLVMRustError = err.c_str();
-    return false;
-  }
-
-  return true;
-}
-
 // Custom memory manager for MCJITting. It needs special features
 // that the generic JIT memory manager doesn't entail. Based on
 // code from LLI, change where needed for Rust.
@@ -121,10 +110,13 @@ public:
   SmallVector<sys::MemoryBlock, 16> AllocatedCodeMem;
   SmallVector<sys::MemoryBlock, 16> FreeCodeMem;
   void* __morestack;
+  DenseSet<DynamicLibrary*> crates;
 
   RustMCJITMemoryManager(void* sym) : __morestack(sym) { }
   ~RustMCJITMemoryManager();
 
+  bool loadCrate(const char*, std::string*);
+
   virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
                                        unsigned SectionID);
 
@@ -197,6 +189,19 @@ public:
   }
 };
 
+bool RustMCJITMemoryManager::loadCrate(const char* file, std::string* err) {
+  DynamicLibrary crate = DynamicLibrary::getPermanentLibrary(file,
+                                                             err);
+
+  if(crate.isValid()) {
+    crates.insert(&crate);
+
+    return true;
+  }
+
+  return false;
+}
+
 uint8_t *RustMCJITMemoryManager::allocateDataSection(uintptr_t Size,
                                                     unsigned Alignment,
                                                     unsigned SectionID) {
@@ -276,6 +281,19 @@ void *RustMCJITMemoryManager::getPointerToNamedFunction(const std::string &Name,
   if (Name == "__morestack") return &__morestack;
 
   const char *NameStr = Name.c_str();
+
+  // Look through loaded crates for symbols.
+
+  for (DenseSet<DynamicLibrary*>::iterator I = crates.begin(),
+       E = crates.end(); I != E; ++I) {
+    void *Ptr = (*I)->getAddressOfSymbol(NameStr);
+
+    if (Ptr) return Ptr;
+  }
+
+  // Fallback to using any symbols LLVM has loaded (generally
+  // from the main program).
+
   void *Ptr = sys::DynamicLibrary::SearchForAddressOfSymbol(NameStr);
   if (Ptr) return Ptr;
 
@@ -293,11 +311,34 @@ RustMCJITMemoryManager::~RustMCJITMemoryManager() {
 }
 
 extern "C" void*
-LLVMRustJIT(void* __morestack,
-            LLVMPassManagerRef PMR,
-            LLVMModuleRef M,
-            CodeGenOpt::Level OptLevel,
-            bool EnableSegmentedStacks) {
+LLVMRustPrepareJIT(void* __morestack) {
+  // An execution engine will take ownership of this later
+  // and clean it up for us.
+
+  return (void*) new RustMCJITMemoryManager(__morestack);
+}
+
+extern "C" bool
+LLVMRustLoadCrate(void* mem, const char* crate) {
+  RustMCJITMemoryManager* manager = (RustMCJITMemoryManager*) mem;
+  std::string Err;
+
+  assert(manager);
+
+  if(!manager->loadCrate(crate, &Err)) {
+    LLVMRustError = Err.c_str();
+    return false;
+  }
+
+  return true;
+}
+
+extern "C" void*
+LLVMRustExecuteJIT(void* mem,
+                   LLVMPassManagerRef PMR,
+                   LLVMModuleRef M,
+                   CodeGenOpt::Level OptLevel,
+                   bool EnableSegmentedStacks) {
 
   InitializeNativeTarget();
   InitializeNativeTargetAsmPrinter();
@@ -308,6 +349,9 @@ LLVMRustJIT(void* __morestack,
   Options.NoFramePointerElim = true;
   Options.EnableSegmentedStacks = EnableSegmentedStacks;
   PassManager *PM = unwrap<PassManager>(PMR);
+  RustMCJITMemoryManager* MM = (RustMCJITMemoryManager*) mem;
+
+  assert(MM);
 
   PM->add(createBasicAliasAnalysisPass());
   PM->add(createInstructionCombiningPass());
@@ -318,7 +362,6 @@ LLVMRustJIT(void* __morestack,
   PM->add(createPromoteMemoryToRegisterPass());
   PM->run(*unwrap(M));
 
-  RustMCJITMemoryManager* MM = new RustMCJITMemoryManager(__morestack);
   ExecutionEngine* EE = EngineBuilder(unwrap(M))
     .setTargetOptions(Options)
     .setJITMemoryManager(MM)
diff --git a/src/rustllvm/rustllvm.def.in b/src/rustllvm/rustllvm.def.in
index 1de1e3ba58f..36833e5175e 100644
--- a/src/rustllvm/rustllvm.def.in
+++ b/src/rustllvm/rustllvm.def.in
@@ -4,8 +4,9 @@ LLVMRustWriteOutputFile
 LLVMRustGetLastError
 LLVMRustConstSmallInt
 LLVMRustConstInt
-LLVMRustLoadLibrary
-LLVMRustJIT
+LLVMRustLoadCrate
+LLVMRustPrepareJIT
+LLVMRustExecuteJIT
 LLVMRustParseBitcode
 LLVMRustParseAssemblyFile
 LLVMRustPrintPassTimings
-- 
cgit 1.4.1-3-g733a5


From 64de6d638da71f7b3a55d663b194b95f7f06d6c8 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Wed, 26 Sep 2012 16:27:54 -0700
Subject: core: Fix mode warnings in str

---
 src/libcore/str.rs            | 8 ++++----
 src/rustc/metadata/encoder.rs | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index 0993d1df63f..d7e90c1a42d 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -1827,10 +1827,10 @@ const tag_six_b: uint = 252u;
  * let i = str::as_bytes("Hello World") { |bytes| vec::len(bytes) };
  * ~~~
  */
-pure fn as_bytes<T>(s: &const ~str, f: fn(~[u8]) -> T) -> T {
+pure fn as_bytes<T>(s: &const ~str, f: fn((&~[u8])) -> T) -> T {
     unsafe {
         let v: *~[u8] = cast::transmute(copy s);
-        f(*v)
+        f(&*v)
     }
 }
 
@@ -1945,7 +1945,7 @@ fn reserve_at_least(s: &const ~str, n: uint) {
  */
 pure fn capacity(s: &const ~str) -> uint {
     do as_bytes(s) |buf| {
-        let vcap = vec::capacity(buf);
+        let vcap = vec::capacity(*buf);
         assert vcap > 0u;
         vcap - 1u
     }
@@ -2037,7 +2037,7 @@ mod raw {
 
     /// Form a slice from a *u8 buffer of the given length without copying.
     unsafe fn buf_as_slice<T>(buf: *u8, len: uint,
-                              f: fn(&&v: &str) -> T) -> T {
+                              f: fn(v: &str) -> T) -> T {
         let v = (buf, len + 1);
         assert is_utf8(::cast::reinterpret_cast(&v));
         f(::cast::transmute(move v))
diff --git a/src/rustc/metadata/encoder.rs b/src/rustc/metadata/encoder.rs
index 81ad9dfc3a5..8edee2bfe48 100644
--- a/src/rustc/metadata/encoder.rs
+++ b/src/rustc/metadata/encoder.rs
@@ -1175,7 +1175,7 @@ fn encode_metadata(parms: encode_parms, crate: @crate) -> ~[u8] {
     //   vec::from_slice(metadata_encoding_version) +
 
     (do str::as_bytes(&~"rust\x00\x00\x00\x01") |bytes| {
-        vec::slice(bytes, 0, 8)
+        vec::slice(*bytes, 0, 8)
     }) + flate::deflate_bytes(wr.buf.check_out(|buf| buf))
 }
 
-- 
cgit 1.4.1-3-g733a5


From e8fe718bfd4d88b0bc59117326a14a10f2598568 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Wed, 26 Sep 2012 16:27:12 -0700
Subject: core: Replace map/map_default with map_ref/map_default_ref

---
 src/compiletest/compiletest.rs               |  2 +-
 src/compiletest/header.rs                    |  2 +-
 src/libcore/dlist.rs                         |  4 ++--
 src/libcore/iter.rs                          |  2 +-
 src/libcore/option.rs                        | 28 ++++------------------
 src/libcore/os.rs                            |  2 +-
 src/libcore/task/local_data_priv.rs          |  6 ++---
 src/libcore/task/spawn.rs                    |  2 +-
 src/libcore/vec.rs                           |  4 ++--
 src/libsyntax/diagnostic.rs                  |  2 +-
 src/libsyntax/fold.rs                        | 36 ++++++++++++++--------------
 src/libsyntax/parse.rs                       |  2 +-
 src/libsyntax/parse/parser.rs                |  4 ++--
 src/libsyntax/visit.rs                       |  2 +-
 src/rustc/driver/driver.rs                   |  2 +-
 src/rustc/driver/rustc.rs                    |  6 ++---
 src/rustc/front/config.rs                    |  2 +-
 src/rustc/metadata/cstore.rs                 |  2 +-
 src/rustc/metadata/decoder.rs                |  4 ++--
 src/rustc/middle/borrowck/check_loans.rs     |  2 +-
 src/rustc/middle/liveness.rs                 |  6 ++---
 src/rustc/middle/mem_categorization.rs       | 14 +++++------
 src/rustc/middle/trans/callee.rs             |  2 +-
 src/rustc/middle/trans/common.rs             |  2 +-
 src/rustc/middle/trans/glue.rs               | 10 ++++----
 src/rustc/middle/ty.rs                       | 10 ++++----
 src/rustc/middle/typeck/check/regionmanip.rs |  6 ++---
 src/rustc/middle/typeck/check/vtable.rs      |  2 +-
 src/rustdoc/config.rs                        |  6 ++---
 src/rustdoc/text_pass.rs                     |  2 +-
 30 files changed, 79 insertions(+), 97 deletions(-)

(limited to 'src/rustc')

diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs
index 8d48669ab17..264ee61018b 100644
--- a/src/compiletest/compiletest.rs
+++ b/src/compiletest/compiletest.rs
@@ -58,7 +58,7 @@ fn parse_config(args: ~[~str]) -> config {
              } else { option::None },
          logfile: option::map(&getopts::opt_maybe_str(matches,
                                                      ~"logfile"),
-                              |s| Path(s)),
+                              |s| Path(*s)),
          runtool: getopts::opt_maybe_str(matches, ~"runtool"),
          rustcflags: getopts::opt_maybe_str(matches, ~"rustcflags"),
          jit: getopts::opt_present(matches, ~"jit"),
diff --git a/src/compiletest/header.rs b/src/compiletest/header.rs
index 19a3c621d27..d72a9d65e05 100644
--- a/src/compiletest/header.rs
+++ b/src/compiletest/header.rs
@@ -103,7 +103,7 @@ fn parse_compile_flags(line: ~str) -> Option<~str> {
 fn parse_exec_env(line: ~str) -> Option<(~str, ~str)> {
     do parse_name_value_directive(line, ~"exec-env").map |nv| {
         // nv is either FOO or FOO=BAR
-        let strs = str::splitn_char(nv, '=', 1u);
+        let strs = str::splitn_char(*nv, '=', 1u);
         match strs.len() {
           1u => (strs[0], ~""),
           2u => (strs[0], strs[1]),
diff --git a/src/libcore/dlist.rs b/src/libcore/dlist.rs
index d50abc64f2b..fcf8146200d 100644
--- a/src/libcore/dlist.rs
+++ b/src/libcore/dlist.rs
@@ -275,13 +275,13 @@ impl<T> DList<T> {
     /// Remove a node from the head of the list. O(1).
     fn pop_n() -> Option<DListNode<T>> {
         let hd = self.peek_n();
-        hd.map(|nobe| self.unlink(nobe));
+        hd.map(|nobe| self.unlink(*nobe));
         hd
     }
     /// Remove a node from the tail of the list. O(1).
     fn pop_tail_n() -> Option<DListNode<T>> {
         let tl = self.peek_tail_n();
-        tl.map(|nobe| self.unlink(nobe));
+        tl.map(|nobe| self.unlink(*nobe));
         tl
     }
     /// Get the node at the list's head. O(1).
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 00091d0ed41..bc1955698fc 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -290,7 +290,7 @@ pure fn from_elem<T: Copy,BT: Buildable<T>>(n_elts: uint, t: T) -> BT {
 pure fn append<T: Copy,IT: BaseIter<T>,BT: Buildable<T>>(
     lhs: IT, rhs: IT) -> BT {
     let size_opt = lhs.size_hint().chain(
-        |sz1| rhs.size_hint().map(|sz2| sz1+sz2));
+        |sz1| rhs.size_hint().map(|sz2| sz1+*sz2));
     do build_sized_opt(size_opt) |push| {
         for lhs.each |x| { push(*x); }
         for rhs.each |x| { push(*x); }
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index 518775ec751..ae28c6db083 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -61,13 +61,7 @@ pure fn expect<T: Copy>(opt: &Option<T>, +reason: ~str) -> T {
     match *opt { Some(x) => x, None => fail reason }
 }
 
-pure fn map<T, U>(opt: &Option<T>, f: fn(T) -> U) -> Option<U> {
-    //! Maps a `some` value from one type to another
-
-    match *opt { Some(x) => Some(f(x)), None => None }
-}
-
-pure fn map_ref<T, U>(opt: &Option<T>, f: fn(x: &T) -> U) -> Option<U> {
+pure fn map<T, U>(opt: &Option<T>, f: fn(x: &T) -> U) -> Option<U> {
     //! Maps a `some` value by reference from one type to another
 
     match *opt { Some(ref x) => Some(f(x)), None => None }
@@ -138,14 +132,7 @@ pure fn get_default<T: Copy>(opt: &Option<T>, +def: T) -> T {
     match *opt { Some(x) => x, None => def }
 }
 
-pure fn map_default<T, U>(opt: &Option<T>, +def: U, f: fn(T) -> U) -> U {
-    //! Applies a function to the contained value or returns a default
-
-    match *opt { None => move def, Some(t) => f(t) }
-}
-
-// This should replace map_default.
-pure fn map_default_ref<T, U>(opt: &Option<T>, +def: U,
+pure fn map_default<T, U>(opt: &Option<T>, +def: U,
                               f: fn(x: &T) -> U) -> U {
     //! Applies a function to the contained value or returns a default
 
@@ -200,17 +187,12 @@ impl<T> Option<T> {
      * function that returns an option.
      */
     pure fn chain<U>(f: fn(T) -> Option<U>) -> Option<U> { chain(&self, f) }
-    /// Applies a function to the contained value or returns a default
-    pure fn map_default<U>(+def: U, f: fn(T) -> U) -> U
-        { map_default(&self, move def, f) }
     /// Performs an operation on the contained value or does nothing
     pure fn iter(f: fn(T)) { iter(&self, f) }
     /// Returns true if the option equals `none`
     pure fn is_none() -> bool { is_none(&self) }
     /// Returns true if the option contains some value
     pure fn is_some() -> bool { is_some(&self) }
-    /// Maps a `some` value from one type to another
-    pure fn map<U>(f: fn(T) -> U) -> Option<U> { map(&self, f) }
 }
 
 impl<T> &Option<T> {
@@ -222,12 +204,12 @@ impl<T> &Option<T> {
         chain_ref(self, f)
     }
     /// Applies a function to the contained value or returns a default
-    pure fn map_default_ref<U>(+def: U, f: fn(x: &T) -> U) -> U
-        { map_default_ref(self, move def, f) }
+    pure fn map_default<U>(+def: U, f: fn(x: &T) -> U) -> U
+        { map_default(self, move def, f) }
     /// Performs an operation on the contained value by reference
     pure fn iter_ref(f: fn(x: &T)) { iter_ref(self, f) }
     /// Maps a `some` value from one type to another by reference
-    pure fn map_ref<U>(f: fn(x: &T) -> U) -> Option<U> { map_ref(self, f) }
+    pure fn map<U>(f: fn(x: &T) -> U) -> Option<U> { map(self, f) }
     /// Gets an immutable reference to the value inside a `some`.
     pure fn get_ref() -> &self/T { get_ref(self) }
 }
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
index 0a2f00e3f2b..7803783ea66 100644
--- a/src/libcore/os.rs
+++ b/src/libcore/os.rs
@@ -439,7 +439,7 @@ fn self_exe_path() -> Option<Path> {
     }
 
     do load_self().map |pth| {
-        Path(pth).dir_path()
+        Path(*pth).dir_path()
     }
 }
 
diff --git a/src/libcore/task/local_data_priv.rs b/src/libcore/task/local_data_priv.rs
index 2fbb88327ed..31369c47c64 100644
--- a/src/libcore/task/local_data_priv.rs
+++ b/src/libcore/task/local_data_priv.rs
@@ -75,8 +75,8 @@ unsafe fn local_data_lookup<T: Owned>(
     );
     do map_pos.map |index| {
         // .get() is guaranteed because of "None { false }" above.
-        let (_, data_ptr, _) = (*map)[index].get();
-        (index, data_ptr)
+        let (_, data_ptr, _) = (*map)[*index].get();
+        (*index, data_ptr)
     }
 }
 
@@ -91,7 +91,7 @@ unsafe fn local_get_helper<T: Owned>(
         // was referenced in the local_data box, though, not here, so before
         // overwriting the local_data_box we need to give an extra reference.
         // We must also give an extra reference when not removing.
-        let (index, data_ptr) = result;
+        let (index, data_ptr) = *result;
         let data: @T = cast::transmute(move data_ptr);
         cast::bump_box_refcount(data);
         if do_pop {
diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs
index 21f217d57f4..f2568414392 100644
--- a/src/libcore/task/spawn.rs
+++ b/src/libcore/task/spawn.rs
@@ -200,7 +200,7 @@ fn each_ancestor(list:        &mut AncestorList,
         // the end of the list, which doesn't make sense to coalesce.
         return do (**ancestors).map_default((None,false)) |ancestor_arc| {
             // NB: Takes a lock! (this ancestor node)
-            do access_ancestors(&ancestor_arc) |nobe| {
+            do access_ancestors(ancestor_arc) |nobe| {
                 // Check monotonicity
                 assert last_generation > nobe.generation;
                 /*##########################################################*
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index 50011dbacec..a0516116bdf 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -969,7 +969,7 @@ pure fn find<T: Copy>(v: &[T], f: fn(T) -> bool) -> Option<T> {
  */
 pure fn find_between<T: Copy>(v: &[T], start: uint, end: uint,
                       f: fn(T) -> bool) -> Option<T> {
-    position_between(v, start, end, f).map(|i| v[i])
+    position_between(v, start, end, f).map(|i| v[*i])
 }
 
 /**
@@ -992,7 +992,7 @@ pure fn rfind<T: Copy>(v: &[T], f: fn(T) -> bool) -> Option<T> {
  */
 pure fn rfind_between<T: Copy>(v: &[T], start: uint, end: uint,
                                f: fn(T) -> bool) -> Option<T> {
-    rposition_between(v, start, end, f).map(|i| v[i])
+    rposition_between(v, start, end, f).map(|i| v[*i])
 }
 
 /// Find the first index containing a matching value
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index ca9db6d25ad..1c12397568d 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -262,7 +262,7 @@ fn highlight_lines(cm: codemap::codemap, sp: span,
 fn print_macro_backtrace(cm: codemap::codemap, sp: span) {
     do option::iter(&sp.expn_info) |ei| {
         let ss = option::map_default(&ei.callie.span, @~"",
-                                     |span| @codemap::span_to_str(span, cm));
+                                     |span| @codemap::span_to_str(*span, cm));
         print_diagnostic(*ss, note,
                          fmt!("in expansion of #%s", ei.callie.name));
         let ss = codemap::span_to_str(ei.call_site, cm);
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 12c8dc2f7bb..3d9234df41e 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -114,7 +114,7 @@ fn fold_mac_(m: mac, fld: ast_fold) -> mac {
              match m.node {
                mac_invoc(pth, arg, body) => {
                  mac_invoc(fld.fold_path(pth),
-                           option::map(&arg, |x| fld.fold_expr(x)), body)
+                           option::map(&arg, |x| fld.fold_expr(*x)), body)
                }
                mac_invoc_tt(*) => m.node,
                mac_ellipsis => mac_ellipsis,
@@ -243,7 +243,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
                 variants: vec::map(enum_definition.variants,
                                    |x| fld.fold_variant(*x)),
                 common: option::map(&enum_definition.common,
-                                    |x| fold_struct_def(x, fld))
+                                    |x| fold_struct_def(*x, fld))
             }), fold_ty_params(typms, fld))
           }
           item_class(struct_def, typms) => {
@@ -252,7 +252,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
           }
           item_impl(tps, ifce, ty, methods) => {
               item_impl(fold_ty_params(tps, fld),
-                        ifce.map(|p| fold_trait_ref(p, fld)),
+                        ifce.map(|p| fold_trait_ref(*p, fld)),
                         fld.fold_ty(ty),
                         vec::map(methods, |x| fld.fold_method(*x)))
           }
@@ -292,7 +292,7 @@ fn fold_struct_def(struct_def: @ast::struct_def, fld: ast_fold)
         let dtor_id   = fld.new_id(dtor.node.id);
         {node: {body: dtor_body,
                 id: dtor_id,.. dtor.node},
-            .. dtor}};
+            .. *dtor}};
     return @{
         traits: vec::map(struct_def.traits, |p| fold_trait_ref(*p, fld)),
         fields: vec::map(struct_def.fields, |f| fold_struct_field(*f, fld)),
@@ -332,7 +332,7 @@ fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method {
 fn noop_fold_block(b: blk_, fld: ast_fold) -> blk_ {
     return {view_items: vec::map(b.view_items, |x| fld.fold_view_item(*x)),
          stmts: vec::map(b.stmts, |x| fld.fold_stmt(*x)),
-         expr: option::map(&b.expr, |x| fld.fold_expr(x)),
+         expr: option::map(&b.expr, |x| fld.fold_expr(*x)),
          id: fld.new_id(b.id),
          rules: b.rules};
 }
@@ -347,7 +347,7 @@ fn noop_fold_stmt(s: stmt_, fld: ast_fold) -> stmt_ {
 
 fn noop_fold_arm(a: arm, fld: ast_fold) -> arm {
     return {pats: vec::map(a.pats, |x| fld.fold_pat(*x)),
-         guard: option::map(&a.guard, |x| fld.fold_expr(x)),
+         guard: option::map(&a.guard, |x| fld.fold_expr(*x)),
          body: fld.fold_block(a.body)};
 }
 
@@ -357,12 +357,12 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
           pat_ident(binding_mode, pth, sub) => {
             pat_ident(binding_mode,
                       fld.fold_path(pth),
-                      option::map(&sub, |x| fld.fold_pat(x)))
+                      option::map(&sub, |x| fld.fold_pat(*x)))
           }
           pat_lit(e) => pat_lit(fld.fold_expr(e)),
           pat_enum(pth, pats) => {
               pat_enum(fld.fold_path(pth), option::map(&pats,
-                       |pats| vec::map(pats, |x| fld.fold_pat(*x))))
+                       |pats| vec::map(*pats, |x| fld.fold_pat(*x))))
           }
           pat_rec(fields, etc) => {
             let mut fs = ~[];
@@ -432,7 +432,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
             expr_repeat(fld.fold_expr(expr), fld.fold_expr(count), mutt),
           expr_rec(fields, maybe_expr) => {
             expr_rec(vec::map(fields, |x| fold_field(*x)),
-                     option::map(&maybe_expr, |x| fld.fold_expr(x)))
+                     option::map(&maybe_expr, |x| fld.fold_expr(*x)))
           }
           expr_tup(elts) => expr_tup(vec::map(elts, |x| fld.fold_expr(*x))),
           expr_call(f, args, blk) => {
@@ -451,14 +451,14 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
           expr_addr_of(m, ohs) => expr_addr_of(m, fld.fold_expr(ohs)),
           expr_if(cond, tr, fl) => {
             expr_if(fld.fold_expr(cond), fld.fold_block(tr),
-                    option::map(&fl, |x| fld.fold_expr(x)))
+                    option::map(&fl, |x| fld.fold_expr(*x)))
           }
           expr_while(cond, body) => {
             expr_while(fld.fold_expr(cond), fld.fold_block(body))
           }
           expr_loop(body, opt_ident) => {
               expr_loop(fld.fold_block(body),
-                        option::map(&opt_ident, |x| fld.fold_ident(x)))
+                        option::map(&opt_ident, |x| fld.fold_ident(*x)))
           }
           expr_match(expr, arms) => {
             expr_match(fld.fold_expr(expr),
@@ -500,12 +500,12 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
             expr_index(fld.fold_expr(el), fld.fold_expr(er))
           }
           expr_path(pth) => expr_path(fld.fold_path(pth)),
-          expr_fail(e) => expr_fail(option::map(&e, |x| fld.fold_expr(x))),
+          expr_fail(e) => expr_fail(option::map(&e, |x| fld.fold_expr(*x))),
           expr_break(opt_ident) =>
-            expr_break(option::map(&opt_ident, |x| fld.fold_ident(x))),
+            expr_break(option::map(&opt_ident, |x| fld.fold_ident(*x))),
           expr_again(opt_ident) =>
-            expr_again(option::map(&opt_ident, |x| fld.fold_ident(x))),
-          expr_ret(e) => expr_ret(option::map(&e, |x| fld.fold_expr(x))),
+            expr_again(option::map(&opt_ident, |x| fld.fold_ident(*x))),
+          expr_ret(e) => expr_ret(option::map(&e, |x| fld.fold_expr(*x))),
           expr_log(i, lv, e) => expr_log(i, fld.fold_expr(lv),
                                          fld.fold_expr(e)),
           expr_assert(e) => expr_assert(fld.fold_expr(e)),
@@ -513,7 +513,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
           expr_struct(path, fields, maybe_expr) => {
             expr_struct(fld.fold_path(path),
                         vec::map(fields, |x| fold_field(*x)),
-                        option::map(&maybe_expr, |x| fld.fold_expr(x)))
+                        option::map(&maybe_expr, |x| fld.fold_expr(*x)))
           }
         }
 }
@@ -577,7 +577,7 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
                 let dtor_id   = fld.new_id(dtor.node.id);
                 {node: {body: dtor_body,
                         id: dtor_id,.. dtor.node},
-                    .. dtor}};
+                    .. *dtor}};
             kind = struct_variant_kind(@{
                 traits: ~[],
                 fields: vec::map(struct_def.fields,
@@ -593,7 +593,7 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
             let variants = vec::map(enum_definition.variants,
                                     |x| fld.fold_variant(*x));
             let common = option::map(&enum_definition.common,
-                                     |x| fold_struct_def(x, fld));
+                                     |x| fold_struct_def(*x, fld));
             kind = enum_variant_kind(ast::enum_def({ variants: variants,
                                                      common: common }));
         }
diff --git a/src/libsyntax/parse.rs b/src/libsyntax/parse.rs
index 751b3ce62b9..2c04b2a1419 100644
--- a/src/libsyntax/parse.rs
+++ b/src/libsyntax/parse.rs
@@ -73,7 +73,7 @@ fn parse_crate_from_crate_file(input: &Path, cfg: ast::crate_cfg,
     sess.chpos = rdr.chpos;
     sess.byte_pos = sess.byte_pos + rdr.pos;
     let cx = @{sess: sess, cfg: /* FIXME (#2543) */ copy p.cfg};
-    let companionmod = input.filestem().map(|s| Path(s));
+    let companionmod = input.filestem().map(|s| Path(*s));
     let (m, attrs) = eval::eval_crate_directives_to_mod(
         cx, cdirs, &prefix, &companionmod);
     let mut hi = p.span.hi;
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index b650a8890c5..f8ad6c541f6 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2758,7 +2758,7 @@ impl parser {
         }
 
         let actual_dtor = do the_dtor.map |dtor| {
-            let (d_body, d_attrs, d_s) = dtor;
+            let (d_body, d_attrs, d_s) = *dtor;
             {node: {id: self.get_id(),
                     attrs: d_attrs,
                     self_id: self.get_id(),
@@ -3126,7 +3126,7 @@ impl parser {
         }
         self.bump();
         let mut actual_dtor = do the_dtor.map |dtor| {
-            let (d_body, d_attrs, d_s) = dtor;
+            let (d_body, d_attrs, d_s) = *dtor;
             {node: {id: self.get_id(),
                     attrs: d_attrs,
                     self_id: self.get_id(),
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index de9caf48b63..93ef9508610 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -395,7 +395,7 @@ fn visit_exprs<E>(exprs: ~[@expr], e: E, v: vt<E>) {
 fn visit_mac<E>(m: mac, e: E, v: vt<E>) {
     match m.node {
       ast::mac_invoc(_, arg, _) => {
-        option::map(&arg, |arg| v.visit_expr(arg, e, v)); }
+        option::map(&arg, |arg| v.visit_expr(*arg, e, v)); }
       ast::mac_invoc_tt(*) => { /* no user-serviceable parts inside */ }
       ast::mac_ellipsis => (),
       ast::mac_aq(*) => { /* FIXME: maybe visit (Issue #2340) */ }
diff --git a/src/rustc/driver/driver.rs b/src/rustc/driver/driver.rs
index 3acacd3c0a5..e389f3a4bdf 100644
--- a/src/rustc/driver/driver.rs
+++ b/src/rustc/driver/driver.rs
@@ -507,7 +507,7 @@ fn build_session_options(binary: ~str,
     let extra_debuginfo = opt_present(matches, ~"xg");
     let debuginfo = opt_present(matches, ~"g") || extra_debuginfo;
     let sysroot_opt = getopts::opt_maybe_str(matches, ~"sysroot");
-    let sysroot_opt = sysroot_opt.map(|m| Path(m));
+    let sysroot_opt = sysroot_opt.map(|m| Path(*m));
     let target_opt = getopts::opt_maybe_str(matches, ~"target");
     let save_temps = getopts::opt_present(matches, ~"save-temps");
     match output_type {
diff --git a/src/rustc/driver/rustc.rs b/src/rustc/driver/rustc.rs
index 6ea5bb28023..38ce7a4fbac 100644
--- a/src/rustc/driver/rustc.rs
+++ b/src/rustc/driver/rustc.rs
@@ -172,14 +172,14 @@ fn run_compiler(args: ~[~str], demitter: diagnostic::emitter) {
     let sopts = build_session_options(binary, matches, demitter);
     let sess = build_session(sopts, demitter);
     let odir = getopts::opt_maybe_str(matches, ~"out-dir");
-    let odir = odir.map(|o| Path(o));
+    let odir = odir.map(|o| Path(*o));
     let ofile = getopts::opt_maybe_str(matches, ~"o");
-    let ofile = ofile.map(|o| Path(o));
+    let ofile = ofile.map(|o| Path(*o));
     let cfg = build_configuration(sess, binary, input);
     let pretty =
         option::map(&getopts::opt_default(matches, ~"pretty",
                                          ~"normal"),
-                    |a| parse_pretty(sess, a) );
+                    |a| parse_pretty(sess, *a) );
     match pretty {
       Some::<pp_mode>(ppm) => {
         pretty_print_input(sess, cfg, input, ppm);
diff --git a/src/rustc/front/config.rs b/src/rustc/front/config.rs
index 4c262e3dc65..7e0d9ec2e86 100644
--- a/src/rustc/front/config.rs
+++ b/src/rustc/front/config.rs
@@ -104,7 +104,7 @@ fn fold_block(cx: ctxt, b: ast::blk_, fld: fold::ast_fold) ->
     let filtered_stmts = vec::filter_map(b.stmts, filter);
     return {view_items: b.view_items,
          stmts: vec::map(filtered_stmts, |x| fld.fold_stmt(*x)),
-         expr: option::map(&b.expr, |x| fld.fold_expr(x)),
+         expr: option::map(&b.expr, |x| fld.fold_expr(*x)),
          id: b.id,
          rules: b.rules};
 }
diff --git a/src/rustc/metadata/cstore.rs b/src/rustc/metadata/cstore.rs
index edf6a9612c7..49e79e009da 100644
--- a/src/rustc/metadata/cstore.rs
+++ b/src/rustc/metadata/cstore.rs
@@ -177,7 +177,7 @@ fn get_dep_hashes(cstore: cstore) -> ~[~str] {
 
 fn get_path(cstore: cstore, d: ast::def_id) -> ~[~str] {
     option::map_default(&p(cstore).mod_path_map.find(d), ~[],
-                        |ds| str::split_str(*ds, ~"::"))
+                        |ds| str::split_str(**ds, ~"::"))
 }
 // Local Variables:
 // mode: rust
diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs
index a6bb681bc16..bebf8344c08 100644
--- a/src/rustc/metadata/decoder.rs
+++ b/src/rustc/metadata/decoder.rs
@@ -196,7 +196,7 @@ fn field_mutability(d: ebml::Doc) -> ast::class_mutability {
         &ebml::maybe_get_doc(d, tag_class_mut),
         ast::class_immutable,
         |d| {
-            match ebml::doc_as_u8(d) as char {
+            match ebml::doc_as_u8(*d) as char {
               'm' => ast::class_mutable,
               _   => ast::class_immutable
             }
@@ -246,7 +246,7 @@ fn item_ty_param_bounds(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd)
 
 fn item_ty_region_param(item: ebml::Doc) -> Option<ty::region_variance> {
     ebml::maybe_get_doc(item, tag_region_param).map(|doc| {
-        let d = ebml::ebml_deserializer(doc);
+        let d = ebml::ebml_deserializer(*doc);
         ty::deserialize_region_variance(d)
     })
 }
diff --git a/src/rustc/middle/borrowck/check_loans.rs b/src/rustc/middle/borrowck/check_loans.rs
index cedab91b04e..841d54c6b0d 100644
--- a/src/rustc/middle/borrowck/check_loans.rs
+++ b/src/rustc/middle/borrowck/check_loans.rs
@@ -183,7 +183,7 @@ impl check_loan_ctxt {
         debug!("check_pure_callee_or_arg(pc=%?, expr=%?, \
                 callee_id=%d, ty=%s)",
                pc,
-               opt_expr.map(|e| pprust::expr_to_str(e, tcx.sess.intr()) ),
+               opt_expr.map(|e| pprust::expr_to_str(*e, tcx.sess.intr()) ),
                callee_id,
                ty_to_str(self.tcx(), ty::node_id_to_type(tcx, callee_id)));
 
diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs
index b39b7914905..ce998378fe5 100644
--- a/src/rustc/middle/liveness.rs
+++ b/src/rustc/middle/liveness.rs
@@ -659,7 +659,7 @@ impl Liveness {
           expr_path(_) => {
             let def = self.tcx.def_map.get(expr.id);
             relevant_def(def).map(
-                |rdef| self.variable_from_rdef(rdef, expr.span)
+                |rdef| self.variable_from_rdef(*rdef, expr.span)
             )
           }
           _ => None
@@ -675,7 +675,7 @@ impl Liveness {
         match self.tcx.def_map.find(node_id) {
           Some(def) => {
             relevant_def(def).map(
-                |rdef| self.variable_from_rdef(rdef, span)
+                |rdef| self.variable_from_rdef(*rdef, span)
             )
           }
           None => {
@@ -1396,7 +1396,7 @@ impl Liveness {
                 // Note: the field_map is empty unless we are in a ctor
                 return self.ir.field_map.find(fld).map(|var| {
                     let ln = self.live_node(expr.id, expr.span);
-                    (ln, var)
+                    (ln, *var)
                 });
               }
               _ => return None
diff --git a/src/rustc/middle/mem_categorization.rs b/src/rustc/middle/mem_categorization.rs
index 03d453a84f5..a9f4c195765 100644
--- a/src/rustc/middle/mem_categorization.rs
+++ b/src/rustc/middle/mem_categorization.rs
@@ -612,7 +612,7 @@ impl &mem_categorization_ctxt {
                                 cmt: cmt) -> cmt {
         @{id: arg.id(), span: arg.span(),
           cat: cat_comp(cmt, comp_variant(enum_did)),
-          lp: cmt.lp.map(|l| @lp_comp(l, comp_variant(enum_did)) ),
+          lp: cmt.lp.map(|l| @lp_comp(*l, comp_variant(enum_did)) ),
           mutbl: cmt.mutbl, // imm iff in an immutable context
           ty: self.tcx.ty(arg)}
     }
@@ -649,7 +649,7 @@ impl &mem_categorization_ctxt {
         };
         let m = self.inherited_mutability(base_cmt.mutbl, f_mutbl);
         let f_comp = comp_field(f_name, f_mutbl);
-        let lp = base_cmt.lp.map(|lp| @lp_comp(lp, f_comp) );
+        let lp = base_cmt.lp.map(|lp| @lp_comp(*lp, f_comp) );
         @{id: node.id(), span: node.span(),
           cat: cat_comp(base_cmt, f_comp), lp:lp,
           mutbl: m, ty: self.tcx.ty(node)}
@@ -699,7 +699,7 @@ impl &mem_categorization_ctxt {
             }
 
             deref_comp(comp) => {
-                let lp = base_cmt.lp.map(|l| @lp_comp(l, comp) );
+                let lp = base_cmt.lp.map(|l| @lp_comp(*l, comp) );
                 let m = self.inherited_mutability(base_cmt.mutbl, mt.mutbl);
                 @{id:node.id(), span:node.span(),
                   cat:cat_comp(base_cmt, comp), lp:lp,
@@ -724,7 +724,7 @@ impl &mem_categorization_ctxt {
             // (a) the contents are loanable if the base is loanable
             // and this is a *unique* vector
             let deref_lp = match ptr {
-              uniq_ptr => {base_cmt.lp.map(|lp| @lp_deref(lp, uniq_ptr))}
+              uniq_ptr => {base_cmt.lp.map(|lp| @lp_deref(*lp, uniq_ptr))}
               _ => {None}
             };
 
@@ -756,7 +756,7 @@ impl &mem_categorization_ctxt {
         fn comp(expr: @ast::expr, of_cmt: cmt,
                 vect: ty::t, mutbl: ast::mutability, ty: ty::t) -> cmt {
             let comp = comp_index(vect, mutbl);
-            let index_lp = of_cmt.lp.map(|lp| @lp_comp(lp, comp) );
+            let index_lp = of_cmt.lp.map(|lp| @lp_comp(*lp, comp) );
             @{id:expr.id, span:expr.span,
               cat:cat_comp(of_cmt, comp), lp:index_lp,
               mutbl:mutbl, ty:ty}
@@ -766,7 +766,7 @@ impl &mem_categorization_ctxt {
     fn cat_tuple_elt<N: ast_node>(elt: N, cmt: cmt) -> cmt {
         @{id: elt.id(), span: elt.span(),
           cat: cat_comp(cmt, comp_tuple),
-          lp: cmt.lp.map(|l| @lp_comp(l, comp_tuple) ),
+          lp: cmt.lp.map(|l| @lp_comp(*l, comp_tuple) ),
           mutbl: cmt.mutbl, // imm iff in an immutable context
           ty: self.tcx.ty(elt)}
     }
@@ -958,7 +958,7 @@ impl &mem_categorization_ctxt {
              self.cat_to_repr(cmt.cat),
              cmt.id,
              self.mut_to_str(cmt.mutbl),
-             cmt.lp.map_default(~"none", |p| self.lp_to_str(p) ),
+             cmt.lp.map_default(~"none", |p| self.lp_to_str(*p) ),
              ty_to_str(self.tcx, cmt.ty))
     }
 
diff --git a/src/rustc/middle/trans/callee.rs b/src/rustc/middle/trans/callee.rs
index 470d4dbb4ab..e7b4dd171e3 100644
--- a/src/rustc/middle/trans/callee.rs
+++ b/src/rustc/middle/trans/callee.rs
@@ -537,7 +537,7 @@ fn trans_arg_expr(bcx: block,
             ret_flag=%?)",
            formal_ty.mode, bcx.ty_to_str(formal_ty.ty),
            bcx.expr_to_str(arg_expr),
-           ret_flag.map(|v| bcx.val_str(v)));
+           ret_flag.map(|v| bcx.val_str(*v)));
     let _indenter = indenter();
 
     // translate the arg expr to a datum
diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs
index 0df63e40acf..6f14b22d778 100644
--- a/src/rustc/middle/trans/common.rs
+++ b/src/rustc/middle/trans/common.rs
@@ -1222,7 +1222,7 @@ fn node_id_type_params(bcx: block, id: ast::node_id) -> ~[ty::t] {
 fn node_vtables(bcx: block, id: ast::node_id) -> Option<typeck::vtable_res> {
     let raw_vtables = bcx.ccx().maps.vtable_map.find(id);
     raw_vtables.map(
-        |vts| meth::resolve_vtables_in_fn_ctxt(bcx.fcx, vts))
+        |vts| meth::resolve_vtables_in_fn_ctxt(bcx.fcx, *vts))
 }
 
 fn resolve_vtables_in_fn_ctxt(fcx: fn_ctxt, vts: typeck::vtable_res)
diff --git a/src/rustc/middle/trans/glue.rs b/src/rustc/middle/trans/glue.rs
index 50a24a1a825..a8a750cd4be 100644
--- a/src/rustc/middle/trans/glue.rs
+++ b/src/rustc/middle/trans/glue.rs
@@ -192,16 +192,16 @@ fn lazily_emit_simplified_tydesc_glue(ccx: @crate_ctxt, field: uint,
         lazily_emit_tydesc_glue(ccx, field, simpl_ti);
         if field == abi::tydesc_field_take_glue {
             ti.take_glue =
-                simpl_ti.take_glue.map(|v| cast_glue(ccx, ti, v));
+                simpl_ti.take_glue.map(|v| cast_glue(ccx, ti, *v));
         } else if field == abi::tydesc_field_drop_glue {
             ti.drop_glue =
-                simpl_ti.drop_glue.map(|v| cast_glue(ccx, ti, v));
+                simpl_ti.drop_glue.map(|v| cast_glue(ccx, ti, *v));
         } else if field == abi::tydesc_field_free_glue {
             ti.free_glue =
-                simpl_ti.free_glue.map(|v| cast_glue(ccx, ti, v));
+                simpl_ti.free_glue.map(|v| cast_glue(ccx, ti, *v));
         } else if field == abi::tydesc_field_visit_glue {
             ti.visit_glue =
-                simpl_ti.visit_glue.map(|v| cast_glue(ccx, ti, v));
+                simpl_ti.visit_glue.map(|v| cast_glue(ccx, ti, *v));
         }
         return true;
     }
@@ -398,7 +398,7 @@ fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) {
       ty::ty_class(did, ref substs) => {
         // Call the dtor if there is one
         do option::map_default(&ty::ty_dtor(bcx.tcx(), did), bcx) |dt_id| {
-            trans_class_drop(bcx, v, dt_id, did, substs)
+            trans_class_drop(bcx, v, *dt_id, did, substs)
         }
       }
       _ => bcx
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index ed71d27451c..06eb26ec4e7 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -1177,7 +1177,7 @@ fn fold_sty_to_ty(tcx: ty::ctxt, sty: &sty, foldop: fn(t) -> t) -> t {
 fn fold_sty(sty: &sty, fldop: fn(t) -> t) -> sty {
     fn fold_substs(substs: &substs, fldop: fn(t) -> t) -> substs {
         {self_r: substs.self_r,
-         self_ty: substs.self_ty.map(|t| fldop(t)),
+         self_ty: substs.self_ty.map(|t| fldop(*t)),
          tps: substs.tps.map(|t| fldop(*t))}
     }
 
@@ -1273,8 +1273,8 @@ fn fold_regions_and_ty(
         fldr: fn(r: region) -> region,
         fldt: fn(t: t) -> t) -> substs {
 
-        {self_r: substs.self_r.map(|r| fldr(r)),
-         self_ty: substs.self_ty.map(|t| fldt(t)),
+        {self_r: substs.self_r.map(|r| fldr(*r)),
+         self_ty: substs.self_ty.map(|t| fldt(*t)),
          tps: substs.tps.map(|t| fldt(*t))}
     }
 
@@ -1403,8 +1403,8 @@ fn substs_is_noop(substs: &substs) -> bool {
 
 fn substs_to_str(cx: ctxt, substs: &substs) -> ~str {
     fmt!("substs(self_r=%s, self_ty=%s, tps=%?)",
-         substs.self_r.map_default(~"none", |r| region_to_str(cx, r)),
-         substs.self_ty.map_default(~"none", |t| ty_to_str(cx, t)),
+         substs.self_r.map_default(~"none", |r| region_to_str(cx, *r)),
+         substs.self_ty.map_default(~"none", |t| ty_to_str(cx, *t)),
          tys_to_str(cx, substs.tps))
 }
 
diff --git a/src/rustc/middle/typeck/check/regionmanip.rs b/src/rustc/middle/typeck/check/regionmanip.rs
index aec42f77048..29d4e9927ff 100644
--- a/src/rustc/middle/typeck/check/regionmanip.rs
+++ b/src/rustc/middle/typeck/check/regionmanip.rs
@@ -37,7 +37,7 @@ fn replace_bound_regions_in_fn_ty(
 
     debug!("replace_bound_regions_in_fn_ty(self_info.self_ty=%?, fn_ty=%s, \
                 all_tys=%?)",
-           self_ty.map(|t| ty_to_str(tcx, t)),
+           self_ty.map(|t| ty_to_str(tcx, *t)),
            ty_to_str(tcx, ty::mk_fn(tcx, *fn_ty)),
            all_tys.map(|t| ty_to_str(tcx, *t)));
     let _i = indenter();
@@ -50,11 +50,11 @@ fn replace_bound_regions_in_fn_ty(
     let t_fn = ty::fold_sty_to_ty(tcx, &ty_fn, |t| {
         replace_bound_regions(tcx, isr, t)
     });
-    let t_self = self_ty.map(|t| replace_bound_regions(tcx, isr, t));
+    let t_self = self_ty.map(|t| replace_bound_regions(tcx, isr, *t));
 
     debug!("result of replace_bound_regions_in_fn_ty: self_info.self_ty=%?, \
                 fn_ty=%s",
-           t_self.map(|t| ty_to_str(tcx, t)),
+           t_self.map(|t| ty_to_str(tcx, *t)),
            ty_to_str(tcx, t_fn));
 
 
diff --git a/src/rustc/middle/typeck/check/vtable.rs b/src/rustc/middle/typeck/check/vtable.rs
index 453559e5e42..38ca571dae5 100644
--- a/src/rustc/middle/typeck/check/vtable.rs
+++ b/src/rustc/middle/typeck/check/vtable.rs
@@ -69,7 +69,7 @@ fn fixup_substs(fcx: @fn_ctxt, expr: @ast::expr,
     // use a dummy type just to package up the substs that need fixing up
     let t = ty::mk_trait(tcx, id, substs, ty::vstore_slice(ty::re_static));
     do fixup_ty(fcx, expr, t, is_early).map |t_f| {
-        match ty::get(t_f).sty {
+        match ty::get(*t_f).sty {
           ty::ty_trait(_, substs_f, _) => substs_f,
           _ => fail ~"t_f should be a trait"
         }
diff --git a/src/rustdoc/config.rs b/src/rustdoc/config.rs
index d8e79182506..c57e712c020 100644
--- a/src/rustdoc/config.rs
+++ b/src/rustdoc/config.rs
@@ -141,7 +141,7 @@ fn config_from_opts(
     let result = result::Ok(config);
     let result = do result::chain(result) |config| {
         let output_dir = getopts::opt_maybe_str(matches, opt_output_dir());
-        let output_dir = output_dir.map(|s| Path(s));
+        let output_dir = output_dir.map(|s| Path(*s));
         result::Ok({
             output_dir: output_dir.get_default(config.output_dir),
             .. config
@@ -152,7 +152,7 @@ fn config_from_opts(
             matches, opt_output_format());
         do output_format.map_default(result::Ok(config))
             |output_format| {
-            do result::chain(parse_output_format(output_format))
+            do result::chain(parse_output_format(*output_format))
                 |output_format| {
 
                 result::Ok({
@@ -167,7 +167,7 @@ fn config_from_opts(
             getopts::opt_maybe_str(matches, opt_output_style());
         do output_style.map_default(result::Ok(config))
             |output_style| {
-            do result::chain(parse_output_style(output_style))
+            do result::chain(parse_output_style(*output_style))
                 |output_style| {
                 result::Ok({
                     output_style: output_style,
diff --git a/src/rustdoc/text_pass.rs b/src/rustdoc/text_pass.rs
index 76ae3192cef..0da3491c364 100644
--- a/src/rustdoc/text_pass.rs
+++ b/src/rustdoc/text_pass.rs
@@ -32,7 +32,7 @@ fn run(
 }
 
 fn maybe_apply_op(op: Op, s: Option<~str>) -> Option<~str> {
-    s.map(|s| op(s) )
+    s.map(|s| op(*s) )
 }
 
 fn fold_item(fold: fold::Fold<Op>, doc: doc::ItemDoc) -> doc::ItemDoc {
-- 
cgit 1.4.1-3-g733a5


From 7b0ed94bdc6f42f0abed2ee2e293e3800725eaeb Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Thu, 27 Sep 2012 17:42:25 -0700
Subject: rustc: Make enum export visibility inherit properly

---
 src/rustc/middle/resolve.rs                  | 15 ++++++++++-----
 src/test/run-pass/enum-export-inheritance.rs | 12 ++++++++++++
 2 files changed, 22 insertions(+), 5 deletions(-)
 create mode 100644 src/test/run-pass/enum-export-inheritance.rs

(limited to 'src/rustc')

diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs
index 99d98c52f95..def21ae03e0 100644
--- a/src/rustc/middle/resolve.rs
+++ b/src/rustc/middle/resolve.rs
@@ -1063,6 +1063,7 @@ impl Resolver {
                 for enum_definition.variants.each |variant| {
                     self.build_reduced_graph_for_variant(*variant,
                                                          local_def(item.id),
+                                                         privacy,
                                                          new_parent,
                                                          visitor);
                 }
@@ -1156,17 +1157,20 @@ impl Resolver {
     // type and/or value namespaces.
     fn build_reduced_graph_for_variant(variant: variant,
                                        item_id: def_id,
+                                       +parent_privacy: Privacy,
                                        parent: ReducedGraphParent,
                                        &&visitor: vt<ReducedGraphParent>) {
 
-        let legacy = match parent {
-          ModuleReducedGraphParent(m) => m.legacy_exports
-        };
-
         let ident = variant.node.name;
         let (child, _) = self.add_child(ident, parent, ~[ValueNS],
                                         variant.span);
-        let privacy = self.visibility_to_privacy(variant.node.vis, legacy);
+
+        let privacy;
+        match variant.node.vis {
+            public => privacy = Public,
+            private => privacy = Private,
+            inherited => privacy = parent_privacy
+        }
 
         match variant.node.kind {
             tuple_variant_kind(_) => {
@@ -1188,6 +1192,7 @@ impl Resolver {
                                      variant.span);
                 for enum_definition.variants.each |variant| {
                     self.build_reduced_graph_for_variant(*variant, item_id,
+                                                         parent_privacy,
                                                          parent, visitor);
                 }
             }
diff --git a/src/test/run-pass/enum-export-inheritance.rs b/src/test/run-pass/enum-export-inheritance.rs
new file mode 100644
index 00000000000..1fddddba331
--- /dev/null
+++ b/src/test/run-pass/enum-export-inheritance.rs
@@ -0,0 +1,12 @@
+mod a {
+    pub enum Foo {
+        Bar,
+        Baz,
+        Boo
+    }
+}
+
+fn main() {
+    let x = a::Bar;
+}
+
-- 
cgit 1.4.1-3-g733a5


From 438bdd687b8604090676422239f95e92149caddd Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Thu, 27 Sep 2012 17:01:28 -0700
Subject: core: More option demoding

---
 src/compiletest/header.rs              |  4 ++--
 src/libcore/iter.rs                    |  4 ++--
 src/libcore/option.rs                  | 27 +++++++++------------------
 src/libcore/os.rs                      |  6 +++---
 src/libcore/task/spawn.rs              |  2 +-
 src/libsyntax/print/pprust.rs          |  8 ++++----
 src/libsyntax/visit.rs                 |  6 +++---
 src/rustc/metadata/decoder.rs          |  2 +-
 src/rustc/metadata/encoder.rs          |  4 ++--
 src/rustc/middle/astencode.rs          | 18 +++++++++---------
 src/rustc/middle/check_alt.rs          |  2 +-
 src/rustc/middle/check_const.rs        |  2 +-
 src/rustc/middle/kind.rs               |  8 ++++----
 src/rustc/middle/mem_categorization.rs |  4 ++--
 src/rustc/middle/resolve.rs            |  2 +-
 src/rustc/middle/trans/base.rs         |  4 ++--
 src/rustc/middle/trans/closure.rs      |  2 +-
 src/rustc/middle/trans/common.rs       |  2 +-
 src/rustc/middle/trans/type_use.rs     |  4 ++--
 src/rustc/middle/ty.rs                 |  2 +-
 src/rustc/middle/typeck/astconv.rs     |  2 +-
 src/rustc/middle/typeck/check.rs       | 10 +++++-----
 src/rustc/middle/typeck/check/alt.rs   |  2 +-
 src/rustc/middle/typeck/coherence.rs   |  2 +-
 24 files changed, 60 insertions(+), 69 deletions(-)

(limited to 'src/rustc')

diff --git a/src/compiletest/header.rs b/src/compiletest/header.rs
index d72a9d65e05..3071c9a70a1 100644
--- a/src/compiletest/header.rs
+++ b/src/compiletest/header.rs
@@ -41,11 +41,11 @@ fn load_props(testfile: &Path) -> test_props {
         }
 
         do parse_aux_build(ln).iter |ab| {
-            aux_builds.push(ab);
+            aux_builds.push(*ab);
         }
 
         do parse_exec_env(ln).iter |ee| {
-            exec_env.push(ee);
+            exec_env.push(*ee);
         }
     };
     return {
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index bc1955698fc..3a2f5d604c0 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -289,8 +289,8 @@ pure fn from_elem<T: Copy,BT: Buildable<T>>(n_elts: uint, t: T) -> BT {
 #[inline(always)]
 pure fn append<T: Copy,IT: BaseIter<T>,BT: Buildable<T>>(
     lhs: IT, rhs: IT) -> BT {
-    let size_opt = lhs.size_hint().chain(
-        |sz1| rhs.size_hint().map(|sz2| sz1+*sz2));
+    let size_opt = lhs.size_hint().chain_ref(
+        |sz1| rhs.size_hint().map(|sz2| *sz1+*sz2));
     do build_sized_opt(size_opt) |push| {
         for lhs.each |x| { push(*x); }
         for rhs.each |x| { push(*x); }
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index ae28c6db083..f92e1aebdb2 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -75,13 +75,18 @@ pure fn map_consume<T, U>(+opt: Option<T>, f: fn(+v: T) -> U) -> Option<U> {
     if opt.is_some() { Some(f(option::unwrap(move opt))) } else { None }
 }
 
-pure fn chain<T, U>(opt: &Option<T>, f: fn(T) -> Option<U>) -> Option<U> {
+pure fn chain<T, U>(+opt: Option<T>, f: fn(+t: T) -> Option<U>) -> Option<U> {
     /*!
      * Update an optional value by optionally running its content through a
      * function that returns an option.
      */
 
-    match *opt { Some(x) => f(x), None => None }
+    // XXX write with move match
+    if opt.is_some() {
+        f(unwrap(opt))
+    } else {
+        None
+    }
 }
 
 pure fn chain_ref<T, U>(opt: &Option<T>,
@@ -139,14 +144,7 @@ pure fn map_default<T, U>(opt: &Option<T>, +def: U,
     match *opt { None => move def, Some(ref t) => f(t) }
 }
 
-// This should change to by-copy mode; use iter_ref below for by reference
-pure fn iter<T>(opt: &Option<T>, f: fn(T)) {
-    //! Performs an operation on the contained value or does nothing
-
-    match *opt { None => (), Some(t) => f(t) }
-}
-
-pure fn iter_ref<T>(opt: &Option<T>, f: fn(x: &T)) {
+pure fn iter<T>(opt: &Option<T>, f: fn(x: &T)) {
     //! Performs an operation on the contained value by reference
     match *opt { None => (), Some(ref t) => f(t) }
 }
@@ -182,13 +180,6 @@ pure fn unwrap_expect<T>(+opt: Option<T>, reason: &str) -> T {
 
 // Some of these should change to be &Option<T>, some should not. See below.
 impl<T> Option<T> {
-    /**
-     * Update an optional value by optionally running its content through a
-     * function that returns an option.
-     */
-    pure fn chain<U>(f: fn(T) -> Option<U>) -> Option<U> { chain(&self, f) }
-    /// Performs an operation on the contained value or does nothing
-    pure fn iter(f: fn(T)) { iter(&self, f) }
     /// Returns true if the option equals `none`
     pure fn is_none() -> bool { is_none(&self) }
     /// Returns true if the option contains some value
@@ -207,7 +198,7 @@ impl<T> &Option<T> {
     pure fn map_default<U>(+def: U, f: fn(x: &T) -> U) -> U
         { map_default(self, move def, f) }
     /// Performs an operation on the contained value by reference
-    pure fn iter_ref(f: fn(x: &T)) { iter_ref(self, f) }
+    pure fn iter(f: fn(x: &T)) { iter(self, f) }
     /// Maps a `some` value from one type to another by reference
     pure fn map<U>(f: fn(x: &T) -> U) -> Option<U> { map(self, f) }
     /// Gets an immutable reference to the value inside a `some`.
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
index 0b67b136c7f..c1ea71c181b 100644
--- a/src/libcore/os.rs
+++ b/src/libcore/os.rs
@@ -884,7 +884,7 @@ mod tests {
         setenv(~"HOME", ~"");
         assert os::homedir().is_none();
 
-        oldhome.iter(|s| setenv(~"HOME", s));
+        oldhome.iter(|s| setenv(~"HOME", *s));
     }
 
     #[test]
@@ -911,9 +911,9 @@ mod tests {
         setenv(~"USERPROFILE", ~"/home/PaloAlto");
         assert os::homedir() == Some(Path("/home/MountainView"));
 
-        option::iter(&oldhome, |s| setenv(~"HOME", s));
+        option::iter(&oldhome, |s| setenv(~"HOME", *s));
         option::iter(&olduserprofile,
-                               |s| setenv(~"USERPROFILE", s));
+                               |s| setenv(~"USERPROFILE", *s));
     }
 
     #[test]
diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs
index f2568414392..45e0d0f1a0d 100644
--- a/src/libcore/task/spawn.rs
+++ b/src/libcore/task/spawn.rs
@@ -240,7 +240,7 @@ fn each_ancestor(list:        &mut AncestorList,
                 if need_unwind && !nobe_is_dead {
                     do bail_opt.iter |bail_blk| {
                         do with_parent_tg(&mut nobe.parent_group) |tg_opt| {
-                            bail_blk(tg_opt)
+                            (*bail_blk)(tg_opt)
                         }
                     }
                 }
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 00652346e10..5d1067da762 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -979,7 +979,7 @@ fn print_mac(s: ps, m: ast::mac) {
           Some(@{node: ast::expr_vec(_, _), _}) => (),
           _ => word(s.s, ~" ")
         }
-        arg.iter(|a| print_expr(s, a));
+        arg.iter(|a| print_expr(s, *a));
         // FIXME: extension 'body' (#2339)
       }
       ast::mac_invoc_tt(pth, tts) => {
@@ -1177,7 +1177,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
       ast::expr_loop(blk, opt_ident) => {
         head(s, ~"loop");
         space(s.s);
-        opt_ident.iter(|ident| {print_ident(s, ident); space(s.s)});
+        opt_ident.iter(|ident| {print_ident(s, *ident); space(s.s)});
         print_block(s, blk);
       }
       ast::expr_match(expr, arms) => {
@@ -1360,12 +1360,12 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
       ast::expr_break(opt_ident) => {
         word(s.s, ~"break");
         space(s.s);
-        opt_ident.iter(|ident| {print_ident(s, ident); space(s.s)});
+        opt_ident.iter(|ident| {print_ident(s, *ident); space(s.s)});
       }
       ast::expr_again(opt_ident) => {
         word(s.s, ~"loop");
         space(s.s);
-        opt_ident.iter(|ident| {print_ident(s, ident); space(s.s)});
+        opt_ident.iter(|ident| {print_ident(s, *ident); space(s.s)});
       }
       ast::expr_ret(result) => {
         word(s.s, ~"return");
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 93ef9508610..e6fd65eb458 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -241,7 +241,7 @@ fn visit_pat<E>(p: @pat, e: E, v: vt<E>) {
           v.visit_pat(inner, e, v),
       pat_ident(_, path, inner) => {
           visit_path(path, e, v);
-          do option::iter(&inner) |subpat| { v.visit_pat(subpat, e, v)};
+          do option::iter(&inner) |subpat| { v.visit_pat(*subpat, e, v)};
       }
       pat_lit(ex) => v.visit_expr(ex, e, v),
       pat_range(e1, e2) => { v.visit_expr(e1, e, v); v.visit_expr(e2, e, v); }
@@ -342,10 +342,10 @@ fn visit_struct_def<E>(sd: @struct_def, nm: ast::ident, tps: ~[ty_param],
         visit_path(p.path, e, v);
     }
     do option::iter(&sd.ctor) |ctor| {
-      visit_class_ctor_helper(ctor, nm, tps, ast_util::local_def(id), e, v);
+      visit_class_ctor_helper(*ctor, nm, tps, ast_util::local_def(id), e, v);
     };
     do option::iter(&sd.dtor) |dtor| {
-      visit_class_dtor_helper(dtor, tps, ast_util::local_def(id), e, v)
+      visit_class_dtor_helper(*dtor, tps, ast_util::local_def(id), e, v)
     };
 }
 
diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs
index bebf8344c08..d7fd8036c46 100644
--- a/src/rustc/metadata/decoder.rs
+++ b/src/rustc/metadata/decoder.rs
@@ -204,7 +204,7 @@ fn field_mutability(d: ebml::Doc) -> ast::class_mutability {
 }
 
 fn variant_disr_val(d: ebml::Doc) -> Option<int> {
-    do option::chain(&ebml::maybe_get_doc(d, tag_disr_val)) |val_doc| {
+    do option::chain(ebml::maybe_get_doc(d, tag_disr_val)) |val_doc| {
         int::parse_bytes(ebml::doc_data(val_doc), 10u)
     }
 }
diff --git a/src/rustc/metadata/encoder.rs b/src/rustc/metadata/encoder.rs
index 8edee2bfe48..87ef3b4749c 100644
--- a/src/rustc/metadata/encoder.rs
+++ b/src/rustc/metadata/encoder.rs
@@ -609,7 +609,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::Writer, item: @item,
                                    ecx.tcx.sess.str_of(item.ident) +
                                    ~"_dtor"),
                                path, if tps.len() > 0u {
-                                   Some(ii_dtor(dtor, item.ident, tps,
+                                   Some(ii_dtor(*dtor, item.ident, tps,
                                                 local_def(item.id))) }
                                else { None }, tps);
         }
@@ -715,7 +715,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::Writer, item: @item,
             ebml_w.end_tag();
         }
         do opt_trait.iter() |associated_trait| {
-           encode_trait_ref(ebml_w, ecx, associated_trait)
+           encode_trait_ref(ebml_w, ecx, *associated_trait)
         }
         encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
         ebml_w.end_tag();
diff --git a/src/rustc/middle/astencode.rs b/src/rustc/middle/astencode.rs
index acb7bb1bf2c..9332ebe9770 100644
--- a/src/rustc/middle/astencode.rs
+++ b/src/rustc/middle/astencode.rs
@@ -723,7 +723,7 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
         do ebml_w.tag(c::tag_table_def) {
             ebml_w.id(id);
             do ebml_w.tag(c::tag_table_val) {
-                ast::serialize_def(ebml_w, def)
+                ast::serialize_def(ebml_w, *def)
             }
         }
     }
@@ -731,7 +731,7 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
         do ebml_w.tag(c::tag_table_node_type) {
             ebml_w.id(id);
             do ebml_w.tag(c::tag_table_val) {
-                ebml_w.emit_ty(ecx, ty);
+                ebml_w.emit_ty(ecx, *ty);
             }
         }
     }
@@ -740,7 +740,7 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
         do ebml_w.tag(c::tag_table_node_type_subst) {
             ebml_w.id(id);
             do ebml_w.tag(c::tag_table_val) {
-                ebml_w.emit_tys(ecx, tys)
+                ebml_w.emit_tys(ecx, *tys)
             }
         }
     }
@@ -749,7 +749,7 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
         do ebml_w.tag(c::tag_table_freevars) {
             ebml_w.id(id);
             do ebml_w.tag(c::tag_table_val) {
-                do ebml_w.emit_from_vec(*fv) |fv_entry| {
+                do ebml_w.emit_from_vec(**fv) |fv_entry| {
                     encode_freevar_entry(ebml_w, *fv_entry)
                 }
             }
@@ -761,7 +761,7 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
         do ebml_w.tag(c::tag_table_tcache) {
             ebml_w.id(id);
             do ebml_w.tag(c::tag_table_val) {
-                ebml_w.emit_tpbt(ecx, tpbt);
+                ebml_w.emit_tpbt(ecx, *tpbt);
             }
         }
     }
@@ -770,7 +770,7 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
         do ebml_w.tag(c::tag_table_param_bounds) {
             ebml_w.id(id);
             do ebml_w.tag(c::tag_table_val) {
-                ebml_w.emit_bounds(ecx, pbs)
+                ebml_w.emit_bounds(ecx, *pbs)
             }
         }
     }
@@ -810,7 +810,7 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
         do ebml_w.tag(c::tag_table_method_map) {
             ebml_w.id(id);
             do ebml_w.tag(c::tag_table_val) {
-                serialize_method_map_entry(ecx, ebml_w, mme)
+                serialize_method_map_entry(ecx, ebml_w, *mme)
             }
         }
     }
@@ -819,7 +819,7 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
         do ebml_w.tag(c::tag_table_vtable_map) {
             ebml_w.id(id);
             do ebml_w.tag(c::tag_table_val) {
-                encode_vtable_res(ecx, ebml_w, dr);
+                encode_vtable_res(ecx, ebml_w, *dr);
             }
         }
     }
@@ -828,7 +828,7 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
         do ebml_w.tag(c::tag_table_adjustments) {
             ebml_w.id(id);
             do ebml_w.tag(c::tag_table_val) {
-                ty::serialize_AutoAdjustment(ebml_w, *adj)
+                ty::serialize_AutoAdjustment(ebml_w, **adj)
             }
         }
     }
diff --git a/src/rustc/middle/check_alt.rs b/src/rustc/middle/check_alt.rs
index 54f415857ba..a3e85ac56c3 100644
--- a/src/rustc/middle/check_alt.rs
+++ b/src/rustc/middle/check_alt.rs
@@ -269,7 +269,7 @@ fn missing_ctor(tcx: ty::ctxt, m: matrix, left_ty: ty::t) -> Option<ctor> {
         let mut found = ~[];
         for m.each |r| {
             do option::iter(&pat_ctor_id(tcx, r[0])) |id| {
-                if !vec::contains(found, id) { found.push(id); }
+                if !vec::contains(found, *id) { found.push(*id); }
             }
         }
         let variants = ty::enum_variants(tcx, eid);
diff --git a/src/rustc/middle/check_const.rs b/src/rustc/middle/check_const.rs
index 53bdf3db868..bd3abe20134 100644
--- a/src/rustc/middle/check_const.rs
+++ b/src/rustc/middle/check_const.rs
@@ -28,7 +28,7 @@ fn check_item(sess: session, ast_map: ast_map::map,
       item_enum(enum_definition, _) => {
         for enum_definition.variants.each |var| {
             do option::iter(&var.node.disr_expr) |ex| {
-                v.visit_expr(ex, true, v);
+                v.visit_expr(*ex, true, v);
             }
         }
       }
diff --git a/src/rustc/middle/kind.rs b/src/rustc/middle/kind.rs
index 7d911f7d05a..15a7d8f52b1 100644
--- a/src/rustc/middle/kind.rs
+++ b/src/rustc/middle/kind.rs
@@ -264,15 +264,15 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
                 ~"non path/method call expr has type substs??")
           }
         };
-        if vec::len(ts) != vec::len(*bounds) {
+        if vec::len(*ts) != vec::len(*bounds) {
             // Fail earlier to make debugging easier
             fail fmt!("Internal error: in kind::check_expr, length \
                        mismatch between actual and declared bounds: actual = \
                         %s (%u tys), declared = %? (%u tys)",
-                      tys_to_str(cx.tcx, ts), ts.len(),
+                      tys_to_str(cx.tcx, *ts), ts.len(),
                       *bounds, (*bounds).len());
         }
-        do vec::iter2(ts, *bounds) |ty, bound| {
+        do vec::iter2(*ts, *bounds) |ty, bound| {
             check_bounds(cx, id_to_use, e.span, ty, bound)
         }
     }
@@ -376,7 +376,7 @@ fn check_ty(aty: @ty, cx: ctx, v: visit::vt<ctx>) {
         do option::iter(&cx.tcx.node_type_substs.find(id)) |ts| {
             let did = ast_util::def_id_of_def(cx.tcx.def_map.get(id));
             let bounds = ty::lookup_item_type(cx.tcx, did).bounds;
-            do vec::iter2(ts, *bounds) |ty, bound| {
+            do vec::iter2(*ts, *bounds) |ty, bound| {
                 check_bounds(cx, aty.id, aty.span, ty, bound)
             }
         }
diff --git a/src/rustc/middle/mem_categorization.rs b/src/rustc/middle/mem_categorization.rs
index a9f4c195765..fe465db1312 100644
--- a/src/rustc/middle/mem_categorization.rs
+++ b/src/rustc/middle/mem_categorization.rs
@@ -670,14 +670,14 @@ impl &mem_categorization_ctxt {
 
         match deref_kind(self.tcx, base_cmt.ty) {
             deref_ptr(ptr) => {
-                let lp = do base_cmt.lp.chain |l| {
+                let lp = do base_cmt.lp.chain_ref |l| {
                     // Given that the ptr itself is loanable, we can
                     // loan out deref'd uniq ptrs as the data they are
                     // the only way to reach the data they point at.
                     // Other ptr types admit aliases and are therefore
                     // not loanable.
                     match ptr {
-                        uniq_ptr => {Some(@lp_deref(l, ptr))}
+                        uniq_ptr => {Some(@lp_deref(*l, ptr))}
                         gc_ptr | region_ptr(_) | unsafe_ptr => {None}
                     }
                 };
diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs
index def21ae03e0..03efd67a9d5 100644
--- a/src/rustc/middle/resolve.rs
+++ b/src/rustc/middle/resolve.rs
@@ -923,7 +923,7 @@ impl Resolver {
                             namespace_to_str(ns),
                             self.session.str_of(name)));
                   do child.span_for_namespace(ns).iter() |sp| {
-                      self.session.span_note(sp,
+                      self.session.span_note(*sp,
                            #fmt("First definition of %s %s here:",
                                 namespace_to_str(ns),
                                 self.session.str_of(name)));
diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs
index 47ac8e9ef6a..7c70d83bd76 100644
--- a/src/rustc/middle/trans/base.rs
+++ b/src/rustc/middle/trans/base.rs
@@ -1252,7 +1252,7 @@ fn alloc_local(cx: block, local: @ast::local) -> block {
     let val = alloc_ty(cx, t);
     if cx.sess().opts.debuginfo {
         do option::iter(&simple_name) |name| {
-            str::as_c_str(cx.ccx().sess.str_of(name), |buf| {
+            str::as_c_str(cx.ccx().sess.str_of(*name), |buf| {
                 llvm::LLVMSetValueName(val, buf)
             });
         }
@@ -1778,7 +1778,7 @@ fn trans_class_dtor(ccx: @crate_ctxt, path: path,
   /* If we're monomorphizing, register the monomorphized decl
      for the dtor */
     do option::iter(&hash_id) |h_id| {
-    ccx.monomorphized.insert(h_id, lldecl);
+    ccx.monomorphized.insert(*h_id, lldecl);
   }
   /* Translate the dtor body */
   trans_fn(ccx, path, ast_util::dtor_dec(),
diff --git a/src/rustc/middle/trans/closure.rs b/src/rustc/middle/trans/closure.rs
index 7b071866136..95c98126966 100644
--- a/src/rustc/middle/trans/closure.rs
+++ b/src/rustc/middle/trans/closure.rs
@@ -281,7 +281,7 @@ fn build_closure(bcx0: block,
     // variables:
     do option::iter(&include_ret_handle) |flagptr| {
         // Flag indicating we have returned (a by-ref bool):
-        let flag_datum = Datum {val: flagptr, ty: ty::mk_bool(tcx),
+        let flag_datum = Datum {val: *flagptr, ty: ty::mk_bool(tcx),
                                 mode: ByRef, source: FromLvalue};
         env_vals.push(EnvValue {action: EnvRef,
                                 datum: flag_datum});
diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs
index 6f14b22d778..e75d4db897f 100644
--- a/src/rustc/middle/trans/common.rs
+++ b/src/rustc/middle/trans/common.rs
@@ -472,7 +472,7 @@ type optional_boxed_ast_expr = Option<@ast::expr>;
 
 impl optional_boxed_ast_expr: get_node_info {
     fn info() -> Option<node_info> {
-        self.chain(|s| s.info())
+        self.chain_ref(|s| s.info())
     }
 }
 
diff --git a/src/rustc/middle/trans/type_use.rs b/src/rustc/middle/trans/type_use.rs
index 8a0873f0585..b29f40748ed 100644
--- a/src/rustc/middle/trans/type_use.rs
+++ b/src/rustc/middle/trans/type_use.rs
@@ -204,7 +204,7 @@ fn mark_for_expr(cx: ctx, e: @expr) {
       expr_path(_) => {
         do cx.ccx.tcx.node_type_substs.find(e.id).iter |ts| {
             let id = ast_util::def_id_of_def(cx.ccx.tcx.def_map.get(e.id));
-            vec::iter2(type_uses_for(cx.ccx, id, ts.len()), ts,
+            vec::iter2(type_uses_for(cx.ccx, id, ts.len()), *ts,
                        |uses, subst| {
                            type_needs(cx, uses, subst)
                        })
@@ -238,7 +238,7 @@ fn mark_for_expr(cx: ctx, e: @expr) {
             match mth.origin {
               typeck::method_static(did) => {
                 do cx.ccx.tcx.node_type_substs.find(e.id).iter |ts| {
-                    do vec::iter2(type_uses_for(cx.ccx, did, ts.len()), ts)
+                    do vec::iter2(type_uses_for(cx.ccx, did, ts.len()), *ts)
                         |uses, subst| { type_needs(cx, uses, subst)}
                 }
               }
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index 06eb26ec4e7..63720eaad2e 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -902,7 +902,7 @@ fn mk_t_with_id(cx: ctxt, +st: sty, o_def_id: Option<ast::def_id>) -> t {
     fn sflags(substs: &substs) -> uint {
         let mut f = 0u;
         for substs.tps.each |tt| { f |= get(*tt).flags; }
-        substs.self_r.iter(|r| f |= rflags(r));
+        substs.self_r.iter(|r| f |= rflags(*r));
         return f;
     }
     match st {
diff --git a/src/rustc/middle/typeck/astconv.rs b/src/rustc/middle/typeck/astconv.rs
index 5434677b6fc..45a7c22e2f9 100644
--- a/src/rustc/middle/typeck/astconv.rs
+++ b/src/rustc/middle/typeck/astconv.rs
@@ -484,7 +484,7 @@ fn ty_of_fn_decl<AC: ast_conv, RS: region_scope Copy Owned>(
         let rb = in_binding_rscope(rscope);
 
         let input_tys = do decl.inputs.mapi |i, a| {
-            let expected_arg_ty = do expected_tys.chain |e| {
+            let expected_arg_ty = do expected_tys.chain_ref |e| {
                 // no guarantee that the correct number of expected args
                 // were supplied
                 if i < e.inputs.len() {Some(e.inputs[i])} else {None}
diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs
index c642f12cf62..e1a0e8bc9ed 100644
--- a/src/rustc/middle/typeck/check.rs
+++ b/src/rustc/middle/typeck/check.rs
@@ -279,7 +279,7 @@ fn check_fn(ccx: @crate_ctxt,
 
     // Update the self_info to contain an accurate self type (taking
     // into account explicit self).
-    let self_info = do self_info.chain |info| {
+    let self_info = do self_info.chain_ref |info| {
         // If the self type is sty_static, we don't have a self ty.
         if info.explicit_self.node == ast::sty_static {
             None
@@ -288,7 +288,7 @@ fn check_fn(ccx: @crate_ctxt,
             let ty = method::transform_self_type_for_method(
                 fcx.tcx(), self_region,
                 info.self_ty, info.explicit_self.node);
-            Some({self_ty: ty,.. info})
+            Some({self_ty: ty,.. *info})
         }
     };
 
@@ -1864,7 +1864,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
         fcx.write_ty(id, typ);
       }
       ast::expr_rec(fields, base) => {
-        option::iter(&base, |b| { check_expr(fcx, b, expected); });
+        option::iter(&base, |b| { check_expr(fcx, *b, expected); });
         let expected = if expected.is_none() && base.is_some() {
             Some(fcx.expr_ty(base.get()))
         } else { expected };
@@ -1872,8 +1872,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
             match sty { ty::ty_rec(flds) => Some(flds), _ => None }
         );
         let fields_t = vec::map(fields, |f| {
-            bot |= check_expr(fcx, f.node.expr, flds.chain(|flds|
-                vec::find(flds, |tf| tf.ident == f.node.ident)
+            bot |= check_expr(fcx, f.node.expr, flds.chain_ref(|flds|
+                vec::find(*flds, |tf| tf.ident == f.node.ident)
             ).map(|tf| tf.mt.ty));
             let expr_t = fcx.expr_ty(f.node.expr);
             let expr_mt = {ty: expr_t, mutbl: f.node.mutbl};
diff --git a/src/rustc/middle/typeck/check/alt.rs b/src/rustc/middle/typeck/check/alt.rs
index 61d85b2dbfa..3b299caf872 100644
--- a/src/rustc/middle/typeck/check/alt.rs
+++ b/src/rustc/middle/typeck/check/alt.rs
@@ -164,7 +164,7 @@ fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path,
             }
 
             do subpats.iter() |pats| {
-                do vec::iter2(pats, arg_types) |subpat, arg_ty| {
+                do vec::iter2(*pats, arg_types) |subpat, arg_ty| {
                   check_pat(pcx, subpat, arg_ty);
                 }
             };
diff --git a/src/rustc/middle/typeck/coherence.rs b/src/rustc/middle/typeck/coherence.rs
index 907cdb4f5ec..e9238e30c66 100644
--- a/src/rustc/middle/typeck/coherence.rs
+++ b/src/rustc/middle/typeck/coherence.rs
@@ -484,7 +484,7 @@ impl CoherenceChecker {
 
                                         let trait_def_id =
                                             self.trait_ref_to_trait_def_id(
-                                                trait_ref);
+                                                *trait_ref);
 
                                         if trait_def_id.crate != local_crate {
                                             let session =
-- 
cgit 1.4.1-3-g733a5


From b3f418c10ed88163f6d1c6774b51eb69def521f8 Mon Sep 17 00:00:00 2001
From: Zack Corr <zack@z0w0.me>
Date: Fri, 28 Sep 2012 18:05:49 +1000
Subject: jit: Remove old crate loading code and don't search through loaded
 crates (use llvm default instead)

---
 src/rustc/back/link.rs       | 25 ++-----------------------
 src/rustllvm/RustWrapper.cpp | 13 ++-----------
 2 files changed, 4 insertions(+), 34 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/back/link.rs b/src/rustc/back/link.rs
index 751f0369141..27b566ac28a 100644
--- a/src/rustc/back/link.rs
+++ b/src/rustc/back/link.rs
@@ -105,7 +105,7 @@ mod jit {
         // for us.
 
         let entry = llvm::LLVMRustExecuteJIT(manager,
-                                      pm, m, opt, stacks);
+                                             pm, m, opt, stacks);
 
         if ptr::is_null(entry) {
             llvm_err(sess, ~"Could not JIT");
@@ -223,30 +223,9 @@ mod write {
                 // JIT execution takes ownership of the module,
                 // so don't dispose and return.
 
-                // We need to tell LLVM where to resolve all linked
-                // symbols from. The equivalent of -lstd, -lcore, etc.
-                // By default the JIT will resolve symbols from the std and
-                // core linked into rustc. We don't want that,
-                // incase the user wants to use an older std library.
-                /*let cstore = sess.cstore;
-                for cstore::get_used_crate_files(cstore).each |cratepath| {
-                    debug!{"linking: %s", cratepath};
-
-                    let _: () = str::as_c_str(
-                        cratepath,
-                        |buf_t| {
-                            if !llvm::LLVMRustLoadLibrary(buf_t) {
-                                llvm_err(sess, ~"Could not link");
-                            }
-                            debug!{"linked: %s", cratepath};
-                        });
-                }*/
-
                 jit::exec(sess, pm.llpm, llmod, CodeGenOptLevel, true);
 
-                if sess.time_llvm_passes() {
-                    llvm::LLVMRustPrintPassTimings();
-                }
+                if sess.time_llvm_passes() { llvm::LLVMRustPrintPassTimings(); }
                 return;
             }
 
diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp
index 72a97953a94..fc2049507ee 100644
--- a/src/rustllvm/RustWrapper.cpp
+++ b/src/rustllvm/RustWrapper.cpp
@@ -282,17 +282,7 @@ void *RustMCJITMemoryManager::getPointerToNamedFunction(const std::string &Name,
 
   const char *NameStr = Name.c_str();
 
-  // Look through loaded crates for symbols.
-
-  for (DenseSet<DynamicLibrary*>::iterator I = crates.begin(),
-       E = crates.end(); I != E; ++I) {
-    void *Ptr = (*I)->getAddressOfSymbol(NameStr);
-
-    if (Ptr) return Ptr;
-  }
-
-  // Fallback to using any symbols LLVM has loaded (generally
-  // from the main program).
+  // Look through loaded crates and main for symbols.
 
   void *Ptr = sys::DynamicLibrary::SearchForAddressOfSymbol(NameStr);
   if (Ptr) return Ptr;
@@ -365,6 +355,7 @@ LLVMRustExecuteJIT(void* mem,
   PM->run(*unwrap(M));
 
   ExecutionEngine* EE = EngineBuilder(unwrap(M))
+    .setErrorStr(&Err)
     .setTargetOptions(Options)
     .setJITMemoryManager(MM)
     .setOptLevel(OptLevel)
-- 
cgit 1.4.1-3-g733a5


From 00b2086374af127a2ba4fca37bce20c80d2b0dd2 Mon Sep 17 00:00:00 2001
From: Zack Corr <zack@z0w0.me>
Date: Fri, 28 Sep 2012 19:46:40 +1000
Subject: jit: Change expected main signature

---
 src/rustc/back/link.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/rustc')

diff --git a/src/rustc/back/link.rs b/src/rustc/back/link.rs
index 27b566ac28a..592e4ecea35 100644
--- a/src/rustc/back/link.rs
+++ b/src/rustc/back/link.rs
@@ -114,7 +114,7 @@ mod jit {
                 code: entry,
                 env: ptr::null()
             };
-            let func: fn(~[~str]) = cast::transmute(move closure);
+            let func: fn(++argv: ~[~str]) = cast::transmute(move closure);
 
             func(~[sess.opts.binary]);
         }
-- 
cgit 1.4.1-3-g733a5


From 21519bc7e0a32e388e8b12be5d36d4440129f417 Mon Sep 17 00:00:00 2001
From: Niko Matsakis <niko@alum.mit.edu>
Date: Thu, 27 Sep 2012 22:20:47 -0700
Subject: demode vec

---
 src/cargo/cargo.rs                                 |   2 +-
 src/compiletest/runtest.rs                         |   5 +-
 src/fuzzer/fuzzer.rs                               |   2 +-
 src/libcore/dlist.rs                               |   2 +-
 src/libcore/dvec.rs                                |   8 +-
 src/libcore/float.rs                               |   2 +-
 src/libcore/io.rs                                  |   6 +-
 src/libcore/os.rs                                  |   6 +-
 src/libcore/path.rs                                |   6 +-
 src/libcore/pipes.rs                               |   4 +-
 src/libcore/ptr.rs                                 |   6 +-
 src/libcore/str.rs                                 |   8 +-
 src/libcore/tuple.rs                               |  43 +-
 src/libcore/vec.rs                                 | 530 ++++++++++++---------
 src/libstd/ebml.rs                                 |   2 +-
 src/libstd/ebml2.rs                                |   2 +-
 src/libstd/getopts.rs                              |   5 +-
 src/libstd/json.rs                                 |   2 +-
 src/libstd/list.rs                                 |   2 +-
 src/libstd/net_ip.rs                               |   2 +-
 src/libstd/net_tcp.rs                              |   2 +-
 src/libstd/par.rs                                  |   8 +-
 src/libstd/smallintmap.rs                          |   2 +-
 src/libstd/test.rs                                 |   4 +-
 src/libsyntax/ast_map.rs                           |   2 +-
 src/libsyntax/ast_util.rs                          |   4 +-
 src/libsyntax/attr.rs                              |  16 +-
 src/libsyntax/ext/auto_serialize.rs                |  10 +-
 src/libsyntax/ext/auto_serialize2.rs               |  12 +-
 src/libsyntax/ext/base.rs                          |   2 +-
 src/libsyntax/ext/expand.rs                        |   4 +-
 src/libsyntax/ext/pipes/pipec.rs                   |   4 +-
 src/libsyntax/ext/simplext.rs                      |   2 +-
 src/libsyntax/ext/tt/macro_parser.rs               |   6 +-
 src/libsyntax/ext/tt/transcribe.rs                 |  11 +-
 src/libsyntax/fold.rs                              |   2 +-
 src/libsyntax/print/pprust.rs                      |   2 +-
 src/rustc/driver/rustc.rs                          |   2 +-
 src/rustc/front/config.rs                          |  23 +-
 src/rustc/front/test.rs                            |   8 +-
 src/rustc/metadata/cstore.rs                       |   4 +-
 src/rustc/metadata/decoder.rs                      |   2 +-
 src/rustc/middle/borrowck/check_loans.rs           |   2 +-
 src/rustc/middle/borrowck/gather_loans.rs          |   4 +-
 src/rustc/middle/check_alt.rs                      |   8 +-
 src/rustc/middle/const_eval.rs                     |   4 +-
 src/rustc/middle/kind.rs                           |   4 +-
 src/rustc/middle/liveness.rs                       |   8 +-
 src/rustc/middle/resolve.rs                        |   2 +-
 src/rustc/middle/trans/alt.rs                      |   2 +-
 src/rustc/middle/trans/base.rs                     |   2 +-
 src/rustc/middle/trans/common.rs                   |   2 +-
 src/rustc/middle/trans/controlflow.rs              |   2 +-
 src/rustc/middle/trans/foreign.rs                  |   4 +-
 src/rustc/middle/trans/monomorphize.rs             |  12 +-
 src/rustc/middle/trans/type_use.rs                 |   4 +-
 src/rustc/middle/ty.rs                             |  14 +-
 src/rustc/middle/typeck/check.rs                   |  10 +-
 src/rustc/middle/typeck/check/alt.rs               |   2 +-
 src/rustc/middle/typeck/check/vtable.rs            |   4 +-
 src/rustc/middle/typeck/collect.rs                 |   2 +-
 src/rustc/middle/typeck/infer.rs                   |   2 +-
 .../middle/typeck/infer/region_var_bindings.rs     |   2 +-
 src/rustc/middle/typeck/infer/resolve.rs           |   4 +-
 src/rustdoc/attr_pass.rs                           |   2 +-
 src/rustdoc/config.rs                              |   4 +-
 src/rustdoc/desc_to_brief_pass.rs                  |   6 +-
 src/rustdoc/doc.rs                                 |  36 +-
 src/rustdoc/page_pass.rs                           |   2 +-
 src/rustdoc/path_pass.rs                           |   4 +-
 src/rustdoc/tystr_pass.rs                          |   2 +-
 src/rustdoc/unindent_pass.rs                       |   6 +-
 src/test/bench/core-std.rs                         |   2 +-
 src/test/bench/graph500-bfs.rs                     |  14 +-
 src/test/bench/msgsend-ring-mutex-arcs.rs          |   2 +-
 src/test/bench/msgsend-ring-rw-arcs.rs             |   2 +-
 .../compile-fail/block-arg-as-stmt-with-value.rs   |   2 +-
 .../compile-fail/regions-escape-loop-via-vec.rs    |   2 +-
 .../run-pass/block-arg-can-be-followed-by-binop.rs |   2 +-
 src/test/run-pass/block-arg-in-parentheses.rs      |   8 +-
 src/test/run-pass/block-arg.rs                     |  22 +-
 src/test/run-pass/block-vec-map2.rs                |   2 +-
 src/test/run-pass/ret-break-cont-in-block.rs       |   8 +-
 83 files changed, 541 insertions(+), 464 deletions(-)

(limited to 'src/rustc')

diff --git a/src/cargo/cargo.rs b/src/cargo/cargo.rs
index dd0e53143f5..6136652c873 100644
--- a/src/cargo/cargo.rs
+++ b/src/cargo/cargo.rs
@@ -527,7 +527,7 @@ fn load_one_source_package(src: @Source, p: &json::Object) {
         Some(json::List(js)) => {
           for js.each |j| {
                 match *j {
-                    json::String(j) => vec::grow(tags, 1u, j),
+                    json::String(ref j) => tags.grow(1u, j),
                     _ => ()
                 }
             }
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
index dae5105ce71..ff695f64088 100644
--- a/src/compiletest/runtest.rs
+++ b/src/compiletest/runtest.rs
@@ -503,10 +503,7 @@ fn make_run_args(config: config, _props: test_props, testfile: &Path) ->
 
 fn split_maybe_args(argstr: Option<~str>) -> ~[~str] {
     fn rm_whitespace(v: ~[~str]) -> ~[~str] {
-        fn flt(&&s: ~str) -> Option<~str> {
-          if !str::is_whitespace(s) { option::Some(s) } else { option::None }
-        }
-        vec::filter_map(v, flt)
+        vec::filter(v, |s| !str::is_whitespace(*s))
     }
 
     match argstr {
diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs
index ab3c2c7c2ca..ace96c389ef 100644
--- a/src/fuzzer/fuzzer.rs
+++ b/src/fuzzer/fuzzer.rs
@@ -229,7 +229,7 @@ fn check_variants_of_ast(crate: ast::crate, codemap: codemap::codemap,
                          filename: &Path, cx: context) {
     let stolen = steal(crate, cx.mode);
     let extra_exprs = vec::filter(common_exprs(),
-                                  |a| safe_to_use_expr(a, cx.mode) );
+                                  |a| safe_to_use_expr(*a, cx.mode) );
     check_variants_T(crate, codemap, filename, ~"expr",
                      extra_exprs + stolen.exprs, pprust::expr_to_str,
                      replace_expr_in_crate, cx);
diff --git a/src/libcore/dlist.rs b/src/libcore/dlist.rs
index fcf8146200d..0bdf5caec0c 100644
--- a/src/libcore/dlist.rs
+++ b/src/libcore/dlist.rs
@@ -99,7 +99,7 @@ pub pure fn from_elem<T>(+data: T) -> DList<T> {
 
 pub fn from_vec<T: Copy>(+vec: &[T]) -> DList<T> {
     do vec::foldl(DList(), vec) |list,data| {
-        list.push(data); // Iterating left-to-right -- add newly to the tail.
+        list.push(*data); // Iterating left-to-right -- add newly to the tail.
         list
     }
 }
diff --git a/src/libcore/dvec.rs b/src/libcore/dvec.rs
index eb221926fc1..d360eab3c8a 100644
--- a/src/libcore/dvec.rs
+++ b/src/libcore/dvec.rs
@@ -157,7 +157,7 @@ impl<A> DVec<A> {
     fn pop() -> A {
         do self.check_out |v| {
             let mut v <- v;
-            let result = vec::pop(v);
+            let result = v.pop();
             self.give_back(move v);
             move result
         }
@@ -187,7 +187,7 @@ impl<A> DVec<A> {
     fn shift() -> A {
         do self.check_out |v| {
             let mut v = move v;
-            let result = vec::shift(v);
+            let result = v.shift();
             self.give_back(move v);
             move result
         }
@@ -305,10 +305,10 @@ impl<A: Copy> DVec<A> {
      * growing the vector if necessary.  New elements will be initialized
      * with `initval`
      */
-    fn grow_set_elt(idx: uint, initval: A, +val: A) {
+    fn grow_set_elt(idx: uint, initval: &A, +val: A) {
         do self.swap |v| {
             let mut v = move v;
-            vec::grow_set(v, idx, initval, val);
+            v.grow_set(idx, initval, val);
             move v
         }
     }
diff --git a/src/libcore/float.rs b/src/libcore/float.rs
index aff6db3c10f..098e82f5fad 100644
--- a/src/libcore/float.rs
+++ b/src/libcore/float.rs
@@ -140,7 +140,7 @@ pub fn to_str_common(num: float, digits: uint, exact: bool) -> ~str {
     // turn digits into string
     // using stack of digits
     while fractionalParts.is_not_empty() {
-        let mut adjusted_digit = carry + vec::pop(fractionalParts);
+        let mut adjusted_digit = carry + fractionalParts.pop();
 
         if adjusted_digit == 10 {
             carry = 1;
diff --git a/src/libcore/io.rs b/src/libcore/io.rs
index 47ea01af677..667aaaf7b0e 100644
--- a/src/libcore/io.rs
+++ b/src/libcore/io.rs
@@ -64,11 +64,11 @@ trait ReaderUtil {
 impl<T: Reader> T : ReaderUtil {
     fn read_bytes(len: uint) -> ~[u8] {
         let mut buf = vec::with_capacity(len);
-        unsafe { vec::raw::set_len(buf, len); }
+        unsafe { vec::raw::set_len(&mut buf, len); }
 
         let count = self.read(buf, len);
 
-        unsafe { vec::raw::set_len(buf, count); }
+        unsafe { vec::raw::set_len(&mut buf, count); }
         move buf
     }
     fn read_line() -> ~str {
@@ -695,7 +695,7 @@ impl BytesWriter: Writer {
 
             let count = uint::max(buf_len, self.pos + v_len);
             vec::reserve(&mut buf, count);
-            unsafe { vec::raw::set_len(buf, count); }
+            unsafe { vec::raw::set_len(&mut buf, count); }
 
             {
                 let view = vec::mut_view(buf, self.pos, count);
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
index c1ea71c181b..644cef42b41 100644
--- a/src/libcore/os.rs
+++ b/src/libcore/os.rs
@@ -582,7 +582,7 @@ pub fn list_dir(p: &Path) -> ~[~str] {
     fn star(p: &Path) -> Path { p.push("*") }
 
     do rustrt::rust_list_files(star(p).to_str()).filter |filename| {
-        filename != ~"." && filename != ~".."
+        *filename != ~"." && *filename != ~".."
     }
 }
 
@@ -857,10 +857,10 @@ mod tests {
 
         let mut e = env();
         setenv(n, ~"VALUE");
-        assert !vec::contains(e, (copy n, ~"VALUE"));
+        assert !vec::contains(e, &(copy n, ~"VALUE"));
 
         e = env();
-        assert vec::contains(e, (n, ~"VALUE"));
+        assert vec::contains(e, &(n, ~"VALUE"));
     }
 
     #[test]
diff --git a/src/libcore/path.rs b/src/libcore/path.rs
index c384745bb5e..1afcc7ba09d 100644
--- a/src/libcore/path.rs
+++ b/src/libcore/path.rs
@@ -221,7 +221,7 @@ impl PosixPath : GenericPath {
     pure fn pop() -> PosixPath {
         let mut cs = copy self.components;
         if cs.len() != 0 {
-            unsafe { vec::pop(cs); }
+            unsafe { cs.pop(); }
         }
         return PosixPath { components: move cs, ..self }
     }
@@ -415,7 +415,7 @@ impl WindowsPath : GenericPath {
     pure fn pop() -> WindowsPath {
         let mut cs = copy self.components;
         if cs.len() != 0 {
-            unsafe { vec::pop(cs); }
+            unsafe { cs.pop(); }
         }
         return WindowsPath { components: move cs, ..self }
     }
@@ -437,7 +437,7 @@ pub pure fn normalize(components: &[~str]) -> ~[~str] {
                 if *c == ~"." && components.len() > 1 { loop; }
                 if *c == ~"" { loop; }
                 if *c == ~".." && cs.len() != 0 {
-                    vec::pop(cs);
+                    cs.pop();
                     loop;
                 }
                 cs.push(copy *c);
diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs
index 3559753410f..7a4d15ac4fe 100644
--- a/src/libcore/pipes.rs
+++ b/src/libcore/pipes.rs
@@ -704,7 +704,7 @@ pub fn select<T: Send, Tb: Send>(+endpoints: ~[RecvPacketBuffered<T, Tb>])
 {
     let ready = wait_many(endpoints.map(|p| p.header()));
     let mut remaining <- endpoints;
-    let port = vec::swap_remove(remaining, ready);
+    let port = remaining.swap_remove(ready);
     let result = try_recv(move port);
     (ready, move result, move remaining)
 }
@@ -1067,7 +1067,7 @@ impl<T: Send> PortSet<T> : Recv<T> {
                 }
                 None => {
                     // Remove this port.
-                    let _ = vec::swap_remove(ports, i);
+                    let _ = ports.swap_remove(i);
                 }
             }
         }
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index 72fa2cda1a7..7f1f1e4b345 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -127,7 +127,7 @@ pub unsafe fn memset<T>(dst: *mut T, c: int, count: uint) {
   reinterpret_cast.
 */
 #[inline(always)]
-pub fn to_unsafe_ptr<T>(thing: &T) -> *T {
+pub pure fn to_unsafe_ptr<T>(thing: &T) -> *T {
     unsafe { cast::reinterpret_cast(&thing) }
 }
 
@@ -137,7 +137,7 @@ pub fn to_unsafe_ptr<T>(thing: &T) -> *T {
   reinterpret_cast.
 */
 #[inline(always)]
-pub fn to_const_unsafe_ptr<T>(thing: &const T) -> *const T {
+pub pure fn to_const_unsafe_ptr<T>(thing: &const T) -> *const T {
     unsafe { cast::reinterpret_cast(&thing) }
 }
 
@@ -147,7 +147,7 @@ pub fn to_const_unsafe_ptr<T>(thing: &const T) -> *const T {
   reinterpret_cast.
 */
 #[inline(always)]
-pub fn to_mut_unsafe_ptr<T>(thing: &mut T) -> *mut T {
+pub pure fn to_mut_unsafe_ptr<T>(thing: &mut T) -> *mut T {
     unsafe { cast::reinterpret_cast(&thing) }
 }
 
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index d7e90c1a42d..a932a6133c5 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -450,7 +450,7 @@ Section: Transforming strings
  */
 pure fn to_bytes(s: &str) -> ~[u8] unsafe {
     let mut v: ~[u8] = ::cast::transmute(from_slice(s));
-    vec::raw::set_len(v, len(s));
+    vec::raw::set_len(&mut v, len(s));
     move v
 }
 
@@ -1945,7 +1945,7 @@ fn reserve_at_least(s: &const ~str, n: uint) {
  */
 pure fn capacity(s: &const ~str) -> uint {
     do as_bytes(s) |buf| {
-        let vcap = vec::capacity(*buf);
+        let vcap = vec::capacity(buf);
         assert vcap > 0u;
         vcap - 1u
     }
@@ -2008,7 +2008,7 @@ mod raw {
         vec::as_mut_buf(v, |vbuf, _len| {
             ptr::memcpy(vbuf, buf as *u8, len)
         });
-        vec::raw::set_len(v, len);
+        vec::raw::set_len(&mut v, len);
         v.push(0u8);
 
         assert is_utf8(v);
@@ -2065,7 +2065,7 @@ mod raw {
                     let src = ptr::offset(sbuf, begin);
                     ptr::memcpy(vbuf, src, end - begin);
                 }
-                vec::raw::set_len(v, end - begin);
+                vec::raw::set_len(&mut v, end - begin);
                 v.push(0u8);
                 ::cast::transmute(move v)
             }
diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs
index a89661c3291..50f55383167 100644
--- a/src/libcore/tuple.rs
+++ b/src/libcore/tuple.rs
@@ -35,35 +35,44 @@ impl<T: Copy, U: Copy> (T, U): TupleOps<T,U> {
 }
 
 trait ExtendedTupleOps<A,B> {
-    fn zip() -> ~[(A, B)];
-    fn map<C>(f: &fn(A, B) -> C) -> ~[C];
+    fn zip(&self) -> ~[(A, B)];
+    fn map<C>(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C];
 }
 
 impl<A: Copy, B: Copy> (&[A], &[B]): ExtendedTupleOps<A,B> {
-
-    fn zip() -> ~[(A, B)] {
-        let (a, b) = self;
-        vec::zip_slice(a, b)
+    fn zip(&self) -> ~[(A, B)] {
+        match *self {
+            (ref a, ref b) => {
+                vec::zip_slice(*a, *b)
+            }
+        }
     }
 
-    fn map<C>(f: &fn(A, B) -> C) -> ~[C] {
-        let (a, b) = self;
-        vec::map2(a, b, f)
+    fn map<C>(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C] {
+        match *self {
+            (ref a, ref b) => {
+                vec::map2(*a, *b, f)
+            }
+        }
     }
 }
 
 impl<A: Copy, B: Copy> (~[A], ~[B]): ExtendedTupleOps<A,B> {
 
-    fn zip() -> ~[(A, B)] {
-        // FIXME #2543: Bad copy
-        let (a, b) = copy self;
-        vec::zip(move a, move b)
+    fn zip(&self) -> ~[(A, B)] {
+        match *self {
+            (ref a, ref b) => {
+                vec::zip_slice(*a, *b)
+            }
+        }
     }
 
-    fn map<C>(f: &fn(A, B) -> C) -> ~[C] {
-        // FIXME #2543: Bad copy
-        let (a, b) = copy self;
-        vec::map2(a, b, f)
+    fn map<C>(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C] {
+        match *self {
+            (ref a, ref b) => {
+                vec::map2(*a, *b, f)
+            }
+        }
     }
 }
 
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index 07ccb244ddd..914434c9d46 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -1,5 +1,9 @@
 //! Vectors
 
+#[warn(deprecated_mode)];
+#[warn(deprecated_pattern)];
+#[warn(non_camel_case_types)];
+
 use cmp::{Eq, Ord};
 use option::{Some, None};
 use ptr::addr_of;
@@ -140,7 +144,7 @@ pure fn same_length<T, U>(xs: &[const T], ys: &[const U]) -> bool {
  */
 fn reserve<T>(+v: &mut ~[T], +n: uint) {
     // Only make the (slow) call into the runtime if we have to
-    if capacity(*v) < n {
+    if capacity(v) < n {
         unsafe {
             let ptr: **raw::VecRepr = cast::transmute(v);
             rustrt::vec_reserve_shared(sys::get_type_desc::<T>(),
@@ -170,16 +174,16 @@ fn reserve_at_least<T>(v: &mut ~[T], n: uint) {
 
 /// Returns the number of elements the vector can hold without reallocating
 #[inline(always)]
-pure fn capacity<T>(&&v: ~[const T]) -> uint {
+pure fn capacity<T>(v: &const ~[T]) -> uint {
     unsafe {
-        let repr: **raw::VecRepr = ::cast::reinterpret_cast(&addr_of(v));
+        let repr: **raw::VecRepr = ::cast::transmute(v);
         (**repr).unboxed.alloc / sys::size_of::<T>()
     }
 }
 
 /// Returns the length of a vector
 #[inline(always)]
-pure fn len<T>(&&v: &[const T]) -> uint {
+pure fn len<T>(v: &[const T]) -> uint {
     as_const_buf(v, |_p, len| len)
 }
 
@@ -190,11 +194,18 @@ pure fn len<T>(&&v: &[const T]) -> uint {
  * to the value returned by the function `op`.
  */
 pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> ~[T] {
-    let mut v = with_capacity(n_elts);
-    let mut i: uint = 0u;
-    while i < n_elts unsafe { raw::set(v, i, op(i)); i += 1u; }
-    unsafe { raw::set_len(v, n_elts); }
-    move v
+    unsafe {
+        let mut v = with_capacity(n_elts);
+        do as_mut_buf(v) |p, _len| {
+            let mut i: uint = 0u;
+            while i < n_elts {
+                rusti::move_val_init(*ptr::mut_offset(p, i), op(i));
+                i += 1u;
+            }
+        }
+        raw::set_len(&mut v, n_elts);
+        return move v;
+    }
 }
 
 /**
@@ -203,14 +214,8 @@ pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> ~[T] {
  * Creates an immutable vector of size `n_elts` and initializes the elements
  * to the value `t`.
  */
-pure fn from_elem<T: Copy>(n_elts: uint, t: T) -> ~[T] {
-    let mut v = with_capacity(n_elts);
-    let mut i: uint = 0u;
-    unsafe { // because unsafe::set is unsafe
-        while i < n_elts { raw::set(v, i, t); i += 1u; }
-        unsafe { raw::set_len(v, n_elts); }
-    }
-    move v
+pure fn from_elem<T: Copy>(n_elts: uint, +t: T) -> ~[T] {
+    from_fn(n_elts, |_i| copy t)
 }
 
 /// Creates a new unique vector with the same contents as the slice
@@ -378,7 +383,7 @@ pure fn const_view<T>(v: &r/[const T], start: uint,
 }
 
 /// Split the vector `v` by applying each element against the predicate `f`.
-fn split<T: Copy>(v: &[T], f: fn(T) -> bool) -> ~[~[T]] {
+fn split<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> ~[~[T]] {
     let ln = len(v);
     if (ln == 0u) { return ~[] }
 
@@ -401,7 +406,7 @@ fn split<T: Copy>(v: &[T], f: fn(T) -> bool) -> ~[~[T]] {
  * Split the vector `v` by applying each element against the predicate `f` up
  * to `n` times.
  */
-fn splitn<T: Copy>(v: &[T], n: uint, f: fn(T) -> bool) -> ~[~[T]] {
+fn splitn<T: Copy>(v: &[T], n: uint, f: fn(t: &T) -> bool) -> ~[~[T]] {
     let ln = len(v);
     if (ln == 0u) { return ~[] }
 
@@ -427,7 +432,7 @@ fn splitn<T: Copy>(v: &[T], n: uint, f: fn(T) -> bool) -> ~[~[T]] {
  * Reverse split the vector `v` by applying each element against the predicate
  * `f`.
  */
-fn rsplit<T: Copy>(v: &[T], f: fn(T) -> bool) -> ~[~[T]] {
+fn rsplit<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> ~[~[T]] {
     let ln = len(v);
     if (ln == 0u) { return ~[] }
 
@@ -451,7 +456,7 @@ fn rsplit<T: Copy>(v: &[T], f: fn(T) -> bool) -> ~[~[T]] {
  * Reverse split the vector `v` by applying each element against the predicate
  * `f` up to `n times.
  */
-fn rsplitn<T: Copy>(v: &[T], n: uint, f: fn(T) -> bool) -> ~[~[T]] {
+fn rsplitn<T: Copy>(v: &[T], n: uint, f: fn(t: &T) -> bool) -> ~[~[T]] {
     let ln = len(v);
     if (ln == 0u) { return ~[] }
 
@@ -477,12 +482,12 @@ fn rsplitn<T: Copy>(v: &[T], n: uint, f: fn(T) -> bool) -> ~[~[T]] {
 // Mutators
 
 /// Removes the first element from a vector and return it
-fn shift<T>(&v: ~[T]) -> T {
-    let ln = len::<T>(v);
+fn shift<T>(v: &mut ~[T]) -> T {
+    let ln = v.len();
     assert (ln > 0);
 
     let mut vv = ~[];
-    v <-> vv;
+    *v <-> vv;
 
     unsafe {
         let mut rr;
@@ -495,22 +500,22 @@ fn shift<T>(&v: ~[T]) -> T {
                 v.push(move r);
             }
         }
-        raw::set_len(vv, 0);
+        raw::set_len(&mut vv, 0);
 
         move rr
     }
 }
 
 /// Prepend an element to the vector
-fn unshift<T>(&v: ~[T], +x: T) {
+fn unshift<T>(v: &mut ~[T], +x: T) {
     let mut vv = ~[move x];
-    v <-> vv;
-    while len(vv) > 0 {
-        v.push(shift(vv));
-    }
+    *v <-> vv;
+    v.push_all_move(vv);
 }
 
 fn consume<T>(+v: ~[T], f: fn(uint, +v: T)) unsafe {
+    let mut v = move v; // FIXME(#3488)
+
     do as_imm_buf(v) |p, ln| {
         for uint::range(0, ln) |i| {
             let x <- *ptr::offset(p, i);
@@ -518,29 +523,22 @@ fn consume<T>(+v: ~[T], f: fn(uint, +v: T)) unsafe {
         }
     }
 
-    raw::set_len(v, 0);
+    raw::set_len(&mut v, 0);
 }
 
-fn consume_mut<T>(+v: ~[mut T], f: fn(uint, +v: T)) unsafe {
-    do as_imm_buf(v) |p, ln| {
-        for uint::range(0, ln) |i| {
-            let x <- *ptr::offset(p, i);
-            f(i, move x);
-        }
-    }
-
-    raw::set_len(v, 0);
+fn consume_mut<T>(+v: ~[mut T], f: fn(uint, +v: T)) {
+    consume(vec::from_mut(v), f)
 }
 
 /// Remove the last element from a vector and return it
-fn pop<T>(&v: ~[const T]) -> T {
-    let ln = len(v);
+fn pop<T>(v: &mut ~[T]) -> T {
+    let ln = v.len();
     if ln == 0 {
         fail ~"sorry, cannot vec::pop an empty vector"
     }
-    let valptr = ptr::mut_addr_of(v[ln - 1u]);
+    let valptr = ptr::to_mut_unsafe_ptr(&mut v[ln - 1u]);
     unsafe {
-        let val <- *valptr;
+        let val = move *valptr;
         raw::set_len(v, ln - 1u);
         move val
     }
@@ -552,21 +550,15 @@ fn pop<T>(&v: ~[const T]) -> T {
  *
  * Fails if index >= length.
  */
-fn swap_remove<T>(&v: ~[const T], index: uint) -> T {
-    let ln = len(v);
+fn swap_remove<T>(v: &mut ~[T], index: uint) -> T {
+    let ln = v.len();
     if index >= ln {
         fail fmt!("vec::swap_remove - index %u >= length %u", index, ln);
     }
-    let lastptr = ptr::mut_addr_of(v[ln - 1]);
-    unsafe {
-        let mut val <- *lastptr;
-        if index < ln - 1 {
-            let valptr = ptr::mut_addr_of(v[index]);
-            *valptr <-> val;
-        }
-        raw::set_len(v, ln - 1);
-        move val
+    if index < ln - 1 {
+        v[index] <-> v[ln - 1];
     }
+    vec::pop(v)
 }
 
 /// Append an element to a vector
@@ -611,7 +603,8 @@ fn push_all<T: Copy>(+v: &mut ~[T], rhs: &[const T]) {
 }
 
 #[inline(always)]
-fn push_all_move<T>(v: &mut ~[T], -rhs: ~[const T]) {
+fn push_all_move<T>(v: &mut ~[T], +rhs: ~[T]) {
+    let mut rhs = move rhs; // FIXME(#3488)
     reserve(v, v.len() + rhs.len());
     unsafe {
         do as_imm_buf(rhs) |p, len| {
@@ -620,13 +613,13 @@ fn push_all_move<T>(v: &mut ~[T], -rhs: ~[const T]) {
                 push(v, move x);
             }
         }
-        raw::set_len(rhs, 0);
+        raw::set_len(&mut rhs, 0);
     }
 }
 
 /// Shorten a vector, dropping excess elements.
-fn truncate<T>(&v: ~[const T], newlen: uint) {
-    do as_imm_buf(v) |p, oldlen| {
+fn truncate<T>(v: &mut ~[T], newlen: uint) {
+    do as_imm_buf(*v) |p, oldlen| {
         assert(newlen <= oldlen);
         unsafe {
             // This loop is optimized out for non-drop types.
@@ -642,10 +635,10 @@ fn truncate<T>(&v: ~[const T], newlen: uint) {
  * Remove consecutive repeated elements from a vector; if the vector is
  * sorted, this removes all duplicates.
  */
-fn dedup<T: Eq>(&v: ~[const T]) unsafe {
+fn dedup<T: Eq>(v: &mut ~[T]) unsafe {
     if v.len() < 1 { return; }
     let mut last_written = 0, next_to_read = 1;
-    do as_const_buf(v) |p, ln| {
+    do as_const_buf(*v) |p, ln| {
         // We have a mutable reference to v, so we can make arbitrary changes.
         // (cf. push and pop)
         let p = p as *mut T;
@@ -704,12 +697,12 @@ pure fn append_mut<T: Copy>(+lhs: ~[mut T], rhs: &[const T]) -> ~[mut T] {
  * * n - The number of elements to add
  * * initval - The value for the new elements
  */
-fn grow<T: Copy>(&v: ~[T], n: uint, initval: T) {
-    reserve_at_least(&mut v, len(v) + n);
+fn grow<T: Copy>(v: &mut ~[T], n: uint, initval: &T) {
+    reserve_at_least(v, v.len() + n);
     let mut i: uint = 0u;
 
     while i < n {
-        v.push(initval);
+        v.push(*initval);
         i += 1u;
     }
 }
@@ -727,8 +720,8 @@ fn grow<T: Copy>(&v: ~[T], n: uint, initval: T) {
  * * init_op - A function to call to retreive each appended element's
  *             value
  */
-fn grow_fn<T>(&v: ~[T], n: uint, op: iter::InitOp<T>) {
-    reserve_at_least(&mut v, len(v) + n);
+fn grow_fn<T>(v: &mut ~[T], n: uint, op: iter::InitOp<T>) {
+    reserve_at_least(v, v.len() + n);
     let mut i: uint = 0u;
     while i < n {
         v.push(op(i));
@@ -744,15 +737,16 @@ fn grow_fn<T>(&v: ~[T], n: uint, op: iter::InitOp<T>) {
  * of the vector, expands the vector by replicating `initval` to fill the
  * intervening space.
  */
-fn grow_set<T: Copy>(&v: ~[T], index: uint, initval: T, val: T) {
-    if index >= len(v) { grow(v, index - len(v) + 1u, initval); }
-    v[index] = val;
+fn grow_set<T: Copy>(v: &mut ~[T], index: uint, initval: &T, +val: T) {
+    let l = v.len();
+    if index >= l { grow(v, index - l + 1u, initval); }
+    v[index] = move val;
 }
 
 // Functional utilities
 
 /// Apply a function to each element of a vector and return the results
-pure fn map<T, U>(v: &[T], f: fn(v: &T) -> U) -> ~[U] {
+pure fn map<T, U>(v: &[T], f: fn(t: &T) -> U) -> ~[U] {
     let mut result = with_capacity(len(v));
     for each(v) |elem| {
         unsafe {
@@ -771,7 +765,7 @@ fn map_consume<T, U>(+v: ~[T], f: fn(+v: T) -> U) -> ~[U] {
 }
 
 /// Apply a function to each element of a vector and return the results
-pure fn mapi<T, U>(v: &[T], f: fn(uint, v: &T) -> U) -> ~[U] {
+pure fn mapi<T, U>(v: &[T], f: fn(uint, t: &T) -> U) -> ~[U] {
     let mut i = 0;
     do map(v) |e| {
         i += 1;
@@ -783,21 +777,21 @@ pure fn mapi<T, U>(v: &[T], f: fn(uint, v: &T) -> U) -> ~[U] {
  * Apply a function to each element of a vector and return a concatenation
  * of each result vector
  */
-pure fn flat_map<T, U>(v: &[T], f: fn(T) -> ~[U]) -> ~[U] {
+pure fn flat_map<T, U>(v: &[T], f: fn(t: &T) -> ~[U]) -> ~[U] {
     let mut result = ~[];
-    for each(v) |elem| { unsafe{ result.push_all_move(f(*elem)); } }
+    for each(v) |elem| { unsafe{ result.push_all_move(f(elem)); } }
     move result
 }
 
 /// Apply a function to each pair of elements and return the results
 pure fn map2<T: Copy, U: Copy, V>(v0: &[T], v1: &[U],
-                                  f: fn(T, U) -> V) -> ~[V] {
+                                  f: fn(t: &T, v: &U) -> V) -> ~[V] {
     let v0_len = len(v0);
     if v0_len != len(v1) { fail; }
     let mut u: ~[V] = ~[];
     let mut i = 0u;
     while i < v0_len {
-        unsafe { u.push(f(copy v0[i], copy v1[i])) };
+        unsafe { u.push(f(&v0[i], &v1[i])) };
         i += 1u;
     }
     move u
@@ -809,11 +803,11 @@ pure fn map2<T: Copy, U: Copy, V>(v0: &[T], v1: &[U],
  * If function `f` returns `none` then that element is excluded from
  * the resulting vector.
  */
-pure fn filter_map<T, U: Copy>(v: &[T], f: fn(T) -> Option<U>)
+pure fn filter_map<T, U: Copy>(v: &[T], f: fn(t: &T) -> Option<U>)
     -> ~[U] {
     let mut result = ~[];
     for each(v) |elem| {
-        match f(*elem) {
+        match f(elem) {
           None => {/* no-op */ }
           Some(result_elem) => unsafe { result.push(result_elem); }
         }
@@ -828,10 +822,10 @@ pure fn filter_map<T, U: Copy>(v: &[T], f: fn(T) -> Option<U>)
  * Apply function `f` to each element of `v` and return a vector containing
  * only those elements for which `f` returned true.
  */
-pure fn filter<T: Copy>(v: &[T], f: fn(T) -> bool) -> ~[T] {
+pure fn filter<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> ~[T] {
     let mut result = ~[];
     for each(v) |elem| {
-        if f(*elem) { unsafe { result.push(*elem); } }
+        if f(elem) { unsafe { result.push(*elem); } }
     }
     move result
 }
@@ -848,30 +842,32 @@ pure fn concat<T: Copy>(v: &[~[T]]) -> ~[T] {
 }
 
 /// Concatenate a vector of vectors, placing a given separator between each
-pure fn connect<T: Copy>(v: &[~[T]], sep: T) -> ~[T] {
+pure fn connect<T: Copy>(v: &[~[T]], sep: &T) -> ~[T] {
     let mut r: ~[T] = ~[];
     let mut first = true;
     for each(v) |inner| {
-        if first { first = false; } else { unsafe { r.push(sep); } }
+        if first { first = false; } else { unsafe { r.push(*sep); } }
         unsafe { r.push_all(*inner) };
     }
     move r
 }
 
 /// Reduce a vector from left to right
-pure fn foldl<T: Copy, U>(z: T, v: &[U], p: fn(T, U) -> T) -> T {
+pure fn foldl<T: Copy, U>(+z: T, v: &[U], p: fn(+t: T, u: &U) -> T) -> T {
     let mut accum = z;
     for each(v) |elt| {
-        accum = p(accum, *elt);
+        // it should be possible to move accum in, but the liveness analysis
+        // is not smart enough.
+        accum = p(accum, elt);
     }
     return accum;
 }
 
 /// Reduce a vector from right to left
-pure fn foldr<T, U: Copy>(v: &[T], z: U, p: fn(T, U) -> U) -> U {
+pure fn foldr<T, U: Copy>(v: &[T], +z: U, p: fn(t: &T, +u: U) -> U) -> U {
     let mut accum = z;
     for rev_each(v) |elt| {
-        accum = p(*elt, accum);
+        accum = p(elt, accum);
     }
     return accum;
 }
@@ -881,8 +877,8 @@ pure fn foldr<T, U: Copy>(v: &[T], z: U, p: fn(T, U) -> U) -> U {
  *
  * If the vector contains no elements then false is returned.
  */
-pure fn any<T>(v: &[T], f: fn(T) -> bool) -> bool {
-    for each(v) |elem| { if f(*elem) { return true; } }
+pure fn any<T>(v: &[T], f: fn(t: &T) -> bool) -> bool {
+    for each(v) |elem| { if f(elem) { return true; } }
     return false;
 }
 
@@ -892,12 +888,12 @@ pure fn any<T>(v: &[T], f: fn(T) -> bool) -> bool {
  * If the vectors contains no elements then false is returned.
  */
 pure fn any2<T, U>(v0: &[T], v1: &[U],
-                   f: fn(T, U) -> bool) -> bool {
+                   f: fn(a: &T, b: &U) -> bool) -> bool {
     let v0_len = len(v0);
     let v1_len = len(v1);
     let mut i = 0u;
     while i < v0_len && i < v1_len {
-        if f(v0[i], v1[i]) { return true; };
+        if f(&v0[i], &v1[i]) { return true; };
         i += 1u;
     }
     return false;
@@ -908,8 +904,8 @@ pure fn any2<T, U>(v0: &[T], v1: &[U],
  *
  * If the vector contains no elements then true is returned.
  */
-pure fn all<T>(v: &[T], f: fn(T) -> bool) -> bool {
-    for each(v) |elem| { if !f(*elem) { return false; } }
+pure fn all<T>(v: &[T], f: fn(t: &T) -> bool) -> bool {
+    for each(v) |elem| { if !f(elem) { return false; } }
     return true;
 }
 
@@ -918,8 +914,8 @@ pure fn all<T>(v: &[T], f: fn(T) -> bool) -> bool {
  *
  * If the vector contains no elements then true is returned.
  */
-pure fn alli<T>(v: &[T], f: fn(uint, T) -> bool) -> bool {
-    for eachi(v) |i, elem| { if !f(i, *elem) { return false; } }
+pure fn alli<T>(v: &[T], f: fn(uint, t: &T) -> bool) -> bool {
+    for eachi(v) |i, elem| { if !f(i, elem) { return false; } }
     return true;
 }
 
@@ -929,24 +925,24 @@ pure fn alli<T>(v: &[T], f: fn(uint, T) -> bool) -> bool {
  * If the vectors are not the same size then false is returned.
  */
 pure fn all2<T, U>(v0: &[T], v1: &[U],
-                   f: fn(T, U) -> bool) -> bool {
+                   f: fn(t: &T, u: &U) -> bool) -> bool {
     let v0_len = len(v0);
     if v0_len != len(v1) { return false; }
     let mut i = 0u;
-    while i < v0_len { if !f(v0[i], v1[i]) { return false; }; i += 1u; }
+    while i < v0_len { if !f(&v0[i], &v1[i]) { return false; }; i += 1u; }
     return true;
 }
 
 /// Return true if a vector contains an element with the given value
-pure fn contains<T: Eq>(v: &[T], x: T) -> bool {
-    for each(v) |elt| { if x == *elt { return true; } }
+pure fn contains<T: Eq>(v: &[T], x: &T) -> bool {
+    for each(v) |elt| { if *x == *elt { return true; } }
     return false;
 }
 
 /// Returns the number of elements that are equal to a given value
-pure fn count<T: Eq>(v: &[T], x: T) -> uint {
+pure fn count<T: Eq>(v: &[T], x: &T) -> uint {
     let mut cnt = 0u;
-    for each(v) |elt| { if x == *elt { cnt += 1u; } }
+    for each(v) |elt| { if *x == *elt { cnt += 1u; } }
     return cnt;
 }
 
@@ -957,7 +953,7 @@ pure fn count<T: Eq>(v: &[T], x: T) -> uint {
  * When function `f` returns true then an option containing the element
  * is returned. If `f` matches no elements then none is returned.
  */
-pure fn find<T: Copy>(v: &[T], f: fn(T) -> bool) -> Option<T> {
+pure fn find<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> Option<T> {
     find_between(v, 0u, len(v), f)
 }
 
@@ -969,7 +965,7 @@ pure fn find<T: Copy>(v: &[T], f: fn(T) -> bool) -> Option<T> {
  * the element is returned. If `f` matches no elements then none is returned.
  */
 pure fn find_between<T: Copy>(v: &[T], start: uint, end: uint,
-                      f: fn(T) -> bool) -> Option<T> {
+                      f: fn(t: &T) -> bool) -> Option<T> {
     position_between(v, start, end, f).map(|i| v[*i])
 }
 
@@ -980,7 +976,7 @@ pure fn find_between<T: Copy>(v: &[T], start: uint, end: uint,
  * `f` returns true then an option containing the element is returned. If `f`
  * matches no elements then none is returned.
  */
-pure fn rfind<T: Copy>(v: &[T], f: fn(T) -> bool) -> Option<T> {
+pure fn rfind<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> Option<T> {
     rfind_between(v, 0u, len(v), f)
 }
 
@@ -989,16 +985,16 @@ pure fn rfind<T: Copy>(v: &[T], f: fn(T) -> bool) -> Option<T> {
  *
  * Apply function `f` to each element of `v` in reverse order within the range
  * [`start`, `end`). When function `f` returns true then an option containing
- * the element is returned. If `f` matches no elements then none is returned.
+ * the element is returned. If `f` matches no elements then none is return.
  */
 pure fn rfind_between<T: Copy>(v: &[T], start: uint, end: uint,
-                               f: fn(T) -> bool) -> Option<T> {
+                               f: fn(t: &T) -> bool) -> Option<T> {
     rposition_between(v, start, end, f).map(|i| v[*i])
 }
 
 /// Find the first index containing a matching value
-pure fn position_elem<T: Eq>(v: &[T], x: T) -> Option<uint> {
-    position(v, |y| x == y)
+pure fn position_elem<T: Eq>(v: &[T], x: &T) -> Option<uint> {
+    position(v, |y| *x == *y)
 }
 
 /**
@@ -1008,7 +1004,7 @@ pure fn position_elem<T: Eq>(v: &[T], x: T) -> Option<uint> {
  * then an option containing the index is returned. If `f` matches no elements
  * then none is returned.
  */
-pure fn position<T>(v: &[T], f: fn(T) -> bool) -> Option<uint> {
+pure fn position<T>(v: &[T], f: fn(t: &T) -> bool) -> Option<uint> {
     position_between(v, 0u, len(v), f)
 }
 
@@ -1020,17 +1016,17 @@ pure fn position<T>(v: &[T], f: fn(T) -> bool) -> Option<uint> {
  * the index is returned. If `f` matches no elements then none is returned.
  */
 pure fn position_between<T>(v: &[T], start: uint, end: uint,
-                            f: fn(T) -> bool) -> Option<uint> {
+                            f: fn(t: &T) -> bool) -> Option<uint> {
     assert start <= end;
     assert end <= len(v);
     let mut i = start;
-    while i < end { if f(v[i]) { return Some::<uint>(i); } i += 1u; }
+    while i < end { if f(&v[i]) { return Some::<uint>(i); } i += 1u; }
     return None;
 }
 
 /// Find the last index containing a matching value
-pure fn rposition_elem<T: Eq>(v: &[T], x: T) -> Option<uint> {
-    rposition(v, |y| x == y)
+pure fn rposition_elem<T: Eq>(v: &[T], x: &T) -> Option<uint> {
+    rposition(v, |y| *x == *y)
 }
 
 /**
@@ -1040,7 +1036,7 @@ pure fn rposition_elem<T: Eq>(v: &[T], x: T) -> Option<uint> {
  * `f` returns true then an option containing the index is returned. If `f`
  * matches no elements then none is returned.
  */
-pure fn rposition<T>(v: &[T], f: fn(T) -> bool) -> Option<uint> {
+pure fn rposition<T>(v: &[T], f: fn(t: &T) -> bool) -> Option<uint> {
     rposition_between(v, 0u, len(v), f)
 }
 
@@ -1053,12 +1049,12 @@ pure fn rposition<T>(v: &[T], f: fn(T) -> bool) -> Option<uint> {
  * returned.
  */
 pure fn rposition_between<T>(v: &[T], start: uint, end: uint,
-                             f: fn(T) -> bool) -> Option<uint> {
+                             f: fn(t: &T) -> bool) -> Option<uint> {
     assert start <= end;
     assert end <= len(v);
     let mut i = end;
     while i > start {
-        if f(v[i - 1u]) { return Some::<uint>(i - 1u); }
+        if f(&v[i - 1u]) { return Some::<uint>(i - 1u); }
         i -= 1u;
     }
     return None;
@@ -1122,12 +1118,13 @@ pure fn zip_slice<T: Copy, U: Copy>(v: &[const T], u: &[const U])
  * Returns a vector of tuples, where the i-th tuple contains contains the
  * i-th elements from each of the input vectors.
  */
-pure fn zip<T, U>(+v: ~[const T], +u: ~[const U]) -> ~[(T, U)] {
-    let mut v = move v, u = move u, i = len(v);
+pure fn zip<T, U>(+v: ~[T], +u: ~[U]) -> ~[(T, U)] {
+    let mut v = move v, u = move u; // FIXME(#3488)
+    let mut i = len(v);
     assert i == len(u);
     let mut w = with_capacity(i);
     while i > 0 {
-        unsafe { w.push((pop(v),pop(u))); }
+        unsafe { w.push((v.pop(),u.pop())); }
         i -= 1;
     }
     unsafe { reverse(w); }
@@ -1269,10 +1266,10 @@ pure fn rev_eachi<T>(v: &r/[T], blk: fn(i: uint, v: &r/T) -> bool) {
  * Both vectors must have the same length
  */
 #[inline]
-fn iter2<U, T>(v1: &[U], v2: &[T], f: fn(U, T)) {
+fn iter2<U, T>(v1: &[U], v2: &[T], f: fn(u: &U, t: &T)) {
     assert len(v1) == len(v2);
     for uint::range(0u, len(v1)) |i| {
-        f(v1[i], v2[i])
+        f(&v1[i], &v2[i])
     }
 }
 
@@ -1286,20 +1283,24 @@ fn iter2<U, T>(v1: &[U], v2: &[T], f: fn(U, T)) {
  * The total number of permutations produced is `len(v)!`.  If `v` contains
  * repeated elements, then some permutations are repeated.
  */
-pure fn permute<T: Copy>(v: &[const T], put: fn(~[T])) {
+pure fn each_permutation<T: Copy>(+v: &[T], put: fn(ts: &[T]) -> bool) {
     let ln = len(v);
-    if ln == 0u {
-        put(~[]);
+    if ln <= 1 {
+        put(v);
     } else {
+        // This does not seem like the most efficient implementation.  You
+        // could make far fewer copies if you put your mind to it.
         let mut i = 0u;
         while i < ln {
             let elt = v[i];
             let mut rest = slice(v, 0u, i);
             unsafe {
                 rest.push_all(const_view(v, i+1u, ln));
-                permute(rest, |permutation| {
-                    put(append(~[elt], permutation))
-                })
+                for each_permutation(rest) |permutation| {
+                    if !put(append(~[elt], permutation)) {
+                        return;
+                    }
+                }
             }
             i += 1u;
         }
@@ -1528,20 +1529,20 @@ impl<T: Copy> &[const T]: CopyableVector<T> {
 
 trait ImmutableVector<T> {
     pure fn view(start: uint, end: uint) -> &self/[T];
-    pure fn foldr<U: Copy>(z: U, p: fn(T, U) -> U) -> U;
-    pure fn map<U>(f: fn(v: &T) -> U) -> ~[U];
-    pure fn mapi<U>(f: fn(uint, v: &T) -> U) -> ~[U];
+    pure fn foldr<U: Copy>(z: U, p: fn(t: &T, +u: U) -> U) -> U;
+    pure fn map<U>(f: fn(t: &T) -> U) -> ~[U];
+    pure fn mapi<U>(f: fn(uint, t: &T) -> U) -> ~[U];
     fn map_r<U>(f: fn(x: &T) -> U) -> ~[U];
-    pure fn alli(f: fn(uint, T) -> bool) -> bool;
-    pure fn flat_map<U>(f: fn(T) -> ~[U]) -> ~[U];
-    pure fn filter_map<U: Copy>(f: fn(T) -> Option<U>) -> ~[U];
+    pure fn alli(f: fn(uint, t: &T) -> bool) -> bool;
+    pure fn flat_map<U>(f: fn(t: &T) -> ~[U]) -> ~[U];
+    pure fn filter_map<U: Copy>(f: fn(t: &T) -> Option<U>) -> ~[U];
 }
 
 trait ImmutableEqVector<T: Eq> {
-    pure fn position(f: fn(T) -> bool) -> Option<uint>;
-    pure fn position_elem(x: T) -> Option<uint>;
-    pure fn rposition(f: fn(T) -> bool) -> Option<uint>;
-    pure fn rposition_elem(x: T) -> Option<uint>;
+    pure fn position(f: fn(t: &T) -> bool) -> Option<uint>;
+    pure fn position_elem(t: &T) -> Option<uint>;
+    pure fn rposition(f: fn(t: &T) -> bool) -> Option<uint>;
+    pure fn rposition_elem(t: &T) -> Option<uint>;
 }
 
 /// Extension methods for vectors
@@ -1552,15 +1553,17 @@ impl<T> &[T]: ImmutableVector<T> {
     }
     /// Reduce a vector from right to left
     #[inline]
-    pure fn foldr<U: Copy>(z: U, p: fn(T, U) -> U) -> U { foldr(self, z, p) }
+    pure fn foldr<U: Copy>(z: U, p: fn(t: &T, +u: U) -> U) -> U {
+        foldr(self, z, p)
+    }
     /// Apply a function to each element of a vector and return the results
     #[inline]
-    pure fn map<U>(f: fn(v: &T) -> U) -> ~[U] { map(self, f) }
+    pure fn map<U>(f: fn(t: &T) -> U) -> ~[U] { map(self, f) }
     /**
      * Apply a function to the index and value of each element in the vector
      * and return the results
      */
-    pure fn mapi<U>(f: fn(uint, v: &T) -> U) -> ~[U] {
+    pure fn mapi<U>(f: fn(uint, t: &T) -> U) -> ~[U] {
         mapi(self, f)
     }
 
@@ -1580,7 +1583,7 @@ impl<T> &[T]: ImmutableVector<T> {
      *
      *     If the vector is empty, true is returned.
      */
-    pure fn alli(f: fn(uint, T) -> bool) -> bool {
+    pure fn alli(f: fn(uint, t: &T) -> bool) -> bool {
         alli(self, f)
     }
     /**
@@ -1588,7 +1591,9 @@ impl<T> &[T]: ImmutableVector<T> {
      * of each result vector
      */
     #[inline]
-    pure fn flat_map<U>(f: fn(T) -> ~[U]) -> ~[U] { flat_map(self, f) }
+    pure fn flat_map<U>(f: fn(t: &T) -> ~[U]) -> ~[U] {
+        flat_map(self, f)
+    }
     /**
      * Apply a function to each element of a vector and return the results
      *
@@ -1596,7 +1601,7 @@ impl<T> &[T]: ImmutableVector<T> {
      * the resulting vector.
      */
     #[inline]
-    pure fn filter_map<U: Copy>(f: fn(T) -> Option<U>) -> ~[U] {
+    pure fn filter_map<U: Copy>(f: fn(t: &T) -> Option<U>) -> ~[U] {
         filter_map(self, f)
     }
 }
@@ -1610,10 +1615,16 @@ impl<T: Eq> &[T]: ImmutableEqVector<T> {
      * elements then none is returned.
      */
     #[inline]
-    pure fn position(f: fn(T) -> bool) -> Option<uint> { position(self, f) }
+    pure fn position(f: fn(t: &T) -> bool) -> Option<uint> {
+        position(self, f)
+    }
+
     /// Find the first index containing a matching value
     #[inline]
-    pure fn position_elem(x: T) -> Option<uint> { position_elem(self, x) }
+    pure fn position_elem(x: &T) -> Option<uint> {
+        position_elem(self, x)
+    }
+
     /**
      * Find the last index matching some predicate
      *
@@ -1622,15 +1633,21 @@ impl<T: Eq> &[T]: ImmutableEqVector<T> {
      * returned. If `f` matches no elements then none is returned.
      */
     #[inline]
-    pure fn rposition(f: fn(T) -> bool) -> Option<uint> { rposition(self, f) }
+    pure fn rposition(f: fn(t: &T) -> bool) -> Option<uint> {
+        rposition(self, f)
+    }
+
     /// Find the last index containing a matching value
     #[inline]
-    pure fn rposition_elem(x: T) -> Option<uint> { rposition_elem(self, x) }
+    pure fn rposition_elem(t: &T) -> Option<uint> {
+        rposition_elem(self, t)
+    }
 }
 
 trait ImmutableCopyableVector<T> {
-    pure fn filter(f: fn(T) -> bool) -> ~[T];
-    pure fn rfind(f: fn(T) -> bool) -> Option<T>;
+    pure fn filter(f: fn(t: &T) -> bool) -> ~[T];
+
+    pure fn rfind(f: fn(t: &T) -> bool) -> Option<T>;
 }
 
 /// Extension methods for vectors
@@ -1643,7 +1660,10 @@ impl<T: Copy> &[T]: ImmutableCopyableVector<T> {
      * containing only those elements for which `f` returned true.
      */
     #[inline]
-    pure fn filter(f: fn(T) -> bool) -> ~[T] { filter(self, f) }
+    pure fn filter(f: fn(t: &T) -> bool) -> ~[T] {
+        filter(self, f)
+    }
+
     /**
      * Search for the last element that matches a given predicate
      *
@@ -1652,16 +1672,28 @@ impl<T: Copy> &[T]: ImmutableCopyableVector<T> {
      * returned. If `f` matches no elements then none is returned.
      */
     #[inline]
-    pure fn rfind(f: fn(T) -> bool) -> Option<T> { rfind(self, f) }
+    pure fn rfind(f: fn(t: &T) -> bool) -> Option<T> { rfind(self, f) }
 }
 
 trait MutableVector<T> {
     fn push(&mut self, +t: T);
-    fn push_all_move(&mut self, -rhs: ~[const T]);
+    fn push_all_move(&mut self, +rhs: ~[T]);
+    fn pop(&mut self) -> T;
+    fn shift(&mut self) -> T;
+    fn unshift(&mut self, +x: T);
+    fn swap_remove(&mut self, index: uint) -> T;
+    fn truncate(&mut self, newlen: uint);
 }
 
 trait MutableCopyableVector<T: Copy> {
     fn push_all(&mut self, rhs: &[const T]);
+    fn grow(&mut self, n: uint, initval: &T);
+    fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>);
+    fn grow_set(&mut self, index: uint, initval: &T, +val: T);
+}
+
+trait MutableEqVector<T: Eq> {
+    fn dedup(&mut self);
 }
 
 impl<T> ~[T]: MutableVector<T> {
@@ -1669,15 +1701,53 @@ impl<T> ~[T]: MutableVector<T> {
         push(self, move t);
     }
 
-    fn push_all_move(&mut self, -rhs: ~[const T]) {
+    fn push_all_move(&mut self, +rhs: ~[T]) {
         push_all_move(self, move rhs);
     }
+
+    fn pop(&mut self) -> T {
+        pop(self)
+    }
+
+    fn shift(&mut self) -> T {
+        shift(self)
+    }
+
+    fn unshift(&mut self, +x: T) {
+        unshift(self, x)
+    }
+
+    fn swap_remove(&mut self, index: uint) -> T {
+        swap_remove(self, index)
+    }
+
+    fn truncate(&mut self, newlen: uint) {
+        truncate(self, newlen);
+    }
 }
 
 impl<T: Copy> ~[T]: MutableCopyableVector<T> {
     fn push_all(&mut self, rhs: &[const T]) {
         push_all(self, rhs);
     }
+
+    fn grow(&mut self, n: uint, initval: &T) {
+        grow(self, n, initval);
+    }
+
+    fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>) {
+        grow_fn(self, n, op);
+    }
+
+    fn grow_set(&mut self, index: uint, initval: &T, +val: T) {
+        grow_set(self, index, initval, val);
+    }
+}
+
+impl<T: Eq> ~[T]: MutableEqVector<T> {
+    fn dedup(&mut self) {
+        dedup(self)
+    }
 }
 
 /// Unsafe operations
@@ -1714,7 +1784,7 @@ mod raw {
     #[inline(always)]
     unsafe fn from_buf<T>(ptr: *T, elts: uint) -> ~[T] {
         let mut dst = with_capacity(elts);
-        set_len(dst, elts);
+        set_len(&mut dst, elts);
         as_mut_buf(dst, |p_dst, _len_dst| ptr::memcpy(p_dst, ptr, elts));
         move dst
     }
@@ -1727,8 +1797,8 @@ mod raw {
      * the vector is actually the specified size.
      */
     #[inline(always)]
-    unsafe fn set_len<T>(&&v: ~[const T], new_len: uint) {
-        let repr: **VecRepr = ::cast::reinterpret_cast(&addr_of(v));
+    unsafe fn set_len<T>(v: &mut ~[T], new_len: uint) {
+        let repr: **VecRepr = ::cast::transmute(v);
         (**repr).unboxed.fill = new_len * sys::size_of::<T>();
     }
 
@@ -1742,22 +1812,22 @@ mod raw {
      * would also make any pointers to it invalid.
      */
     #[inline(always)]
-    unsafe fn to_ptr<T>(v: &[T]) -> *T {
-        let repr: **SliceRepr = ::cast::reinterpret_cast(&addr_of(v));
+    unsafe fn to_ptr<T>(+v: &[T]) -> *T {
+        let repr: **SliceRepr = ::cast::transmute(&v);
         return ::cast::reinterpret_cast(&addr_of((**repr).data));
     }
 
     /** see `to_ptr()` */
     #[inline(always)]
-    unsafe fn to_const_ptr<T>(v: &[const T]) -> *const T {
-        let repr: **SliceRepr = ::cast::reinterpret_cast(&addr_of(v));
+    unsafe fn to_const_ptr<T>(+v: &[const T]) -> *const T {
+        let repr: **SliceRepr = ::cast::transmute(&v);
         return ::cast::reinterpret_cast(&addr_of((**repr).data));
     }
 
     /** see `to_ptr()` */
     #[inline(always)]
-    unsafe fn to_mut_ptr<T>(v: &[mut T]) -> *mut T {
-        let repr: **SliceRepr = ::cast::reinterpret_cast(&addr_of(v));
+    unsafe fn to_mut_ptr<T>(+v: &[mut T]) -> *mut T {
+        let repr: **SliceRepr = ::cast::transmute(&v);
         return ::cast::reinterpret_cast(&addr_of((**repr).data));
     }
 
@@ -1782,10 +1852,12 @@ mod raw {
     }
 
     /**
-     * Unchecked vector index assignment.
+     * Unchecked vector index assignment.  Does not drop the
+     * old value and hence is only suitable when the vector
+     * is newly allocated.
      */
     #[inline(always)]
-    unsafe fn set<T>(v: &[mut T], i: uint, +val: T) {
+    unsafe fn init_elem<T>(v: &[mut T], i: uint, +val: T) {
         let mut box = Some(move val);
         do as_mut_buf(v) |p, _len| {
             let mut box2 = None;
@@ -1963,17 +2035,17 @@ mod tests {
 
     fn square_ref(n: &uint) -> uint { return square(*n); }
 
-    pure fn is_three(&&n: uint) -> bool { return n == 3u; }
+    pure fn is_three(n: &uint) -> bool { return *n == 3u; }
 
-    pure fn is_odd(&&n: uint) -> bool { return n % 2u == 1u; }
+    pure fn is_odd(n: &uint) -> bool { return *n % 2u == 1u; }
 
-    pure fn is_equal(&&x: uint, &&y:uint) -> bool { return x == y; }
+    pure fn is_equal(x: &uint, y:&uint) -> bool { return *x == *y; }
 
-    fn square_if_odd(&&n: uint) -> Option<uint> {
-        return if n % 2u == 1u { Some(n * n) } else { None };
+    fn square_if_odd(n: &uint) -> Option<uint> {
+        return if *n % 2u == 1u { Some(*n * *n) } else { None };
     }
 
-    fn add(&&x: uint, &&y: uint) -> uint { return x + y; }
+    fn add(+x: uint, y: &uint) -> uint { return x + *y; }
 
     #[test]
     fn test_unsafe_ptrs() {
@@ -2103,7 +2175,7 @@ mod tests {
     fn test_pop() {
         // Test on-stack pop.
         let mut v = ~[1, 2, 3];
-        let mut e = pop(v);
+        let mut e = v.pop();
         assert (len(v) == 2u);
         assert (v[0] == 1);
         assert (v[1] == 2);
@@ -2111,7 +2183,7 @@ mod tests {
 
         // Test on-heap pop.
         v = ~[1, 2, 3, 4, 5];
-        e = pop(v);
+        e = v.pop();
         assert (len(v) == 4u);
         assert (v[0] == 1);
         assert (v[1] == 2);
@@ -2123,11 +2195,11 @@ mod tests {
     #[test]
     fn test_swap_remove() {
         let mut v = ~[1, 2, 3, 4, 5];
-        let mut e = swap_remove(v, 0);
+        let mut e = v.swap_remove(0);
         assert (len(v) == 4);
         assert e == 1;
         assert (v[0] == 5);
-        e = swap_remove(v, 3);
+        e = v.swap_remove(3);
         assert (len(v) == 3);
         assert e == 4;
         assert (v[0] == 5);
@@ -2140,11 +2212,11 @@ mod tests {
         // Tests that we don't accidentally run destructors twice.
         let mut v = ~[::private::exclusive(()), ::private::exclusive(()),
                       ::private::exclusive(())];
-        let mut _e = swap_remove(v, 0);
+        let mut _e = v.swap_remove(0);
         assert (len(v) == 2);
-        _e = swap_remove(v, 1);
+        _e = v.swap_remove(1);
         assert (len(v) == 1);
-        _e = swap_remove(v, 0);
+        _e = v.swap_remove(0);
         assert (len(v) == 0);
     }
 
@@ -2167,13 +2239,13 @@ mod tests {
     fn test_grow() {
         // Test on-stack grow().
         let mut v = ~[];
-        grow(v, 2u, 1);
+        v.grow(2u, &1);
         assert (len(v) == 2u);
         assert (v[0] == 1);
         assert (v[1] == 1);
 
         // Test on-heap grow().
-        grow(v, 3u, 2);
+        v.grow(3u, &2);
         assert (len(v) == 5u);
         assert (v[0] == 1);
         assert (v[1] == 1);
@@ -2185,7 +2257,7 @@ mod tests {
     #[test]
     fn test_grow_fn() {
         let mut v = ~[];
-        grow_fn(v, 3u, square);
+        v.grow_fn(3u, square);
         assert (len(v) == 3u);
         assert (v[0] == 0u);
         assert (v[1] == 1u);
@@ -2195,7 +2267,7 @@ mod tests {
     #[test]
     fn test_grow_set() {
         let mut v = ~[1, 2, 3];
-        grow_set(v, 4u, 4, 5);
+        v.grow_set(4u, &4, 5);
         assert (len(v) == 5u);
         assert (v[0] == 1);
         assert (v[1] == 2);
@@ -2207,7 +2279,7 @@ mod tests {
     #[test]
     fn test_truncate() {
         let mut v = ~[@6,@5,@4];
-        truncate(v, 1);
+        v.truncate(1);
         assert(v.len() == 1);
         assert(*(v[0]) == 6);
         // If the unsafe block didn't drop things properly, we blow up here.
@@ -2217,7 +2289,7 @@ mod tests {
     fn test_dedup() {
         fn case(-a: ~[uint], -b: ~[uint]) {
             let mut v = a;
-            dedup(v);
+            v.dedup();
             assert(v == b);
         }
         case(~[], ~[]);
@@ -2233,11 +2305,11 @@ mod tests {
     #[test]
     fn test_dedup_unique() {
         let mut v0 = ~[~1, ~1, ~2, ~3];
-        dedup(v0);
+        v0.dedup();
         let mut v1 = ~[~1, ~2, ~2, ~3];
-        dedup(v1);
+        v1.dedup();
         let mut v2 = ~[~1, ~2, ~3, ~3];
-        dedup(v2);
+        v2.dedup();
         /*
          * If the ~pointers were leaked or otherwise misused, valgrind and/or
          * rustrt should raise errors.
@@ -2247,11 +2319,11 @@ mod tests {
     #[test]
     fn test_dedup_shared() {
         let mut v0 = ~[@1, @1, @2, @3];
-        dedup(v0);
+        v0.dedup();
         let mut v1 = ~[@1, @2, @2, @3];
-        dedup(v1);
+        v1.dedup();
         let mut v2 = ~[@1, @2, @3, @3];
-        dedup(v2);
+        v2.dedup();
         /*
          * If the @pointers were leaked or otherwise misused, valgrind and/or
          * rustrt should raise errors.
@@ -2281,7 +2353,7 @@ mod tests {
 
     #[test]
     fn test_map2() {
-        fn times(&&x: int, &&y: int) -> int { return x * y; }
+        fn times(x: &int, y: &int) -> int { return *x * *y; }
         let f = times;
         let v0 = ~[1, 2, 3, 4, 5];
         let v1 = ~[5, 4, 3, 2, 1];
@@ -2307,9 +2379,9 @@ mod tests {
         assert (w[1] == 9u);
         assert (w[2] == 25u);
 
-        fn halve(&&i: int) -> Option<int> {
-            if i % 2 == 0 {
-                return option::Some::<int>(i / 2);
+        fn halve(i: &int) -> Option<int> {
+            if *i % 2 == 0 {
+                return option::Some::<int>(*i / 2);
             } else { return option::None::<int>; }
         }
         fn halve_for_sure(i: &int) -> int { return *i / 2; }
@@ -2345,8 +2417,8 @@ mod tests {
 
     #[test]
     fn test_foldl2() {
-        fn sub(&&a: int, &&b: int) -> int {
-            a - b
+        fn sub(+a: int, b: &int) -> int {
+            a - *b
         }
         let mut v = ~[1, 2, 3, 4];
         let sum = foldl(0, v, sub);
@@ -2355,8 +2427,8 @@ mod tests {
 
     #[test]
     fn test_foldr() {
-        fn sub(&&a: int, &&b: int) -> int {
-            a - b
+        fn sub(a: &int, +b: int) -> int {
+            *a - b
         }
         let mut v = ~[1, 2, 3, 4];
         let sum = foldr(v, 0, sub);
@@ -2419,23 +2491,23 @@ mod tests {
     }
 
     #[test]
-    fn test_permute() {
+    fn test_each_permutation() {
         let mut results: ~[~[int]];
 
         results = ~[];
-        permute(~[], |v| results.push(copy v));
+        for each_permutation(~[]) |v| { results.push(from_slice(v)); }
         assert results == ~[~[]];
 
         results = ~[];
-        permute(~[7], |v| results.push(copy v));
+        for each_permutation(~[7]) |v| { results.push(from_slice(v)); }
         assert results == ~[~[7]];
 
         results = ~[];
-        permute(~[1,1], |v| results.push(copy v));
+        for each_permutation(~[1,1]) |v| { results.push(from_slice(v)); }
         assert results == ~[~[1,1],~[1,1]];
 
         results = ~[];
-        permute(~[5,2,0], |v| results.push(copy v));
+        for each_permutation(~[5,2,0]) |v| { results.push(from_slice(v)); }
         assert results ==
             ~[~[5,2,0],~[5,0,2],~[2,5,0],~[2,0,5],~[0,5,2],~[0,2,5]];
     }
@@ -2487,19 +2559,19 @@ mod tests {
 
     #[test]
     fn test_position_elem() {
-        assert position_elem(~[], 1).is_none();
+        assert position_elem(~[], &1).is_none();
 
         let v1 = ~[1, 2, 3, 3, 2, 5];
-        assert position_elem(v1, 1) == Some(0u);
-        assert position_elem(v1, 2) == Some(1u);
-        assert position_elem(v1, 5) == Some(5u);
-        assert position_elem(v1, 4).is_none();
+        assert position_elem(v1, &1) == Some(0u);
+        assert position_elem(v1, &2) == Some(1u);
+        assert position_elem(v1, &5) == Some(5u);
+        assert position_elem(v1, &4).is_none();
     }
 
     #[test]
     fn test_position() {
-        fn less_than_three(&&i: int) -> bool { return i < 3; }
-        fn is_eighteen(&&i: int) -> bool { return i == 18; }
+        fn less_than_three(i: &int) -> bool { return *i < 3; }
+        fn is_eighteen(i: &int) -> bool { return *i == 18; }
 
         assert position(~[], less_than_three).is_none();
 
@@ -2512,7 +2584,7 @@ mod tests {
     fn test_position_between() {
         assert position_between(~[], 0u, 0u, f).is_none();
 
-        fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' }
+        fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
         assert position_between(v, 0u, 0u, f).is_none();
@@ -2540,8 +2612,8 @@ mod tests {
     fn test_find() {
         assert find(~[], f).is_none();
 
-        fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' }
-        fn g(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'd' }
+        fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
+        fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
         assert find(v, f) == Some((1, 'b'));
@@ -2552,7 +2624,7 @@ mod tests {
     fn test_find_between() {
         assert find_between(~[], 0u, 0u, f).is_none();
 
-        fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' }
+        fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
         assert find_between(v, 0u, 0u, f).is_none();
@@ -2580,8 +2652,8 @@ mod tests {
     fn test_rposition() {
         assert find(~[], f).is_none();
 
-        fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' }
-        fn g(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'd' }
+        fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
+        fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
         assert position(v, f) == Some(1u);
@@ -2592,7 +2664,7 @@ mod tests {
     fn test_rposition_between() {
         assert rposition_between(~[], 0u, 0u, f).is_none();
 
-        fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' }
+        fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
         assert rposition_between(v, 0u, 0u, f).is_none();
@@ -2620,8 +2692,8 @@ mod tests {
     fn test_rfind() {
         assert rfind(~[], f).is_none();
 
-        fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' }
-        fn g(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'd' }
+        fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
+        fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
         assert rfind(v, f) == Some((3, 'b'));
@@ -2632,7 +2704,7 @@ mod tests {
     fn test_rfind_between() {
         assert rfind_between(~[], 0u, 0u, f).is_none();
 
-        fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' }
+        fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
         assert rfind_between(v, 0u, 0u, f).is_none();
@@ -2692,7 +2764,7 @@ mod tests {
 
     #[test]
     fn test_split() {
-        fn f(&&x: int) -> bool { x == 3 }
+        fn f(x: &int) -> bool { *x == 3 }
 
         assert split(~[], f) == ~[];
         assert split(~[1, 2], f) == ~[~[1, 2]];
@@ -2703,7 +2775,7 @@ mod tests {
 
     #[test]
     fn test_splitn() {
-        fn f(&&x: int) -> bool { x == 3 }
+        fn f(x: &int) -> bool { *x == 3 }
 
         assert splitn(~[], 1u, f) == ~[];
         assert splitn(~[1, 2], 1u, f) == ~[~[1, 2]];
@@ -2715,7 +2787,7 @@ mod tests {
 
     #[test]
     fn test_rsplit() {
-        fn f(&&x: int) -> bool { x == 3 }
+        fn f(x: &int) -> bool { *x == 3 }
 
         assert rsplit(~[], f) == ~[];
         assert rsplit(~[1, 2], f) == ~[~[1, 2]];
@@ -2725,7 +2797,7 @@ mod tests {
 
     #[test]
     fn test_rsplitn() {
-        fn f(&&x: int) -> bool { x == 3 }
+        fn f(x: &int) -> bool { *x == 3 }
 
         assert rsplitn(~[], 1u, f) == ~[];
         assert rsplitn(~[1, 2], 1u, f) == ~[~[1, 2]];
@@ -2748,9 +2820,9 @@ mod tests {
 
     #[test]
     fn test_connect() {
-        assert connect(~[], 0) == ~[];
-        assert connect(~[~[1], ~[2, 3]], 0) == ~[1, 0, 2, 3];
-        assert connect(~[~[1], ~[2], ~[3]], 0) == ~[1, 0, 2, 0, 3];
+        assert connect(~[], &0) == ~[];
+        assert connect(~[~[1], ~[2, 3]], &0) == ~[1, 0, 2, 3];
+        assert connect(~[~[1], ~[2], ~[3]], &0) == ~[1, 0, 2, 0, 3];
     }
 
     #[test]
@@ -2796,7 +2868,7 @@ mod tests {
     #[test]
     fn test_unshift() {
         let mut x = ~[1, 2, 3];
-        unshift(x, 0);
+        x.unshift(0);
         assert x == ~[0, 1, 2, 3];
     }
 
@@ -2804,10 +2876,10 @@ mod tests {
     fn test_capacity() {
         let mut v = ~[0u64];
         reserve(&mut v, 10u);
-        assert capacity(v) == 10u;
+        assert capacity(&v) == 10u;
         let mut v = ~[0u32];
         reserve(&mut v, 10u);
-        assert capacity(v) == 10u;
+        assert capacity(&v) == 10u;
     }
 
     #[test]
@@ -3012,7 +3084,7 @@ mod tests {
     #[should_fail]
     fn test_grow_fn_fail() {
         let mut v = ~[];
-        do grow_fn(v, 100) |i| {
+        do v.grow_fn(100) |i| {
             if i == 50 {
                 fail
             }
@@ -3318,7 +3390,7 @@ mod tests {
     fn test_permute_fail() {
         let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)];
         let mut i = 0;
-        do permute(v) |_elt| {
+        for each_permutation(v) |_elt| {
             if i == 2 {
                 fail
             }
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 3f6bcd31a73..59de3631118 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -217,7 +217,7 @@ impl Writer {
     }
 
     fn end_tag() {
-        let last_size_pos = vec::pop::<uint>(self.size_positions);
+        let last_size_pos = self.size_positions.pop();
         let cur_pos = self.writer.tell();
         self.writer.seek(last_size_pos as int, io::SeekSet);
         let size = (cur_pos - last_size_pos - 4u);
diff --git a/src/libstd/ebml2.rs b/src/libstd/ebml2.rs
index 496010d579e..21a7d7817c9 100644
--- a/src/libstd/ebml2.rs
+++ b/src/libstd/ebml2.rs
@@ -226,7 +226,7 @@ impl Serializer {
     }
 
     fn end_tag() {
-        let last_size_pos = vec::pop::<uint>(self.size_positions);
+        let last_size_pos = self.size_positions.pop();
         let cur_pos = self.writer.tell();
         self.writer.seek(last_size_pos as int, io::SeekSet);
         let size = (cur_pos - last_size_pos - 4u);
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index 8d27ea5783b..a04eadb7732 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -428,9 +428,8 @@ fn opt_maybe_str(+mm: Matches, nm: &str) -> Option<~str> {
     let vals = opt_vals(mm, nm);
     if vec::len::<Optval>(vals) == 0u { return None::<~str>; }
     return match vals[0] {
-      Val(copy s) =>
-      Some::<~str>(s),
-      _ => None::<~str>
+        Val(copy s) => Some(s),
+        _ => None
     };
 }
 
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 059b5c22545..247c13396d0 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -696,7 +696,7 @@ priv impl Deserializer {
 
     fn pop(&self) -> &self/Json {
         if self.stack.len() == 0 { self.stack.push(&self.json); }
-        vec::pop(self.stack)
+        self.stack.pop()
     }
 }
 
diff --git a/src/libstd/list.rs b/src/libstd/list.rs
index 1568c6c099f..2a7019f5a58 100644
--- a/src/libstd/list.rs
+++ b/src/libstd/list.rs
@@ -13,7 +13,7 @@ enum List<T> {
 
 /// Cregate a list from a vector
 fn from_vec<T: Copy>(v: &[T]) -> @List<T> {
-    vec::foldr(v, @Nil::<T>, |h, t| @Cons(h, t))
+    vec::foldr(v, @Nil::<T>, |h, t| @Cons(*h, t))
 }
 
 /**
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index 202ca548d6b..5b2ea0a84a6 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -163,7 +163,7 @@ mod v4 {
         if vec::len(parts) != 4u {
                 result::Err(fmt!("'%s' doesn't have 4 parts", ip))
                 }
-        else if vec::contains(parts, 256u) {
+        else if vec::contains(parts, &256u) {
                 result::Err(fmt!("invalid octal in addr '%s'", ip))
                 }
         else {
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index f8347be3d08..699fec961c4 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -800,7 +800,7 @@ impl TcpSocketBuf: io::Reader {
         if self.read(bytes, 1u) == 0 { fail } else { bytes[0] as int }
     }
     fn unread_byte(amt: int) {
-        vec::unshift((*(self.data)).buf, amt as u8);
+        self.data.buf.unshift(amt as u8);
     }
     fn eof() -> bool {
         false // noop
diff --git a/src/libstd/par.rs b/src/libstd/par.rs
index a0c9a1b92fe..9cfcd8c2acb 100644
--- a/src/libstd/par.rs
+++ b/src/libstd/par.rs
@@ -123,17 +123,17 @@ pub fn alli<A: Copy Send>(xs: ~[A], f: fn~(uint, A) -> bool) -> bool {
     do vec::all(map_slices(xs, || {
         fn~(base: uint, slice : &[A], copy f) -> bool {
             vec::alli(slice, |i, x| {
-                f(i + base, x)
+                f(i + base, *x)
             })
         }
-    })) |x| { x }
+    })) |x| { *x }
 }
 
 /// Returns true if the function holds for any elements in the vector.
 pub fn any<A: Copy Send>(xs: ~[A], f: fn~(A) -> bool) -> bool {
     do vec::any(map_slices(xs, || {
         fn~(_base : uint, slice: &[A], copy f) -> bool {
-            vec::any(slice, |x| f(x))
+            vec::any(slice, |x| f(*x))
         }
-    })) |x| { x }
+    })) |x| { *x }
 }
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index e3927ef188c..1100485e7f1 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -30,7 +30,7 @@ fn mk<T: Copy>() -> SmallIntMap<T> {
 #[inline(always)]
 fn insert<T: Copy>(self: SmallIntMap<T>, key: uint, +val: T) {
     //io::println(fmt!("%?", key));
-    self.v.grow_set_elt(key, None, Some(val));
+    self.v.grow_set_elt(key, &None, Some(val));
 }
 
 /**
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 9ea43177cea..691f0e840e6 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -358,7 +358,7 @@ fn filter_tests(opts: &TestOpts,
             } else { return option::None; }
         }
 
-        vec::filter_map(filtered, |x| filter_fn(&x, filter_str))
+        vec::filter_map(filtered, |x| filter_fn(x, filter_str))
     };
 
     // Maybe pull out the ignored test and unignore them
@@ -374,7 +374,7 @@ fn filter_tests(opts: &TestOpts,
             } else { return option::None; }
         };
 
-        vec::filter_map(filtered, |x| filter(&x))
+        vec::filter_map(filtered, |x| filter(x))
     };
 
     // Sort the tests alphabetically
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index b6d4c2d0fe3..d05c6eadaf6 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -278,7 +278,7 @@ fn map_item(i: @item, cx: ctx, v: vt) {
       _ => cx.path.push(path_name(i.ident))
     }
     visit::visit_item(i, cx, v);
-    vec::pop(cx.path);
+    cx.path.pop();
 }
 
 fn map_struct_def(struct_def: @ast::struct_def, parent_node: ast_node,
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index a2c935ea6f4..2431947184d 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -275,14 +275,14 @@ fn ident_to_path(s: span, +i: ident) -> @path {
       rp: None, types: ~[]}
 }
 
-pure fn is_unguarded(&&a: arm) -> bool {
+pure fn is_unguarded(a: &arm) -> bool {
     match a.guard {
       None => true,
       _    => false
     }
 }
 
-pure fn unguarded_pat(a: arm) -> Option<~[@pat]> {
+pure fn unguarded_pat(a: &arm) -> Option<~[@pat]> {
     if is_unguarded(a) { Some(/* FIXME (#2543) */ copy a.pats) } else { None }
 }
 
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index 7ef34d8eb0b..d08edd7af1d 100644
--- a/src/libsyntax/attr.rs
+++ b/src/libsyntax/attr.rs
@@ -163,9 +163,9 @@ fn get_name_value_str_pair(item: @ast::meta_item) -> Option<(~str, ~str)> {
 fn find_attrs_by_name(attrs: ~[ast::attribute], name: ~str) ->
    ~[ast::attribute] {
     let filter = (
-        fn@(a: ast::attribute) -> Option<ast::attribute> {
-            if get_attr_name(a) == name {
-                option::Some(a)
+        fn@(a: &ast::attribute) -> Option<ast::attribute> {
+            if get_attr_name(*a) == name {
+                option::Some(*a)
             } else { option::None }
         }
     );
@@ -175,9 +175,9 @@ fn find_attrs_by_name(attrs: ~[ast::attribute], name: ~str) ->
 /// Searcha list of meta items and return only those with a specific name
 fn find_meta_items_by_name(metas: ~[@ast::meta_item], name: ~str) ->
    ~[@ast::meta_item] {
-    let filter = fn@(&&m: @ast::meta_item) -> Option<@ast::meta_item> {
-        if get_meta_item_name(m) == name {
-            option::Some(m)
+    let filter = fn@(m: &@ast::meta_item) -> Option<@ast::meta_item> {
+        if get_meta_item_name(*m) == name {
+            option::Some(*m)
         } else { option::None }
     };
     return vec::filter_map(metas, filter);
@@ -289,8 +289,8 @@ fn remove_meta_items_by_name(items: ~[@ast::meta_item], name: ~str) ->
    ~[@ast::meta_item] {
 
     return vec::filter_map(items, |item| {
-        if get_meta_item_name(item) != name {
-            option::Some(/* FIXME (#2543) */ copy item)
+        if get_meta_item_name(*item) != name {
+            option::Some(/* FIXME (#2543) */ copy *item)
         } else {
             option::None
         }
diff --git a/src/libsyntax/ext/auto_serialize.rs b/src/libsyntax/ext/auto_serialize.rs
index 4ebb8501041..fa14d3b5e99 100644
--- a/src/libsyntax/ext/auto_serialize.rs
+++ b/src/libsyntax/ext/auto_serialize.rs
@@ -90,8 +90,8 @@ fn expand(cx: ext_ctxt,
           span: span,
           _mitem: ast::meta_item,
           in_items: ~[@ast::item]) -> ~[@ast::item] {
-    fn not_auto_serialize(a: ast::attribute) -> bool {
-        attr::get_attr_name(a) != ~"auto_serialize"
+    fn not_auto_serialize(a: &ast::attribute) -> bool {
+        attr::get_attr_name(*a) != ~"auto_serialize"
     }
 
     fn filter_attrs(item: @ast::item) -> @ast::item {
@@ -102,12 +102,12 @@ fn expand(cx: ext_ctxt,
     do vec::flat_map(in_items) |in_item| {
         match in_item.node {
           ast::item_ty(ty, tps) => {
-            vec::append(~[filter_attrs(in_item)],
+            vec::append(~[filter_attrs(*in_item)],
                         ty_fns(cx, in_item.ident, ty, tps))
           }
 
           ast::item_enum(enum_definition, tps) => {
-            vec::append(~[filter_attrs(in_item)],
+            vec::append(~[filter_attrs(*in_item)],
                         enum_fns(cx, in_item.ident,
                                  in_item.span, enum_definition.variants, tps))
           }
@@ -116,7 +116,7 @@ fn expand(cx: ext_ctxt,
             cx.span_err(span, ~"#[auto_serialize] can only be \
                                applied to type and enum \
                                definitions");
-            ~[in_item]
+            ~[*in_item]
           }
         }
     }
diff --git a/src/libsyntax/ext/auto_serialize2.rs b/src/libsyntax/ext/auto_serialize2.rs
index b51184eefd8..099ba67713f 100644
--- a/src/libsyntax/ext/auto_serialize2.rs
+++ b/src/libsyntax/ext/auto_serialize2.rs
@@ -75,8 +75,8 @@ fn expand(cx: ext_ctxt,
           span: span,
           _mitem: ast::meta_item,
           in_items: ~[@ast::item]) -> ~[@ast::item] {
-    fn not_auto_serialize2(a: ast::attribute) -> bool {
-        attr::get_attr_name(a) != ~"auto_serialize2"
+    fn not_auto_serialize2(a: &ast::attribute) -> bool {
+        attr::get_attr_name(*a) != ~"auto_serialize2"
     }
 
     fn filter_attrs(item: @ast::item) -> @ast::item {
@@ -88,19 +88,19 @@ fn expand(cx: ext_ctxt,
         match item.node {
             ast::item_ty(@{node: ast::ty_rec(fields), _}, tps) => {
                 ~[
-                    filter_attrs(item),
+                    filter_attrs(*item),
                     mk_rec_impl(cx, item.span, item.ident, fields, tps),
                 ]
             },
             ast::item_class(@{ fields, _}, tps) => {
                 ~[
-                    filter_attrs(item),
+                    filter_attrs(*item),
                     mk_struct_impl(cx, item.span, item.ident, fields, tps),
                 ]
             },
             ast::item_enum(enum_def, tps) => {
                 ~[
-                    filter_attrs(item),
+                    filter_attrs(*item),
                     mk_enum_impl(cx, item.span, item.ident, enum_def, tps),
                 ]
             },
@@ -108,7 +108,7 @@ fn expand(cx: ext_ctxt,
                 cx.span_err(span, ~"#[auto_serialize2] can only be applied \
                                     to structs, record types, and enum \
                                     definitions");
-                ~[item]
+                ~[*item]
             }
         }
     }
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 566cdc4fa21..5f4d86b9860 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -161,7 +161,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
         fn print_backtrace() { }
         fn backtrace() -> expn_info { self.backtrace }
         fn mod_push(i: ast::ident) { self.mod_path.push(i); }
-        fn mod_pop() { vec::pop(self.mod_path); }
+        fn mod_pop() { self.mod_path.pop(); }
         fn mod_path() -> ~[ast::ident] { return self.mod_path; }
         fn bt_push(ei: codemap::expn_info_) {
             match ei {
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index dbe475c1b50..22e2cfcde6b 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -144,7 +144,7 @@ fn expand_mod_items(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
     // decorated with "item decorators", then use that function to transform
     // the item into a new set of items.
     let new_items = do vec::flat_map(module_.items) |item| {
-        do vec::foldr(item.attrs, ~[item]) |attr, items| {
+        do vec::foldr(item.attrs, ~[*item]) |attr, items| {
             let mname = match attr.node.value.node {
               ast::meta_word(n) => n,
               ast::meta_name_value(n, _) => n,
@@ -160,7 +160,7 @@ fn expand_mod_items(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
         }
     };
 
-    return {items: new_items,.. module_};
+    return {items: new_items, ..module_};
 }
 
 
diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs
index f93fa830f92..b9b1484ce5a 100644
--- a/src/libsyntax/ext/pipes/pipec.rs
+++ b/src/libsyntax/ext/pipes/pipec.rs
@@ -47,7 +47,7 @@ impl message: gen_send {
             let arg_names = tys.mapi(|i, _ty| cx.ident_of(~"x_"+i.to_str()));
 
             let args_ast = (arg_names, tys).map(
-                |n, t| cx.arg_mode(n, t, ast::by_copy)
+                |n, t| cx.arg_mode(*n, *t, ast::by_copy)
             );
 
             let pipe_ty = cx.ty_path_ast_builder(
@@ -129,7 +129,7 @@ impl message: gen_send {
                 let arg_names = tys.mapi(|i, _ty| (~"x_" + i.to_str()));
 
                 let args_ast = (arg_names, tys).map(
-                    |n, t| cx.arg_mode(cx.ident_of(n), t, ast::by_copy)
+                    |n, t| cx.arg_mode(cx.ident_of(*n), *t, ast::by_copy)
                 );
 
                 let args_ast = vec::append(
diff --git a/src/libsyntax/ext/simplext.rs b/src/libsyntax/ext/simplext.rs
index 51239754635..e16e1c55349 100644
--- a/src/libsyntax/ext/simplext.rs
+++ b/src/libsyntax/ext/simplext.rs
@@ -307,7 +307,7 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
                 while idx < rc {
                     idx_path.push(idx);
                     res.push(recur(repeat_me)); // whew!
-                    vec::pop(*idx_path);
+                    idx_path.pop();
                     idx += 1u;
                 }
               }
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index 737694337e3..16e3454ca2c 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -219,7 +219,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
 
         /* we append new items to this while we go */
         while cur_eis.len() > 0u { /* for each Earley Item */
-            let mut ei = vec::pop(cur_eis);
+            let mut ei = cur_eis.pop();
 
             let idx = ei.idx;
             let len = ei.elts.len();
@@ -350,13 +350,13 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
             } else if (next_eis.len() > 0u) {
                 /* Now process the next token */
                 while(next_eis.len() > 0u) {
-                    cur_eis.push(vec::pop(next_eis));
+                    cur_eis.push(next_eis.pop());
                 }
                 rdr.next_token();
             } else /* bb_eis.len() == 1 */ {
                 let rust_parser = parser(sess, cfg, rdr.dup(), SOURCE_FILE);
 
-                let ei = vec::pop(bb_eis);
+                let ei = bb_eis.pop();
                 match ei.elts[ei.idx].node {
                   match_nonterminal(_, name, idx) => {
                     ei.matches[idx].push(@matched_nonterminal(
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index 558593579bf..a8a41cca6cb 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -82,13 +82,13 @@ pure fn dup_tt_reader(&&r: tt_reader) -> tt_reader {
 
 pure fn lookup_cur_matched_by_matched(r: tt_reader,
                                       start: @named_match) -> @named_match {
-    pure fn red(&&ad: @named_match, &&idx: uint) -> @named_match {
+    pure fn red(+ad: @named_match, idx: &uint) -> @named_match {
         match *ad {
           matched_nonterminal(_) => {
             // end of the line; duplicate henceforth
             ad
           }
-          matched_seq(ads, _) => ads[idx]
+          matched_seq(ads, _) => ads[*idx]
         }
     }
     vec::foldl(start, r.repeat_idx, red)
@@ -122,8 +122,8 @@ fn lockstep_iter_size(t: token_tree, r: tt_reader) -> lis {
     }
     match t {
       tt_delim(tts) | tt_seq(_, tts, _, _) => {
-        vec::foldl(lis_unconstrained, tts, {|lis, tt|
-            lis_merge(lis, lockstep_iter_size(tt, r), r) })
+        vec::foldl(lis_unconstrained, tts, |lis, tt|
+            lis_merge(lis, lockstep_iter_size(*tt, r), r))
       }
       tt_tok(*) => lis_unconstrained,
       tt_nonterminal(_, name) => match *lookup_cur_matched(r, name) {
@@ -148,7 +148,8 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} {
               }
               tt_frame_up(Some(tt_f)) => {
                 if r.cur.dotdotdoted {
-                    vec::pop(r.repeat_idx); vec::pop(r.repeat_len);
+                    r.repeat_idx.pop();
+                    r.repeat_len.pop();
                 }
 
                 r.cur = tt_f;
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 4f3dafcb21b..088df01985e 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -552,7 +552,7 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
 // ...nor do modules
 fn noop_fold_mod(m: _mod, fld: ast_fold) -> _mod {
     return {view_items: vec::map(m.view_items, |x| fld.fold_view_item(*x)),
-         items: vec::filter_map(m.items, |x| fld.fold_item(x))};
+         items: vec::filter_map(m.items, |x| fld.fold_item(*x))};
 }
 
 fn noop_fold_foreign_mod(nm: foreign_mod, fld: ast_fold) -> foreign_mod {
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 5d1067da762..240c9f34c81 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -1111,7 +1111,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
       ast::expr_call(func, args, has_block) => {
         let mut base_args = args;
         let blk = if has_block {
-            let blk_arg = vec::pop(base_args);
+            let blk_arg = base_args.pop();
             match blk_arg.node {
               ast::expr_loop_body(_) => { head(s, ~"for"); }
               ast::expr_do_body(_) => { head(s, ~"do"); }
diff --git a/src/rustc/driver/rustc.rs b/src/rustc/driver/rustc.rs
index 38ce7a4fbac..8b1202e632e 100644
--- a/src/rustc/driver/rustc.rs
+++ b/src/rustc/driver/rustc.rs
@@ -122,7 +122,7 @@ fn run_compiler(args: ~[~str], demitter: diagnostic::emitter) {
     logging::console_off();
 
     let mut args = args;
-    let binary = vec::shift(args);
+    let binary = args.shift();
 
     if vec::len(args) == 0u { usage(binary); return; }
 
diff --git a/src/rustc/front/config.rs b/src/rustc/front/config.rs
index 7e0d9ec2e86..4577b54fb5c 100644
--- a/src/rustc/front/config.rs
+++ b/src/rustc/front/config.rs
@@ -50,13 +50,12 @@ fn filter_view_item(cx: ctxt, &&view_item: @ast::view_item
 
 fn fold_mod(cx: ctxt, m: ast::_mod, fld: fold::ast_fold) ->
    ast::_mod {
-    let item_filter = |a| filter_item(cx, a);
-    let filtered_items = vec::filter_map(m.items, item_filter);
-    let view_item_filter = |a| filter_view_item(cx, a);
-    let filtered_view_items = vec::filter_map(m.view_items, view_item_filter);
+    let filtered_items = vec::filter_map(m.items, |a| filter_item(cx, *a));
+    let filtered_view_items = vec::filter_map(m.view_items,
+                                              |a| filter_view_item(cx, *a));
     return {
         view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(*x)),
-        items: vec::filter_map(filtered_items, |x| fld.fold_item(x))
+        items: vec::filter_map(filtered_items, |x| fld.fold_item(*x))
     };
 }
 
@@ -69,11 +68,10 @@ fn filter_foreign_item(cx: ctxt, &&item: @ast::foreign_item) ->
 
 fn fold_foreign_mod(cx: ctxt, nm: ast::foreign_mod,
                    fld: fold::ast_fold) -> ast::foreign_mod {
-    let item_filter = |a| filter_foreign_item(cx, a);
-    let filtered_items = vec::filter_map(nm.items, item_filter);
-    let view_item_filter = |a| filter_view_item(cx, a);
-    let filtered_view_items = vec::filter_map(
-        nm.view_items, view_item_filter);
+    let filtered_items = vec::filter_map(nm.items,
+                                         |a| filter_foreign_item(cx, *a));
+    let filtered_view_items = vec::filter_map(nm.view_items,
+                                              |a| filter_view_item(cx, *a));
     return {
         sort: nm.sort,
         view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(*x)),
@@ -100,8 +98,7 @@ fn filter_stmt(cx: ctxt, &&stmt: @ast::stmt) ->
 
 fn fold_block(cx: ctxt, b: ast::blk_, fld: fold::ast_fold) ->
    ast::blk_ {
-    let filter = |a| filter_stmt(cx, a);
-    let filtered_stmts = vec::filter_map(b.stmts, filter);
+    let filtered_stmts = vec::filter_map(b.stmts, |a| filter_stmt(cx, *a));
     return {view_items: b.view_items,
          stmts: vec::map(filtered_stmts, |x| fld.fold_stmt(*x)),
          expr: option::map(&b.expr, |x| fld.fold_expr(*x)),
@@ -136,7 +133,7 @@ fn metas_in_cfg(cfg: ast::crate_cfg, metas: ~[@ast::meta_item]) -> bool {
     // so we can match against them. This is the list of configurations for
     // which the item is valid
     let cfg_metas = vec::concat(vec::filter_map(cfg_metas,
-        |&&i| attr::get_meta_item_list(i) ));
+        |i| attr::get_meta_item_list(*i)));
 
     let has_cfg_metas = vec::len(cfg_metas) > 0u;
     if !has_cfg_metas { return true; }
diff --git a/src/rustc/front/test.rs b/src/rustc/front/test.rs
index 55d71ab6950..952d7b9ab79 100644
--- a/src/rustc/front/test.rs
+++ b/src/rustc/front/test.rs
@@ -81,8 +81,8 @@ fn fold_mod(cx: test_ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod {
     }
 
     let mod_nomain =
-        {view_items: m.view_items, items: vec::filter_map(m.items,
-                                                          |i| nomain(cx, i))};
+        {view_items: m.view_items,
+         items: vec::filter_map(m.items, |i| nomain(cx, *i))};
     return fold::noop_fold_mod(mod_nomain, fld);
 }
 
@@ -122,7 +122,7 @@ fn fold_item(cx: test_ctxt, &&i: @ast::item, fld: fold::ast_fold) ->
     }
 
     let res = fold::noop_fold_item(i, fld);
-    vec::pop(cx.path);
+    cx.path.pop();
     return res;
 }
 
@@ -152,7 +152,7 @@ fn is_ignored(cx: test_ctxt, i: @ast::item) -> bool {
     let ignoreattrs = attr::find_attrs_by_name(i.attrs, ~"ignore");
     let ignoreitems = attr::attr_metas(ignoreattrs);
     let cfg_metas = vec::concat(vec::filter_map(ignoreitems,
-        |&&i| attr::get_meta_item_list(i) ));
+        |i| attr::get_meta_item_list(*i)));
     return if vec::is_not_empty(ignoreitems) {
         config::metas_in_cfg(cx.crate.node.config, cfg_metas)
     } else {
diff --git a/src/rustc/metadata/cstore.rs b/src/rustc/metadata/cstore.rs
index 49e79e009da..483f7ea06a9 100644
--- a/src/rustc/metadata/cstore.rs
+++ b/src/rustc/metadata/cstore.rs
@@ -114,7 +114,7 @@ fn iter_crate_data(cstore: cstore, i: fn(ast::crate_num, crate_metadata)) {
 }
 
 fn add_used_crate_file(cstore: cstore, lib: &Path) {
-    if !vec::contains(p(cstore).used_crate_files, copy *lib) {
+    if !vec::contains(p(cstore).used_crate_files, lib) {
         p(cstore).used_crate_files.push(copy *lib);
     }
 }
@@ -126,7 +126,7 @@ fn get_used_crate_files(cstore: cstore) -> ~[Path] {
 fn add_used_library(cstore: cstore, lib: ~str) -> bool {
     assert lib != ~"";
 
-    if vec::contains(p(cstore).used_libraries, lib) { return false; }
+    if vec::contains(p(cstore).used_libraries, &lib) { return false; }
     p(cstore).used_libraries.push(lib);
     return true;
 }
diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs
index d7fd8036c46..0e6bc2aee15 100644
--- a/src/rustc/metadata/decoder.rs
+++ b/src/rustc/metadata/decoder.rs
@@ -980,7 +980,7 @@ fn get_crate_module_paths(intr: @ident_interner, cdata: cmd)
         res.push((did, path));
     }
     return do vec::filter(res) |x| {
-        let (_, xp) = x;
+        let (_, xp) = *x;
         mods.contains_key(xp)
     }
 }
diff --git a/src/rustc/middle/borrowck/check_loans.rs b/src/rustc/middle/borrowck/check_loans.rs
index 841d54c6b0d..b2469718140 100644
--- a/src/rustc/middle/borrowck/check_loans.rs
+++ b/src/rustc/middle/borrowck/check_loans.rs
@@ -527,7 +527,7 @@ impl check_loan_ctxt {
         do vec::iter2(args, arg_tys) |arg, arg_ty| {
             match ty::resolved_mode(self.tcx(), arg_ty.mode) {
                 ast::by_move => {
-                    self.check_move_out(arg);
+                    self.check_move_out(*arg);
                 }
                 ast::by_mutbl_ref | ast::by_ref |
                 ast::by_copy | ast::by_val => {
diff --git a/src/rustc/middle/borrowck/gather_loans.rs b/src/rustc/middle/borrowck/gather_loans.rs
index b3f846d47fd..85eae29529f 100644
--- a/src/rustc/middle/borrowck/gather_loans.rs
+++ b/src/rustc/middle/borrowck/gather_loans.rs
@@ -116,11 +116,11 @@ fn req_loans_in_expr(ex: @ast::expr,
         do vec::iter2(args, arg_tys) |arg, arg_ty| {
             match ty::resolved_mode(self.tcx(), arg_ty.mode) {
               ast::by_mutbl_ref => {
-                let arg_cmt = self.bccx.cat_expr(arg);
+                let arg_cmt = self.bccx.cat_expr(*arg);
                 self.guarantee_valid(arg_cmt, m_mutbl, scope_r);
               }
               ast::by_ref => {
-                let arg_cmt = self.bccx.cat_expr(arg);
+                let arg_cmt = self.bccx.cat_expr(*arg);
                 self.guarantee_valid(arg_cmt, m_imm,  scope_r);
               }
               ast::by_val => {
diff --git a/src/rustc/middle/check_alt.rs b/src/rustc/middle/check_alt.rs
index a3e85ac56c3..efbeb490db9 100644
--- a/src/rustc/middle/check_alt.rs
+++ b/src/rustc/middle/check_alt.rs
@@ -195,7 +195,7 @@ fn is_useful(tcx: ty::ctxt, m: matrix, v: ~[@pat]) -> useful {
             }
           }
           Some(ctor) => {
-            match is_useful(tcx, vec::filter_map(m, |r| default(tcx, r) ),
+            match is_useful(tcx, vec::filter_map(m, |r| default(tcx, *r) ),
                           vec::tail(v)) {
               useful_ => useful(left_ty, ctor),
               u => u
@@ -212,7 +212,7 @@ fn is_useful(tcx: ty::ctxt, m: matrix, v: ~[@pat]) -> useful {
 
 fn is_useful_specialized(tcx: ty::ctxt, m: matrix, v: ~[@pat], ctor: ctor,
                           arity: uint, lty: ty::t) -> useful {
-    let ms = vec::filter_map(m, |r| specialize(tcx, r, ctor, arity, lty) );
+    let ms = vec::filter_map(m, |r| specialize(tcx, *r, ctor, arity, lty) );
     let could_be_useful = is_useful(
         tcx, ms, specialize(tcx, v, ctor, arity, lty).get());
     match could_be_useful {
@@ -269,7 +269,9 @@ fn missing_ctor(tcx: ty::ctxt, m: matrix, left_ty: ty::t) -> Option<ctor> {
         let mut found = ~[];
         for m.each |r| {
             do option::iter(&pat_ctor_id(tcx, r[0])) |id| {
-                if !vec::contains(found, *id) { found.push(*id); }
+                if !vec::contains(found, id) {
+                    found.push(*id);
+                }
             }
         }
         let variants = ty::enum_variants(tcx, eid);
diff --git a/src/rustc/middle/const_eval.rs b/src/rustc/middle/const_eval.rs
index 463bf502036..5def18cacc3 100644
--- a/src/rustc/middle/const_eval.rs
+++ b/src/rustc/middle/const_eval.rs
@@ -41,7 +41,7 @@ enum constness {
 }
 
 fn join(a: constness, b: constness) -> constness {
-    match (a,b) {
+    match (a, b) {
       (integral_const, integral_const) => integral_const,
       (integral_const, general_const)
       | (general_const, integral_const)
@@ -51,7 +51,7 @@ fn join(a: constness, b: constness) -> constness {
 }
 
 fn join_all(cs: &[constness]) -> constness {
-    vec::foldl(integral_const, cs, join)
+    vec::foldl(integral_const, cs, |a, b| join(a, *b))
 }
 
 fn classify(e: @expr,
diff --git a/src/rustc/middle/kind.rs b/src/rustc/middle/kind.rs
index 15a7d8f52b1..b1323d7fc93 100644
--- a/src/rustc/middle/kind.rs
+++ b/src/rustc/middle/kind.rs
@@ -273,7 +273,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
                       *bounds, (*bounds).len());
         }
         do vec::iter2(*ts, *bounds) |ty, bound| {
-            check_bounds(cx, id_to_use, e.span, ty, bound)
+            check_bounds(cx, id_to_use, e.span, *ty, *bound)
         }
     }
 
@@ -377,7 +377,7 @@ fn check_ty(aty: @ty, cx: ctx, v: visit::vt<ctx>) {
             let did = ast_util::def_id_of_def(cx.tcx.def_map.get(id));
             let bounds = ty::lookup_item_type(cx.tcx, did).bounds;
             do vec::iter2(*ts, *bounds) |ty, bound| {
-                check_bounds(cx, aty.id, aty.span, ty, bound)
+                check_bounds(cx, aty.id, aty.span, *ty, *bound)
             }
         }
       }
diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs
index ce998378fe5..689f69f1ad0 100644
--- a/src/rustc/middle/liveness.rs
+++ b/src/rustc/middle/liveness.rs
@@ -955,7 +955,7 @@ impl Liveness {
     fn propagate_through_block(blk: blk, succ: LiveNode) -> LiveNode {
         let succ = self.propagate_through_opt_expr(blk.node.expr, succ);
         do blk.node.stmts.foldr(succ) |stmt, succ| {
-            self.propagate_through_stmt(stmt, succ)
+            self.propagate_through_stmt(*stmt, succ)
         }
     }
 
@@ -975,7 +975,7 @@ impl Liveness {
         match decl.node {
           decl_local(locals) => {
             do locals.foldr(succ) |local, succ| {
-                self.propagate_through_local(local, succ)
+                self.propagate_through_local(*local, succ)
             }
           }
           decl_item(_) => {
@@ -1007,7 +1007,7 @@ impl Liveness {
     fn propagate_through_exprs(exprs: ~[@expr],
                                succ: LiveNode) -> LiveNode {
         do exprs.foldr(succ) |expr, succ| {
-            self.propagate_through_expr(expr, succ)
+            self.propagate_through_expr(*expr, succ)
         }
     }
 
@@ -1575,7 +1575,7 @@ fn check_expr(expr: @expr, &&self: @Liveness, vt: vt<@Liveness>) {
             match ty::resolved_mode(self.tcx, arg_ty.mode) {
                 by_val | by_copy | by_ref | by_mutbl_ref => {}
                 by_move => {
-                    self.check_move_from_expr(arg_expr, vt);
+                    self.check_move_from_expr(*arg_expr, vt);
                 }
             }
         }
diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs
index 03efd67a9d5..fc66b5dc7a1 100644
--- a/src/rustc/middle/resolve.rs
+++ b/src/rustc/middle/resolve.rs
@@ -1560,7 +1560,7 @@ impl Resolver {
                     path_entry.def_like);
 
             let mut pieces = split_str(path_entry.path_string, ~"::");
-            let final_ident_str = pop(pieces);
+            let final_ident_str = pieces.pop();
             let final_ident = self.session.ident_of(final_ident_str);
 
             // Find the module we need, creating modules along the way if we
diff --git a/src/rustc/middle/trans/alt.rs b/src/rustc/middle/trans/alt.rs
index 165ca8e2fc4..6450e48486c 100644
--- a/src/rustc/middle/trans/alt.rs
+++ b/src/rustc/middle/trans/alt.rs
@@ -581,7 +581,7 @@ fn collect_record_or_struct_fields(m: &[@Match], col: uint) -> ~[ast::ident] {
     fn extend(idents: &mut ~[ast::ident], field_pats: &[ast::field_pat]) {
         for field_pats.each |field_pat| {
             let field_ident = field_pat.ident;
-            if !vec::any(*idents, |x| x == field_ident) {
+            if !vec::any(*idents, |x| *x == field_ident) {
                 idents.push(field_ident);
             }
         }
diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs
index 7c70d83bd76..70231357003 100644
--- a/src/rustc/middle/trans/base.rs
+++ b/src/rustc/middle/trans/base.rs
@@ -57,7 +57,7 @@ struct icx_popper {
     ccx: @crate_ctxt,
     drop {
       if self.ccx.sess.count_llvm_insns() {
-          vec::pop(*(self.ccx.stats.llvm_insn_ctxt));
+          self.ccx.stats.llvm_insn_ctxt.pop();
       }
     }
 }
diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs
index e75d4db897f..907146be4fd 100644
--- a/src/rustc/middle/trans/common.rs
+++ b/src/rustc/middle/trans/common.rs
@@ -402,7 +402,7 @@ fn revoke_clean(cx: block, val: ValueRef) {
     do in_scope_cx(cx) |info| {
         let cleanup_pos = vec::position(
             info.cleanups,
-            |cu| match cu {
+            |cu| match *cu {
                 clean_temp(v, _, _) if v == val => true,
                 _ => false
             });
diff --git a/src/rustc/middle/trans/controlflow.rs b/src/rustc/middle/trans/controlflow.rs
index 5d8b0fbbbe1..68ebf5fa189 100644
--- a/src/rustc/middle/trans/controlflow.rs
+++ b/src/rustc/middle/trans/controlflow.rs
@@ -158,7 +158,7 @@ fn trans_log(log_ex: @ast::expr,
     let modpath = vec::append(
         ~[path_mod(ccx.sess.ident_of(ccx.link_meta.name))],
         vec::filter(bcx.fcx.path, |e|
-            match e { path_mod(_) => true, _ => false }
+            match *e { path_mod(_) => true, _ => false }
         ));
     let modname = path_str(ccx.sess, modpath);
 
diff --git a/src/rustc/middle/trans/foreign.rs b/src/rustc/middle/trans/foreign.rs
index f1077912fec..74dadd2cab4 100644
--- a/src/rustc/middle/trans/foreign.rs
+++ b/src/rustc/middle/trans/foreign.rs
@@ -92,7 +92,7 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] {
             Double => 8,
             Struct => {
               do vec::foldl(0, struct_tys(ty)) |a, t| {
-                  uint::max(a, ty_align(t))
+                  uint::max(a, ty_align(*t))
               }
             }
             Array => {
@@ -113,7 +113,7 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] {
             Double => 8,
             Struct => {
               do vec::foldl(0, struct_tys(ty)) |s, t| {
-                    s + ty_size(t)
+                    s + ty_size(*t)
                 }
             }
             Array => {
diff --git a/src/rustc/middle/trans/monomorphize.rs b/src/rustc/middle/trans/monomorphize.rs
index bbcacec052e..cd8cffa297a 100644
--- a/src/rustc/middle/trans/monomorphize.rs
+++ b/src/rustc/middle/trans/monomorphize.rs
@@ -33,7 +33,7 @@ fn monomorphic_fn(ccx: @crate_ctxt,
     let param_uses = type_use::type_uses_for(ccx, fn_id, substs.len());
     let hash_id = make_mono_id(ccx, fn_id, substs, vtables, Some(param_uses));
     if vec::any(hash_id.params,
-                |p| match p { mono_precise(_, _) => false, _ => true }) {
+                |p| match *p { mono_precise(_, _) => false, _ => true }) {
         must_cast = true;
     }
 
@@ -243,7 +243,7 @@ fn make_mono_id(ccx: @crate_ctxt, item: ast::def_id, substs: ~[ty::t],
         let mut i = 0u;
         vec::map2(*bounds, substs, |bounds, subst| {
             let mut v = ~[];
-            for vec::each(*bounds) |bound| {
+            for bounds.each |bound| {
                 match *bound {
                   ty::bound_trait(_) => {
                     v.push(meth::vtable_id(ccx, vts[i]));
@@ -252,7 +252,7 @@ fn make_mono_id(ccx: @crate_ctxt, item: ast::def_id, substs: ~[ty::t],
                   _ => ()
                 }
             }
-            (subst, if v.len() > 0u { Some(v) } else { None })
+            (*subst, if v.len() > 0u { Some(v) } else { None })
         })
       }
       None => {
@@ -262,12 +262,12 @@ fn make_mono_id(ccx: @crate_ctxt, item: ast::def_id, substs: ~[ty::t],
     let param_ids = match param_uses {
       Some(uses) => {
         vec::map2(precise_param_ids, uses, |id, uses| {
-            match id {
+            match *id {
                 (a, b@Some(_)) => mono_precise(a, b),
                 (subst, None) => {
-                    if uses == 0u {
+                    if *uses == 0u {
                         mono_any
-                    } else if uses == type_use::use_repr &&
+                    } else if *uses == type_use::use_repr &&
                         !ty::type_needs_drop(ccx.tcx, subst)
                     {
                         let llty = type_of::type_of(ccx, subst);
diff --git a/src/rustc/middle/trans/type_use.rs b/src/rustc/middle/trans/type_use.rs
index b29f40748ed..f0d67b92339 100644
--- a/src/rustc/middle/trans/type_use.rs
+++ b/src/rustc/middle/trans/type_use.rs
@@ -206,7 +206,7 @@ fn mark_for_expr(cx: ctx, e: @expr) {
             let id = ast_util::def_id_of_def(cx.ccx.tcx.def_map.get(e.id));
             vec::iter2(type_uses_for(cx.ccx, id, ts.len()), *ts,
                        |uses, subst| {
-                           type_needs(cx, uses, subst)
+                           type_needs(cx, *uses, *subst)
                        })
         }
       }
@@ -239,7 +239,7 @@ fn mark_for_expr(cx: ctx, e: @expr) {
               typeck::method_static(did) => {
                 do cx.ccx.tcx.node_type_substs.find(e.id).iter |ts| {
                     do vec::iter2(type_uses_for(cx.ccx, did, ts.len()), *ts)
-                        |uses, subst| { type_needs(cx, uses, subst)}
+                        |uses, subst| { type_needs(cx, *uses, *subst)}
                 }
               }
               typeck::method_param({param_num: param, _}) => {
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index 63720eaad2e..397a1cd6aa1 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -2238,7 +2238,7 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
             false
           }
 
-          ty_class(did, _) if vec::contains(*seen, did) => {
+          ty_class(ref did, _) if vec::contains(*seen, did) => {
             false
           }
 
@@ -2246,15 +2246,15 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
               seen.push(did);
               let r = vec::any(class_items_as_fields(cx, did, substs),
                                |f| type_requires(cx, seen, r_ty, f.mt.ty));
-              vec::pop(*seen);
+              seen.pop();
             r
           }
 
           ty_tup(ts) => {
-            vec::any(ts, |t| type_requires(cx, seen, r_ty, t))
+            vec::any(ts, |t| type_requires(cx, seen, r_ty, *t))
           }
 
-          ty_enum(did, _) if vec::contains(*seen, did) => {
+          ty_enum(ref did, _) if vec::contains(*seen, did) => {
             false
           }
 
@@ -2263,11 +2263,11 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
                 let vs = enum_variants(cx, did);
                 let r = vec::len(*vs) > 0u && vec::all(*vs, |variant| {
                     vec::any(variant.args, |aty| {
-                        let sty = subst(cx, substs, aty);
+                        let sty = subst(cx, substs, *aty);
                         type_requires(cx, seen, r_ty, sty)
                     })
                 });
-                vec::pop(*seen);
+                seen.pop();
                 r
             }
         };
@@ -3063,7 +3063,7 @@ fn occurs_check(tcx: ctxt, sp: span, vid: TyVid, rt: t) {
     if !type_needs_infer(rt) { return; }
 
     // Occurs check!
-    if vec::contains(vars_in_type(rt), vid) {
+    if vec::contains(vars_in_type(rt), &vid) {
             // Maybe this should be span_err -- however, there's an
             // assertion later on that the type doesn't contain
             // variables, so in this case we have to be sure to die.
diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs
index e1a0e8bc9ed..a1cfb91ebdc 100644
--- a/src/rustc/middle/typeck/check.rs
+++ b/src/rustc/middle/typeck/check.rs
@@ -309,7 +309,7 @@ fn check_fn(ccx: @crate_ctxt,
         fcx.write_ty(info.self_id, info.self_ty);
     }
     do vec::iter2(decl.inputs, arg_tys) |input, arg| {
-        fcx.write_ty(input.id, arg);
+        fcx.write_ty(input.id, *arg);
     }
 
     // If we don't have any enclosing function scope, it is time to
@@ -352,7 +352,7 @@ fn check_fn(ccx: @crate_ctxt,
 
         // Add formal parameters.
         do vec::iter2(arg_tys, decl.inputs) |arg_ty, input| {
-            assign(input.ty.span, input.id, Some(arg_ty));
+            assign(input.ty.span, input.id, Some(*arg_ty));
             debug!("Argument %s is assigned to %s",
                    tcx.sess.str_of(input.ident),
                    fcx.inh.locals.get(input.id).to_str());
@@ -807,7 +807,7 @@ fn do_autoderef(fcx: @fn_ctxt, sp: span, t: ty::t) -> (ty::t, uint) {
                     _ => ()
                 }
             }
-            ty::ty_enum(did, _) => {
+            ty::ty_enum(ref did, _) => {
                 // Watch out for a type like `enum t = @t`.  Such a
                 // type would otherwise infinitely auto-deref.  Only
                 // autoderef loops during typeck (basically, this one
@@ -818,7 +818,7 @@ fn do_autoderef(fcx: @fn_ctxt, sp: span, t: ty::t) -> (ty::t, uint) {
                 if vec::contains(enum_dids, did) {
                     return (t1, autoderefs);
                 }
-                enum_dids.push(did);
+                enum_dids.push(*did);
             }
             _ => { /*ok*/ }
         }
@@ -2294,7 +2294,7 @@ fn check_enum_variants(ccx: @crate_ctxt,
               }
               _ => ()
             }
-            if vec::contains(*disr_vals, *disr_val) {
+            if vec::contains(*disr_vals, &*disr_val) {
                 ccx.tcx.sess.span_err(v.span,
                                       ~"discriminator value already exists");
             }
diff --git a/src/rustc/middle/typeck/check/alt.rs b/src/rustc/middle/typeck/check/alt.rs
index 3b299caf872..ace045ec4a7 100644
--- a/src/rustc/middle/typeck/check/alt.rs
+++ b/src/rustc/middle/typeck/check/alt.rs
@@ -165,7 +165,7 @@ fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path,
 
             do subpats.iter() |pats| {
                 do vec::iter2(*pats, arg_types) |subpat, arg_ty| {
-                  check_pat(pcx, subpat, arg_ty);
+                  check_pat(pcx, *subpat, *arg_ty);
                 }
             };
         } else if subpats_len > 0u {
diff --git a/src/rustc/middle/typeck/check/vtable.rs b/src/rustc/middle/typeck/check/vtable.rs
index 38ca571dae5..06f466f74d5 100644
--- a/src/rustc/middle/typeck/check/vtable.rs
+++ b/src/rustc/middle/typeck/check/vtable.rs
@@ -23,7 +23,7 @@ use util::common::indenter;
 
 fn has_trait_bounds(tps: ~[ty::param_bounds]) -> bool {
     vec::any(tps, |bs| {
-        vec::any(*bs, |b| {
+        bs.any(|b| {
             match b { ty::bound_trait(_) => true, _ => false }
         })
     })
@@ -393,7 +393,7 @@ fn connect_trait_tps(fcx: @fn_ctxt, expr: @ast::expr, impl_tys: ~[ty::t],
     match ty::get(trait_ty).sty {
      ty::ty_trait(_, substs, _) => {
         vec::iter2(substs.tps, trait_tys,
-                   |a, b| demand::suptype(fcx, expr.span, a, b));
+                   |a, b| demand::suptype(fcx, expr.span, *a, *b));
       }
      _ => tcx.sess.impossible_case(expr.span, "connect_trait_tps: \
             don't know how to handle a non-trait ty")
diff --git a/src/rustc/middle/typeck/collect.rs b/src/rustc/middle/typeck/collect.rs
index 630ac8c13a1..18e29981af3 100644
--- a/src/rustc/middle/typeck/collect.rs
+++ b/src/rustc/middle/typeck/collect.rs
@@ -725,7 +725,7 @@ fn ty_of_foreign_item(ccx: @crate_ctxt, it: @ast::foreign_item)
 fn compute_bounds(ccx: @crate_ctxt,
                   ast_bounds: @~[ast::ty_param_bound]) -> ty::param_bounds {
     @do vec::flat_map(*ast_bounds) |b| {
-        match b {
+        match *b {
           ast::bound_send => ~[ty::bound_send],
           ast::bound_copy => ~[ty::bound_copy],
           ast::bound_const => ~[ty::bound_const],
diff --git a/src/rustc/middle/typeck/infer.rs b/src/rustc/middle/typeck/infer.rs
index a0bb828e412..e5aa0debfe1 100644
--- a/src/rustc/middle/typeck/infer.rs
+++ b/src/rustc/middle/typeck/infer.rs
@@ -507,7 +507,7 @@ fn rollback_to<V:Copy vid, T:Copy>(
     vb: &vals_and_bindings<V, T>, len: uint) {
 
     while vb.bindings.len() != len {
-        let (vid, old_v) = vec::pop(vb.bindings);
+        let (vid, old_v) = vb.bindings.pop();
         vb.vals.insert(vid.to_uint(), old_v);
     }
 }
diff --git a/src/rustc/middle/typeck/infer/region_var_bindings.rs b/src/rustc/middle/typeck/infer/region_var_bindings.rs
index 8eabb2c0787..c86850e19d2 100644
--- a/src/rustc/middle/typeck/infer/region_var_bindings.rs
+++ b/src/rustc/middle/typeck/infer/region_var_bindings.rs
@@ -1192,7 +1192,7 @@ impl RegionVarBindings {
         set.insert(*orig_node_idx, ());
         let mut result = ~[];
         while !vec::is_empty(stack) {
-            let node_idx = vec::pop(stack);
+            let node_idx = stack.pop();
             for self.each_edge(graph, node_idx, dir) |edge| {
                 match edge.constraint {
                   ConstrainVarSubVar(from_vid, to_vid) => {
diff --git a/src/rustc/middle/typeck/infer/resolve.rs b/src/rustc/middle/typeck/infer/resolve.rs
index a366a2ef1c7..2a851a5f7bb 100644
--- a/src/rustc/middle/typeck/infer/resolve.rs
+++ b/src/rustc/middle/typeck/infer/resolve.rs
@@ -170,7 +170,7 @@ impl resolve_state {
     }
 
     fn resolve_ty_var(vid: TyVid) -> ty::t {
-        if vec::contains(self.v_seen, vid) {
+        if vec::contains(self.v_seen, &vid) {
             self.err = Some(cyclic_ty(vid));
             return ty::mk_var(self.infcx.tcx, vid);
         } else {
@@ -197,7 +197,7 @@ impl resolve_state {
                 ty::mk_var(tcx, vid)
               }
             };
-            vec::pop(self.v_seen);
+            self.v_seen.pop();
             return t1;
         }
     }
diff --git a/src/rustdoc/attr_pass.rs b/src/rustdoc/attr_pass.rs
index b3ba7f14109..71a32dc112f 100644
--- a/src/rustdoc/attr_pass.rs
+++ b/src/rustdoc/attr_pass.rs
@@ -236,7 +236,7 @@ fn merge_method_attrs(
 
         {
             desc: desc,
-            .. doc
+            ..*doc
         }
     }
 }
diff --git a/src/rustdoc/config.rs b/src/rustdoc/config.rs
index c57e712c020..d601d6d92d1 100644
--- a/src/rustdoc/config.rs
+++ b/src/rustdoc/config.rs
@@ -228,8 +228,8 @@ fn maybe_find_pandoc(
     };
 
     let pandoc = do vec::find(possible_pandocs) |pandoc| {
-        let output = program_output(pandoc, ~[~"--version"]);
-        debug!("testing pandoc cmd %s: %?", pandoc, output);
+        let output = program_output(*pandoc, ~[~"--version"]);
+        debug!("testing pandoc cmd %s: %?", *pandoc, output);
         output.status == 0
     };
 
diff --git a/src/rustdoc/desc_to_brief_pass.rs b/src/rustdoc/desc_to_brief_pass.rs
index b517c2f2409..3fcce7db6c4 100644
--- a/src/rustdoc/desc_to_brief_pass.rs
+++ b/src/rustdoc/desc_to_brief_pass.rs
@@ -165,7 +165,7 @@ fn paragraphs(s: ~str) -> ~[~str] {
     let paras = do vec::foldl(~[], lines) |paras, line| {
         let mut res = paras;
 
-        if str::is_whitespace(line) {
+        if str::is_whitespace(*line) {
             whitespace_lines += 1;
         } else {
             if whitespace_lines > 0 {
@@ -178,9 +178,9 @@ fn paragraphs(s: ~str) -> ~[~str] {
             whitespace_lines = 0;
 
             accum = if str::is_empty(accum) {
-                line
+                *line
             } else {
-                accum + ~"\n" + line
+                accum + ~"\n" + *line
             }
         }
 
diff --git a/src/rustdoc/doc.rs b/src/rustdoc/doc.rs
index 82bddf11d16..0764d9e2432 100644
--- a/src/rustdoc/doc.rs
+++ b/src/rustdoc/doc.rs
@@ -378,7 +378,7 @@ impl IndexEntry : cmp::Eq {
 impl Doc {
     fn CrateDoc() -> CrateDoc {
         option::get(&vec::foldl(None, self.pages, |_m, page| {
-            match page {
+            match *page {
               doc::CratePage(doc) => Some(doc),
               _ => None
             }
@@ -395,7 +395,7 @@ impl ModDoc {
 
     fn mods() -> ~[ModDoc] {
         do vec::filter_map(self.items) |itemtag| {
-            match itemtag {
+            match *itemtag {
               ModTag(ModDoc) => Some(ModDoc),
               _ => None
             }
@@ -404,7 +404,7 @@ impl ModDoc {
 
     fn nmods() -> ~[NmodDoc] {
         do vec::filter_map(self.items) |itemtag| {
-            match itemtag {
+            match *itemtag {
               NmodTag(nModDoc) => Some(nModDoc),
               _ => None
             }
@@ -413,7 +413,7 @@ impl ModDoc {
 
     fn fns() -> ~[FnDoc] {
         do vec::filter_map(self.items) |itemtag| {
-            match itemtag {
+            match *itemtag {
               FnTag(FnDoc) => Some(FnDoc),
               _ => None
             }
@@ -422,7 +422,7 @@ impl ModDoc {
 
     fn consts() -> ~[ConstDoc] {
         do vec::filter_map(self.items) |itemtag| {
-            match itemtag {
+            match *itemtag {
               ConstTag(ConstDoc) => Some(ConstDoc),
               _ => None
             }
@@ -431,7 +431,7 @@ impl ModDoc {
 
     fn enums() -> ~[EnumDoc] {
         do vec::filter_map(self.items) |itemtag| {
-            match itemtag {
+            match *itemtag {
               EnumTag(EnumDoc) => Some(EnumDoc),
               _ => None
             }
@@ -440,7 +440,7 @@ impl ModDoc {
 
     fn traits() -> ~[TraitDoc] {
         do vec::filter_map(self.items) |itemtag| {
-            match itemtag {
+            match *itemtag {
               TraitTag(TraitDoc) => Some(TraitDoc),
               _ => None
             }
@@ -449,7 +449,7 @@ impl ModDoc {
 
     fn impls() -> ~[ImplDoc] {
         do vec::filter_map(self.items) |itemtag| {
-            match itemtag {
+            match *itemtag {
               ImplTag(ImplDoc) => Some(ImplDoc),
               _ => None
             }
@@ -458,7 +458,7 @@ impl ModDoc {
 
     fn types() -> ~[TyDoc] {
         do vec::filter_map(self.items) |itemtag| {
-            match itemtag {
+            match *itemtag {
               TyTag(TyDoc) => Some(TyDoc),
               _ => None
             }
@@ -467,7 +467,7 @@ impl ModDoc {
 
     fn structs() -> ~[StructDoc] {
         do vec::filter_map(self.items) |itemtag| {
-            match itemtag {
+            match *itemtag {
                 StructTag(StructDoc) => Some(StructDoc),
                 _ => None
             }
@@ -490,7 +490,7 @@ impl ~[Page]: PageUtils {
 
     fn mods() -> ~[ModDoc] {
         do vec::filter_map(self) |page| {
-            match page {
+            match *page {
               ItemPage(ModTag(ModDoc)) => Some(ModDoc),
               _ => None
             }
@@ -499,7 +499,7 @@ impl ~[Page]: PageUtils {
 
     fn nmods() -> ~[NmodDoc] {
         do vec::filter_map(self) |page| {
-            match page {
+            match *page {
               ItemPage(NmodTag(nModDoc)) => Some(nModDoc),
               _ => None
             }
@@ -508,7 +508,7 @@ impl ~[Page]: PageUtils {
 
     fn fns() -> ~[FnDoc] {
         do vec::filter_map(self) |page| {
-            match page {
+            match *page {
               ItemPage(FnTag(FnDoc)) => Some(FnDoc),
               _ => None
             }
@@ -517,7 +517,7 @@ impl ~[Page]: PageUtils {
 
     fn consts() -> ~[ConstDoc] {
         do vec::filter_map(self) |page| {
-            match page {
+            match *page {
               ItemPage(ConstTag(ConstDoc)) => Some(ConstDoc),
               _ => None
             }
@@ -526,7 +526,7 @@ impl ~[Page]: PageUtils {
 
     fn enums() -> ~[EnumDoc] {
         do vec::filter_map(self) |page| {
-            match page {
+            match *page {
               ItemPage(EnumTag(EnumDoc)) => Some(EnumDoc),
               _ => None
             }
@@ -535,7 +535,7 @@ impl ~[Page]: PageUtils {
 
     fn traits() -> ~[TraitDoc] {
         do vec::filter_map(self) |page| {
-            match page {
+            match *page {
               ItemPage(TraitTag(TraitDoc)) => Some(TraitDoc),
               _ => None
             }
@@ -544,7 +544,7 @@ impl ~[Page]: PageUtils {
 
     fn impls() -> ~[ImplDoc] {
         do vec::filter_map(self) |page| {
-            match page {
+            match *page {
               ItemPage(ImplTag(ImplDoc)) => Some(ImplDoc),
               _ => None
             }
@@ -553,7 +553,7 @@ impl ~[Page]: PageUtils {
 
     fn types() -> ~[TyDoc] {
         do vec::filter_map(self) |page| {
-            match page {
+            match *page {
               ItemPage(TyTag(TyDoc)) => Some(TyDoc),
               _ => None
             }
diff --git a/src/rustdoc/page_pass.rs b/src/rustdoc/page_pass.rs
index 8710792f0e4..ad3f679a97c 100644
--- a/src/rustdoc/page_pass.rs
+++ b/src/rustdoc/page_pass.rs
@@ -105,7 +105,7 @@ fn fold_mod(
 fn strip_mod(doc: doc::ModDoc) -> doc::ModDoc {
     doc::ModDoc_({
         items: do vec::filter(doc.items) |item| {
-            match item {
+            match *item {
               doc::ModTag(_) => false,
               doc::NmodTag(_) => false,
               _ => true
diff --git a/src/rustdoc/path_pass.rs b/src/rustdoc/path_pass.rs
index 96ed269a7e9..f6a241fdac8 100644
--- a/src/rustdoc/path_pass.rs
+++ b/src/rustdoc/path_pass.rs
@@ -45,7 +45,7 @@ fn fold_mod(fold: fold::Fold<Ctxt>, doc: doc::ModDoc) -> doc::ModDoc {
 
     if !is_topmod { fold.ctxt.path.push(doc.name()); }
     let doc = fold::default_any_fold_mod(fold, doc);
-    if !is_topmod { vec::pop(fold.ctxt.path); }
+    if !is_topmod { fold.ctxt.path.pop(); }
 
     doc::ModDoc_({
         item: fold.fold_item(fold, doc.item),
@@ -56,7 +56,7 @@ fn fold_mod(fold: fold::Fold<Ctxt>, doc: doc::ModDoc) -> doc::ModDoc {
 fn fold_nmod(fold: fold::Fold<Ctxt>, doc: doc::NmodDoc) -> doc::NmodDoc {
     fold.ctxt.path.push(doc.name());
     let doc = fold::default_seq_fold_nmod(fold, doc);
-    vec::pop(fold.ctxt.path);
+    fold.ctxt.path.pop();
 
     {
         item: fold.fold_item(fold, doc.item),
diff --git a/src/rustdoc/tystr_pass.rs b/src/rustdoc/tystr_pass.rs
index 62db53b7600..5e2d141318a 100644
--- a/src/rustdoc/tystr_pass.rs
+++ b/src/rustdoc/tystr_pass.rs
@@ -177,7 +177,7 @@ fn get_method_sig(
             node: ast::item_trait(_, _, methods), _
           }, _) => {
             match vec::find(methods, |method| {
-                match method {
+                match *method {
                   ast::required(ty_m) => to_str(ty_m.ident) == method_name,
                   ast::provided(m) => to_str(m.ident) == method_name,
                 }
diff --git a/src/rustdoc/unindent_pass.rs b/src/rustdoc/unindent_pass.rs
index 42c9e80ab7b..aa31892d466 100644
--- a/src/rustdoc/unindent_pass.rs
+++ b/src/rustdoc/unindent_pass.rs
@@ -29,7 +29,7 @@ fn unindent(s: ~str) -> ~str {
         let ignore_previous_indents =
             saw_first_line &&
             !saw_second_line &&
-            !str::is_whitespace(line);
+            !str::is_whitespace(*line);
 
         let min_indent = if ignore_previous_indents {
             uint::max_value
@@ -41,12 +41,12 @@ fn unindent(s: ~str) -> ~str {
             saw_second_line = true;
         }
 
-        if str::is_whitespace(line) {
+        if str::is_whitespace(*line) {
             min_indent
         } else {
             saw_first_line = true;
             let mut spaces = 0;
-            do str::all(line) |char| {
+            do str::all(*line) |char| {
                 // Only comparing against space because I wouldn't
                 // know what to do with mixed whitespace chars
                 if char == ' ' {
diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs
index 9454ef7aec7..cf44d478356 100644
--- a/src/test/bench/core-std.rs
+++ b/src/test/bench/core-std.rs
@@ -47,7 +47,7 @@ fn shift_push() {
     let mut v2 = ~[];
 
     while v1.len() > 0 {
-        v2.push(vec::shift(v1));
+        v2.push(v1.shift());
     }
 }
 
diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs
index ef2fa8dfa9e..10b38f2572c 100644
--- a/src/test/bench/graph500-bfs.rs
+++ b/src/test/bench/graph500-bfs.rs
@@ -97,7 +97,7 @@ fn gen_search_keys(graph: graph, n: uint) -> ~[node_id] {
         let k = r.gen_uint_range(0u, graph.len());
 
         if graph[k].len() > 0u && vec::any(graph[k], |i| {
-            i != k as node_id
+            *i != k as node_id
         }) {
             map::set_add(keys, k as node_id);
         }
@@ -160,8 +160,8 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result {
         }
     };
 
-    fn is_gray(c: color) -> bool {
-        match c {
+    fn is_gray(c: &color) -> bool {
+        match *c {
           gray(_) => { true }
           _ => { false }
         }
@@ -183,7 +183,7 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result {
                 let mut color = white;
 
                 do neighbors.each() |k| {
-                    if is_gray(colors[*k]) {
+                    if is_gray(&colors[*k]) {
                         color = gray(*k);
                         false
                     }
@@ -314,7 +314,7 @@ fn validate(edges: ~[(node_id, node_id)],
         }
         else {
             while parent != root {
-                if vec::contains(path, parent) {
+                if vec::contains(path, &parent) {
                     status = false;
                 }
 
@@ -336,8 +336,8 @@ fn validate(edges: ~[(node_id, node_id)],
     log(info, ~"Verifying tree edges...");
 
     let status = do tree.alli() |k, parent| {
-        if parent != root && parent != -1i64 {
-            level[parent] == level[k] - 1
+        if *parent != root && *parent != -1i64 {
+            level[*parent] == level[k] - 1
         }
         else {
             true
diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs
index 2931cab248f..ec144b78a10 100644
--- a/src/test/bench/msgsend-ring-mutex-arcs.rs
+++ b/src/test/bench/msgsend-ring-mutex-arcs.rs
@@ -27,7 +27,7 @@ fn recv(p: &pipe) -> uint {
         while vec::is_empty(*state) {
             cond.wait();
         }
-        vec::pop(*state)
+        state.pop()
     }
 }
 
diff --git a/src/test/bench/msgsend-ring-rw-arcs.rs b/src/test/bench/msgsend-ring-rw-arcs.rs
index 525cf8f1c50..1b857b6caeb 100644
--- a/src/test/bench/msgsend-ring-rw-arcs.rs
+++ b/src/test/bench/msgsend-ring-rw-arcs.rs
@@ -27,7 +27,7 @@ fn recv(p: &pipe) -> uint {
         while vec::is_empty(*state) {
             cond.wait();
         }
-        vec::pop(*state)
+        state.pop()
     }
 }
 
diff --git a/src/test/compile-fail/block-arg-as-stmt-with-value.rs b/src/test/compile-fail/block-arg-as-stmt-with-value.rs
index b8e34aefd6f..15154ab5a4e 100644
--- a/src/test/compile-fail/block-arg-as-stmt-with-value.rs
+++ b/src/test/compile-fail/block-arg-as-stmt-with-value.rs
@@ -2,7 +2,7 @@
 fn compute1() -> float {
     let v = ~[0f, 1f, 2f, 3f];
 
-    do vec::foldl(0f, v) |x, y| { x + y } - 10f
+    do vec::foldl(0f, v) |x, y| { x + *y } - 10f
     //~^ ERROR mismatched types: expected `()`
 }
 
diff --git a/src/test/compile-fail/regions-escape-loop-via-vec.rs b/src/test/compile-fail/regions-escape-loop-via-vec.rs
index 638f14f8794..276862ce106 100644
--- a/src/test/compile-fail/regions-escape-loop-via-vec.rs
+++ b/src/test/compile-fail/regions-escape-loop-via-vec.rs
@@ -7,7 +7,7 @@ fn broken() -> int {
         y += ~[&mut z]; //~ ERROR illegal borrow
         x += 1;
     }
-    vec::foldl(0, y, |v, p| v + *p )
+    vec::foldl(0, y, |v, p| v + **p )
 }
 
 fn main() { }
\ No newline at end of file
diff --git a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs b/src/test/run-pass/block-arg-can-be-followed-by-binop.rs
index 53f158471e8..bab28a06934 100644
--- a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs
+++ b/src/test/run-pass/block-arg-can-be-followed-by-binop.rs
@@ -2,7 +2,7 @@ fn main() {
     let v = ~[-1f, 0f, 1f, 2f, 3f];
 
     // Trailing expressions don't require parentheses:
-    let y = do vec::foldl(0f, v) |x, y| { x + y } + 10f;
+    let y = do vec::foldl(0f, v) |x, y| { x + *y } + 10f;
 
     assert y == 15f;
 }
diff --git a/src/test/run-pass/block-arg-in-parentheses.rs b/src/test/run-pass/block-arg-in-parentheses.rs
index 14b05b29dc3..1121cc4dd2f 100644
--- a/src/test/run-pass/block-arg-in-parentheses.rs
+++ b/src/test/run-pass/block-arg-in-parentheses.rs
@@ -1,20 +1,20 @@
 fn w_semi(v: ~[int]) -> int {
     // the semicolon causes compiler not to
     // complain about the ignored return value:
-    do vec::foldl(0, v) |x,y| { x+y };
+    do vec::foldl(0, v) |x,y| { x+*y };
     -10
 }
 
 fn w_paren1(v: ~[int]) -> int {
-    (do vec::foldl(0, v) |x,y| { x+y }) - 10
+    (do vec::foldl(0, v) |x,y| { x+*y }) - 10
 }
 
 fn w_paren2(v: ~[int]) -> int {
-    (do vec::foldl(0, v) |x,y| { x+y} - 10)
+    (do vec::foldl(0, v) |x,y| { x+*y} - 10)
 }
 
 fn w_ret(v: ~[int]) -> int {
-    return do vec::foldl(0, v) |x,y| { x+y } - 10;
+    return do vec::foldl(0, v) |x,y| { x+*y } - 10;
 }
 
 fn main() {
diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs
index 5953e0b85fb..0f77a0e0816 100644
--- a/src/test/run-pass/block-arg.rs
+++ b/src/test/run-pass/block-arg.rs
@@ -8,28 +8,28 @@ fn main() {
     }
 
     // Usable at all:
-    let mut any_negative = do vec::any(v) |e| { float::is_negative(e) };
+    let mut any_negative = do vec::any(v) |e| { float::is_negative(*e) };
     assert any_negative;
 
     // Higher precedence than assignments:
-    any_negative = do vec::any(v) |e| { float::is_negative(e) };
+    any_negative = do vec::any(v) |e| { float::is_negative(*e) };
     assert any_negative;
 
     // Higher precedence than unary operations:
     let abs_v = do vec::map(v) |e| { float::abs(*e) };
-    assert do vec::all(abs_v) |e| { float::is_nonnegative(e) };
-    assert !do vec::any(abs_v) |e| { float::is_negative(e) };
+    assert do vec::all(abs_v) |e| { float::is_nonnegative(*e) };
+    assert !do vec::any(abs_v) |e| { float::is_negative(*e) };
 
     // Usable in funny statement-like forms:
-    if !do vec::any(v) |e| { float::is_positive(e) } {
+    if !do vec::any(v) |e| { float::is_positive(*e) } {
         assert false;
     }
-    match do vec::all(v) |e| { float::is_negative(e) } {
+    match do vec::all(v) |e| { float::is_negative(*e) } {
         true => { fail ~"incorrect answer."; }
         false => { }
     }
     match 3 {
-      _ if do vec::any(v) |e| { float::is_negative(e) } => {
+      _ if do vec::any(v) |e| { float::is_negative(*e) } => {
       }
       _ => {
         fail ~"wrong answer.";
@@ -38,15 +38,15 @@ fn main() {
 
 
     // Lower precedence than binary operations:
-    let w = do vec::foldl(0f, v) |x, y| { x + y } + 10f;
-    let y = do vec::foldl(0f, v) |x, y| { x + y } + 10f;
-    let z = 10f + do vec::foldl(0f, v) |x, y| { x + y };
+    let w = do vec::foldl(0f, v) |x, y| { x + *y } + 10f;
+    let y = do vec::foldl(0f, v) |x, y| { x + *y } + 10f;
+    let z = 10f + do vec::foldl(0f, v) |x, y| { x + *y };
     assert w == y;
     assert y == z;
 
     // In the tail of a block
     let w =
-        if true { do vec::any(abs_v) |e| { float::is_nonnegative(e) } }
+        if true { do vec::any(abs_v) |e| { float::is_nonnegative(*e) } }
       else { false };
     assert w;
 }
diff --git a/src/test/run-pass/block-vec-map2.rs b/src/test/run-pass/block-vec-map2.rs
index 332afc65f72..d270800de11 100644
--- a/src/test/run-pass/block-vec-map2.rs
+++ b/src/test/run-pass/block-vec-map2.rs
@@ -4,7 +4,7 @@ fn main() {
     let v =
         vec::map2(~[1, 2, 3, 4, 5],
                   ~[true, false, false, true, true],
-                  |i, b| if b { -i } else { i } );
+                  |i, b| if *b { -(*i) } else { *i } );
     log(error, v);
     assert (v == ~[-1, 2, 3, -4, -5]);
 }
diff --git a/src/test/run-pass/ret-break-cont-in-block.rs b/src/test/run-pass/ret-break-cont-in-block.rs
index 9013842ba8b..4e7e978cf55 100644
--- a/src/test/run-pass/ret-break-cont-in-block.rs
+++ b/src/test/run-pass/ret-break-cont-in-block.rs
@@ -43,10 +43,10 @@ fn ret_deep() -> ~str {
 fn main() {
     let mut last = 0;
     for vec::all(~[1, 2, 3, 4, 5, 6, 7]) |e| {
-        last = e;
-        if e == 5 { break; }
-        if e % 2 == 1 { loop; }
-        assert e % 2 == 0;
+        last = *e;
+        if *e == 5 { break; }
+        if *e % 2 == 1 { loop; }
+        assert *e % 2 == 0;
     };
     assert last == 5;
 
-- 
cgit 1.4.1-3-g733a5


From 2f4ee891199d3dffd8382742f576c3e78081634e Mon Sep 17 00:00:00 2001
From: Tim Chevalier <chevalier@alum.wellesley.edu>
Date: Fri, 28 Sep 2012 12:22:33 -0700
Subject: Demode extfmt

Needs a snapshot before this can be completed, because I changed
the mode for conv_poly.
---
 src/libcore/cast.rs         |  4 +--
 src/libcore/extfmt.rs       | 83 ++++++++++++++++++++++++---------------------
 src/libcore/run.rs          |  2 +-
 src/libstd/net_ip.rs        |  8 ++---
 src/libsyntax/diagnostic.rs | 70 +++++++++++++++++++-------------------
 src/libsyntax/ext/base.rs   | 24 ++++++-------
 src/libsyntax/ext/build.rs  |  4 +++
 src/libsyntax/ext/fmt.rs    |  9 ++---
 src/rustc/driver/rustc.rs   |  2 +-
 src/rustdoc/astsrv.rs       | 16 ++++-----
 10 files changed, 117 insertions(+), 105 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libcore/cast.rs b/src/libcore/cast.rs
index d6dacf18171..714c85c75c3 100644
--- a/src/libcore/cast.rs
+++ b/src/libcore/cast.rs
@@ -21,7 +21,7 @@ pub unsafe fn reinterpret_cast<T, U>(src: &T) -> U {
  * reinterpret_cast on managed pointer types.
  */
 #[inline(always)]
-pub unsafe fn forget<T>(-thing: T) { rusti::forget(move thing); }
+pub unsafe fn forget<T>(+thing: T) { rusti::forget(move thing); }
 
 /**
  * Force-increment the reference count on a shared box. If used
@@ -40,7 +40,7 @@ pub unsafe fn bump_box_refcount<T>(+t: @T) { forget(move t); }
  *     assert transmute("L") == ~[76u8, 0u8];
  */
 #[inline(always)]
-pub unsafe fn transmute<L, G>(-thing: L) -> G {
+pub unsafe fn transmute<L, G>(+thing: L) -> G {
     let newthing: G = reinterpret_cast(&thing);
     forget(move thing);
     move newthing
diff --git a/src/libcore/extfmt.rs b/src/libcore/extfmt.rs
index fda3f50ca29..ff5fd11ccc2 100644
--- a/src/libcore/extfmt.rs
+++ b/src/libcore/extfmt.rs
@@ -81,14 +81,14 @@ mod ct {
 
     // A fragment of the output sequence
     enum Piece { PieceString(~str), PieceConv(Conv), }
-    type ErrorFn = fn@(~str) -> ! ;
+    type ErrorFn = fn@(&str) -> ! ;
 
-    fn parse_fmt_string(s: ~str, error: ErrorFn) -> ~[Piece] {
+    fn parse_fmt_string(s: &str, error: ErrorFn) -> ~[Piece] {
         let mut pieces: ~[Piece] = ~[];
         let lim = str::len(s);
         let mut buf = ~"";
-        fn flush_buf(+buf: ~str, &pieces: ~[Piece]) -> ~str {
-            if str::len(buf) > 0 {
+        fn flush_buf(+buf: ~str, pieces: &mut ~[Piece]) -> ~str {
+            if buf.len() > 0 {
                 let piece = PieceString(move buf);
                 pieces.push(move piece);
             }
@@ -108,17 +108,17 @@ mod ct {
                     buf += curr2;
                     i += 1;
                 } else {
-                    buf = flush_buf(move buf, pieces);
+                    buf = flush_buf(move buf, &mut pieces);
                     let rs = parse_conversion(s, i, lim, error);
                     pieces.push(copy rs.piece);
                     i = rs.next;
                 }
             } else { buf += curr; i += size; }
         }
-        flush_buf(move buf, pieces);
+        flush_buf(move buf, &mut pieces);
         move pieces
     }
-    fn peek_num(s: ~str, i: uint, lim: uint) ->
+    fn peek_num(s: &str, i: uint, lim: uint) ->
        Option<{num: uint, next: uint}> {
         let mut j = i;
         let mut accum = 0u;
@@ -140,7 +140,7 @@ mod ct {
             None
         }
     }
-    fn parse_conversion(s: ~str, i: uint, lim: uint, error: ErrorFn) ->
+    fn parse_conversion(s: &str, i: uint, lim: uint, error: ErrorFn) ->
        {piece: Piece, next: uint} {
         let parm = parse_parameter(s, i, lim);
         let flags = parse_flags(s, parm.next, lim);
@@ -155,7 +155,7 @@ mod ct {
                              ty: ty.ty}),
              next: ty.next};
     }
-    fn parse_parameter(s: ~str, i: uint, lim: uint) ->
+    fn parse_parameter(s: &str, i: uint, lim: uint) ->
        {param: Option<int>, next: uint} {
         if i >= lim { return {param: None, next: i}; }
         let num = peek_num(s, i, lim);
@@ -170,12 +170,12 @@ mod ct {
               }
             };
     }
-    fn parse_flags(s: ~str, i: uint, lim: uint) ->
+    fn parse_flags(s: &str, i: uint, lim: uint) ->
        {flags: ~[Flag], next: uint} {
         let noflags: ~[Flag] = ~[];
         if i >= lim { return {flags: move noflags, next: i}; }
 
-        fn more_(f: Flag, s: ~str, i: uint, lim: uint) ->
+        fn more(f: Flag, s: &str, i: uint, lim: uint) ->
            {flags: ~[Flag], next: uint} {
             let next = parse_flags(s, i + 1u, lim);
             let rest = copy next.flags;
@@ -183,21 +183,22 @@ mod ct {
             let curr: ~[Flag] = ~[f];
             return {flags: vec::append(move curr, rest), next: j};
         }
-        let more = |x, copy s| more_(x, copy s, i, lim);
+        // Unfortunate, but because s is borrowed, can't use a closure
+     //   fn more(f: Flag, s: &str) { more_(f, s, i, lim); }
         let f = s[i];
         return if f == '-' as u8 {
-                more(FlagLeftJustify)
+                more(FlagLeftJustify, s, i, lim)
             } else if f == '0' as u8 {
-                more(FlagLeftZeroPad)
+                more(FlagLeftZeroPad, s, i, lim)
             } else if f == ' ' as u8 {
-                more(FlagSpaceForSign)
+                more(FlagSpaceForSign, s, i, lim)
             } else if f == '+' as u8 {
-                more(FlagSignAlways)
+                more(FlagSignAlways, s, i, lim)
             } else if f == '#' as u8 {
-                more(FlagAlternate)
+                more(FlagAlternate, s, i, lim)
             } else { {flags: move noflags, next: i} };
     }
-    fn parse_count(s: ~str, i: uint, lim: uint)
+    fn parse_count(s: &str, i: uint, lim: uint)
         -> {count: Count, next: uint} {
         return if i >= lim {
                 {count: CountImplied, next: i}
@@ -219,7 +220,7 @@ mod ct {
                 }
             };
     }
-    fn parse_precision(s: ~str, i: uint, lim: uint) ->
+    fn parse_precision(s: &str, i: uint, lim: uint) ->
        {count: Count, next: uint} {
         return if i >= lim {
                 {count: CountImplied, next: i}
@@ -235,7 +236,7 @@ mod ct {
                 }
             } else { {count: CountImplied, next: i} };
     }
-    fn parse_type(s: ~str, i: uint, lim: uint, error: ErrorFn) ->
+    fn parse_type(s: &str, i: uint, lim: uint, error: ErrorFn) ->
        {ty: Ty, next: uint} {
         if i >= lim { error(~"missing type in conversion"); }
         let tstr = str::slice(s, i, i+1u);
@@ -269,10 +270,7 @@ mod ct {
     }
 }
 
-// Functions used by the fmt extension at runtime. For now there are a lot of
-// decisions made a runtime. If it proves worthwhile then some of these
-// conditions can be evaluated at compile-time. For now though it's cleaner to
-// implement it 0this way, I think.
+// OLD CODE -- eventually remove
 mod rt {
     #[legacy_exports];
     const flag_none : u32 = 0u32;
@@ -328,7 +326,7 @@ mod rt {
         let mut unpadded = match cv.precision {
           CountImplied => s.to_unique(),
           CountIs(max) => if max as uint < str::char_len(s) {
-            str::substr(s, 0u, max as uint)
+            str::substr(s, 0, max as uint)
           } else {
             s.to_unique()
           }
@@ -338,7 +336,7 @@ mod rt {
     pure fn conv_float(cv: Conv, f: float) -> ~str {
         let (to_str, digits) = match cv.precision {
               CountIs(c) => (float::to_str_exact, c as uint),
-              CountImplied => (float::to_str, 6u)
+              CountImplied => (float::to_str, 6)
         };
         let mut s = unsafe { to_str(f, digits) };
         if 0.0 <= f {
@@ -404,16 +402,17 @@ mod rt {
         pure fn ne(other: &PadMode) -> bool { !self.eq(other) }
     }
 
-    fn pad(cv: Conv, &s: ~str, mode: PadMode) -> ~str {
+    fn pad(cv: Conv, +s: ~str, mode: PadMode) -> ~str {
+        let mut s = move s; // sadtimes
         let uwidth : uint = match cv.width {
-          CountImplied => return copy s,
+          CountImplied => return s,
           CountIs(width) => {
               // FIXME: width should probably be uint (see Issue #1996)
               width as uint
           }
         };
         let strlen = str::char_len(s);
-        if uwidth <= strlen { return copy s; }
+        if uwidth <= strlen { return s; }
         let mut padchar = ' ';
         let diff = uwidth - strlen;
         if have_flag(cv.flags, flag_left_justify) {
@@ -444,7 +443,7 @@ mod rt {
         // zeros. It may make sense to convert zero padding to a precision
         // instead.
 
-        if signed && zero_padding && str::len(s) > 0u {
+        if signed && zero_padding && s.len() > 0 {
             let head = str::shift_char(&mut s);
             if head == '+' || head == '-' || head == ' ' {
                 let headstr = str::from_chars(vec::from_elem(1u, head));
@@ -461,7 +460,12 @@ mod rt {
     }
 }
 
-// XXX remove after snapshots
+// NEW CODE
+
+// Functions used by the fmt extension at runtime. For now there are a lot of
+// decisions made a runtime. If it proves worthwhile then some of these
+// conditions can be evaluated at compile-time. For now though it's cleaner to
+// implement it 0this way, I think.
 mod rt2 {
     #[legacy_exports];
     const flag_none : u32 = 0u32;
@@ -477,7 +481,7 @@ mod rt2 {
     type Conv = {flags: u32, width: Count, precision: Count, ty: Ty};
 
     pure fn conv_int(cv: Conv, i: int) -> ~str {
-        let radix = 10u;
+        let radix = 10;
         let prec = get_int_precision(cv);
         let mut s : ~str = int_to_str_prec(i, radix, prec);
         if 0 <= i {
@@ -511,7 +515,7 @@ mod rt2 {
         let mut s = str::from_char(c);
         return unsafe { pad(cv, s, PadNozero) };
     }
-    pure fn conv_str(cv: Conv, s: &str) -> ~str {
+    pure fn conv_str(cv: Conv, +s: &str) -> ~str {
         // For strings, precision is the maximum characters
         // displayed
         let mut unpadded = match cv.precision {
@@ -539,8 +543,8 @@ mod rt2 {
         }
         return unsafe { pad(cv, s, PadFloat) };
     }
-    pure fn conv_poly<T>(cv: Conv, v: T) -> ~str {
-        let s = sys::log_str(&v);
+    pure fn conv_poly<T>(cv: Conv, v: &T) -> ~str {
+        let s = sys::log_str(v);
         return conv_str(cv, s);
     }
 
@@ -593,16 +597,17 @@ mod rt2 {
         pure fn ne(other: &PadMode) -> bool { !self.eq(other) }
     }
 
-    fn pad(cv: Conv, &s: ~str, mode: PadMode) -> ~str {
+    fn pad(cv: Conv, +s: ~str, mode: PadMode) -> ~str {
+        let mut s = move s; // sadtimes
         let uwidth : uint = match cv.width {
-          CountImplied => return copy s,
+          CountImplied => return s,
           CountIs(width) => {
               // FIXME: width should probably be uint (see Issue #1996)
               width as uint
           }
         };
         let strlen = str::char_len(s);
-        if uwidth <= strlen { return copy s; }
+        if uwidth <= strlen { return s; }
         let mut padchar = ' ';
         let diff = uwidth - strlen;
         if have_flag(cv.flags, flag_left_justify) {
@@ -633,7 +638,7 @@ mod rt2 {
         // zeros. It may make sense to convert zero padding to a precision
         // instead.
 
-        if signed && zero_padding && str::len(s) > 0u {
+        if signed && zero_padding && s.len() > 0 {
             let head = str::shift_char(&mut s);
             if head == '+' || head == '-' || head == ' ' {
                 let headstr = str::from_chars(vec::from_elem(1u, head));
diff --git a/src/libcore/run.rs b/src/libcore/run.rs
index ae6a0bbb1dd..85d921e8833 100644
--- a/src/libcore/run.rs
+++ b/src/libcore/run.rs
@@ -328,7 +328,7 @@ pub fn program_output(prog: &str, args: &[~str]) ->
     return {status: status, out: move outs, err: move errs};
 }
 
-fn writeclose(fd: c_int, s: &str) {
+fn writeclose(fd: c_int, +s: ~str) {
     use io::WriterUtil;
 
     error!("writeclose %d, %s", fd as int, s);
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index 5b2ea0a84a6..321eb3158a9 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -156,14 +156,14 @@ mod v4 {
     fn parse_to_ipv4_rep(ip: &str) -> result::Result<Ipv4Rep, ~str> {
         let parts = vec::map(str::split_char(ip, '.'), |s| {
             match uint::from_str(*s) {
-              Some(n) if n <= 255u => n,
-              _ => 256u
+              Some(n) if n <= 255 => n,
+              _ => 256
             }
         });
-        if vec::len(parts) != 4u {
+        if parts.len() != 4 {
                 result::Err(fmt!("'%s' doesn't have 4 parts", ip))
                 }
-        else if vec::contains(parts, &256u) {
+        else if parts.contains(&256) {
                 result::Err(fmt!("invalid octal in addr '%s'", ip))
                 }
         else {
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index 1c12397568d..7f208a3a710 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -10,30 +10,30 @@ export ice_msg;
 export expect;
 
 type emitter = fn@(cmsp: Option<(codemap::codemap, span)>,
-                   msg: ~str, lvl: level);
+                   msg: &str, lvl: level);
 
 
 trait span_handler {
-    fn span_fatal(sp: span, msg: ~str) -> !;
-    fn span_err(sp: span, msg: ~str);
-    fn span_warn(sp: span, msg: ~str);
-    fn span_note(sp: span, msg: ~str);
-    fn span_bug(sp: span, msg: ~str) -> !;
-    fn span_unimpl(sp: span, msg: ~str) -> !;
+    fn span_fatal(sp: span, msg: &str) -> !;
+    fn span_err(sp: span, msg: &str);
+    fn span_warn(sp: span, msg: &str);
+    fn span_note(sp: span, msg: &str);
+    fn span_bug(sp: span, msg: &str) -> !;
+    fn span_unimpl(sp: span, msg: &str) -> !;
     fn handler() -> handler;
 }
 
 trait handler {
-    fn fatal(msg: ~str) -> !;
-    fn err(msg: ~str);
+    fn fatal(msg: &str) -> !;
+    fn err(msg: &str);
     fn bump_err_count();
     fn has_errors() -> bool;
     fn abort_if_errors();
-    fn warn(msg: ~str);
-    fn note(msg: ~str);
-    fn bug(msg: ~str) -> !;
-    fn unimpl(msg: ~str) -> !;
-    fn emit(cmsp: Option<(codemap::codemap, span)>, msg: ~str, lvl: level);
+    fn warn(msg: &str);
+    fn note(msg: &str);
+    fn bug(msg: &str) -> !;
+    fn unimpl(msg: &str) -> !;
+    fn emit(cmsp: Option<(codemap::codemap, span)>, msg: &str, lvl: level);
 }
 
 type handler_t = @{
@@ -47,24 +47,24 @@ type codemap_t = @{
 };
 
 impl codemap_t: span_handler {
-    fn span_fatal(sp: span, msg: ~str) -> ! {
+    fn span_fatal(sp: span, msg: &str) -> ! {
         self.handler.emit(Some((self.cm, sp)), msg, fatal);
         fail;
     }
-    fn span_err(sp: span, msg: ~str) {
+    fn span_err(sp: span, msg: &str) {
         self.handler.emit(Some((self.cm, sp)), msg, error);
         self.handler.bump_err_count();
     }
-    fn span_warn(sp: span, msg: ~str) {
+    fn span_warn(sp: span, msg: &str) {
         self.handler.emit(Some((self.cm, sp)), msg, warning);
     }
-    fn span_note(sp: span, msg: ~str) {
+    fn span_note(sp: span, msg: &str) {
         self.handler.emit(Some((self.cm, sp)), msg, note);
     }
-    fn span_bug(sp: span, msg: ~str) -> ! {
+    fn span_bug(sp: span, msg: &str) -> ! {
         self.span_fatal(sp, ice_msg(msg));
     }
-    fn span_unimpl(sp: span, msg: ~str) -> ! {
+    fn span_unimpl(sp: span, msg: &str) -> ! {
         self.span_bug(sp, ~"unimplemented " + msg);
     }
     fn handler() -> handler {
@@ -73,11 +73,11 @@ impl codemap_t: span_handler {
 }
 
 impl handler_t: handler {
-    fn fatal(msg: ~str) -> ! {
+    fn fatal(msg: &str) -> ! {
         self.emit(None, msg, fatal);
         fail;
     }
-    fn err(msg: ~str) {
+    fn err(msg: &str) {
         self.emit(None, msg, error);
         self.bump_err_count();
     }
@@ -97,22 +97,22 @@ impl handler_t: handler {
         }
         self.fatal(s);
     }
-    fn warn(msg: ~str) {
+    fn warn(msg: &str) {
         self.emit(None, msg, warning);
     }
-    fn note(msg: ~str) {
+    fn note(msg: &str) {
         self.emit(None, msg, note);
     }
-    fn bug(msg: ~str) -> ! {
+    fn bug(msg: &str) -> ! {
         self.fatal(ice_msg(msg));
     }
-    fn unimpl(msg: ~str) -> ! { self.bug(~"unimplemented " + msg); }
-    fn emit(cmsp: Option<(codemap::codemap, span)>, msg: ~str, lvl: level) {
+    fn unimpl(msg: &str) -> ! { self.bug(~"unimplemented " + msg); }
+    fn emit(cmsp: Option<(codemap::codemap, span)>, msg: &str, lvl: level) {
         self.emit(cmsp, msg, lvl);
     }
 }
 
-fn ice_msg(msg: ~str) -> ~str {
+fn ice_msg(msg: &str) -> ~str {
     fmt!("internal compiler error: %s", msg)
 }
 
@@ -126,17 +126,19 @@ fn mk_handler(emitter: Option<emitter>) -> handler {
       Some(e) => e,
       None => {
         let f = fn@(cmsp: Option<(codemap::codemap, span)>,
-            msg: ~str, t: level) {
+            msg: &str, t: level) {
             emit(cmsp, msg, t);
         };
         f
       }
     };
 
-    @{
-        mut err_count: 0u,
+    let x: handler_t = @{
+        mut err_count: 0,
         emit: emit
-    } as handler
+    };
+
+    x as handler
 }
 
 enum level {
@@ -171,7 +173,7 @@ fn diagnosticcolor(lvl: level) -> u8 {
     }
 }
 
-fn print_diagnostic(topic: ~str, lvl: level, msg: ~str) {
+fn print_diagnostic(topic: ~str, lvl: level, msg: &str) {
     let use_color = term::color_supported() &&
         io::stderr().get_type() == io::Screen;
     if str::is_not_empty(topic) {
@@ -188,7 +190,7 @@ fn print_diagnostic(topic: ~str, lvl: level, msg: ~str) {
 }
 
 fn emit(cmsp: Option<(codemap::codemap, span)>,
-        msg: ~str, lvl: level) {
+        msg: &str, lvl: level) {
     match cmsp {
       Some((cm, sp)) => {
         let sp = codemap::adjust_span(cm,sp);
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 5f4d86b9860..6c71fd8fcbc 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -133,12 +133,12 @@ trait ext_ctxt {
     fn mod_path() -> ~[ast::ident];
     fn bt_push(ei: codemap::expn_info_);
     fn bt_pop();
-    fn span_fatal(sp: span, msg: ~str) -> !;
-    fn span_err(sp: span, msg: ~str);
-    fn span_warn(sp: span, msg: ~str);
-    fn span_unimpl(sp: span, msg: ~str) -> !;
-    fn span_bug(sp: span, msg: ~str) -> !;
-    fn bug(msg: ~str) -> !;
+    fn span_fatal(sp: span, msg: &str) -> !;
+    fn span_err(sp: span, msg: &str);
+    fn span_warn(sp: span, msg: &str);
+    fn span_unimpl(sp: span, msg: &str) -> !;
+    fn span_bug(sp: span, msg: &str) -> !;
+    fn bug(msg: &str) -> !;
     fn next_id() -> ast::node_id;
     pure fn trace_macros() -> bool;
     fn set_trace_macros(x: bool);
@@ -182,27 +182,27 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
               _ => self.bug(~"tried to pop without a push")
             }
         }
-        fn span_fatal(sp: span, msg: ~str) -> ! {
+        fn span_fatal(sp: span, msg: &str) -> ! {
             self.print_backtrace();
             self.parse_sess.span_diagnostic.span_fatal(sp, msg);
         }
-        fn span_err(sp: span, msg: ~str) {
+        fn span_err(sp: span, msg: &str) {
             self.print_backtrace();
             self.parse_sess.span_diagnostic.span_err(sp, msg);
         }
-        fn span_warn(sp: span, msg: ~str) {
+        fn span_warn(sp: span, msg: &str) {
             self.print_backtrace();
             self.parse_sess.span_diagnostic.span_warn(sp, msg);
         }
-        fn span_unimpl(sp: span, msg: ~str) -> ! {
+        fn span_unimpl(sp: span, msg: &str) -> ! {
             self.print_backtrace();
             self.parse_sess.span_diagnostic.span_unimpl(sp, msg);
         }
-        fn span_bug(sp: span, msg: ~str) -> ! {
+        fn span_bug(sp: span, msg: &str) -> ! {
             self.print_backtrace();
             self.parse_sess.span_diagnostic.span_bug(sp, msg);
         }
-        fn bug(msg: ~str) -> ! {
+        fn bug(msg: &str) -> ! {
             self.print_backtrace();
             self.parse_sess.span_diagnostic.handler().bug(msg);
         }
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 8ce426f0357..a43b0cb69f4 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -50,6 +50,10 @@ fn mk_access(cx: ext_ctxt, sp: span, p: ~[ast::ident], m: ast::ident)
     let pathexpr = mk_path(cx, sp, p);
     return mk_access_(cx, sp, pathexpr, m);
 }
+fn mk_addr_of(cx: ext_ctxt, sp: span, e: @ast::expr) -> @ast::expr {
+    return mk_expr(cx, sp, ast::expr_addr_of(ast::m_imm, e));
+}
+
 fn mk_call_(cx: ext_ctxt, sp: span, fn_expr: @ast::expr,
             args: ~[@ast::expr]) -> @ast::expr {
     mk_expr(cx, sp, ast::expr_call(fn_expr, args, false))
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
index e4f197801c2..8b94620f9b6 100644
--- a/src/libsyntax/ext/fmt.rs
+++ b/src/libsyntax/ext/fmt.rs
@@ -20,10 +20,10 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
     let fmtspan = args[0].span;
     debug!("Format string:");
     log(debug, fmt);
-    fn parse_fmt_err_(cx: ext_ctxt, sp: span, msg: ~str) -> ! {
+    fn parse_fmt_err_(cx: ext_ctxt, sp: span, msg: &str) -> ! {
         cx.span_fatal(sp, msg);
     }
-    let parse_fmt_err = fn@(s: ~str) -> ! {
+    let parse_fmt_err = fn@(s: &str) -> ! {
         parse_fmt_err_(cx, fmtspan, s)
     };
     let pieces = parse_fmt_string(fmt, parse_fmt_err);
@@ -39,7 +39,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
    -> @ast::expr {
     fn make_path_vec(_cx: ext_ctxt, ident: @~str) -> ~[ast::ident] {
         let intr = _cx.parse_sess().interner;
-        return ~[intr.intern(@~"extfmt"), intr.intern(@~"rt"),
+        return ~[intr.intern(@~"extfmt"), intr.intern(@~"rt2"),
                  intr.intern(ident)];
     }
     fn make_rt_path_expr(cx: ext_ctxt, sp: span, nm: @~str) -> @ast::expr {
@@ -187,7 +187,8 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
           TyFloat => {
             return make_conv_call(cx, arg.span, ~"float", cnv, arg);
           }
-          TyPoly => return make_conv_call(cx, arg.span, ~"poly", cnv, arg)
+          TyPoly => return make_conv_call(cx, arg.span, ~"poly", cnv,
+                                          mk_addr_of(cx, sp, arg))
         }
     }
     fn log_conv(c: Conv) {
diff --git a/src/rustc/driver/rustc.rs b/src/rustc/driver/rustc.rs
index 8b1202e632e..7db9261d133 100644
--- a/src/rustc/driver/rustc.rs
+++ b/src/rustc/driver/rustc.rs
@@ -236,7 +236,7 @@ fn monitor(+f: fn~(diagnostic::emitter)) {
         // The 'diagnostics emitter'. Every error, warning, etc. should
         // go through this function.
         let demitter = fn@(cmsp: Option<(codemap::codemap, codemap::span)>,
-                           msg: ~str, lvl: diagnostic::level) {
+                           msg: &str, lvl: diagnostic::level) {
             if lvl == diagnostic::fatal {
                 comm::send(ch, fatal);
             }
diff --git a/src/rustdoc/astsrv.rs b/src/rustdoc/astsrv.rs
index 2ae641a73bb..ab6b348c04a 100644
--- a/src/rustdoc/astsrv.rs
+++ b/src/rustdoc/astsrv.rs
@@ -145,25 +145,25 @@ fn build_error_handlers(
     };
 
     impl DiagnosticHandler: diagnostic::handler {
-        fn fatal(msg: ~str) -> ! { self.inner.fatal(msg) }
-        fn err(msg: ~str) { self.inner.err(msg) }
+        fn fatal(msg: &str) -> ! { self.inner.fatal(msg) }
+        fn err(msg: &str) { self.inner.err(msg) }
         fn bump_err_count() {
             self.inner.bump_err_count();
         }
         fn has_errors() -> bool { self.inner.has_errors() }
         fn abort_if_errors() { self.inner.abort_if_errors() }
-        fn warn(msg: ~str) { self.inner.warn(msg) }
-        fn note(msg: ~str) { self.inner.note(msg) }
-        fn bug(msg: ~str) -> ! { self.inner.bug(msg) }
-        fn unimpl(msg: ~str) -> ! { self.inner.unimpl(msg) }
+        fn warn(msg: &str) { self.inner.warn(msg) }
+        fn note(msg: &str) { self.inner.note(msg) }
+        fn bug(msg: &str) -> ! { self.inner.bug(msg) }
+        fn unimpl(msg: &str) -> ! { self.inner.unimpl(msg) }
         fn emit(cmsp: Option<(codemap::codemap, codemap::span)>,
-                msg: ~str, lvl: diagnostic::level) {
+                msg: &str, lvl: diagnostic::level) {
             self.inner.emit(cmsp, msg, lvl)
         }
     }
 
     let emitter = fn@(cmsp: Option<(codemap::codemap, codemap::span)>,
-                       msg: ~str, lvl: diagnostic::level) {
+                       msg: &str, lvl: diagnostic::level) {
         diagnostic::emit(cmsp, msg, lvl);
     };
     let inner_handler = diagnostic::mk_handler(Some(emitter));
-- 
cgit 1.4.1-3-g733a5


From 565b39b3024a16c3398286ebc4b34f09da50c8c0 Mon Sep 17 00:00:00 2001
From: Niko Matsakis <niko@alum.mit.edu>
Date: Fri, 28 Sep 2012 15:48:25 -0700
Subject: rename iter2 to each2, make it follow iterator protocol

---
 src/libcore/vec.rs                        |  8 +++++---
 src/libsyntax/ext/auto_serialize.rs       |  4 ++--
 src/rustc/middle/borrowck/check_loans.rs  |  2 +-
 src/rustc/middle/borrowck/gather_loans.rs |  2 +-
 src/rustc/middle/kind.rs                  |  4 ++--
 src/rustc/middle/lint.rs                  |  2 +-
 src/rustc/middle/liveness.rs              |  2 +-
 src/rustc/middle/trans/inline.rs          |  2 +-
 src/rustc/middle/trans/type_use.rs        | 14 ++++++++------
 src/rustc/middle/typeck/check.rs          |  4 ++--
 src/rustc/middle/typeck/check/alt.rs      |  2 +-
 src/rustc/middle/typeck/check/vtable.rs   |  5 +++--
 12 files changed, 28 insertions(+), 23 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index 914434c9d46..4f3761bc70b 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -82,7 +82,7 @@ export swap;
 export reverse;
 export reversed;
 export each, each_mut, each_const, eachi, rev_each, rev_eachi;
-export iter2;
+export each2;
 export permute;
 export windowed;
 export as_imm_buf;
@@ -1266,10 +1266,12 @@ pure fn rev_eachi<T>(v: &r/[T], blk: fn(i: uint, v: &r/T) -> bool) {
  * Both vectors must have the same length
  */
 #[inline]
-fn iter2<U, T>(v1: &[U], v2: &[T], f: fn(u: &U, t: &T)) {
+fn each2<U, T>(v1: &[U], v2: &[T], f: fn(u: &U, t: &T) -> bool) {
     assert len(v1) == len(v2);
     for uint::range(0u, len(v1)) |i| {
-        f(&v1[i], &v2[i])
+        if !f(&v1[i], &v2[i]) {
+            return;
+        }
     }
 }
 
diff --git a/src/libsyntax/ext/auto_serialize.rs b/src/libsyntax/ext/auto_serialize.rs
index fa14d3b5e99..64915c60742 100644
--- a/src/libsyntax/ext/auto_serialize.rs
+++ b/src/libsyntax/ext/auto_serialize.rs
@@ -566,7 +566,7 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident,
                     tp_inputs);
 
     let tps_map = map::HashMap();
-    do vec::iter2(tps, tp_inputs) |tp, arg| {
+    for vec::each2(tps, tp_inputs) |tp, arg| {
         let arg_ident = arg.ident;
         tps_map.insert(
             tp.ident,
@@ -773,7 +773,7 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
                     tp_inputs);
 
     let tps_map = map::HashMap();
-    do vec::iter2(tps, tp_inputs) |tp, arg| {
+    for vec::each2(tps, tp_inputs) |tp, arg| {
         let arg_ident = arg.ident;
         tps_map.insert(
             tp.ident,
diff --git a/src/rustc/middle/borrowck/check_loans.rs b/src/rustc/middle/borrowck/check_loans.rs
index b2469718140..0c79c0fcd7f 100644
--- a/src/rustc/middle/borrowck/check_loans.rs
+++ b/src/rustc/middle/borrowck/check_loans.rs
@@ -524,7 +524,7 @@ impl check_loan_ctxt {
         let arg_tys =
             ty::ty_fn_args(
                 ty::node_id_to_type(self.tcx(), callee_id));
-        do vec::iter2(args, arg_tys) |arg, arg_ty| {
+        for vec::each2(args, arg_tys) |arg, arg_ty| {
             match ty::resolved_mode(self.tcx(), arg_ty.mode) {
                 ast::by_move => {
                     self.check_move_out(*arg);
diff --git a/src/rustc/middle/borrowck/gather_loans.rs b/src/rustc/middle/borrowck/gather_loans.rs
index 85eae29529f..327db51518b 100644
--- a/src/rustc/middle/borrowck/gather_loans.rs
+++ b/src/rustc/middle/borrowck/gather_loans.rs
@@ -113,7 +113,7 @@ fn req_loans_in_expr(ex: @ast::expr,
       ast::expr_call(f, args, _) => {
         let arg_tys = ty::ty_fn_args(ty::expr_ty(self.tcx(), f));
         let scope_r = ty::re_scope(ex.id);
-        do vec::iter2(args, arg_tys) |arg, arg_ty| {
+        for vec::each2(args, arg_tys) |arg, arg_ty| {
             match ty::resolved_mode(self.tcx(), arg_ty.mode) {
               ast::by_mutbl_ref => {
                 let arg_cmt = self.bccx.cat_expr(*arg);
diff --git a/src/rustc/middle/kind.rs b/src/rustc/middle/kind.rs
index b1323d7fc93..9aff382775c 100644
--- a/src/rustc/middle/kind.rs
+++ b/src/rustc/middle/kind.rs
@@ -272,7 +272,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
                       tys_to_str(cx.tcx, *ts), ts.len(),
                       *bounds, (*bounds).len());
         }
-        do vec::iter2(*ts, *bounds) |ty, bound| {
+        for vec::each2(*ts, *bounds) |ty, bound| {
             check_bounds(cx, id_to_use, e.span, *ty, *bound)
         }
     }
@@ -376,7 +376,7 @@ fn check_ty(aty: @ty, cx: ctx, v: visit::vt<ctx>) {
         do option::iter(&cx.tcx.node_type_substs.find(id)) |ts| {
             let did = ast_util::def_id_of_def(cx.tcx.def_map.get(id));
             let bounds = ty::lookup_item_type(cx.tcx, did).bounds;
-            do vec::iter2(*ts, *bounds) |ty, bound| {
+            for vec::each2(*ts, *bounds) |ty, bound| {
                 check_bounds(cx, aty.id, aty.span, *ty, *bound)
             }
         }
diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs
index b92f8e8441f..964e2359527 100644
--- a/src/rustc/middle/lint.rs
+++ b/src/rustc/middle/lint.rs
@@ -675,7 +675,7 @@ fn check_fn_deprecated_modes(tcx: ty::ctxt, fn_ty: ty::t, decl: ast::fn_decl,
     match ty::get(fn_ty).sty {
         ty::ty_fn(fn_ty) => {
             let mut counter = 0;
-            do vec::iter2(fn_ty.sig.inputs, decl.inputs) |arg_ty, arg_ast| {
+            for vec::each2(fn_ty.sig.inputs, decl.inputs) |arg_ty, arg_ast| {
                 counter += 1;
                 debug!("arg %d, ty=%s, mode=%s",
                        counter,
diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs
index 689f69f1ad0..90c1b6ba54e 100644
--- a/src/rustc/middle/liveness.rs
+++ b/src/rustc/middle/liveness.rs
@@ -1571,7 +1571,7 @@ fn check_expr(expr: @expr, &&self: @Liveness, vt: vt<@Liveness>) {
 
       expr_call(f, args, _) => {
         let targs = ty::ty_fn_args(ty::expr_ty(self.tcx, f));
-        do vec::iter2(args, targs) |arg_expr, arg_ty| {
+        for vec::each2(args, targs) |arg_expr, arg_ty| {
             match ty::resolved_mode(self.tcx, arg_ty.mode) {
                 by_val | by_copy | by_ref | by_mutbl_ref => {}
                 by_move => {
diff --git a/src/rustc/middle/trans/inline.rs b/src/rustc/middle/trans/inline.rs
index 08e9cde6ac5..76888471bf9 100644
--- a/src/rustc/middle/trans/inline.rs
+++ b/src/rustc/middle/trans/inline.rs
@@ -49,7 +49,7 @@ fn maybe_instantiate_inline(ccx: @crate_ctxt, fn_id: ast::def_id)
               ast::item_enum(_, _) => {
                 let vs_here = ty::enum_variants(ccx.tcx, local_def(item.id));
                 let vs_there = ty::enum_variants(ccx.tcx, parent_id);
-                do vec::iter2(*vs_here, *vs_there) |here, there| {
+                for vec::each2(*vs_here, *vs_there) |here, there| {
                     if there.id == fn_id { my_id = here.id.node; }
                     ccx.external.insert(there.id, Some(here.id.node));
                 }
diff --git a/src/rustc/middle/trans/type_use.rs b/src/rustc/middle/trans/type_use.rs
index f0d67b92339..6bd3c22f626 100644
--- a/src/rustc/middle/trans/type_use.rs
+++ b/src/rustc/middle/trans/type_use.rs
@@ -204,10 +204,10 @@ fn mark_for_expr(cx: ctx, e: @expr) {
       expr_path(_) => {
         do cx.ccx.tcx.node_type_substs.find(e.id).iter |ts| {
             let id = ast_util::def_id_of_def(cx.ccx.tcx.def_map.get(e.id));
-            vec::iter2(type_uses_for(cx.ccx, id, ts.len()), *ts,
-                       |uses, subst| {
-                           type_needs(cx, *uses, *subst)
-                       })
+            let uses_for_ts = type_uses_for(cx.ccx, id, ts.len());
+            for vec::each2(uses_for_ts, *ts) |uses, subst| {
+                type_needs(cx, *uses, *subst)
+            }
         }
       }
       expr_fn(*) | expr_fn_block(*) => {
@@ -238,8 +238,10 @@ fn mark_for_expr(cx: ctx, e: @expr) {
             match mth.origin {
               typeck::method_static(did) => {
                 do cx.ccx.tcx.node_type_substs.find(e.id).iter |ts| {
-                    do vec::iter2(type_uses_for(cx.ccx, did, ts.len()), *ts)
-                        |uses, subst| { type_needs(cx, *uses, *subst)}
+                    let type_uses = type_uses_for(cx.ccx, did, ts.len());
+                    for vec::each2(type_uses, *ts) |uses, subst| {
+                        type_needs(cx, *uses, *subst)
+                    }
                 }
               }
               typeck::method_param({param_num: param, _}) => {
diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs
index a1cfb91ebdc..41acc2ce070 100644
--- a/src/rustc/middle/typeck/check.rs
+++ b/src/rustc/middle/typeck/check.rs
@@ -308,7 +308,7 @@ fn check_fn(ccx: @crate_ctxt,
     for self_info.each |info| {
         fcx.write_ty(info.self_id, info.self_ty);
     }
-    do vec::iter2(decl.inputs, arg_tys) |input, arg| {
+    for vec::each2(decl.inputs, arg_tys) |input, arg| {
         fcx.write_ty(input.id, *arg);
     }
 
@@ -351,7 +351,7 @@ fn check_fn(ccx: @crate_ctxt,
         }
 
         // Add formal parameters.
-        do vec::iter2(arg_tys, decl.inputs) |arg_ty, input| {
+        for vec::each2(arg_tys, decl.inputs) |arg_ty, input| {
             assign(input.ty.span, input.id, Some(*arg_ty));
             debug!("Argument %s is assigned to %s",
                    tcx.sess.str_of(input.ident),
diff --git a/src/rustc/middle/typeck/check/alt.rs b/src/rustc/middle/typeck/check/alt.rs
index ace045ec4a7..0b2e9c8ab3d 100644
--- a/src/rustc/middle/typeck/check/alt.rs
+++ b/src/rustc/middle/typeck/check/alt.rs
@@ -164,7 +164,7 @@ fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path,
             }
 
             do subpats.iter() |pats| {
-                do vec::iter2(*pats, arg_types) |subpat, arg_ty| {
+                for vec::each2(*pats, arg_types) |subpat, arg_ty| {
                   check_pat(pcx, *subpat, *arg_ty);
                 }
             };
diff --git a/src/rustc/middle/typeck/check/vtable.rs b/src/rustc/middle/typeck/check/vtable.rs
index 06f466f74d5..2d1455d04ce 100644
--- a/src/rustc/middle/typeck/check/vtable.rs
+++ b/src/rustc/middle/typeck/check/vtable.rs
@@ -392,8 +392,9 @@ fn connect_trait_tps(fcx: @fn_ctxt, expr: @ast::expr, impl_tys: ~[ty::t],
            ty::get(trait_ty).sty, impl_did);
     match ty::get(trait_ty).sty {
      ty::ty_trait(_, substs, _) => {
-        vec::iter2(substs.tps, trait_tys,
-                   |a, b| demand::suptype(fcx, expr.span, *a, *b));
+         for vec::each2(substs.tps, trait_tys) |a, b| {
+             demand::suptype(fcx, expr.span, *a, *b)
+         }
       }
      _ => tcx.sess.impossible_case(expr.span, "connect_trait_tps: \
             don't know how to handle a non-trait ty")
-- 
cgit 1.4.1-3-g733a5


From 9a8d4adb7decf774bbb87c7a8415c1a95fe1825b Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Fri, 28 Sep 2012 17:30:40 -0700
Subject: Long lines

---
 src/libcore/task/spawn.rs | 4 +++-
 src/rustc/back/link.rs    | 4 +++-
 2 files changed, 6 insertions(+), 2 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs
index 33e711ce9ac..7ae4c7b0950 100644
--- a/src/libcore/task/spawn.rs
+++ b/src/libcore/task/spawn.rs
@@ -451,7 +451,9 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
             // it should be enabled only in debug builds.
             let new_generation =
                 match *old_ancestors {
-                    Some(ref arc) => access_ancestors(arc, |a| a.generation+1),
+                    Some(ref arc) => {
+                        access_ancestors(arc, |a| a.generation+1)
+                    }
                     None      => 0 // the actual value doesn't really matter.
                 };
             assert new_generation < uint::max_value;
diff --git a/src/rustc/back/link.rs b/src/rustc/back/link.rs
index 592e4ecea35..2e310785306 100644
--- a/src/rustc/back/link.rs
+++ b/src/rustc/back/link.rs
@@ -225,7 +225,9 @@ mod write {
 
                 jit::exec(sess, pm.llpm, llmod, CodeGenOptLevel, true);
 
-                if sess.time_llvm_passes() { llvm::LLVMRustPrintPassTimings(); }
+                if sess.time_llvm_passes() {
+                    llvm::LLVMRustPrintPassTimings();
+                }
                 return;
             }
 
-- 
cgit 1.4.1-3-g733a5


From fec96b2ae0f387488f718390eee4c67a043d9a9b Mon Sep 17 00:00:00 2001
From: Tim Chevalier <chevalier@alum.wellesley.edu>
Date: Fri, 28 Sep 2012 17:04:39 -0700
Subject: Demoding in iter: any, all, map_to_vec, flat_map_to_vec,
 filter_to_vec

---
 src/libcore/iter-trait.rs               | 20 ++++++++++----------
 src/libcore/iter.rs                     | 26 +++++++++++++-------------
 src/libcore/vec.rs                      | 12 ++++++------
 src/libsyntax/ext/pipes/proto.rs        |  4 ++--
 src/rustc/metadata/creader.rs           |  4 ++--
 src/rustc/middle/check_alt.rs           |  6 +++---
 src/rustc/middle/lint.rs                |  2 +-
 src/rustc/middle/trans/alt.rs           |  2 +-
 src/rustc/middle/typeck/check/vtable.rs |  2 +-
 src/test/bench/graph500-bfs.rs          |  2 +-
 src/test/run-pass/issue-2611.rs         |  6 +++---
 src/test/run-pass/iter-all.rs           |  2 +-
 src/test/run-pass/iter-any.rs           |  6 +++---
 src/test/run-pass/iter-filter-to-vec.rs | 10 +++++-----
 src/test/run-pass/iter-map-to-vec.rs    | 10 +++++-----
 15 files changed, 57 insertions(+), 57 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libcore/iter-trait.rs b/src/libcore/iter-trait.rs
index 4cf2002adaa..98fd0e27e97 100644
--- a/src/libcore/iter-trait.rs
+++ b/src/libcore/iter-trait.rs
@@ -14,8 +14,8 @@ impl<A> IMPL_T<A>: iter::BaseIter<A> {
 
 impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
     pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(&self, blk) }
-    pure fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) }
-    pure fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) }
+    pure fn all(blk: fn(&A) -> bool) -> bool { iter::all(&self, blk) }
+    pure fn any(blk: fn(&A) -> bool) -> bool { iter::any(&self, blk) }
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
         iter::foldl(self, move b0, blk)
     }
@@ -30,18 +30,18 @@ impl<A: Eq> IMPL_T<A>: iter::EqIter<A> {
 }
 
 impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {
-    pure fn filter_to_vec(pred: fn(A) -> bool) -> ~[A] {
-        iter::filter_to_vec(self, pred)
+    pure fn filter_to_vec(pred: fn(+a: A) -> bool) -> ~[A] {
+        iter::filter_to_vec(&self, pred)
     }
-    pure fn map_to_vec<B>(op: fn(v: &A) -> B) -> ~[B] {
-        iter::map_to_vec(self, op)
+    pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B] {
+        iter::map_to_vec(&self, op)
     }
     pure fn to_vec() -> ~[A] { iter::to_vec(self) }
 
-    // FIXME--bug in resolve prevents this from working (#2611)
-    // fn flat_map_to_vec<B:copy,IB:base_iter<B>>(op: fn(A) -> IB) -> ~[B] {
-    //     iter::flat_map_to_vec(self, op)
-    // }
+    pure fn flat_map_to_vec<B:Copy,IB:BaseIter<B>>(op: fn(+a: A) -> IB)
+        -> ~[B] {
+        iter::flat_map_to_vec(&self, op)
+    }
 
     pure fn find(p: fn(A) -> bool) -> Option<A> { iter::find(self, p) }
 }
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index b03a0415145..2db68107fc3 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -16,8 +16,8 @@ trait BaseIter<A> {
 
 trait ExtendedIter<A> {
     pure fn eachi(blk: fn(uint, v: &A) -> bool);
-    pure fn all(blk: fn(A) -> bool) -> bool;
-    pure fn any(blk: fn(A) -> bool) -> bool;
+    pure fn all(blk: fn(&A) -> bool) -> bool;
+    pure fn any(blk: fn(&A) -> bool) -> bool;
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B;
     pure fn position(f: fn(A) -> bool) -> Option<uint>;
 }
@@ -35,8 +35,8 @@ trait TimesIx{
 }
 
 trait CopyableIter<A:Copy> {
-    pure fn filter_to_vec(pred: fn(A) -> bool) -> ~[A];
-    pure fn map_to_vec<B>(op: fn(v: &A) -> B) -> ~[B];
+    pure fn filter_to_vec(pred: fn(+a: A) -> bool) -> ~[A];
+    pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B];
     pure fn to_vec() -> ~[A];
     pure fn find(p: fn(A) -> bool) -> Option<A>;
 }
@@ -74,22 +74,22 @@ pure fn eachi<A,IA:BaseIter<A>>(self: &IA, blk: fn(uint, v: &A) -> bool) {
     }
 }
 
-pure fn all<A,IA:BaseIter<A>>(self: IA, blk: fn(A) -> bool) -> bool {
+pure fn all<A,IA:BaseIter<A>>(self: &IA, blk: fn(&A) -> bool) -> bool {
     for self.each |a| {
-        if !blk(*a) { return false; }
+        if !blk(a) { return false; }
     }
     return true;
 }
 
-pure fn any<A,IA:BaseIter<A>>(self: IA, blk: fn(A) -> bool) -> bool {
+pure fn any<A,IA:BaseIter<A>>(self: &IA, blk: fn(&A) -> bool) -> bool {
     for self.each |a| {
-        if blk(*a) { return true; }
+        if blk(a) { return true; }
     }
     return false;
 }
 
-pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(self: IA,
-                                         prd: fn(A) -> bool) -> ~[A] {
+pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(self: &IA,
+                                         prd: fn(+a: A) -> bool) -> ~[A] {
     do vec::build_sized_opt(self.size_hint()) |push| {
         for self.each |a| {
             if prd(*a) { push(*a); }
@@ -97,17 +97,17 @@ pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(self: IA,
     }
 }
 
-pure fn map_to_vec<A:Copy,B,IA:BaseIter<A>>(self: IA, op: fn(v: &A) -> B)
+pure fn map_to_vec<A:Copy,B,IA:BaseIter<A>>(self: &IA, op: fn(+v: A) -> B)
     -> ~[B] {
     do vec::build_sized_opt(self.size_hint()) |push| {
         for self.each |a| {
-            push(op(a));
+            push(op(*a));
         }
     }
 }
 
 pure fn flat_map_to_vec<A:Copy,B:Copy,IA:BaseIter<A>,IB:BaseIter<B>>(
-    self: IA, op: fn(A) -> IB) -> ~[B] {
+    self: &IA, op: fn(+a: A) -> IB) -> ~[B] {
 
     do vec::build |push| {
         for self.each |a| {
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index aba511f0a7f..7c1c2f2d805 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -1991,8 +1991,8 @@ impl<A> &[A]: iter::BaseIter<A> {
 
 impl<A> &[A]: iter::ExtendedIter<A> {
     pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(&self, blk) }
-    pure fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) }
-    pure fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) }
+    pure fn all(blk: fn(&A) -> bool) -> bool { iter::all(&self, blk) }
+    pure fn any(blk: fn(&A) -> bool) -> bool { iter::any(&self, blk) }
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
         iter::foldl(self, move b0, blk)
     }
@@ -2007,11 +2007,11 @@ impl<A: Eq> &[A]: iter::EqIter<A> {
 }
 
 impl<A: Copy> &[A]: iter::CopyableIter<A> {
-    pure fn filter_to_vec(pred: fn(A) -> bool) -> ~[A] {
-        iter::filter_to_vec(self, pred)
+    pure fn filter_to_vec(pred: fn(+a: A) -> bool) -> ~[A] {
+        iter::filter_to_vec(&self, pred)
     }
-    pure fn map_to_vec<B>(op: fn(v: &A) -> B) -> ~[B] {
-        iter::map_to_vec(self, op)
+    pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B] {
+        iter::map_to_vec(&self, op)
     }
     pure fn to_vec() -> ~[A] { iter::to_vec(self) }
 
diff --git a/src/libsyntax/ext/pipes/proto.rs b/src/libsyntax/ext/pipes/proto.rs
index 70b38e83ad5..6d58d209fcf 100644
--- a/src/libsyntax/ext/pipes/proto.rs
+++ b/src/libsyntax/ext/pipes/proto.rs
@@ -210,10 +210,10 @@ fn visit<Tproto, Tstate, Tmessage, V: visitor<Tproto, Tstate, Tmessage>>(
     // the copy keywords prevent recursive use of dvec
     let states = do (copy proto.states).map_to_vec |s| {
         let messages = do (copy s.messages).map_to_vec |m| {
-            let message(name, span, tys, this, next) = *m;
+            let message(name, span, tys, this, next) = m;
             visitor.visit_message(name, span, tys, this, next)
         };
-        visitor.visit_state(*s, messages)
+        visitor.visit_state(s, messages)
     };
     visitor.visit_proto(proto, states)
 }
diff --git a/src/rustc/metadata/creader.rs b/src/rustc/metadata/creader.rs
index 0d19fe796e1..3ed56a1953e 100644
--- a/src/rustc/metadata/creader.rs
+++ b/src/rustc/metadata/creader.rs
@@ -63,9 +63,9 @@ fn warn_if_multiple_versions(e: env, diag: span_handler,
             partition(crate_cache.map_to_vec(|entry| {
                 let othername = loader::crate_name_from_metas(*entry.metas);
                 if name == othername {
-                    Left(*entry)
+                    Left(entry)
                 } else {
-                    Right(*entry)
+                    Right(entry)
                 }
             }));
 
diff --git a/src/rustc/middle/check_alt.rs b/src/rustc/middle/check_alt.rs
index efbeb490db9..f71b82a2be7 100644
--- a/src/rustc/middle/check_alt.rs
+++ b/src/rustc/middle/check_alt.rs
@@ -432,7 +432,7 @@ fn check_local(tcx: ty::ctxt, loc: @local, &&s: (), v: visit::vt<()>) {
     }
 }
 
-fn is_refutable(tcx: ty::ctxt, pat: @pat) -> bool {
+fn is_refutable(tcx: ty::ctxt, pat: &pat) -> bool {
     match tcx.def_map.find(pat.id) {
       Some(def_variant(enum_id, _)) => {
         if vec::len(*ty::enum_variants(tcx, enum_id)) != 1u {
@@ -457,10 +457,10 @@ fn is_refutable(tcx: ty::ctxt, pat: @pat) -> bool {
         fields.any(|f| is_refutable(tcx, f.pat))
       }
       pat_tup(elts) => {
-        elts.any(|elt| is_refutable(tcx, elt))
+        elts.any(|elt| is_refutable(tcx, *elt))
       }
       pat_enum(_, Some(args)) => {
-        args.any(|a| is_refutable(tcx, a))
+        args.any(|a| is_refutable(tcx, *a))
       }
       pat_enum(_,_) => { false }
     }
diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs
index 964e2359527..266ee056e2c 100644
--- a/src/rustc/middle/lint.rs
+++ b/src/rustc/middle/lint.rs
@@ -149,7 +149,7 @@ fn get_lint_dict() -> lint_dict {
         (~"deprecated_mode",
          @{lint: deprecated_mode,
            desc: ~"warn about deprecated uses of modes",
-           default: allow}),
+           default: warn}),
 
         (~"deprecated_pattern",
          @{lint: deprecated_pattern,
diff --git a/src/rustc/middle/trans/alt.rs b/src/rustc/middle/trans/alt.rs
index 6450e48486c..73f1e9bd119 100644
--- a/src/rustc/middle/trans/alt.rs
+++ b/src/rustc/middle/trans/alt.rs
@@ -514,7 +514,7 @@ fn enter_region(bcx: block, dm: DefMap, m: &[@Match/&r],
 
 fn get_options(ccx: @crate_ctxt, m: &[@Match], col: uint) -> ~[Opt] {
     fn add_to_set(tcx: ty::ctxt, set: &DVec<Opt>, val: Opt) {
-        if set.any(|l| opt_eq(tcx, &l, &val)) {return;}
+        if set.any(|l| opt_eq(tcx, l, &val)) {return;}
         set.push(val);
     }
 
diff --git a/src/rustc/middle/typeck/check/vtable.rs b/src/rustc/middle/typeck/check/vtable.rs
index 2d1455d04ce..0c9440f3ec2 100644
--- a/src/rustc/middle/typeck/check/vtable.rs
+++ b/src/rustc/middle/typeck/check/vtable.rs
@@ -24,7 +24,7 @@ use util::common::indenter;
 fn has_trait_bounds(tps: ~[ty::param_bounds]) -> bool {
     vec::any(tps, |bs| {
         bs.any(|b| {
-            match b { ty::bound_trait(_) => true, _ => false }
+            match b { &ty::bound_trait(_) => true, _ => false }
         })
     })
 }
diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs
index 10b38f2572c..27e5c696e59 100644
--- a/src/test/bench/graph500-bfs.rs
+++ b/src/test/bench/graph500-bfs.rs
@@ -352,7 +352,7 @@ fn validate(edges: ~[(node_id, node_id)],
     log(info, ~"Verifying graph edges...");
 
     let status = do edges.all() |e| {
-        let (u, v) = e;
+        let (u, v) = *e;
 
         abs(level[u] - level[v]) <= 1
     };
diff --git a/src/test/run-pass/issue-2611.rs b/src/test/run-pass/issue-2611.rs
index cc2e89c76ea..8fb5a0d6e04 100644
--- a/src/test/run-pass/issue-2611.rs
+++ b/src/test/run-pass/issue-2611.rs
@@ -4,12 +4,12 @@
 use iter::BaseIter;
 
 trait FlatMapToVec<A> {
-  fn flat_map_to_vec<B:Copy, IB:BaseIter<B>>(op: fn(A) -> IB) -> ~[B];
+  fn flat_map_to_vec<B:Copy, IB:BaseIter<B>>(op: fn(+a: A) -> IB) -> ~[B];
 }
 
 impl<A:Copy> BaseIter<A>: FlatMapToVec<A> {
-   fn flat_map_to_vec<B:Copy, IB:BaseIter<B>>(op: fn(A) -> IB) -> ~[B] {
-     iter::flat_map_to_vec(self, op)
+   fn flat_map_to_vec<B:Copy, IB:BaseIter<B>>(op: fn(+a: A) -> IB) -> ~[B] {
+     iter::flat_map_to_vec(&self, op)
    }
 }
 
diff --git a/src/test/run-pass/iter-all.rs b/src/test/run-pass/iter-all.rs
index eb5dbd6aa5c..75334db86cc 100644
--- a/src/test/run-pass/iter-all.rs
+++ b/src/test/run-pass/iter-all.rs
@@ -1,4 +1,4 @@
-fn is_even(&&x: uint) -> bool { (x % 2u) == 0u }
+fn is_even(x: &uint) -> bool { (*x % 2) == 0 }
 
 fn main() {
     assert ![1u, 2u]/_.all(is_even);
diff --git a/src/test/run-pass/iter-any.rs b/src/test/run-pass/iter-any.rs
index d672df09c24..22057b74a41 100644
--- a/src/test/run-pass/iter-any.rs
+++ b/src/test/run-pass/iter-any.rs
@@ -1,11 +1,11 @@
-fn is_even(&&x: uint) -> bool { (x % 2u) == 0u }
+fn is_even(x: &uint) -> bool { (*x % 2) == 0 }
 
 fn main() {
     assert ![1u, 3u]/_.any(is_even);
     assert [1u, 2u]/_.any(is_even);
     assert ![]/_.any(is_even);
 
-    assert !Some(1u).any(is_even);
-    assert Some(2u).any(is_even);
+    assert !Some(1).any(is_even);
+    assert Some(2).any(is_even);
     assert !None.any(is_even);
 }
diff --git a/src/test/run-pass/iter-filter-to-vec.rs b/src/test/run-pass/iter-filter-to-vec.rs
index 8cb9e0e9d53..f96b18f140a 100644
--- a/src/test/run-pass/iter-filter-to-vec.rs
+++ b/src/test/run-pass/iter-filter-to-vec.rs
@@ -1,9 +1,9 @@
-fn is_even(&&x: uint) -> bool { (x % 2u) == 0u }
+fn is_even(+x: uint) -> bool { (x % 2) == 0 }
 
 fn main() {
-    assert [1u, 3u]/_.filter_to_vec(is_even) == ~[];
-    assert [1u, 2u, 3u]/_.filter_to_vec(is_even) == ~[2u];
+    assert [1, 3]/_.filter_to_vec(is_even) == ~[];
+    assert [1, 2, 3]/_.filter_to_vec(is_even) == ~[2];
     assert None.filter_to_vec(is_even) == ~[];
-    assert Some(1u).filter_to_vec(is_even) == ~[];
-    assert Some(2u).filter_to_vec(is_even) == ~[2u];
+    assert Some(1).filter_to_vec(is_even) == ~[];
+    assert Some(2).filter_to_vec(is_even) == ~[2];
 }
diff --git a/src/test/run-pass/iter-map-to-vec.rs b/src/test/run-pass/iter-map-to-vec.rs
index 11f2cc1efb1..2f5359f197f 100644
--- a/src/test/run-pass/iter-map-to-vec.rs
+++ b/src/test/run-pass/iter-map-to-vec.rs
@@ -1,9 +1,9 @@
-fn inc(x: &uint) -> uint { *x + 1u }
+fn inc(+x: uint) -> uint { x + 1 }
 
 fn main() {
-    assert [1u, 3u]/_.map_to_vec(inc) == ~[2u, 4u];
-    assert [1u, 2u, 3u]/_.map_to_vec(inc) == ~[2u, 3u, 4u];
+    assert [1, 3]/_.map_to_vec(inc) == ~[2, 4];
+    assert [1, 2, 3]/_.map_to_vec(inc) == ~[2, 3, 4];
     assert None.map_to_vec(inc) == ~[];
-    assert Some(1u).map_to_vec(inc) == ~[2u];
-    assert Some(2u).map_to_vec(inc) == ~[3u];
+    assert Some(1).map_to_vec(inc) == ~[2];
+    assert Some(2).map_to_vec(inc) == ~[3];
 }
-- 
cgit 1.4.1-3-g733a5


From a3a257cc3b29cb134b05a72adbfeff08f1e7a98c Mon Sep 17 00:00:00 2001
From: Tim Chevalier <chevalier@alum.wellesley.edu>
Date: Fri, 28 Sep 2012 16:37:14 -0700
Subject: Demode iter::foldl and friends

---
 src/libcore/dlist.rs                         |  2 +-
 src/libcore/iter-trait.rs                    | 12 ++++----
 src/libcore/iter.rs                          | 41 ++++++++++++----------------
 src/libcore/vec.rs                           | 12 ++++----
 src/rustc/middle/liveness.rs                 |  2 +-
 src/rustc/middle/trans/meth.rs               |  4 +--
 src/rustc/middle/ty.rs                       | 10 +++----
 src/rustc/middle/typeck/check/regionmanip.rs |  4 +--
 src/test/run-pass/iter-foldl.rs              |  2 +-
 9 files changed, 42 insertions(+), 47 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libcore/dlist.rs b/src/libcore/dlist.rs
index 0bdf5caec0c..4e08dd4c2f3 100644
--- a/src/libcore/dlist.rs
+++ b/src/libcore/dlist.rs
@@ -675,7 +675,7 @@ mod tests {
     #[test]
     fn test_dlist_foldl() {
         let l = from_vec(vec::from_fn(101, |x|x));
-        assert iter::foldl(l, 0, |accum,elem| accum+elem) == 5050;
+        assert iter::foldl(&l, 0, |accum,elem| *accum+*elem) == 5050;
     }
     #[test]
     fn test_dlist_break_early() {
diff --git a/src/libcore/iter-trait.rs b/src/libcore/iter-trait.rs
index 98fd0e27e97..a6acd1c040e 100644
--- a/src/libcore/iter-trait.rs
+++ b/src/libcore/iter-trait.rs
@@ -16,8 +16,8 @@ impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
     pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(&self, blk) }
     pure fn all(blk: fn(&A) -> bool) -> bool { iter::all(&self, blk) }
     pure fn any(blk: fn(&A) -> bool) -> bool { iter::any(&self, blk) }
-    pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
-        iter::foldl(self, move b0, blk)
+    pure fn foldl<B>(+b0: B, blk: fn(&B, &A) -> B) -> B {
+        iter::foldl(&self, move b0, blk)
     }
     pure fn position(f: fn(A) -> bool) -> Option<uint> {
         iter::position(self, f)
@@ -26,7 +26,7 @@ impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
 
 impl<A: Eq> IMPL_T<A>: iter::EqIter<A> {
     pure fn contains(x: &A) -> bool { iter::contains(self, x) }
-    pure fn count(x: &A) -> uint { iter::count(self, x) }
+    pure fn count(x: &A) -> uint { iter::count(&self, x) }
 }
 
 impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {
@@ -36,7 +36,7 @@ impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {
     pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B] {
         iter::map_to_vec(&self, op)
     }
-    pure fn to_vec() -> ~[A] { iter::to_vec(self) }
+    pure fn to_vec() -> ~[A] { iter::to_vec(&self) }
 
     pure fn flat_map_to_vec<B:Copy,IB:BaseIter<B>>(op: fn(+a: A) -> IB)
         -> ~[B] {
@@ -47,7 +47,7 @@ impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {
 }
 
 impl<A: Copy Ord> IMPL_T<A>: iter::CopyableOrderedIter<A> {
-    pure fn min() -> A { iter::min(self) }
-    pure fn max() -> A { iter::max(self) }
+    pure fn min() -> A { iter::min(&self) }
+    pure fn max() -> A { iter::max(&self) }
 }
 
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 2db68107fc3..77f9abe8e0b 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -18,7 +18,7 @@ trait ExtendedIter<A> {
     pure fn eachi(blk: fn(uint, v: &A) -> bool);
     pure fn all(blk: fn(&A) -> bool) -> bool;
     pure fn any(blk: fn(&A) -> bool) -> bool;
-    pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B;
+    pure fn foldl<B>(+b0: B, blk: fn(&B, &A) -> B) -> B;
     pure fn position(f: fn(A) -> bool) -> Option<uint>;
 }
 
@@ -118,16 +118,17 @@ pure fn flat_map_to_vec<A:Copy,B:Copy,IA:BaseIter<A>,IB:BaseIter<B>>(
     }
 }
 
-pure fn foldl<A,B,IA:BaseIter<A>>(self: IA, +b0: B, blk: fn(B, A) -> B) -> B {
+pure fn foldl<A,B,IA:BaseIter<A>>(self: &IA, +b0: B, blk: fn(&B, &A) -> B)
+    -> B {
     let mut b <- b0;
     for self.each |a| {
-        b = blk(b, *a);
+        b = blk(&b, a);
     }
     move b
 }
 
-pure fn to_vec<A:Copy,IA:BaseIter<A>>(self: IA) -> ~[A] {
-    foldl::<A,~[A],IA>(self, ~[], |r, a| vec::append(copy r, ~[a]))
+pure fn to_vec<A:Copy,IA:BaseIter<A>>(self: &IA) -> ~[A] {
+    foldl::<A,~[A],IA>(self, ~[], |r, a| vec::append(*r, ~[*a]))
 }
 
 pure fn contains<A:Eq,IA:BaseIter<A>>(self: IA, x: &A) -> bool {
@@ -137,12 +138,12 @@ pure fn contains<A:Eq,IA:BaseIter<A>>(self: IA, x: &A) -> bool {
     return false;
 }
 
-pure fn count<A:Eq,IA:BaseIter<A>>(self: IA, x: &A) -> uint {
+pure fn count<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> uint {
     do foldl(self, 0) |count, value| {
-        if value == *x {
-            count + 1
+        if *value == *x {
+            *count + 1
         } else {
-            count
+            *count
         }
     }
 }
@@ -170,16 +171,13 @@ pure fn repeat(times: uint, blk: fn() -> bool) {
     }
 }
 
-// XXX bad copies
-pure fn min<A:Copy Ord,IA:BaseIter<A>>(self: IA) -> A {
+pure fn min<A:Copy Ord,IA:BaseIter<A>>(self: &IA) -> A {
     match do foldl::<A,Option<A>,IA>(self, None) |a, b| {
         match a {
-          Some(copy a_) if a_ < b => {
-            // FIXME (#2005): Not sure if this is successfully optimized to
-            // a move
-            a
+          &Some(a_) if a_ < *b => {
+             *(move a)
           }
-          _ => Some(b)
+          _ => Some(*b)
         }
     } {
         Some(move val) => val,
@@ -187,16 +185,13 @@ pure fn min<A:Copy Ord,IA:BaseIter<A>>(self: IA) -> A {
     }
 }
 
-// XXX bad copies
-pure fn max<A:Copy Ord,IA:BaseIter<A>>(self: IA) -> A {
+pure fn max<A:Copy Ord,IA:BaseIter<A>>(self: &IA) -> A {
     match do foldl::<A,Option<A>,IA>(self, None) |a, b| {
         match a {
-          Some(copy a_) if a_ > b => {
-            // FIXME (#2005): Not sure if this is successfully optimized to
-            // a move.
-            a
+          &Some(a_) if a_ > *b => {
+              *(move a)
           }
-          _ => Some(b)
+          _ => Some(*b)
         }
     } {
         Some(move val) => val,
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index 2044bbe42c9..66b1c0d95ec 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -1993,8 +1993,8 @@ impl<A> &[A]: iter::ExtendedIter<A> {
     pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(&self, blk) }
     pure fn all(blk: fn(&A) -> bool) -> bool { iter::all(&self, blk) }
     pure fn any(blk: fn(&A) -> bool) -> bool { iter::any(&self, blk) }
-    pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
-        iter::foldl(self, move b0, blk)
+    pure fn foldl<B>(+b0: B, blk: fn(&B, &A) -> B) -> B {
+        iter::foldl(&self, move b0, blk)
     }
     pure fn position(f: fn(A) -> bool) -> Option<uint> {
         iter::position(self, f)
@@ -2003,7 +2003,7 @@ impl<A> &[A]: iter::ExtendedIter<A> {
 
 impl<A: Eq> &[A]: iter::EqIter<A> {
     pure fn contains(x: &A) -> bool { iter::contains(self, x) }
-    pure fn count(x: &A) -> uint { iter::count(self, x) }
+    pure fn count(x: &A) -> uint { iter::count(&self, x) }
 }
 
 impl<A: Copy> &[A]: iter::CopyableIter<A> {
@@ -2013,7 +2013,7 @@ impl<A: Copy> &[A]: iter::CopyableIter<A> {
     pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B] {
         iter::map_to_vec(&self, op)
     }
-    pure fn to_vec() -> ~[A] { iter::to_vec(self) }
+    pure fn to_vec() -> ~[A] { iter::to_vec(&self) }
 
     // FIXME--bug in resolve prevents this from working (#2611)
     // fn flat_map_to_vec<B:copy,IB:base_iter<B>>(op: fn(A) -> IB) -> ~[B] {
@@ -2024,8 +2024,8 @@ impl<A: Copy> &[A]: iter::CopyableIter<A> {
 }
 
 impl<A: Copy Ord> &[A]: iter::CopyableOrderedIter<A> {
-    pure fn min() -> A { iter::min(self) }
-    pure fn max() -> A { iter::max(self) }
+    pure fn min() -> A { iter::min(&self) }
+    pure fn max() -> A { iter::max(&self) }
 }
 // ___________________________________________________________________________
 
diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs
index 90c1b6ba54e..90762c5b714 100644
--- a/src/rustc/middle/liveness.rs
+++ b/src/rustc/middle/liveness.rs
@@ -1014,7 +1014,7 @@ impl Liveness {
     fn propagate_through_opt_expr(opt_expr: Option<@expr>,
                                   succ: LiveNode) -> LiveNode {
         do opt_expr.foldl(succ) |succ, expr| {
-            self.propagate_through_expr(expr, succ)
+            self.propagate_through_expr(*expr, *succ)
         }
     }
 
diff --git a/src/rustc/middle/trans/meth.rs b/src/rustc/middle/trans/meth.rs
index 33df35cca52..ebc1645e3d8 100644
--- a/src/rustc/middle/trans/meth.rs
+++ b/src/rustc/middle/trans/meth.rs
@@ -364,8 +364,8 @@ fn combine_impl_and_methods_origins(bcx: block,
 
     // Flatten out to find the number of vtables the method expects.
     let m_vtables = m_boundss.foldl(0, |sum, m_bounds| {
-        m_bounds.foldl(sum, |sum, m_bound| {
-            sum + match m_bound {
+        m_bounds.foldl(*sum, |sum, m_bound| {
+            (*sum) + match (*m_bound) {
                 ty::bound_copy | ty::bound_owned |
                 ty::bound_send | ty::bound_const => 0,
                 ty::bound_trait(_) => 1
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index 397a1cd6aa1..973db90ff66 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -2137,25 +2137,25 @@ fn type_size(cx: ctxt, ty: t) -> uint {
       }
 
       ty_rec(flds) => {
-        flds.foldl(0, |s, f| s + type_size(cx, f.mt.ty))
+        flds.foldl(0, |s, f| *s + type_size(cx, f.mt.ty))
       }
 
       ty_class(did, ref substs) => {
         let flds = class_items_as_fields(cx, did, substs);
-        flds.foldl(0, |s, f| s + type_size(cx, f.mt.ty))
+        flds.foldl(0, |s, f| *s + type_size(cx, f.mt.ty))
       }
 
       ty_tup(tys) => {
-        tys.foldl(0, |s, t| s + type_size(cx, t))
+        tys.foldl(0, |s, t| *s + type_size(cx, *t))
       }
 
       ty_enum(did, ref substs) => {
         let variants = substd_enum_variants(cx, did, substs);
         variants.foldl( // find max size of any variant
             0,
-            |m, v| uint::max(m,
+            |m, v| uint::max(*m,
                              // find size of this variant:
-                             v.args.foldl(0, |s, a| s + type_size(cx, a))))
+                             v.args.foldl(0, |s, a| *s + type_size(cx, *a))))
       }
 
       ty_param(_) | ty_self => {
diff --git a/src/rustc/middle/typeck/check/regionmanip.rs b/src/rustc/middle/typeck/check/regionmanip.rs
index 29d4e9927ff..4afb3ad78a6 100644
--- a/src/rustc/middle/typeck/check/regionmanip.rs
+++ b/src/rustc/middle/typeck/check/regionmanip.rs
@@ -111,14 +111,14 @@ fn replace_bound_regions_in_fn_ty(
 
         // For each type `ty` in `tys`...
         do tys.foldl(isr) |isr, ty| {
-            let mut isr = isr;
+            let mut isr = *isr;
 
             // Using fold_regions is inefficient, because it
             // constructs new types, but it avoids code duplication in
             // terms of locating all the regions within the various
             // kinds of types.  This had already caused me several
             // bugs so I decided to switch over.
-            do ty::fold_regions(tcx, ty) |r, in_fn| {
+            do ty::fold_regions(tcx, *ty) |r, in_fn| {
                 if !in_fn { isr = append_isr(isr, to_r, r); }
                 r
             };
diff --git a/src/test/run-pass/iter-foldl.rs b/src/test/run-pass/iter-foldl.rs
index 41bb6b82ddd..bbc1673f686 100644
--- a/src/test/run-pass/iter-foldl.rs
+++ b/src/test/run-pass/iter-foldl.rs
@@ -1,4 +1,4 @@
-fn add(&&x: float, &&y: uint) -> float { x + (y as float) }
+fn add(x: &float, y: &uint) -> float { *x + ((*y) as float) }
 
 fn main() {
     assert [1u, 3u]/_.foldl(20f, add) == 24f;
-- 
cgit 1.4.1-3-g733a5


From c9fb1b19aab4f2cb1d447b1943159e462f6ffe2d Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Fri, 28 Sep 2012 18:38:59 -0700
Subject: Add allow(deprecated_\*) to syntax, rustc, rustdoc, et al

---
 src/cargo/cargo.rc             | 2 ++
 src/compiletest/compiletest.rc | 2 ++
 src/fuzzer/fuzzer.rc           | 2 ++
 src/libsyntax/syntax.rc        | 2 ++
 src/rustc/rustc.rc             | 3 ++-
 src/rustdoc/rustdoc.rc         | 2 ++
 6 files changed, 12 insertions(+), 1 deletion(-)

(limited to 'src/rustc')

diff --git a/src/cargo/cargo.rc b/src/cargo/cargo.rc
index ae095318873..17ddacfd7eb 100644
--- a/src/cargo/cargo.rc
+++ b/src/cargo/cargo.rc
@@ -24,6 +24,8 @@
 #[allow(vecs_implicitly_copyable,
         non_implicitly_copyable_typarams)];
 #[allow(non_camel_case_types)];
+#[allow(deprecated_mode)];
+#[allow(deprecated_pattern)];
 
 extern mod core(vers = "0.4");
 extern mod std(vers = "0.4");
diff --git a/src/compiletest/compiletest.rc b/src/compiletest/compiletest.rc
index ce11245dba5..991d2d2cb0e 100644
--- a/src/compiletest/compiletest.rc
+++ b/src/compiletest/compiletest.rc
@@ -5,6 +5,8 @@
 
 #[allow(vecs_implicitly_copyable)];
 #[allow(non_camel_case_types)];
+#[allow(deprecated_mode)];
+#[allow(deprecated_pattern)];
 
 extern mod core(vers = "0.4");
 extern mod std(vers = "0.4");
diff --git a/src/fuzzer/fuzzer.rc b/src/fuzzer/fuzzer.rc
index 073335fbc72..640bcccc7a8 100644
--- a/src/fuzzer/fuzzer.rc
+++ b/src/fuzzer/fuzzer.rc
@@ -9,6 +9,8 @@
 
 #[allow(vecs_implicitly_copyable)];
 #[allow(non_camel_case_types)];
+#[allow(deprecated_mode)];
+#[allow(deprecated_pattern)];
 
 extern mod core(vers = "0.4");
 extern mod std(vers = "0.4");
diff --git a/src/libsyntax/syntax.rc b/src/libsyntax/syntax.rc
index a8ae9bd63a1..38abf5f445c 100644
--- a/src/libsyntax/syntax.rc
+++ b/src/libsyntax/syntax.rc
@@ -13,6 +13,8 @@
 
 #[allow(vecs_implicitly_copyable)];
 #[allow(non_camel_case_types)];
+#[allow(deprecated_mode)];
+#[allow(deprecated_pattern)];
 
 extern mod core(vers = "0.4");
 extern mod std(vers = "0.4");
diff --git a/src/rustc/rustc.rc b/src/rustc/rustc.rc
index c021a4e2854..dad27b706e6 100644
--- a/src/rustc/rustc.rc
+++ b/src/rustc/rustc.rc
@@ -16,7 +16,8 @@
 
 #[allow(vecs_implicitly_copyable)];
 #[allow(non_camel_case_types)];
-// #[warn(deprecated_pattern)];
+#[allow(deprecated_mode)];
+#[allow(deprecated_pattern)];
 
 extern mod core(vers = "0.4");
 extern mod std(vers = "0.4");
diff --git a/src/rustdoc/rustdoc.rc b/src/rustdoc/rustdoc.rc
index 1686f56e3f1..f8714b0e9ba 100644
--- a/src/rustdoc/rustdoc.rc
+++ b/src/rustdoc/rustdoc.rc
@@ -15,6 +15,8 @@
 
 #[allow(vecs_implicitly_copyable)];
 #[allow(non_implicitly_copyable_typarams)];
+#[allow(deprecated_mode)];
+#[allow(deprecated_pattern)];
 
 extern mod core(vers = "0.4");
 extern mod std(vers = "0.4");
-- 
cgit 1.4.1-3-g733a5


From 1c76d189c02ddc6cb6fcf15ae94f3a3ae4de5fa7 Mon Sep 17 00:00:00 2001
From: Gareth Daniel Smith <garethdanielsmith@gmail.com>
Date: Sat, 29 Sep 2012 12:34:11 +0100
Subject: When a vec/str bounds check fails, include the bad index and the
 length of the str/vec in the fail message.

---
 src/libcore/rt.rs                                     | 10 ++++++++++
 src/rustc/middle/trans/controlflow.rs                 | 18 ++++++++++++++++++
 src/rustc/middle/trans/expr.rs                        |  4 +++-
 src/test/run-fail/bug-2470-bounds-check-overflow-2.rs |  4 ++--
 src/test/run-fail/bug-2470-bounds-check-overflow-3.rs |  2 +-
 src/test/run-fail/bug-2470-bounds-check-overflow.rs   |  2 +-
 src/test/run-fail/small-negative-indexing.rs          |  2 +-
 src/test/run-fail/str-overrun.rs                      |  2 +-
 src/test/run-fail/vec-overrun.rs                      |  2 +-
 src/test/run-fail/vec-underrun.rs                     |  2 +-
 10 files changed, 39 insertions(+), 9 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libcore/rt.rs b/src/libcore/rt.rs
index 644edb69d56..da598fc3e7f 100644
--- a/src/libcore/rt.rs
+++ b/src/libcore/rt.rs
@@ -40,6 +40,16 @@ fn rt_fail_(expr: *c_char, file: *c_char, line: size_t) {
     rustrt::rust_upcall_fail(expr, file, line);
 }
 
+#[rt(fail_bounds_check)]
+fn rt_fail_bounds_check(file: *c_char, line: size_t,
+                        index: size_t, len: size_t) {
+    let msg = fmt!("index out of bounds: the len is %d but the index is %d",
+                    len as int, index as int);
+    do str::as_buf(msg) |p, _len| {
+        rt_fail_(p as *c_char, file, line);
+    }
+}
+
 #[rt(exchange_malloc)]
 fn rt_exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
     return rustrt::rust_upcall_exchange_malloc(td, size);
diff --git a/src/rustc/middle/trans/controlflow.rs b/src/rustc/middle/trans/controlflow.rs
index 68ebf5fa189..ce32cd0a2dd 100644
--- a/src/rustc/middle/trans/controlflow.rs
+++ b/src/rustc/middle/trans/controlflow.rs
@@ -344,3 +344,21 @@ fn trans_fail_value(bcx: block, sp_opt: Option<span>, V_fail_str: ValueRef)
     Unreachable(bcx);
     return bcx;
 }
+
+fn trans_fail_bounds_check(bcx: block, sp: span,
+                           index: ValueRef, len: ValueRef) -> block {
+    let _icx = bcx.insn_ctxt("trans_fail_bounds_check");
+    let ccx = bcx.ccx();
+
+    let loc = codemap::lookup_char_pos(bcx.sess().parse_sess.cm, sp.lo);
+    let line = C_int(ccx, loc.line as int);
+    let filename_cstr = C_cstr(bcx.ccx(), loc.file.name);
+    let filename = PointerCast(bcx, filename_cstr, T_ptr(T_i8()));
+
+    let args = ~[filename, line, index, len];
+    let bcx = callee::trans_rtcall(bcx, ~"fail_bounds_check", args,
+                                   expr::Ignore);
+    Unreachable(bcx);
+    return bcx;
+}
+
diff --git a/src/rustc/middle/trans/expr.rs b/src/rustc/middle/trans/expr.rs
index dafaebef9e0..57439daca2f 100644
--- a/src/rustc/middle/trans/expr.rs
+++ b/src/rustc/middle/trans/expr.rs
@@ -946,7 +946,9 @@ fn trans_index(bcx: block,
 
     let bounds_check = ICmp(bcx, lib::llvm::IntUGE, scaled_ix, len);
     let bcx = do with_cond(bcx, bounds_check) |bcx| {
-        controlflow::trans_fail(bcx, Some(index_expr.span), ~"bounds check")
+        let unscaled_len = UDiv(bcx, len, vt.llunit_size);
+        controlflow::trans_fail_bounds_check(bcx, index_expr.span,
+                                             ix_val, unscaled_len)
     };
     let elt = InBoundsGEP(bcx, base, ~[ix_val]);
     let elt = PointerCast(bcx, elt, T_ptr(vt.llunit_ty));
diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs b/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs
index 0db43856612..ef371d07569 100644
--- a/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs
+++ b/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs
@@ -1,5 +1,5 @@
 // xfail-test
-// error-pattern:bounds check
+// error-pattern:index out of bounds
 
 fn main() {
     let x = ~[1u,2u,3u];
@@ -14,4 +14,4 @@ fn main() {
 
     // This should fail.
     error!("ov2 0x%x",  x[idx]);
-}
\ No newline at end of file
+}
diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs b/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs
index 949d303eb01..ae3a9c55b93 100644
--- a/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs
+++ b/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs
@@ -1,5 +1,5 @@
 // xfail-test
-// error-pattern:bounds check
+// error-pattern:index out of bounds
 
 #[cfg(target_arch="x86")]
 fn main() {
diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow.rs b/src/test/run-fail/bug-2470-bounds-check-overflow.rs
index 924b3dda149..fdbcb4de2be 100644
--- a/src/test/run-fail/bug-2470-bounds-check-overflow.rs
+++ b/src/test/run-fail/bug-2470-bounds-check-overflow.rs
@@ -1,4 +1,4 @@
-// error-pattern:bounds check
+// error-pattern:index out of bounds
 
 fn main() {
 
diff --git a/src/test/run-fail/small-negative-indexing.rs b/src/test/run-fail/small-negative-indexing.rs
index 96f0c12c760..5ba6e9dd27a 100644
--- a/src/test/run-fail/small-negative-indexing.rs
+++ b/src/test/run-fail/small-negative-indexing.rs
@@ -1,4 +1,4 @@
-// error-pattern:bounds check
+// error-pattern:index out of bounds: the len is 1024 but the index is -1
 fn main() {
     let v = vec::from_fn(1024u, {|n| n});
     // this should trip a bounds check
diff --git a/src/test/run-fail/str-overrun.rs b/src/test/run-fail/str-overrun.rs
index b8bccfe82d4..d9485f3a289 100644
--- a/src/test/run-fail/str-overrun.rs
+++ b/src/test/run-fail/str-overrun.rs
@@ -1,6 +1,6 @@
 // -*- rust -*-
 
-// error-pattern:bounds check
+// error-pattern:index out of bounds: the len is 5 but the index is 5
 fn main() {
     let s: ~str = ~"hello";
 
diff --git a/src/test/run-fail/vec-overrun.rs b/src/test/run-fail/vec-overrun.rs
index 8301a05f76b..fd3254bc6b1 100644
--- a/src/test/run-fail/vec-overrun.rs
+++ b/src/test/run-fail/vec-overrun.rs
@@ -1,6 +1,6 @@
 // -*- rust -*-
 
-// error-pattern:bounds check
+// error-pattern:index out of bounds: the len is 1 but the index is 2
 fn main() {
     let v: ~[int] = ~[10];
     let x: int = 0;
diff --git a/src/test/run-fail/vec-underrun.rs b/src/test/run-fail/vec-underrun.rs
index 1228e95ac1e..88b29471dac 100644
--- a/src/test/run-fail/vec-underrun.rs
+++ b/src/test/run-fail/vec-underrun.rs
@@ -1,6 +1,6 @@
 // -*- rust -*-
 
-// error-pattern:bounds check
+// error-pattern:index out of bounds: the len is 2 but the index is -1
 fn main() {
     let v: ~[int] = ~[10, 20];
     let x: int = 0;
-- 
cgit 1.4.1-3-g733a5


From c71dc77dac5c8d477fc7df86607f98f2ee784f0f Mon Sep 17 00:00:00 2001
From: Erick Tryzelaar <erick.tryzelaar@gmail.com>
Date: Fri, 28 Sep 2012 23:03:29 -0700
Subject: rustc: uniquely mangle expr_fn names

two closures in the same function body can end up having
the same mangled name. This small patch uses gensym to
uniquely name each closure body so there won't be conflicts.
---
 src/rustc/middle/trans/closure.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/rustc')

diff --git a/src/rustc/middle/trans/closure.rs b/src/rustc/middle/trans/closure.rs
index 95c98126966..1ab25a18329 100644
--- a/src/rustc/middle/trans/closure.rs
+++ b/src/rustc/middle/trans/closure.rs
@@ -363,7 +363,7 @@ fn trans_expr_fn(bcx: block,
     let llfnty = type_of_fn_from_ty(ccx, fty);
     let sub_path = vec::append_one(bcx.fcx.path,
                                    path_name(special_idents::anon));
-    let s = mangle_internal_name_by_path(ccx, sub_path);
+    let s = mangle_internal_name_by_path_and_seq(ccx, sub_path, ~"expr_fn");
     let llfn = decl_internal_cdecl_fn(ccx.llmod, s, llfnty);
 
     let trans_closure_env = fn@(ck: ty::closure_kind) -> Result {
-- 
cgit 1.4.1-3-g733a5


From fd6557ea11a967f30a74b62404c92c4e1abe2107 Mon Sep 17 00:00:00 2001
From: Erick Tryzelaar <erick.tryzelaar@gmail.com>
Date: Fri, 28 Sep 2012 23:43:00 -0700
Subject: rustc: llvm grew some new enum variants

---
 src/rustc/lib/llvm.rs | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/lib/llvm.rs b/src/rustc/lib/llvm.rs
index c16fe31f933..0d92c19b952 100644
--- a/src/rustc/lib/llvm.rs
+++ b/src/rustc/lib/llvm.rs
@@ -28,19 +28,19 @@ enum Linkage {
     AvailableExternallyLinkage = 1,
     LinkOnceAnyLinkage = 2,
     LinkOnceODRLinkage = 3,
-    WeakAnyLinkage = 4,
-    WeakODRLinkage = 5,
-    AppendingLinkage = 6,
-    InternalLinkage = 7,
-    PrivateLinkage = 8,
-    DLLImportLinkage = 9,
-    DLLExportLinkage = 10,
-    ExternalWeakLinkage = 11,
-    GhostLinkage = 12,
-    CommonLinkage = 13,
-    LinkerPrivateLinkage = 14,
-    LinkerPrivateWeakLinkage = 15,
-    LinkerPrivateWeakDefAutoLinkage = 16,
+    LinkOnceODRAutoHideLinkage = 4,
+    WeakAnyLinkage = 5,
+    WeakODRLinkage = 6,
+    AppendingLinkage = 7,
+    InternalLinkage = 8,
+    PrivateLinkage = 9,
+    DLLImportLinkage = 10,
+    DLLExportLinkage = 11,
+    ExternalWeakLinkage = 12,
+    GhostLinkage = 13,
+    CommonLinkage = 14,
+    LinkerPrivateLinkage = 15,
+    LinkerPrivateWeakLinkage = 16,
 }
 
 enum Attribute {
@@ -91,6 +91,7 @@ enum IntPredicate {
 
 // enum for the LLVM RealPredicate type
 enum RealPredicate {
+    RealPredicateFalse = 0,
     RealOEQ = 1,
     RealOGT = 2,
     RealOGE = 3,
@@ -105,6 +106,7 @@ enum RealPredicate {
     RealULT = 12,
     RealULE = 13,
     RealUNE = 14,
+    RealPredicateTrue = 15,
 }
 
 // enum for the LLVM TypeKind type - must stay in sync with the def of
-- 
cgit 1.4.1-3-g733a5


From b18320446e553a3f8436f87306dded57e16a4b94 Mon Sep 17 00:00:00 2001
From: Tim Chevalier <chevalier@alum.wellesley.edu>
Date: Mon, 1 Oct 2012 12:47:02 -0700
Subject: Move over to calling ptr::addr_of

Everything should now call ptr::addr_of instead of
ptr::p2::addr_of. Only the pipes macro code when compiled
by stage0 will call ptr::p2::addr_of. Needs a snapshot to get
rid of that.
---
 doc/tutorial-ffi.md                                |  2 +-
 src/libcore/at_vec.rs                              |  2 +-
 src/libcore/box.rs                                 |  2 +-
 src/libcore/comm.rs                                | 12 +++---
 src/libcore/flate.rs                               |  4 +-
 src/libcore/gc.rs                                  |  2 +-
 src/libcore/pipes.rs                               | 18 ++++-----
 src/libcore/ptr.rs                                 |  5 +--
 src/libcore/str.rs                                 |  2 +-
 src/libcore/task/spawn.rs                          |  2 +-
 src/libcore/vec.rs                                 |  2 +-
 src/libstd/dbg.rs                                  |  8 ++--
 src/libstd/net_ip.rs                               |  6 +--
 src/libstd/net_tcp.rs                              | 42 ++++++++++-----------
 src/libstd/sync.rs                                 |  4 +-
 src/libstd/timer.rs                                |  4 +-
 src/libstd/uv_global_loop.rs                       |  4 +-
 src/libstd/uv_iotask.rs                            | 10 ++---
 src/libstd/uv_ll.rs                                | 44 +++++++++++-----------
 src/libsyntax/ast.rs                               |  4 +-
 src/libsyntax/ext/fmt.rs                           |  2 +-
 src/libsyntax/ext/pipes/pipec.rs                   |  6 +--
 src/rustc/middle/lang_items.rs                     |  2 +-
 src/rustc/middle/liveness.rs                       |  2 +-
 src/rustc/middle/trans/build.rs                    |  6 +--
 src/rustc/middle/trans/common.rs                   |  2 +-
 src/rustc/middle/typeck/check.rs                   |  2 +-
 src/test/auxiliary/test_comm.rs                    |  6 +--
 src/test/bench/msgsend-pipes-shared.rs             |  2 +-
 src/test/bench/msgsend-pipes.rs                    |  2 +-
 src/test/bench/msgsend-ring-pipes.rs               |  2 +-
 src/test/bench/pingpong.rs                         |  2 +-
 src/test/bench/task-perf-word-count-generic.rs     |  2 +-
 src/test/run-pass/binops.rs                        |  4 +-
 .../run-pass/borrowck-borrow-from-expr-block.rs    |  2 +-
 .../run-pass/borrowck-preserve-box-in-discr.rs     |  6 +--
 .../run-pass/borrowck-preserve-box-in-field.rs     |  6 +--
 src/test/run-pass/borrowck-preserve-box-in-pat.rs  |  6 +--
 src/test/run-pass/borrowck-preserve-box-in-uniq.rs |  6 +--
 src/test/run-pass/borrowck-preserve-box.rs         |  6 +--
 src/test/run-pass/borrowck-preserve-expl-deref.rs  |  6 +--
 src/test/run-pass/cap-clause-move.rs               | 24 ++++++------
 src/test/run-pass/issue-2718.rs                    |  4 +-
 src/test/run-pass/last-use-corner-cases.rs         |  8 ++--
 src/test/run-pass/pipe-bank-proto.rs               |  2 +-
 src/test/run-pass/pipe-pingpong-bounded.rs         | 10 ++---
 src/test/run-pass/reflect-visit-data.rs            |  2 +-
 src/test/run-pass/resource-cycle.rs                | 12 +++---
 src/test/run-pass/rt-sched-1.rs                    |  2 +-
 src/test/run-pass/select-macro.rs                  |  2 +-
 src/test/run-pass/stable-addr-of.rs                |  2 +-
 src/test/run-pass/task-killjoin-rsrc.rs            |  4 +-
 src/test/run-pass/task-spawn-move-and-copy.rs      |  8 ++--
 src/test/run-pass/uniq-cc-generic.rs               |  2 +-
 54 files changed, 169 insertions(+), 172 deletions(-)

(limited to 'src/rustc')

diff --git a/doc/tutorial-ffi.md b/doc/tutorial-ffi.md
index 92ba09856b0..463bd4746fe 100644
--- a/doc/tutorial-ffi.md
+++ b/doc/tutorial-ffi.md
@@ -231,7 +231,7 @@ fn unix_time_in_microseconds() -> u64 unsafe {
         mut tv_sec: 0 as c_ulonglong,
         mut tv_usec: 0 as c_ulonglong
     };
-    lib_c::gettimeofday(ptr::addr_of(x), ptr::null());
+    lib_c::gettimeofday(ptr::addr_of(&x), ptr::null());
     return (x.tv_sec as u64) * 1000_000_u64 + (x.tv_usec as u64);
 }
 
diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs
index 6377c25b8c4..6936de2bccb 100644
--- a/src/libcore/at_vec.rs
+++ b/src/libcore/at_vec.rs
@@ -5,7 +5,7 @@
 #[forbid(deprecated_pattern)];
 
 use cast::transmute;
-use ptr::p2::addr_of;
+use ptr::addr_of;
 
 /// Code for dealing with @-vectors. This is pretty incomplete, and
 /// contains a bunch of duplication from the code for ~-vectors.
diff --git a/src/libcore/box.rs b/src/libcore/box.rs
index 43307b92664..d34679f2bd7 100644
--- a/src/libcore/box.rs
+++ b/src/libcore/box.rs
@@ -24,7 +24,7 @@ pub mod raw {
 
 pub pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
     //! Determine if two shared boxes point to the same object
-    unsafe { ptr::p2::addr_of(&(*a)) == ptr::p2::addr_of(&(*b)) }
+    unsafe { ptr::addr_of(&(*a)) == ptr::addr_of(&(*b)) }
 }
 
 impl<T:Eq> @const T : Eq {
diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs
index 37468aaaab6..46767bc1172 100644
--- a/src/libcore/comm.rs
+++ b/src/libcore/comm.rs
@@ -103,7 +103,7 @@ struct PortPtr<T:Send> {
         // Once the port is detached it's guaranteed not to receive further
         // messages
         let yield = 0;
-        let yieldp = ptr::p2::addr_of(&yield);
+        let yieldp = ptr::addr_of(&yield);
         rustrt::rust_port_begin_detach(self.po, yieldp);
         if yield != 0 {
             // Need to wait for the port to be detached
@@ -176,7 +176,7 @@ pub fn Chan<T: Send>(p: Port<T>) -> Chan<T> {
  */
 pub fn send<T: Send>(ch: Chan<T>, +data: T) {
     let Chan_(p) = ch;
-    let data_ptr = ptr::p2::addr_of(&data) as *();
+    let data_ptr = ptr::addr_of(&data) as *();
     let res = rustrt::rust_port_id_send(p, data_ptr);
     if res != 0 unsafe {
         // Data sent successfully
@@ -206,10 +206,10 @@ fn peek_chan<T: Send>(ch: comm::Chan<T>) -> bool {
 /// Receive on a raw port pointer
 fn recv_<T: Send>(p: *rust_port) -> T {
     let yield = 0;
-    let yieldp = ptr::p2::addr_of(&yield);
+    let yieldp = ptr::addr_of(&yield);
     let mut res;
     res = rusti::init::<T>();
-    rustrt::port_recv(ptr::p2::addr_of(&res) as *uint, p, yieldp);
+    rustrt::port_recv(ptr::addr_of(&res) as *uint, p, yieldp);
 
     if yield != 0 {
         // Data isn't available yet, so res has not been initialized.
@@ -233,12 +233,12 @@ fn peek_(p: *rust_port) -> bool {
 pub fn select2<A: Send, B: Send>(p_a: Port<A>, p_b: Port<B>)
     -> Either<A, B> {
     let ports = ~[(**p_a).po, (**p_b).po];
-    let yield = 0, yieldp = ptr::p2::addr_of(&yield);
+    let yield = 0, yieldp = ptr::addr_of(&yield);
 
     let mut resport: *rust_port;
     resport = rusti::init::<*rust_port>();
     do vec::as_imm_buf(ports) |ports, n_ports| {
-        rustrt::rust_port_select(ptr::p2::addr_of(&resport), ports,
+        rustrt::rust_port_select(ptr::addr_of(&resport), ports,
                                  n_ports as size_t, yieldp);
     }
 
diff --git a/src/libcore/flate.rs b/src/libcore/flate.rs
index cfc34b03a94..7c5176494a2 100644
--- a/src/libcore/flate.rs
+++ b/src/libcore/flate.rs
@@ -34,7 +34,7 @@ pub fn deflate_bytes(bytes: &[const u8]) -> ~[u8] {
             let res =
                 rustrt::tdefl_compress_mem_to_heap(b as *c_void,
                                                    len as size_t,
-                                                   ptr::addr_of(outsz),
+                                                   ptr::addr_of(&outsz),
                                                    lz_norm);
             assert res as int != 0;
             let out = vec::raw::from_buf(res as *u8,
@@ -52,7 +52,7 @@ pub fn inflate_bytes(bytes: &[const u8]) -> ~[u8] {
             let res =
                 rustrt::tinfl_decompress_mem_to_heap(b as *c_void,
                                                      len as size_t,
-                                                     ptr::addr_of(outsz),
+                                                     ptr::addr_of(&outsz),
                                                      0);
             assert res as int != 0;
             let out = vec::raw::from_buf(res as *u8,
diff --git a/src/libcore/gc.rs b/src/libcore/gc.rs
index ace4156f5b4..de2e4412812 100644
--- a/src/libcore/gc.rs
+++ b/src/libcore/gc.rs
@@ -316,7 +316,7 @@ pub fn cleanup_stack_for_failure() {
         // own stack roots on the stack anyway.
         let sentinel_box = ~0;
         let sentinel: **Word = if expect_sentinel() {
-            cast::reinterpret_cast(&ptr::p2::addr_of(&sentinel_box))
+            cast::reinterpret_cast(&ptr::addr_of(&sentinel_box))
         } else {
             ptr::null()
         };
diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs
index 95edeca9837..4d446df9cd5 100644
--- a/src/libcore/pipes.rs
+++ b/src/libcore/pipes.rs
@@ -85,7 +85,7 @@ use option::unwrap;
 const SPIN_COUNT: uint = 0;
 
 macro_rules! move_it (
-    { $x:expr } => { unsafe { let y <- *ptr::addr_of($x); move y } }
+    { $x:expr } => { unsafe { let y <- *ptr::addr_of(&($x)); move y } }
 )
 
 #[doc(hidden)]
@@ -219,7 +219,7 @@ fn unibuffer<T: Send>() -> ~Buffer<Packet<T>> {
 #[doc(hidden)]
 pub fn packet<T: Send>() -> *Packet<T> {
     let b = unibuffer();
-    let p = ptr::p2::addr_of(&(b.data));
+    let p = ptr::addr_of(&(b.data));
     // We'll take over memory management from here.
     unsafe { forget(move b) }
     p
@@ -359,7 +359,7 @@ pub fn send<T: Send, Tbuffer: Send>(+p: SendPacketBuffered<T, Tbuffer>,
     let header = p.header();
     let p_ = p.unwrap();
     let p = unsafe { &*p_ };
-    assert ptr::p2::addr_of(&(p.header)) == header;
+    assert ptr::addr_of(&(p.header)) == header;
     assert p.payload.is_none();
     p.payload <- Some(move payload);
     let old_state = swap_state_rel(&mut p.header.state, Full);
@@ -377,7 +377,7 @@ pub fn send<T: Send, Tbuffer: Send>(+p: SendPacketBuffered<T, Tbuffer>,
             let old_task = swap_task(&mut p.header.blocked_task, ptr::null());
             if !old_task.is_null() {
                 rustrt::task_signal_event(
-                    old_task, ptr::p2::addr_of(&(p.header)) as *libc::c_void);
+                    old_task, ptr::addr_of(&(p.header)) as *libc::c_void);
                 rustrt::rust_task_deref(old_task);
             }
 
@@ -529,7 +529,7 @@ fn sender_terminate<T: Send>(p: *Packet<T>) {
         if !old_task.is_null() {
             rustrt::task_signal_event(
                 old_task,
-                ptr::p2::addr_of(&(p.header)) as *libc::c_void);
+                ptr::addr_of(&(p.header)) as *libc::c_void);
             rustrt::rust_task_deref(old_task);
         }
         // The receiver will eventually clean up.
@@ -744,7 +744,7 @@ pub fn SendPacketBuffered<T: Send, Tbuffer: Send>(p: *Packet<T>)
         p: Some(p),
         buffer: unsafe {
             Some(BufferResource(
-                get_buffer(ptr::p2::addr_of(&((*p).header)))))
+                get_buffer(ptr::addr_of(&((*p).header)))))
         }
     }
 }
@@ -760,7 +760,7 @@ impl<T: Send, Tbuffer: Send> SendPacketBuffered<T, Tbuffer> {
         match self.p {
           Some(packet) => unsafe {
             let packet = &*packet;
-            let header = ptr::p2::addr_of(&(packet.header));
+            let header = ptr::addr_of(&(packet.header));
             //forget(packet);
             header
           },
@@ -815,7 +815,7 @@ impl<T: Send, Tbuffer: Send> RecvPacketBuffered<T, Tbuffer> : Selectable {
         match self.p {
           Some(packet) => unsafe {
             let packet = &*packet;
-            let header = ptr::p2::addr_of(&(packet.header));
+            let header = ptr::addr_of(&(packet.header));
             //forget(packet);
             header
           },
@@ -838,7 +838,7 @@ pub fn RecvPacketBuffered<T: Send, Tbuffer: Send>(p: *Packet<T>)
         p: Some(p),
         buffer: unsafe {
             Some(BufferResource(
-                get_buffer(ptr::p2::addr_of(&((*p).header)))))
+                get_buffer(ptr::addr_of(&((*p).header)))))
         }
     }
 }
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index 9f9d2eea0e6..550b0121e45 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -24,12 +24,9 @@ extern mod rusti {
     fn addr_of<T>(val: T) -> *T;
 }
 
-/*
-Remove this after snapshot; make p2::addr_of addr_of
-*/
 /// Get an unsafe pointer to a value
 #[inline(always)]
-pub pure fn addr_of<T>(val: T) -> *T { unsafe { rusti::addr_of(val) } }
+pub pure fn addr_of<T>(val: &T) -> *T { unsafe { rusti::addr_of(*val) } }
 
 pub mod p2 {
     /// Get an unsafe pointer to a value
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index c6e7116675f..227635944dd 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -1780,7 +1780,7 @@ pub pure fn as_c_str<T>(s: &str, f: fn(*libc::c_char) -> T) -> T {
 #[inline(always)]
 pub pure fn as_buf<T>(s: &str, f: fn(*u8, uint) -> T) -> T {
     unsafe {
-        let v : *(*u8,uint) = ::cast::reinterpret_cast(&ptr::p2::addr_of(&s));
+        let v : *(*u8,uint) = ::cast::reinterpret_cast(&ptr::addr_of(&s));
         let (buf,len) = *v;
         f(buf, len)
     }
diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs
index 2095961e14e..982679f9398 100644
--- a/src/libcore/task/spawn.rs
+++ b/src/libcore/task/spawn.rs
@@ -66,7 +66,7 @@ use rt::rust_task;
 use rt::rust_closure;
 
 macro_rules! move_it (
-    { $x:expr } => { unsafe { let y <- *ptr::p2::addr_of(&($x)); move y } }
+    { $x:expr } => { unsafe { let y <- *ptr::addr_of(&($x)); move y } }
 )
 
 type TaskSet = send_map::linear::LinearMap<*rust_task,()>;
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index a8286eb4e08..d01b24f5354 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -6,7 +6,7 @@
 
 use cmp::{Eq, Ord};
 use option::{Some, None};
-use ptr::p2::addr_of;
+use ptr::addr_of;
 use libc::size_t;
 
 export append;
diff --git a/src/libstd/dbg.rs b/src/libstd/dbg.rs
index 26b2a02ec9c..df97df51643 100644
--- a/src/libstd/dbg.rs
+++ b/src/libstd/dbg.rs
@@ -21,19 +21,19 @@ pub fn debug_tydesc<T>() {
 }
 
 pub fn debug_opaque<T>(+x: T) {
-    rustrt::debug_opaque(sys::get_type_desc::<T>(), ptr::addr_of(x) as *());
+    rustrt::debug_opaque(sys::get_type_desc::<T>(), ptr::addr_of(&x) as *());
 }
 
 pub fn debug_box<T>(x: @T) {
-    rustrt::debug_box(sys::get_type_desc::<T>(), ptr::addr_of(x) as *());
+    rustrt::debug_box(sys::get_type_desc::<T>(), ptr::addr_of(&x) as *());
 }
 
 pub fn debug_tag<T>(+x: T) {
-    rustrt::debug_tag(sys::get_type_desc::<T>(), ptr::addr_of(x) as *());
+    rustrt::debug_tag(sys::get_type_desc::<T>(), ptr::addr_of(&x) as *());
 }
 
 pub fn debug_fn<T>(+x: T) {
-    rustrt::debug_fn(sys::get_type_desc::<T>(), ptr::addr_of(x) as *());
+    rustrt::debug_fn(sys::get_type_desc::<T>(), ptr::addr_of(&x) as *());
 }
 
 pub unsafe fn ptr_cast<T, U>(x: @T) -> @U {
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index 321eb3158a9..9aa29df4a62 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -89,11 +89,11 @@ fn get_addr(node: &str, iotask: iotask)
         do str::as_buf(node) |node_ptr, len| unsafe {
             log(debug, fmt!("slice len %?", len));
             let handle = create_uv_getaddrinfo_t();
-            let handle_ptr = ptr::addr_of(handle);
+            let handle_ptr = ptr::addr_of(&handle);
             let handle_data: GetAddrData = {
                 output_ch: output_ch
             };
-            let handle_data_ptr = ptr::addr_of(handle_data);
+            let handle_data_ptr = ptr::addr_of(&handle_data);
             do interact(iotask) |loop_ptr| unsafe {
                 let result = uv_getaddrinfo(
                     loop_ptr,
@@ -150,7 +150,7 @@ mod v4 {
     impl Ipv4Rep: AsUnsafeU32 {
         // this is pretty dastardly, i know
         unsafe fn as_u32() -> u32 {
-            *((ptr::addr_of(self)) as *u32)
+            *((ptr::addr_of(&self)) as *u32)
         }
     }
     fn parse_to_ipv4_rep(ip: &str) -> result::Result<Ipv4Rep, ~str> {
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index 820c2bfcc4d..aedd53d41cc 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -138,7 +138,7 @@ fn connect(+input_ip: ip::IpAddr, port: uint,
         result_ch: core::comm::Chan(result_po),
         closed_signal_ch: core::comm::Chan(closed_signal_po)
     };
-    let conn_data_ptr = ptr::addr_of(conn_data);
+    let conn_data_ptr = ptr::addr_of(&conn_data);
     let reader_po = core::comm::Port::<result::Result<~[u8], TcpErrData>>();
     let stream_handle_ptr = malloc_uv_tcp_t();
     *(stream_handle_ptr as *mut uv::ll::uv_tcp_t) = uv::ll::tcp_t();
@@ -150,7 +150,7 @@ fn connect(+input_ip: ip::IpAddr, port: uint,
         write_req: uv::ll::write_t(),
         iotask: iotask
     };
-    let socket_data_ptr = ptr::addr_of(*socket_data);
+    let socket_data_ptr = ptr::addr_of(&(*socket_data));
     log(debug, fmt!("tcp_connect result_ch %?", conn_data.result_ch));
     // get an unsafe representation of our stream_handle_ptr that
     // we can send into the interact cb to be handled in libuv..
@@ -165,7 +165,7 @@ fn connect(+input_ip: ip::IpAddr, port: uint,
             log(debug, ~"tcp_init successful");
             log(debug, ~"dealing w/ ipv4 connection..");
             let connect_req_ptr =
-                ptr::addr_of((*socket_data_ptr).connect_req);
+                ptr::addr_of(&((*socket_data_ptr).connect_req));
             let addr_str = ip::format_addr(&input_ip);
             let connect_result = match input_ip {
               ip::Ipv4(ref addr) => {
@@ -179,7 +179,7 @@ fn connect(+input_ip: ip::IpAddr, port: uint,
                 uv::ll::tcp_connect(
                     connect_req_ptr,
                     stream_handle_ptr,
-                    ptr::addr_of(in_addr),
+                    ptr::addr_of(&in_addr),
                     tcp_connect_on_connect_cb)
               }
               ip::Ipv6(ref addr) => {
@@ -188,7 +188,7 @@ fn connect(+input_ip: ip::IpAddr, port: uint,
                 uv::ll::tcp_connect6(
                     connect_req_ptr,
                     stream_handle_ptr,
-                    ptr::addr_of(in_addr),
+                    ptr::addr_of(&in_addr),
                     tcp_connect_on_connect_cb)
               }
             };
@@ -264,7 +264,7 @@ fn connect(+input_ip: ip::IpAddr, port: uint,
  */
 fn write(sock: &TcpSocket, raw_write_data: ~[u8])
     -> result::Result<(), TcpErrData> unsafe {
-    let socket_data_ptr = ptr::addr_of(*(sock.socket_data));
+    let socket_data_ptr = ptr::addr_of(&(*(sock.socket_data)));
     write_common_impl(socket_data_ptr, raw_write_data)
 }
 
@@ -301,7 +301,7 @@ fn write(sock: &TcpSocket, raw_write_data: ~[u8])
  */
 fn write_future(sock: &TcpSocket, raw_write_data: ~[u8])
     -> future::Future<result::Result<(), TcpErrData>> unsafe {
-    let socket_data_ptr = ptr::addr_of(*(sock.socket_data));
+    let socket_data_ptr = ptr::addr_of(&(*(sock.socket_data)));
     do future_spawn {
         let data_copy = copy(raw_write_data);
         write_common_impl(socket_data_ptr, data_copy)
@@ -326,7 +326,7 @@ fn write_future(sock: &TcpSocket, raw_write_data: ~[u8])
 fn read_start(sock: &TcpSocket)
     -> result::Result<comm::Port<
         result::Result<~[u8], TcpErrData>>, TcpErrData> unsafe {
-    let socket_data = ptr::addr_of(*(sock.socket_data));
+    let socket_data = ptr::addr_of(&(*(sock.socket_data)));
     read_start_common_impl(socket_data)
 }
 
@@ -341,7 +341,7 @@ fn read_stop(sock: &TcpSocket,
              +read_port: comm::Port<result::Result<~[u8], TcpErrData>>) ->
     result::Result<(), TcpErrData> unsafe {
     log(debug, fmt!("taking the read_port out of commission %?", read_port));
-    let socket_data = ptr::addr_of(*sock.socket_data);
+    let socket_data = ptr::addr_of(&(*sock.socket_data));
     read_stop_common_impl(socket_data)
 }
 
@@ -362,7 +362,7 @@ fn read_stop(sock: &TcpSocket,
  */
 fn read(sock: &TcpSocket, timeout_msecs: uint)
     -> result::Result<~[u8],TcpErrData> {
-    let socket_data = ptr::addr_of(*(sock.socket_data));
+    let socket_data = ptr::addr_of(&(*(sock.socket_data)));
     read_common_impl(socket_data, timeout_msecs)
 }
 
@@ -397,7 +397,7 @@ fn read(sock: &TcpSocket, timeout_msecs: uint)
  */
 fn read_future(sock: &TcpSocket, timeout_msecs: uint)
     -> future::Future<result::Result<~[u8],TcpErrData>> {
-    let socket_data = ptr::addr_of(*(sock.socket_data));
+    let socket_data = ptr::addr_of(&(*(sock.socket_data)));
     do future_spawn {
         read_common_impl(socket_data, timeout_msecs)
     }
@@ -491,7 +491,7 @@ fn accept(new_conn: TcpNewConnection)
             write_req : uv::ll::write_t(),
             iotask : iotask
         };
-        let client_socket_data_ptr = ptr::addr_of(*client_socket_data);
+        let client_socket_data_ptr = ptr::addr_of(&(*client_socket_data));
         let client_stream_handle_ptr =
             (*client_socket_data_ptr).stream_handle_ptr;
 
@@ -596,7 +596,7 @@ fn listen_common(+host_ip: ip::IpAddr, port: uint, backlog: uint,
     let kill_po = core::comm::Port::<Option<TcpErrData>>();
     let kill_ch = core::comm::Chan(kill_po);
     let server_stream = uv::ll::tcp_t();
-    let server_stream_ptr = ptr::addr_of(server_stream);
+    let server_stream_ptr = ptr::addr_of(&server_stream);
     let server_data = {
         server_stream_ptr: server_stream_ptr,
         stream_closed_ch: core::comm::Chan(stream_closed_po),
@@ -605,7 +605,7 @@ fn listen_common(+host_ip: ip::IpAddr, port: uint, backlog: uint,
         iotask: iotask,
         mut active: true
     };
-    let server_data_ptr = ptr::addr_of(server_data);
+    let server_data_ptr = ptr::addr_of(&server_data);
 
     let setup_result = do core::comm::listen |setup_ch| {
         // this is to address a compiler warning about
@@ -627,13 +627,13 @@ fn listen_common(+host_ip: ip::IpAddr, port: uint, backlog: uint,
                     log(debug, fmt!("addr: %?", addr));
                     let in_addr = uv::ll::ip4_addr(addr_str, port as int);
                     uv::ll::tcp_bind(server_stream_ptr,
-                                     ptr::addr_of(in_addr))
+                                     ptr::addr_of(&in_addr))
                   }
                   ip::Ipv6(ref addr) => {
                     log(debug, fmt!("addr: %?", addr));
                     let in_addr = uv::ll::ip6_addr(addr_str, port as int);
                     uv::ll::tcp_bind6(server_stream_ptr,
-                                     ptr::addr_of(in_addr))
+                                     ptr::addr_of(&in_addr))
                   }
                 };
                 match bind_result {
@@ -818,7 +818,7 @@ impl TcpSocketBuf: io::Reader {
 impl TcpSocketBuf: io::Writer {
     fn write(data: &[const u8]) unsafe {
         let socket_data_ptr =
-            ptr::addr_of(*((*(self.data)).sock).socket_data);
+            ptr::addr_of(&(*((*(self.data)).sock).socket_data));
         let w_result = write_common_impl(socket_data_ptr,
                                         vec::slice(data, 0, vec::len(data)));
         if w_result.is_err() {
@@ -850,7 +850,7 @@ fn tear_down_socket_data(socket_data: @TcpSocketData) unsafe {
     let close_data = {
         closed_ch: closed_ch
     };
-    let close_data_ptr = ptr::addr_of(close_data);
+    let close_data_ptr = ptr::addr_of(&close_data);
     let stream_handle_ptr = (*socket_data).stream_handle_ptr;
     do iotask::interact((*socket_data).iotask) |loop_ptr| unsafe {
         log(debug, fmt!("interact dtor for tcp_socket stream %? loop %?",
@@ -966,18 +966,18 @@ fn read_start_common_impl(socket_data: *TcpSocketData)
 fn write_common_impl(socket_data_ptr: *TcpSocketData,
                      raw_write_data: ~[u8])
     -> result::Result<(), TcpErrData> unsafe {
-    let write_req_ptr = ptr::addr_of((*socket_data_ptr).write_req);
+    let write_req_ptr = ptr::addr_of(&((*socket_data_ptr).write_req));
     let stream_handle_ptr =
         (*socket_data_ptr).stream_handle_ptr;
     let write_buf_vec =  ~[ uv::ll::buf_init(
         vec::raw::to_ptr(raw_write_data),
         vec::len(raw_write_data)) ];
-    let write_buf_vec_ptr = ptr::addr_of(write_buf_vec);
+    let write_buf_vec_ptr = ptr::addr_of(&write_buf_vec);
     let result_po = core::comm::Port::<TcpWriteResult>();
     let write_data = {
         result_ch: core::comm::Chan(result_po)
     };
-    let write_data_ptr = ptr::addr_of(write_data);
+    let write_data_ptr = ptr::addr_of(&write_data);
     do iotask::interact((*socket_data_ptr).iotask) |loop_ptr| unsafe {
         log(debug, fmt!("in interact cb for tcp::write %?", loop_ptr));
         match uv::ll::write(write_req_ptr,
diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs
index 2b2cd2b0ba7..f66f2f5b5d3 100644
--- a/src/libstd/sync.rs
+++ b/src/libstd/sync.rs
@@ -773,7 +773,7 @@ mod tests {
         let m = ~Mutex();
         let m2 = ~m.clone();
         let mut sharedstate = ~0;
-        let ptr = ptr::addr_of(*sharedstate);
+        let ptr = ptr::p2::addr_of(&(*sharedstate));
         do task::spawn {
             let sharedstate: &mut int =
                 unsafe { cast::reinterpret_cast(&ptr) };
@@ -1045,7 +1045,7 @@ mod tests {
         let (c,p) = pipes::stream();
         let x2 = ~x.clone();
         let mut sharedstate = ~0;
-        let ptr = ptr::addr_of(*sharedstate);
+        let ptr = ptr::p2::addr_of(&(*sharedstate));
         do task::spawn {
             let sharedstate: &mut int =
                 unsafe { cast::reinterpret_cast(&ptr) };
diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs
index a2f9796f89e..8aaf7d3fd87 100644
--- a/src/libstd/timer.rs
+++ b/src/libstd/timer.rs
@@ -28,9 +28,9 @@ pub fn delayed_send<T: Copy Send>(iotask: IoTask,
         unsafe {
             let timer_done_po = core::comm::Port::<()>();
             let timer_done_ch = core::comm::Chan(timer_done_po);
-            let timer_done_ch_ptr = ptr::addr_of(timer_done_ch);
+            let timer_done_ch_ptr = ptr::addr_of(&timer_done_ch);
             let timer = uv::ll::timer_t();
-            let timer_ptr = ptr::addr_of(timer);
+            let timer_ptr = ptr::addr_of(&timer);
             do iotask::interact(iotask) |loop_ptr| unsafe {
                 let init_result = uv::ll::timer_init(loop_ptr, timer_ptr);
                 if (init_result == 0i32) {
diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs
index 508426588d0..9ccacd1f7f6 100644
--- a/src/libstd/uv_global_loop.rs
+++ b/src/libstd/uv_global_loop.rs
@@ -138,11 +138,11 @@ mod test {
     fn impl_uv_hl_simple_timer(iotask: IoTask) unsafe {
         let exit_po = core::comm::Port::<bool>();
         let exit_ch = core::comm::Chan(exit_po);
-        let exit_ch_ptr = ptr::addr_of(exit_ch);
+        let exit_ch_ptr = ptr::p2::addr_of(&exit_ch);
         log(debug, fmt!("EXIT_CH_PTR newly created exit_ch_ptr: %?",
                        exit_ch_ptr));
         let timer_handle = ll::timer_t();
-        let timer_ptr = ptr::addr_of(timer_handle);
+        let timer_ptr = ptr::p2::addr_of(&timer_handle);
         do iotask::interact(iotask) |loop_ptr| unsafe {
             log(debug, ~"user code inside interact loop!!!");
             let init_status = ll::timer_init(loop_ptr, timer_ptr);
diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs
index c31238ecf4f..ab50cc9d929 100644
--- a/src/libstd/uv_iotask.rs
+++ b/src/libstd/uv_iotask.rs
@@ -13,7 +13,7 @@ export interact;
 export exit;
 
 use libc::c_void;
-use ptr::addr_of;
+use ptr::p2::addr_of;
 use comm = core::comm;
 use comm::{Port, Chan, listen};
 use task::TaskBuilder;
@@ -96,7 +96,7 @@ fn run_loop(iotask_ch: Chan<IoTask>) unsafe {
     // set up the special async handle we'll use to allow multi-task
     // communication with this loop
     let async = ll::async_t();
-    let async_handle = addr_of(async);
+    let async_handle = addr_of(&async);
 
     // associate the async handle with the loop
     ll::async_init(loop_ptr, async_handle, wake_up_cb);
@@ -106,7 +106,7 @@ fn run_loop(iotask_ch: Chan<IoTask>) unsafe {
         async_handle: async_handle,
         msg_po: Port()
     };
-    ll::set_data_for_uv_handle(async_handle, addr_of(data));
+    ll::set_data_for_uv_handle(async_handle, addr_of(&data));
 
     // Send out a handle through which folks can talk to us
     // while we dwell in the I/O loop
@@ -188,14 +188,14 @@ mod test {
     };
     fn impl_uv_iotask_async(iotask: IoTask) unsafe {
         let async_handle = ll::async_t();
-        let ah_ptr = ptr::addr_of(async_handle);
+        let ah_ptr = ptr::addr_of(&async_handle);
         let exit_po = core::comm::Port::<()>();
         let exit_ch = core::comm::Chan(exit_po);
         let ah_data = {
             iotask: iotask,
             exit_ch: exit_ch
         };
-        let ah_data_ptr = ptr::addr_of(ah_data);
+        let ah_data_ptr = ptr::addr_of(&ah_data);
         do interact(iotask) |loop_ptr| unsafe {
             ll::async_init(loop_ptr, ah_ptr, async_handle_cb);
             ll::set_data_for_uv_handle(ah_ptr, ah_data_ptr as *libc::c_void);
diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs
index 6d212cd7e92..fca34c01bc1 100644
--- a/src/libstd/uv_ll.rs
+++ b/src/libstd/uv_ll.rs
@@ -796,7 +796,7 @@ unsafe fn async_send(async_handle: *uv_async_t) {
 }
 unsafe fn buf_init(input: *u8, len: uint) -> uv_buf_t {
     let out_buf = { base: ptr::null(), len: 0 as libc::size_t };
-    let out_buf_ptr = ptr::addr_of(out_buf);
+    let out_buf_ptr = ptr::addr_of(&out_buf);
     log(debug, fmt!("buf_init - input %u len %u out_buf: %u",
                      input as uint,
                      len as uint,
@@ -968,7 +968,7 @@ unsafe fn free_base_of_buf(buf: uv_buf_t) {
 
 unsafe fn get_last_err_info(uv_loop: *libc::c_void) -> ~str {
     let err = last_error(uv_loop);
-    let err_ptr = ptr::addr_of(err);
+    let err_ptr = ptr::addr_of(&err);
     let err_name = str::raw::from_c_str(err_name(err_ptr));
     let err_msg = str::raw::from_c_str(strerror(err_ptr));
     return fmt!("LIBUV ERROR: name: %s msg: %s",
@@ -977,7 +977,7 @@ unsafe fn get_last_err_info(uv_loop: *libc::c_void) -> ~str {
 
 unsafe fn get_last_err_data(uv_loop: *libc::c_void) -> uv_err_data {
     let err = last_error(uv_loop);
-    let err_ptr = ptr::addr_of(err);
+    let err_ptr = ptr::addr_of(&err);
     let err_name = str::raw::from_c_str(err_name(err_ptr));
     let err_msg = str::raw::from_c_str(strerror(err_ptr));
     { err_name: err_name, err_msg: err_msg }
@@ -1120,9 +1120,9 @@ mod test {
                           client_chan: *comm::Chan<~str>) unsafe {
         let test_loop = loop_new();
         let tcp_handle = tcp_t();
-        let tcp_handle_ptr = ptr::addr_of(tcp_handle);
+        let tcp_handle_ptr = ptr::addr_of(&tcp_handle);
         let connect_handle = connect_t();
-        let connect_req_ptr = ptr::addr_of(connect_handle);
+        let connect_req_ptr = ptr::addr_of(&connect_handle);
 
         // this is the persistent payload of data that we
         // need to pass around to get this example to work.
@@ -1138,12 +1138,12 @@ mod test {
         // this is the enclosing record, we'll pass a ptr to
         // this to C..
         let write_handle = write_t();
-        let write_handle_ptr = ptr::addr_of(write_handle);
+        let write_handle_ptr = ptr::addr_of(&write_handle);
         log(debug, fmt!("tcp req: tcp stream: %d write_handle: %d",
                          tcp_handle_ptr as int,
                          write_handle_ptr as int));
         let client_data = { writer_handle: write_handle_ptr,
-                    req_buf: ptr::addr_of(req_msg),
+                    req_buf: ptr::addr_of(&req_msg),
                     read_chan: client_chan };
 
         let tcp_init_result = tcp_init(
@@ -1154,7 +1154,7 @@ mod test {
             log(debug, ~"building addr...");
             let addr = ip4_addr(ip, port);
             // FIXME ref #2064
-            let addr_ptr = ptr::addr_of(addr);
+            let addr_ptr = ptr::addr_of(&addr);
             log(debug, fmt!("after build addr in rust. port: %u",
                              addr.sin_port as uint));
 
@@ -1169,10 +1169,10 @@ mod test {
                 // until its initialized
                 set_data_for_req(
                     connect_req_ptr as *libc::c_void,
-                    ptr::addr_of(client_data) as *libc::c_void);
+                    ptr::addr_of(&client_data) as *libc::c_void);
                 set_data_for_uv_handle(
                     tcp_handle_ptr as *libc::c_void,
-                    ptr::addr_of(client_data) as *libc::c_void);
+                    ptr::addr_of(&client_data) as *libc::c_void);
                 log(debug, ~"before run tcp req loop");
                 run(test_loop);
                 log(debug, ~"after run tcp req loop");
@@ -1369,13 +1369,13 @@ mod test {
                           continue_chan: *comm::Chan<bool>) unsafe {
         let test_loop = loop_new();
         let tcp_server = tcp_t();
-        let tcp_server_ptr = ptr::addr_of(tcp_server);
+        let tcp_server_ptr = ptr::addr_of(&tcp_server);
 
         let tcp_client = tcp_t();
-        let tcp_client_ptr = ptr::addr_of(tcp_client);
+        let tcp_client_ptr = ptr::addr_of(&tcp_client);
 
         let server_write_req = write_t();
-        let server_write_req_ptr = ptr::addr_of(server_write_req);
+        let server_write_req_ptr = ptr::addr_of(&server_write_req);
 
         let resp_str_bytes = str::to_bytes(server_resp_msg);
         let resp_msg_ptr: *u8 = vec::raw::to_ptr(resp_str_bytes);
@@ -1386,20 +1386,20 @@ mod test {
 
         let continue_async_handle = async_t();
         let continue_async_handle_ptr =
-            ptr::addr_of(continue_async_handle);
+            ptr::addr_of(&continue_async_handle);
         let async_data =
             { continue_chan: continue_chan };
-        let async_data_ptr = ptr::addr_of(async_data);
+        let async_data_ptr = ptr::addr_of(&async_data);
 
         let server_data: tcp_server_data = {
             client: tcp_client_ptr,
             server: tcp_server_ptr,
             server_kill_msg: kill_server_msg,
-            server_resp_buf: ptr::addr_of(resp_msg),
+            server_resp_buf: ptr::addr_of(&resp_msg),
             server_chan: server_chan,
             server_write_req: server_write_req_ptr
         };
-        let server_data_ptr = ptr::addr_of(server_data);
+        let server_data_ptr = ptr::addr_of(&server_data);
         set_data_for_uv_handle(tcp_server_ptr as *libc::c_void,
                                        server_data_ptr as *libc::c_void);
 
@@ -1409,7 +1409,7 @@ mod test {
         if (tcp_init_result == 0i32) {
             let server_addr = ip4_addr(server_ip, server_port);
             // FIXME ref #2064
-            let server_addr_ptr = ptr::addr_of(server_addr);
+            let server_addr_ptr = ptr::addr_of(&server_addr);
 
             // uv_tcp_bind()
             let bind_result = tcp_bind(tcp_server_ptr,
@@ -1478,13 +1478,13 @@ mod test {
 
         let continue_port = core::comm::Port::<bool>();
         let continue_chan = core::comm::Chan::<bool>(continue_port);
-        let continue_chan_ptr = ptr::addr_of(continue_chan);
+        let continue_chan_ptr = ptr::addr_of(&continue_chan);
 
-        do task::spawn_sched(task::ManualThreads(1u)) {
+        do task::spawn_sched(task::ManualThreads(1)) {
             impl_uv_tcp_server(bind_ip, port,
                                kill_server_msg,
                                server_resp_msg,
-                               ptr::addr_of(server_chan),
+                               ptr::addr_of(&server_chan),
                                continue_chan_ptr);
         };
 
@@ -1496,7 +1496,7 @@ mod test {
         do task::spawn_sched(task::ManualThreads(1u)) {
             impl_uv_tcp_request(request_ip, port,
                                kill_server_msg,
-                               ptr::addr_of(client_chan));
+                               ptr::addr_of(&client_chan));
         };
 
         let msg_from_client = core::comm::recv(server_port);
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 3e62d0b3ab7..67841158ce1 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -1094,10 +1094,10 @@ enum ty_ {
 // since we only care about this for normalizing them to "real" types.
 impl ty : cmp::Eq {
     pure fn eq(other: &ty) -> bool {
-        ptr::addr_of(self) == ptr::addr_of((*other))
+        ptr::addr_of(&self) == ptr::addr_of(&(*other))
     }
     pure fn ne(other: &ty) -> bool {
-        ptr::addr_of(self) != ptr::addr_of((*other))
+        ptr::addr_of(&self) != ptr::addr_of(&(*other))
     }
 }
 
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
index 619511f0454..ea493eab561 100644
--- a/src/libsyntax/ext/fmt.rs
+++ b/src/libsyntax/ext/fmt.rs
@@ -188,7 +188,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
             return make_conv_call(cx, arg.span, ~"float", cnv, arg);
           }
           TyPoly => return make_conv_call(cx, arg.span, ~"poly", cnv,
-                                          mk_addr_of(cx, sp, arg))
+                       mk_addr_of(cx, sp, arg))
         }
     }
     fn log_conv(c: Conv) {
diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs
index cec2972b2a7..9c10d228a23 100644
--- a/src/libsyntax/ext/pipes/pipec.rs
+++ b/src/libsyntax/ext/pipes/pipec.rs
@@ -71,10 +71,10 @@ impl message: gen_send {
 
                 body += ~"let b = pipe.reuse_buffer();\n";
                 body += fmt!("let %s = pipes::SendPacketBuffered(\
-                              ptr::p2::addr_of(&(b.buffer.data.%s)));\n",
+                              ptr::addr_of(&(b.buffer.data.%s)));\n",
                              sp, next.name);
                 body += fmt!("let %s = pipes::RecvPacketBuffered(\
-                              ptr::p2::addr_of(&(b.buffer.data.%s)));\n",
+                              ptr::addr_of(&(b.buffer.data.%s)));\n",
                              rp, next.name);
             }
             else {
@@ -351,7 +351,7 @@ impl protocol: gen_init {
                         fmt!("data.%s.set_buffer_(buffer)",
                              s.name))),
                 ext_cx.parse_expr(
-                    fmt!("ptr::p2::addr_of(&(data.%s))",
+                    fmt!("ptr::addr_of(&(data.%s))",
                          self.states[0].name))));
 
         #ast {{
diff --git a/src/rustc/middle/lang_items.rs b/src/rustc/middle/lang_items.rs
index ea22e3a7809..7cb2c9eb9cf 100644
--- a/src/rustc/middle/lang_items.rs
+++ b/src/rustc/middle/lang_items.rs
@@ -179,7 +179,7 @@ impl LanguageItemCollector {
     }
 
     fn collect_local_language_items() {
-        let this = unsafe { ptr::addr_of(self) };
+        let this = unsafe { ptr::addr_of(&self) };
         visit_crate(*self.crate, (), mk_simple_visitor(@{
             visit_item: |item| {
                 for item.attrs.each |attribute| {
diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs
index 90762c5b714..69b325b03a4 100644
--- a/src/rustc/middle/liveness.rs
+++ b/src/rustc/middle/liveness.rs
@@ -416,7 +416,7 @@ fn visit_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
     let fn_maps = @IrMaps(self.tcx, self.method_map,
                           self.last_use_map);
 
-    debug!("creating fn_maps: %x", ptr::addr_of(*fn_maps) as uint);
+    debug!("creating fn_maps: %x", ptr::addr_of(&(*fn_maps)) as uint);
 
     for decl.inputs.each |arg| {
         debug!("adding argument %d", arg.id);
diff --git a/src/rustc/middle/trans/build.rs b/src/rustc/middle/trans/build.rs
index 070132b4b18..69de8a2cca3 100644
--- a/src/rustc/middle/trans/build.rs
+++ b/src/rustc/middle/trans/build.rs
@@ -134,7 +134,7 @@ fn IndirectBr(cx: block, Addr: ValueRef, NumDests: uint) {
 // lot more efficient) than doing str::as_c_str("", ...) every time.
 fn noname() -> *libc::c_char unsafe {
     const cnull: uint = 0u;
-    return cast::reinterpret_cast(&ptr::addr_of(cnull));
+    return cast::reinterpret_cast(&ptr::addr_of(&cnull));
 }
 
 fn Invoke(cx: block, Fn: ValueRef, Args: ~[ValueRef],
@@ -629,8 +629,8 @@ fn Phi(cx: block, Ty: TypeRef, vals: ~[ValueRef], bbs: ~[BasicBlockRef])
 fn AddIncomingToPhi(phi: ValueRef, val: ValueRef, bb: BasicBlockRef) {
     if llvm::LLVMIsUndef(phi) == lib::llvm::True { return; }
     unsafe {
-        let valptr = cast::reinterpret_cast(&ptr::addr_of(val));
-        let bbptr = cast::reinterpret_cast(&ptr::addr_of(bb));
+        let valptr = cast::reinterpret_cast(&ptr::addr_of(&val));
+        let bbptr = cast::reinterpret_cast(&ptr::addr_of(&bb));
         llvm::LLVMAddIncoming(phi, valptr, bbptr, 1 as c_uint);
     }
 }
diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs
index 907146be4fd..d68bdb08221 100644
--- a/src/rustc/middle/trans/common.rs
+++ b/src/rustc/middle/trans/common.rs
@@ -645,7 +645,7 @@ impl block {
             fmt!("[block %d]", node_info.id)
           }
           None => {
-            fmt!("[block %x]", ptr::addr_of(*self) as uint)
+            fmt!("[block %x]", ptr::addr_of(&(*self)) as uint)
           }
         }
     }
diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs
index 41acc2ce070..368b69cafab 100644
--- a/src/rustc/middle/typeck/check.rs
+++ b/src/rustc/middle/typeck/check.rs
@@ -605,7 +605,7 @@ impl @fn_ctxt: region_scope {
 }
 
 impl @fn_ctxt {
-    fn tag() -> ~str { fmt!("%x", ptr::addr_of(*self) as uint) }
+    fn tag() -> ~str { fmt!("%x", ptr::addr_of(&(*self)) as uint) }
 
     fn expr_to_str(expr: @ast::expr) -> ~str {
         fmt!("expr(%?:%s)", expr.id,
diff --git a/src/test/auxiliary/test_comm.rs b/src/test/auxiliary/test_comm.rs
index b150b58c638..77f107fda09 100644
--- a/src/test/auxiliary/test_comm.rs
+++ b/src/test/auxiliary/test_comm.rs
@@ -34,7 +34,7 @@ struct port_ptr<T:Send> {
     debug!("in the port_ptr destructor");
        do task::unkillable {
         let yield = 0u;
-        let yieldp = ptr::addr_of(yield);
+        let yieldp = ptr::addr_of(&yield);
         rustrt::rust_port_begin_detach(self.po, yieldp);
         if yield != 0u {
             task::yield();
@@ -66,10 +66,10 @@ fn recv<T: Send>(p: port<T>) -> T { recv_((**p).po) }
 /// Receive on a raw port pointer
 fn recv_<T: Send>(p: *rust_port) -> T {
     let yield = 0u;
-    let yieldp = ptr::addr_of(yield);
+    let yieldp = ptr::addr_of(&yield);
     let mut res;
     res = rusti::init::<T>();
-    rustrt::port_recv(ptr::addr_of(res) as *uint, p, yieldp);
+    rustrt::port_recv(ptr::addr_of(&res) as *uint, p, yieldp);
 
     if yield != 0u {
         // Data isn't available yet, so res has not been initialized.
diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs
index 392f67d6714..0a55e7572db 100644
--- a/src/test/bench/msgsend-pipes-shared.rs
+++ b/src/test/bench/msgsend-pipes-shared.rs
@@ -19,7 +19,7 @@ use io::WriterUtil;
 use pipes::{Port, Chan, SharedChan};
 
 macro_rules! move_out (
-    { $x:expr } => { unsafe { let y <- *ptr::addr_of($x); y } }
+    { $x:expr } => { unsafe { let y <- *ptr::addr_of(&($x)); y } }
 )
 
 enum request {
diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs
index 6ba8b71d8c4..ab67a8c7cb1 100644
--- a/src/test/bench/msgsend-pipes.rs
+++ b/src/test/bench/msgsend-pipes.rs
@@ -15,7 +15,7 @@ use io::WriterUtil;
 use pipes::{Port, PortSet, Chan};
 
 macro_rules! move_out (
-    { $x:expr } => { unsafe { let y <- *ptr::addr_of($x); y } }
+    { $x:expr } => { unsafe { let y <- *ptr::addr_of(&($x)); y } }
 )
 
 enum request {
diff --git a/src/test/bench/msgsend-ring-pipes.rs b/src/test/bench/msgsend-ring-pipes.rs
index 3c888fd0c8d..119c2065d6b 100644
--- a/src/test/bench/msgsend-ring-pipes.rs
+++ b/src/test/bench/msgsend-ring-pipes.rs
@@ -24,7 +24,7 @@ proto! ring (
 fn macros() {
     #macro[
         [#move_out[x],
-         unsafe { let y <- *ptr::addr_of(x); y }]
+         unsafe { let y <- *ptr::addr_of(&x); y }]
     ];
 }
 
diff --git a/src/test/bench/pingpong.rs b/src/test/bench/pingpong.rs
index 570ec8c0b6b..70f98934e1b 100644
--- a/src/test/bench/pingpong.rs
+++ b/src/test/bench/pingpong.rs
@@ -33,7 +33,7 @@ proto! pingpong_unbounded (
 
 // This stuff should go in libcore::pipes
 macro_rules! move_it (
-    { $x:expr } => { let t <- *ptr::addr_of($x); t }
+    { $x:expr } => { let t <- *ptr::addr_of(&($x)); t }
 )
 
 macro_rules! follow (
diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs
index 3add41792f3..62612366524 100644
--- a/src/test/bench/task-perf-word-count-generic.rs
+++ b/src/test/bench/task-perf-word-count-generic.rs
@@ -32,7 +32,7 @@ use cmp::Eq;
 use to_bytes::IterBytes;
 
 macro_rules! move_out (
-    { $x:expr } => { unsafe { let y <- *ptr::addr_of($x); y } }
+    { $x:expr } => { unsafe { let y <- *ptr::addr_of(&($x)); y } }
 )
 
 trait word_reader {
diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs
index 0cc828132c9..cfcb158a990 100644
--- a/src/test/run-pass/binops.rs
+++ b/src/test/run-pass/binops.rs
@@ -103,8 +103,8 @@ fn test_class() {
   
   unsafe {
   error!("q = %x, r = %x",
-         (cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(q))),
-         (cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(r))));
+         (cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(&q))),
+         (cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(&r))));
   }
   assert(q == r);
   r.y = 17;
diff --git a/src/test/run-pass/borrowck-borrow-from-expr-block.rs b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
index ec31225f46b..d180fc4b8ae 100644
--- a/src/test/run-pass/borrowck-borrow-from-expr-block.rs
+++ b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
@@ -7,7 +7,7 @@ fn borrow(x: &int, f: fn(x: &int)) {
 fn test1(x: @~int) {
     // Right now, at least, this induces a copy of the unique pointer:
     do borrow({*x}) |p| {
-        let x_a = ptr::addr_of(**x);
+        let x_a = ptr::addr_of(&(**x));
         assert (x_a as uint) != to_uint(p);
         assert unsafe{*x_a} == *p;
     }
diff --git a/src/test/run-pass/borrowck-preserve-box-in-discr.rs b/src/test/run-pass/borrowck-preserve-box-in-discr.rs
index 373830d77af..5ed78488b35 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-discr.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-discr.rs
@@ -5,13 +5,13 @@ fn main() {
     match *x {
       {f: b_x} => {
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) == ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x));
 
         x = @{f: ~4};
 
-        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint);
+        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) != ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x));
       }
     }
 }
\ No newline at end of file
diff --git a/src/test/run-pass/borrowck-preserve-box-in-field.rs b/src/test/run-pass/borrowck-preserve-box-in-field.rs
index 7ab2dc4b99d..d7d3aa68faf 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-field.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-field.rs
@@ -11,11 +11,11 @@ fn main() {
     let mut x = @{f: ~3};
     do borrow(x.f) |b_x| {
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) == ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x));
         x = @{f: ~4};
 
-        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint);
+        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) != ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x));
     }
 }
\ No newline at end of file
diff --git a/src/test/run-pass/borrowck-preserve-box-in-pat.rs b/src/test/run-pass/borrowck-preserve-box-in-pat.rs
index 599879f82f1..f0944ea3544 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-pat.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-pat.rs
@@ -5,13 +5,13 @@ fn main() {
     match x {
       @@{f: b_x} => {
         assert *b_x == 3;
-        assert ptr::addr_of(x.f) == ptr::addr_of(b_x);
+        assert ptr::addr_of(&(x.f)) == ptr::addr_of(&(b_x));
 
         *x = @{f: ~4};
 
-        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint);
+        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) != ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x));
       }
     }
 }
diff --git a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
index bd43ad65cff..b0bb4d8d40c 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
@@ -11,11 +11,11 @@ fn main() {
     let mut x = ~mut @{f: ~3};
     do borrow(x.f) |b_x| {
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) == ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x));
         *x = @{f: ~4};
 
-        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint);
+        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) != ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x));
     }
 }
\ No newline at end of file
diff --git a/src/test/run-pass/borrowck-preserve-box.rs b/src/test/run-pass/borrowck-preserve-box.rs
index 8d59975204b..88f4b459d36 100644
--- a/src/test/run-pass/borrowck-preserve-box.rs
+++ b/src/test/run-pass/borrowck-preserve-box.rs
@@ -11,11 +11,11 @@ fn main() {
     let mut x = @3;
     do borrow(x) |b_x| {
         assert *b_x == 3;
-        assert ptr::addr_of(*x) == ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x)) == ptr::addr_of(&(*b_x));
         x = @22;
 
-        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint);
+        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
         assert *b_x == 3;
-        assert ptr::addr_of(*x) != ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x)) != ptr::addr_of(&(*b_x));
     }
 }
\ No newline at end of file
diff --git a/src/test/run-pass/borrowck-preserve-expl-deref.rs b/src/test/run-pass/borrowck-preserve-expl-deref.rs
index e126ecc4340..ba525eafc51 100644
--- a/src/test/run-pass/borrowck-preserve-expl-deref.rs
+++ b/src/test/run-pass/borrowck-preserve-expl-deref.rs
@@ -11,11 +11,11 @@ fn main() {
     let mut x = @{f: ~3};
     do borrow((*x).f) |b_x| {
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) == ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x));
         x = @{f: ~4};
 
-        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint);
+        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) != ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x));
     }
 }
diff --git a/src/test/run-pass/cap-clause-move.rs b/src/test/run-pass/cap-clause-move.rs
index 260c1d45b76..0561af6ca6d 100644
--- a/src/test/run-pass/cap-clause-move.rs
+++ b/src/test/run-pass/cap-clause-move.rs
@@ -1,29 +1,29 @@
 fn main() {
     let x = ~1;
-    let y = ptr::addr_of(*x) as uint;
-    let lam_copy = fn@(copy x) -> uint { ptr::addr_of(*x) as uint };
-    let lam_move = fn@(move x) -> uint { ptr::addr_of(*x) as uint };
+    let y = ptr::addr_of(&(*x)) as uint;
+    let lam_copy = fn@(copy x) -> uint { ptr::addr_of(&(*x)) as uint };
+    let lam_move = fn@(move x) -> uint { ptr::addr_of(&(*x)) as uint };
     assert lam_copy() != y;
     assert lam_move() == y;
 
     let x = ~2;
-    let y = ptr::addr_of(*x) as uint;
-    let lam_copy: fn@() -> uint = |copy x| ptr::addr_of(*x) as uint;
-    let lam_move: fn@() -> uint = |move x| ptr::addr_of(*x) as uint;
+    let y = ptr::addr_of(&(*x)) as uint;
+    let lam_copy: fn@() -> uint = |copy x| ptr::addr_of(&(*x)) as uint;
+    let lam_move: fn@() -> uint = |move x| ptr::addr_of(&(*x)) as uint;
     assert lam_copy() != y;
     assert lam_move() == y;
 
     let x = ~3;
-    let y = ptr::addr_of(*x) as uint;
-    let snd_copy = fn~(copy x) -> uint { ptr::addr_of(*x) as uint };
-    let snd_move = fn~(move x) -> uint { ptr::addr_of(*x) as uint };
+    let y = ptr::addr_of(&(*x)) as uint;
+    let snd_copy = fn~(copy x) -> uint { ptr::addr_of(&(*x)) as uint };
+    let snd_move = fn~(move x) -> uint { ptr::addr_of(&(*x)) as uint };
     assert snd_copy() != y;
     assert snd_move() == y;
 
     let x = ~4;
-    let y = ptr::addr_of(*x) as uint;
-    let lam_copy: fn~() -> uint = |copy x| ptr::addr_of(*x) as uint;
-    let lam_move: fn~() -> uint = |move x| ptr::addr_of(*x) as uint;
+    let y = ptr::addr_of(&(*x)) as uint;
+    let lam_copy: fn~() -> uint = |copy x| ptr::addr_of(&(*x)) as uint;
+    let lam_move: fn~() -> uint = |move x| ptr::addr_of(&(*x)) as uint;
     assert lam_copy() != y;
     assert lam_move() == y;
 }
diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs
index 6da4349ba5f..b887b86cf2f 100644
--- a/src/test/run-pass/issue-2718.rs
+++ b/src/test/run-pass/issue-2718.rs
@@ -201,7 +201,7 @@ mod pingpong {
 
     fn liberate_ping(-p: ping) -> pipes::send_packet<pong> unsafe {
         let addr : *pipes::send_packet<pong> = match p {
-          ping(x) => { cast::transmute(ptr::addr_of(x)) }
+          ping(x) => { cast::transmute(ptr::addr_of(&x)) }
         };
         let liberated_value <- *addr;
         cast::forget(p);
@@ -210,7 +210,7 @@ mod pingpong {
 
     fn liberate_pong(-p: pong) -> pipes::send_packet<ping> unsafe {
         let addr : *pipes::send_packet<ping> = match p {
-          pong(x) => { cast::transmute(ptr::addr_of(x)) }
+          pong(x) => { cast::transmute(ptr::addr_of(&x)) }
         };
         let liberated_value <- *addr;
         cast::forget(p);
diff --git a/src/test/run-pass/last-use-corner-cases.rs b/src/test/run-pass/last-use-corner-cases.rs
index 2d8e3aa7b8c..a3088a2c125 100644
--- a/src/test/run-pass/last-use-corner-cases.rs
+++ b/src/test/run-pass/last-use-corner-cases.rs
@@ -4,14 +4,14 @@
 fn main() {
     // Make sure closing over can be a last use
     let q = ~10;
-    let addr = ptr::addr_of(*q);
-    let f = fn@() -> *int { ptr::addr_of(*q) };
+    let addr = ptr::addr_of(&(*q));
+    let f = fn@() -> *int { ptr::addr_of(&(*q)) };
     assert addr == f();
 
     // But only when it really is the last use
     let q = ~20;
-    let f = fn@() -> *int { ptr::addr_of(*q) };
-    assert ptr::addr_of(*q) != f();
+    let f = fn@() -> *int { ptr::addr_of(&(*q)) };
+    assert ptr::addr_of(&(*q)) != f();
 
     // Ensure function arguments and box arguments interact sanely.
     fn call_me(x: fn() -> int, y: ~int) { assert x() == *y; }
diff --git a/src/test/run-pass/pipe-bank-proto.rs b/src/test/run-pass/pipe-bank-proto.rs
index 8ac76293284..899b74b2866 100644
--- a/src/test/run-pass/pipe-bank-proto.rs
+++ b/src/test/run-pass/pipe-bank-proto.rs
@@ -33,7 +33,7 @@ proto! bank (
 )
 
 macro_rules! move_it (
-    { $x:expr } => { unsafe { let y <- *ptr::addr_of($x); y } }
+    { $x:expr } => { unsafe { let y <- *ptr::addr_of(&($x)); y } }
 )
 
 fn switch<T: Send, U>(+endp: pipes::RecvPacket<T>,
diff --git a/src/test/run-pass/pipe-pingpong-bounded.rs b/src/test/run-pass/pipe-pingpong-bounded.rs
index f9f091131ab..9bfbbe338e7 100644
--- a/src/test/run-pass/pipe-pingpong-bounded.rs
+++ b/src/test/run-pass/pipe-pingpong-bounded.rs
@@ -28,7 +28,7 @@ mod pingpong {
         do pipes::entangle_buffer(buffer) |buffer, data| {
             data.ping.set_buffer_(buffer);
             data.pong.set_buffer_(buffer);
-            ptr::addr_of(data.ping)
+            ptr::addr_of(&(data.ping))
         }
     }
     enum ping = server::pong;
@@ -38,8 +38,8 @@ mod pingpong {
         fn ping(+pipe: ping) -> pong {
             {
                 let b = pipe.reuse_buffer();
-                let s = SendPacketBuffered(ptr::addr_of(b.buffer.data.pong));
-                let c = RecvPacketBuffered(ptr::addr_of(b.buffer.data.pong));
+                let s = SendPacketBuffered(ptr::addr_of(&(b.buffer.data.pong)));
+                let c = RecvPacketBuffered(ptr::addr_of(&(b.buffer.data.pong)));
                 let message = pingpong::ping(s);
                 pipes::send(pipe, message);
                 c
@@ -57,8 +57,8 @@ mod pingpong {
         fn pong(+pipe: pong) -> ping {
             {
                 let b = pipe.reuse_buffer();
-                let s = SendPacketBuffered(ptr::addr_of(b.buffer.data.ping));
-                let c = RecvPacketBuffered(ptr::addr_of(b.buffer.data.ping));
+                let s = SendPacketBuffered(ptr::addr_of(&(b.buffer.data.ping)));
+                let c = RecvPacketBuffered(ptr::addr_of(&(b.buffer.data.ping)));
                 let message = pingpong::pong(s);
                 pipes::send(pipe, message);
                 c
diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs
index affd0ef6162..e27aaa618ac 100644
--- a/src/test/run-pass/reflect-visit-data.rs
+++ b/src/test/run-pass/reflect-visit-data.rs
@@ -612,7 +612,7 @@ fn get_tydesc_for<T>(&&_t: T) -> *TyDesc {
 
 fn main() {
     let r = (1,2,3,true,false,{x:5,y:4,z:3});
-    let p = ptr::addr_of(r) as *c_void;
+    let p = ptr::addr_of(&r) as *c_void;
     let u = my_visitor(@{mut ptr1: p,
                          mut ptr2: p,
                          mut vals: ~[]});
diff --git a/src/test/run-pass/resource-cycle.rs b/src/test/run-pass/resource-cycle.rs
index 9e0a2c35e2f..26e19ee1b0c 100644
--- a/src/test/run-pass/resource-cycle.rs
+++ b/src/test/run-pass/resource-cycle.rs
@@ -4,8 +4,8 @@ struct r {
   v: *int,
   drop unsafe {
     debug!("r's dtor: self = %x, self.v = %x, self.v's value = %x",
-           cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(self)),
-           cast::reinterpret_cast::<**int, uint>(&ptr::addr_of(self.v)),
+           cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(&self)),
+           cast::reinterpret_cast::<**int, uint>(&ptr::addr_of(&(self.v))),
            cast::reinterpret_cast::<*int, uint>(&self.v));
     let v2: ~int = cast::reinterpret_cast(&self.v); }
 }
@@ -34,27 +34,27 @@ fn main() unsafe {
           r: {
           let rs = r(i1p);
           debug!("r = %x",
-                 cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(rs)));
+                 cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(&rs)));
           rs }
     });
     
     debug!("x1 = %x, x1.r = %x",
         cast::reinterpret_cast::<@t, uint>(&x1),
-        cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(x1.r)));
+        cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(&(x1.r))));
 
     let x2 = @t({
         mut next: None,
           r: {
           let rs = r(i2p);
           debug!("r2 = %x",
-                 cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(rs)));
+                 cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(&rs)));
           rs
             }
     });
     
     debug!("x2 = %x, x2.r = %x",
            cast::reinterpret_cast::<@t, uint>(&x2),
-           cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(x2.r)));
+           cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(&(x2.r))));
 
     x1.next = Some(x2);
     x2.next = Some(x1);
diff --git a/src/test/run-pass/rt-sched-1.rs b/src/test/run-pass/rt-sched-1.rs
index 9604dff64d7..15207b668fe 100644
--- a/src/test/run-pass/rt-sched-1.rs
+++ b/src/test/run-pass/rt-sched-1.rs
@@ -33,7 +33,7 @@ fn main() unsafe {
         assert child_sched_id == new_sched_id;
         comm::send(ch, ());
     };
-    let fptr = cast::reinterpret_cast(&ptr::addr_of(f));
+    let fptr = cast::reinterpret_cast(&ptr::addr_of(&f));
     rustrt::start_task(new_task_id, fptr);
     cast::forget(f);
     comm::recv(po);
diff --git a/src/test/run-pass/select-macro.rs b/src/test/run-pass/select-macro.rs
index 15dd56e46c5..78bddffcc1d 100644
--- a/src/test/run-pass/select-macro.rs
+++ b/src/test/run-pass/select-macro.rs
@@ -28,7 +28,7 @@ macro_rules! select_if (
             match move pipes::try_recv($port) {
               $(Some($message($($(ref $x,)+)* ref next)) => {
                 // FIXME (#2329) we really want move out of enum here.
-                let $next = unsafe { let x <- *ptr::addr_of(*next); x };
+                let $next = unsafe { let x <- *ptr::addr_of(&(*next)); x };
                 $e
               })+
               _ => fail
diff --git a/src/test/run-pass/stable-addr-of.rs b/src/test/run-pass/stable-addr-of.rs
index 060994ed48f..dceb80331b4 100644
--- a/src/test/run-pass/stable-addr-of.rs
+++ b/src/test/run-pass/stable-addr-of.rs
@@ -2,5 +2,5 @@
 
 fn main() {
     let foo = 1;
-    assert ptr::addr_of(foo) == ptr::addr_of(foo);
+    assert ptr::addr_of(&foo) == ptr::addr_of(&foo);
 }
diff --git a/src/test/run-pass/task-killjoin-rsrc.rs b/src/test/run-pass/task-killjoin-rsrc.rs
index 98d5193c86d..405ba82b790 100644
--- a/src/test/run-pass/task-killjoin-rsrc.rs
+++ b/src/test/run-pass/task-killjoin-rsrc.rs
@@ -10,7 +10,7 @@ struct notify {
     drop {
         error!("notify: task=%? v=%x unwinding=%b b=%b",
                task::get_task(),
-               ptr::addr_of(*(self.v)) as uint,
+               ptr::addr_of(&(*(self.v))) as uint,
                task::failing(),
                *(self.v));
         let b = *(self.v);
@@ -30,7 +30,7 @@ fn joinable(+f: fn~()) -> comm::Port<bool> {
         let b = @mut false;
         error!("wrapper: task=%? allocated v=%x",
                task::get_task(),
-               ptr::addr_of(*b) as uint);
+               ptr::addr_of(&(*b)) as uint);
         let _r = notify(c, b);
         f();
         *b = true;
diff --git a/src/test/run-pass/task-spawn-move-and-copy.rs b/src/test/run-pass/task-spawn-move-and-copy.rs
index 9cedfea6130..7316a927751 100644
--- a/src/test/run-pass/task-spawn-move-and-copy.rs
+++ b/src/test/run-pass/task-spawn-move-and-copy.rs
@@ -3,16 +3,16 @@ fn main() {
     let ch = comm::Chan(p);
 
     let x = ~1;
-    let x_in_parent = ptr::addr_of(*x) as uint;
+    let x_in_parent = ptr::addr_of(&(*x)) as uint;
 
     let y = ~2;
-    let y_in_parent = ptr::addr_of(*y) as uint;
+    let y_in_parent = ptr::addr_of(&(*y)) as uint;
 
     task::spawn(fn~(copy ch, copy y, move x) {
-        let x_in_child = ptr::addr_of(*x) as uint;
+        let x_in_child = ptr::addr_of(&(*x)) as uint;
         comm::send(ch, x_in_child);
 
-        let y_in_child = ptr::addr_of(*y) as uint;
+        let y_in_child = ptr::addr_of(&(*y)) as uint;
         comm::send(ch, y_in_child);
     });
     // Ensure last-use analysis doesn't move y to child.
diff --git a/src/test/run-pass/uniq-cc-generic.rs b/src/test/run-pass/uniq-cc-generic.rs
index 18c3db591f6..592d49cc2a8 100644
--- a/src/test/run-pass/uniq-cc-generic.rs
+++ b/src/test/run-pass/uniq-cc-generic.rs
@@ -9,7 +9,7 @@ type pointy = {
 };
 
 fn make_uniq_closure<A:Send Copy>(a: A) -> fn~() -> uint {
-    fn~() -> uint { ptr::addr_of(a) as uint }
+    fn~() -> uint { ptr::addr_of(&a) as uint }
 }
 
 fn empty_pointy() -> @pointy {
-- 
cgit 1.4.1-3-g733a5


From 24fbf88230f37d63bb236569d6a9600ad9560f6f Mon Sep 17 00:00:00 2001
From: Tim Chevalier <chevalier@alum.wellesley.edu>
Date: Mon, 1 Oct 2012 16:43:45 -0700
Subject: In lint, don't complain about infer mode if legacy modes aren't
 enabled

---
 src/rustc/middle/lint.rs | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs
index 266ee056e2c..bba2430d95e 100644
--- a/src/rustc/middle/lint.rs
+++ b/src/rustc/middle/lint.rs
@@ -683,7 +683,8 @@ fn check_fn_deprecated_modes(tcx: ty::ctxt, fn_ty: ty::t, decl: ast::fn_decl,
                        mode_to_str(arg_ast.mode));
                 match arg_ast.mode {
                     ast::expl(ast::by_copy) => {
-                        /* always allow by-copy */
+                        // This should warn, but we can't yet
+                        // since it's still used. -- tjc
                     }
 
                     ast::expl(_) => {
@@ -694,14 +695,16 @@ fn check_fn_deprecated_modes(tcx: ty::ctxt, fn_ty: ty::t, decl: ast::fn_decl,
                     }
 
                     ast::infer(_) => {
-                        let kind = ty::type_kind(tcx, arg_ty.ty);
-                        if !ty::kind_is_safe_for_default_mode(kind) {
-                            tcx.sess.span_lint(
-                                deprecated_mode, id, id,
-                                span,
-                                fmt!("argument %d uses the default mode \
-                                      but shouldn't",
-                                     counter));
+                        if tcx.legacy_modes {
+                            let kind = ty::type_kind(tcx, arg_ty.ty);
+                            if !ty::kind_is_safe_for_default_mode(kind) {
+                                tcx.sess.span_lint(
+                                    deprecated_mode, id, id,
+                                    span,
+                                    fmt!("argument %d uses the default mode \
+                                          but shouldn't",
+                                         counter));
+                            }
                         }
                     }
                 }
-- 
cgit 1.4.1-3-g733a5


From 8fc3088b2aba397c0f561ce978b2d4a47f8a9eab Mon Sep 17 00:00:00 2001
From: Erick Tryzelaar <erick.tryzelaar@gmail.com>
Date: Wed, 26 Sep 2012 21:35:42 -0700
Subject: rename vec::raw::form_slice to buf_as_slice

This matches the str::raw function.
---
 src/libcore/str.rs           | 2 +-
 src/libcore/uint-template.rs | 3 +--
 src/libcore/vec.rs           | 5 +++--
 src/rustc/metadata/loader.rs | 4 ++--
 4 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index 227635944dd..e8a88f3bc1b 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -349,7 +349,7 @@ pub pure fn to_bytes(s: &str) -> ~[u8] unsafe {
 #[inline(always)]
 pub pure fn byte_slice<T>(s: &str, f: fn(v: &[u8]) -> T) -> T {
     do as_buf(s) |p,n| {
-        unsafe { vec::raw::form_slice(p, n-1u, f) }
+        unsafe { vec::raw::buf_as_slice(p, n-1u, f) }
     }
 }
 
diff --git a/src/libcore/uint-template.rs b/src/libcore/uint-template.rs
index eb58d17c5f1..7d0421c0730 100644
--- a/src/libcore/uint-template.rs
+++ b/src/libcore/uint-template.rs
@@ -226,8 +226,7 @@ pub pure fn to_str_bytes<U>(neg: bool, num: T, radix: uint,
                 *ptr::mut_offset(mp, i) = '-' as u8;
             }
 
-            vec::raw::form_slice(ptr::offset(p, i),
-                                 len - i, f)
+            vec::raw::buf_as_slice(ptr::offset(p, i), len - i, f)
         }
     }
 }
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index 3fdf97cf350..ce82215a87c 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -1741,8 +1741,9 @@ pub mod raw {
      * not bytes).
      */
     #[inline(always)]
-    pub unsafe fn form_slice<T,U>(p: *T, len: uint,
-                                  f: fn(v: &[T]) -> U) -> U {
+    pub unsafe fn buf_as_slice<T,U>(p: *T,
+                                    len: uint,
+                                    f: fn(v: &[T]) -> U) -> U {
         let pair = (p, len * sys::size_of::<T>());
         let v : *(&blk/[T]) =
             ::cast::reinterpret_cast(&addr_of(&pair));
diff --git a/src/rustc/metadata/loader.rs b/src/rustc/metadata/loader.rs
index 2ccaccf17a5..0a8354be71f 100644
--- a/src/rustc/metadata/loader.rs
+++ b/src/rustc/metadata/loader.rs
@@ -193,7 +193,7 @@ fn get_metadata_section(os: os,
                        vlen);
                 let minsz = uint::min(vlen, csz);
                 let mut version_ok = false;
-                do vec::raw::form_slice(cvbuf, minsz) |buf0| {
+                do vec::raw::buf_as_slice(cvbuf, minsz) |buf0| {
                     version_ok = (buf0 ==
                                   encoder::metadata_encoding_version);
                 }
@@ -202,7 +202,7 @@ fn get_metadata_section(os: os,
                 let cvbuf1 = ptr::offset(cvbuf, vlen);
                 debug!("inflating %u bytes of compressed metadata",
                        csz - vlen);
-                do vec::raw::form_slice(cvbuf1, csz-vlen) |bytes| {
+                do vec::raw::buf_as_slice(cvbuf1, csz-vlen) |bytes| {
                     let inflated = flate::inflate_bytes(bytes);
                     found = move Some(@(move inflated));
                 }
-- 
cgit 1.4.1-3-g733a5


From 6365adaa61269f6e131fd7296a5970fc2a5c4a64 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Tue, 2 Oct 2012 09:36:50 -0700
Subject: Don't warn about non-camel-case types by default

---
 src/rustc/middle/lint.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/rustc')

diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs
index bba2430d95e..ebdc66156e3 100644
--- a/src/rustc/middle/lint.rs
+++ b/src/rustc/middle/lint.rs
@@ -159,7 +159,7 @@ fn get_lint_dict() -> lint_dict {
         (~"non_camel_case_types",
          @{lint: non_camel_case_types,
            desc: ~"types, variants and traits should have camel case names",
-           default: warn}),
+           default: allow}),
 
         (~"managed_heap_memory",
          @{lint: managed_heap_memory,
-- 
cgit 1.4.1-3-g733a5


From 92841793114d7e60e3227d9087dc8741e7592789 Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Tue, 2 Oct 2012 12:19:04 -0700
Subject: libstd: Switch off legacy modes in both core and std.

---
 src/cargo/cargo.rs                                 |  4 +-
 src/fuzzer/fuzzer.rs                               |  2 +-
 src/libcore/cast.rs                                |  2 +-
 src/libcore/comm.rs                                |  4 +-
 src/libcore/core.rc                                |  1 -
 src/libcore/os.rs                                  |  4 +-
 src/libcore/ptr.rs                                 |  2 +-
 src/libcore/rand.rs                                |  4 +-
 src/libcore/stackwalk.rs                           |  7 ++-
 src/libstd/ebml.rs                                 |  8 +--
 src/libstd/serialization.rs                        | 72 +++++++++++-----------
 src/libstd/std.rc                                  |  1 -
 src/libsyntax/ast.rs                               | 24 ++++----
 src/libsyntax/ast_util.rs                          |  2 +-
 src/libsyntax/parse/obsolete.rs                    |  2 +-
 src/rt/rust_builtin.cpp                            | 10 +++
 src/rt/rustrt.def.in                               |  2 +
 src/rustc/middle/borrowck.rs                       |  2 +-
 src/rustc/middle/trans/common.rs                   |  4 +-
 src/rustc/middle/trans/datum.rs                    |  2 +-
 src/rustc/middle/ty.rs                             | 38 ++++++------
 .../middle/typeck/infer/region_var_bindings.rs     |  4 +-
 src/test/bench/graph500-bfs.rs                     |  2 +-
 src/test/bench/shootout-mandelbrot.rs              |  2 +-
 24 files changed, 108 insertions(+), 97 deletions(-)

(limited to 'src/rustc')

diff --git a/src/cargo/cargo.rs b/src/cargo/cargo.rs
index 6136652c873..81c0ce9a5b7 100644
--- a/src/cargo/cargo.rs
+++ b/src/cargo/cargo.rs
@@ -144,7 +144,7 @@ fn is_uuid(id: ~str) -> bool {
     if vec::len(parts) == 5u {
         let mut correct = 0u;
         for vec::eachi(parts) |i, part| {
-            fn is_hex_digit(ch: char) -> bool {
+            fn is_hex_digit(+ch: char) -> bool {
                 ('0' <= ch && ch <= '9') ||
                 ('a' <= ch && ch <= 'f') ||
                 ('A' <= ch && ch <= 'F')
@@ -402,7 +402,7 @@ fn need_dir(s: &Path) {
 }
 
 fn valid_pkg_name(s: &str) -> bool {
-    fn is_valid_digit(c: char) -> bool {
+    fn is_valid_digit(+c: char) -> bool {
         ('0' <= c && c <= '9') ||
         ('a' <= c && c <= 'z') ||
         ('A' <= c && c <= 'Z') ||
diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs
index ace96c389ef..cd312362d6a 100644
--- a/src/fuzzer/fuzzer.rs
+++ b/src/fuzzer/fuzzer.rs
@@ -221,7 +221,7 @@ fn under(n: uint, it: fn(uint)) {
     while i < n { it(i); i += 1u; }
 }
 
-fn as_str(f: fn@(io::Writer)) -> ~str {
+fn as_str(f: fn@(+x: io::Writer)) -> ~str {
     io::with_str_writer(f)
 }
 
diff --git a/src/libcore/cast.rs b/src/libcore/cast.rs
index 714c85c75c3..21f5861b89e 100644
--- a/src/libcore/cast.rs
+++ b/src/libcore/cast.rs
@@ -3,7 +3,7 @@
 #[abi = "rust-intrinsic"]
 extern mod rusti {
     fn forget<T>(-x: T);
-    fn reinterpret_cast<T, U>(e: T) -> U;
+    fn reinterpret_cast<T, U>(&&e: T) -> U;
 }
 
 /// Casts the value at `src` to U. The two types must have the same length.
diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs
index 81b648d9840..ff9f9498a98 100644
--- a/src/libcore/comm.rs
+++ b/src/libcore/comm.rs
@@ -33,7 +33,7 @@ will once again be the preferred module for intertask communication.
 */
 
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+#[warn(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
 use either::Either;
@@ -166,7 +166,7 @@ fn as_raw_port<T: Send, U>(ch: comm::Chan<T>, f: fn(*rust_port) -> U) -> U {
  * Constructs a channel. The channel is bound to the port used to
  * construct it.
  */
-pub fn Chan<T: Send>(p: Port<T>) -> Chan<T> {
+pub fn Chan<T: Send>(&&p: Port<T>) -> Chan<T> {
     Chan_(rustrt::get_port_id((**p).po))
 }
 
diff --git a/src/libcore/core.rc b/src/libcore/core.rc
index c781a26185a..6cada58fa02 100644
--- a/src/libcore/core.rc
+++ b/src/libcore/core.rc
@@ -36,7 +36,6 @@ Implicitly, all crates behave as if they included the following prologue:
 // Don't link to core. We are core.
 #[no_core];
 
-#[legacy_modes];
 #[legacy_exports];
 
 #[warn(deprecated_mode)];
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
index 1b53a163ad5..1cf4fbab6c9 100644
--- a/src/libcore/os.rs
+++ b/src/libcore/os.rs
@@ -35,7 +35,7 @@ extern mod rustrt {
     fn rust_getcwd() -> ~str;
     fn rust_path_is_dir(path: *libc::c_char) -> c_int;
     fn rust_path_exists(path: *libc::c_char) -> c_int;
-    fn rust_list_files(path: ~str) -> ~[~str];
+    fn rust_list_files2(&&path: ~str) -> ~[~str];
     fn rust_process_wait(handle: c_int) -> c_int;
     fn last_os_error() -> ~str;
     fn rust_set_exit_status(code: libc::intptr_t);
@@ -582,7 +582,7 @@ pub fn list_dir(p: &Path) -> ~[~str] {
     #[cfg(windows)]
     fn star(p: &Path) -> Path { p.push("*") }
 
-    do rustrt::rust_list_files(star(p).to_str()).filter |filename| {
+    do rustrt::rust_list_files2(star(p).to_str()).filter |filename| {
         *filename != ~"." && *filename != ~".."
     }
 }
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index 550b0121e45..fad7eddd2d8 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -21,7 +21,7 @@ extern mod libc_ {
 
 #[abi = "rust-intrinsic"]
 extern mod rusti {
-    fn addr_of<T>(val: T) -> *T;
+    fn addr_of<T>(&&val: T) -> *T;
 }
 
 /// Get an unsafe pointer to a value
diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs
index 501afc0c4bc..f6b7dfa568c 100644
--- a/src/libcore/rand.rs
+++ b/src/libcore/rand.rs
@@ -11,7 +11,7 @@ enum rctx {}
 extern mod rustrt {
     fn rand_seed() -> ~[u8];
     fn rand_new() -> *rctx;
-    fn rand_new_seeded(seed: ~[u8]) -> *rctx;
+    fn rand_new_seeded2(&&seed: ~[u8]) -> *rctx;
     fn rand_next(c: *rctx) -> u32;
     fn rand_free(c: *rctx);
 }
@@ -276,7 +276,7 @@ pub fn Rng() -> Rng {
  * length.
  */
 pub fn seeded_rng(seed: &~[u8]) -> Rng {
-    @RandRes(rustrt::rand_new_seeded(*seed)) as Rng
+    @RandRes(rustrt::rand_new_seeded2(*seed)) as Rng
 }
 
 type XorShiftState = {
diff --git a/src/libcore/stackwalk.rs b/src/libcore/stackwalk.rs
index 4cc91b8b425..d0f8de136e2 100644
--- a/src/libcore/stackwalk.rs
+++ b/src/libcore/stackwalk.rs
@@ -1,7 +1,8 @@
 #[doc(hidden)]; // FIXME #3538
 
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+// XXX: Can't do this because frame_address needs a deprecated mode.
+//#[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
 use cast::reinterpret_cast;
@@ -74,7 +75,7 @@ fn breakpoint() {
     rustrt::rust_dbg_breakpoint()
 }
 
-fn frame_address(f: fn(*u8)) {
+fn frame_address(f: fn(++x: *u8)) {
     rusti::frame_address(f)
 }
 
@@ -86,5 +87,5 @@ extern mod rustrt {
 #[abi = "rust-intrinsic"]
 extern mod rusti {
     #[legacy_exports];
-    fn frame_address(f: fn(*u8));
+    fn frame_address(f: fn(++x: *u8));
 }
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index b88142e9502..7c5b7929f84 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -588,11 +588,11 @@ impl EbmlDeserializer: serialization::Deserializer {
 
 #[test]
 fn test_option_int() {
-    fn serialize_1<S: serialization::Serializer>(s: S, v: int) {
+    fn serialize_1<S: serialization::Serializer>(&&s: S, v: int) {
         s.emit_i64(v as i64);
     }
 
-    fn serialize_0<S: serialization::Serializer>(s: S, v: Option<int>) {
+    fn serialize_0<S: serialization::Serializer>(&&s: S, v: Option<int>) {
         do s.emit_enum(~"core::option::t") {
             match v {
               None => s.emit_enum_variant(
@@ -606,11 +606,11 @@ fn test_option_int() {
         }
     }
 
-    fn deserialize_1<S: serialization::Deserializer>(s: S) -> int {
+    fn deserialize_1<S: serialization::Deserializer>(&&s: S) -> int {
         s.read_i64() as int
     }
 
-    fn deserialize_0<S: serialization::Deserializer>(s: S) -> Option<int> {
+    fn deserialize_0<S: serialization::Deserializer>(&&s: S) -> Option<int> {
         do s.read_enum(~"core::option::t") {
             do s.read_enum_variant |i| {
                 match i {
diff --git a/src/libstd/serialization.rs b/src/libstd/serialization.rs
index 7cf7779f13d..e9067bc6404 100644
--- a/src/libstd/serialization.rs
+++ b/src/libstd/serialization.rs
@@ -81,7 +81,7 @@ trait Deserializer {
 //
 // In some cases, these should eventually be coded as traits.
 
-fn emit_from_vec<S: Serializer, T>(s: S, v: ~[T], f: fn(T)) {
+fn emit_from_vec<S: Serializer, T>(&&s: S, &&v: ~[T], f: fn(&&x: T)) {
     do s.emit_vec(vec::len(v)) {
         for vec::eachi(v) |i,e| {
             do s.emit_vec_elt(i) {
@@ -91,7 +91,7 @@ fn emit_from_vec<S: Serializer, T>(s: S, v: ~[T], f: fn(T)) {
     }
 }
 
-fn read_to_vec<D: Deserializer, T: Copy>(d: D, f: fn() -> T) -> ~[T] {
+fn read_to_vec<D: Deserializer, T: Copy>(&&d: D, f: fn() -> T) -> ~[T] {
     do d.read_vec |len| {
         do vec::from_fn(len) |i| {
             d.read_vec_elt(i, || f())
@@ -100,11 +100,11 @@ fn read_to_vec<D: Deserializer, T: Copy>(d: D, f: fn() -> T) -> ~[T] {
 }
 
 trait SerializerHelpers {
-    fn emit_from_vec<T>(v: ~[T], f: fn(T));
+    fn emit_from_vec<T>(&&v: ~[T], f: fn(&&x: T));
 }
 
 impl<S: Serializer> S: SerializerHelpers {
-    fn emit_from_vec<T>(v: ~[T], f: fn(T)) {
+    fn emit_from_vec<T>(&&v: ~[T], f: fn(&&x: T)) {
         emit_from_vec(self, v, f)
     }
 }
@@ -119,127 +119,127 @@ impl<D: Deserializer> D: DeserializerHelpers {
     }
 }
 
-fn serialize_uint<S: Serializer>(s: S, v: uint) {
+fn serialize_uint<S: Serializer>(&&s: S, v: uint) {
     s.emit_uint(v);
 }
 
-fn deserialize_uint<D: Deserializer>(d: D) -> uint {
+fn deserialize_uint<D: Deserializer>(&&d: D) -> uint {
     d.read_uint()
 }
 
-fn serialize_u8<S: Serializer>(s: S, v: u8) {
+fn serialize_u8<S: Serializer>(&&s: S, v: u8) {
     s.emit_u8(v);
 }
 
-fn deserialize_u8<D: Deserializer>(d: D) -> u8 {
+fn deserialize_u8<D: Deserializer>(&&d: D) -> u8 {
     d.read_u8()
 }
 
-fn serialize_u16<S: Serializer>(s: S, v: u16) {
+fn serialize_u16<S: Serializer>(&&s: S, v: u16) {
     s.emit_u16(v);
 }
 
-fn deserialize_u16<D: Deserializer>(d: D) -> u16 {
+fn deserialize_u16<D: Deserializer>(&&d: D) -> u16 {
     d.read_u16()
 }
 
-fn serialize_u32<S: Serializer>(s: S, v: u32) {
+fn serialize_u32<S: Serializer>(&&s: S, v: u32) {
     s.emit_u32(v);
 }
 
-fn deserialize_u32<D: Deserializer>(d: D) -> u32 {
+fn deserialize_u32<D: Deserializer>(&&d: D) -> u32 {
     d.read_u32()
 }
 
-fn serialize_u64<S: Serializer>(s: S, v: u64) {
+fn serialize_u64<S: Serializer>(&&s: S, v: u64) {
     s.emit_u64(v);
 }
 
-fn deserialize_u64<D: Deserializer>(d: D) -> u64 {
+fn deserialize_u64<D: Deserializer>(&&d: D) -> u64 {
     d.read_u64()
 }
 
-fn serialize_int<S: Serializer>(s: S, v: int) {
+fn serialize_int<S: Serializer>(&&s: S, v: int) {
     s.emit_int(v);
 }
 
-fn deserialize_int<D: Deserializer>(d: D) -> int {
+fn deserialize_int<D: Deserializer>(&&d: D) -> int {
     d.read_int()
 }
 
-fn serialize_i8<S: Serializer>(s: S, v: i8) {
+fn serialize_i8<S: Serializer>(&&s: S, v: i8) {
     s.emit_i8(v);
 }
 
-fn deserialize_i8<D: Deserializer>(d: D) -> i8 {
+fn deserialize_i8<D: Deserializer>(&&d: D) -> i8 {
     d.read_i8()
 }
 
-fn serialize_i16<S: Serializer>(s: S, v: i16) {
+fn serialize_i16<S: Serializer>(&&s: S, v: i16) {
     s.emit_i16(v);
 }
 
-fn deserialize_i16<D: Deserializer>(d: D) -> i16 {
+fn deserialize_i16<D: Deserializer>(&&d: D) -> i16 {
     d.read_i16()
 }
 
-fn serialize_i32<S: Serializer>(s: S, v: i32) {
+fn serialize_i32<S: Serializer>(&&s: S, v: i32) {
     s.emit_i32(v);
 }
 
-fn deserialize_i32<D: Deserializer>(d: D) -> i32 {
+fn deserialize_i32<D: Deserializer>(&&d: D) -> i32 {
     d.read_i32()
 }
 
-fn serialize_i64<S: Serializer>(s: S, v: i64) {
+fn serialize_i64<S: Serializer>(&&s: S, v: i64) {
     s.emit_i64(v);
 }
 
-fn deserialize_i64<D: Deserializer>(d: D) -> i64 {
+fn deserialize_i64<D: Deserializer>(&&d: D) -> i64 {
     d.read_i64()
 }
 
-fn serialize_str<S: Serializer>(s: S, v: &str) {
+fn serialize_str<S: Serializer>(&&s: S, v: &str) {
     s.emit_str(v);
 }
 
-fn deserialize_str<D: Deserializer>(d: D) -> ~str {
+fn deserialize_str<D: Deserializer>(&&d: D) -> ~str {
     d.read_str()
 }
 
-fn serialize_float<S: Serializer>(s: S, v: float) {
+fn serialize_float<S: Serializer>(&&s: S, v: float) {
     s.emit_float(v);
 }
 
-fn deserialize_float<D: Deserializer>(d: D) -> float {
+fn deserialize_float<D: Deserializer>(&&d: D) -> float {
     d.read_float()
 }
 
-fn serialize_f32<S: Serializer>(s: S, v: f32) {
+fn serialize_f32<S: Serializer>(&&s: S, v: f32) {
     s.emit_f32(v);
 }
 
-fn deserialize_f32<D: Deserializer>(d: D) -> f32 {
+fn deserialize_f32<D: Deserializer>(&&d: D) -> f32 {
     d.read_f32()
 }
 
-fn serialize_f64<S: Serializer>(s: S, v: f64) {
+fn serialize_f64<S: Serializer>(&&s: S, v: f64) {
     s.emit_f64(v);
 }
 
-fn deserialize_f64<D: Deserializer>(d: D) -> f64 {
+fn deserialize_f64<D: Deserializer>(&&d: D) -> f64 {
     d.read_f64()
 }
 
-fn serialize_bool<S: Serializer>(s: S, v: bool) {
+fn serialize_bool<S: Serializer>(&&s: S, v: bool) {
     s.emit_bool(v);
 }
 
-fn deserialize_bool<D: Deserializer>(d: D) -> bool {
+fn deserialize_bool<D: Deserializer>(&&d: D) -> bool {
     d.read_bool()
 }
 
-fn serialize_Option<S: Serializer,T>(s: S, v: Option<T>, st: fn(T)) {
+fn serialize_Option<S: Serializer,T>(&&s: S, &&v: Option<T>, st: fn(&&x: T)) {
     do s.emit_enum(~"option") {
         match v {
           None => do s.emit_enum_variant(~"none", 0u, 0u) {
@@ -254,7 +254,7 @@ fn serialize_Option<S: Serializer,T>(s: S, v: Option<T>, st: fn(T)) {
     }
 }
 
-fn deserialize_Option<D: Deserializer,T: Copy>(d: D, st: fn() -> T)
+fn deserialize_Option<D: Deserializer,T: Copy>(&&d: D, st: fn() -> T)
     -> Option<T> {
     do d.read_enum(~"option") {
         do d.read_enum_variant |i| {
diff --git a/src/libstd/std.rc b/src/libstd/std.rc
index 4831ac993a2..aa26c4af29c 100644
--- a/src/libstd/std.rc
+++ b/src/libstd/std.rc
@@ -18,7 +18,6 @@ not required in or otherwise suitable for the core library.
 
 #[no_core];
 
-#[legacy_modes];
 #[legacy_exports];
 
 #[allow(vecs_implicitly_copyable)];
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 67841158ce1..e17b52fb27d 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -69,7 +69,7 @@ impl ident: cmp::Eq {
 }
 
 impl ident: to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         self.repr.iter_bytes(lsb0, f)
     }
 }
@@ -328,7 +328,7 @@ enum binding_mode {
 }
 
 impl binding_mode : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         match self {
           bind_by_value => 0u8.iter_bytes(lsb0, f),
 
@@ -402,7 +402,7 @@ enum pat_ {
 enum mutability { m_mutbl, m_imm, m_const, }
 
 impl mutability : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (self as u8).iter_bytes(lsb0, f)
     }
 }
@@ -541,7 +541,7 @@ enum inferable<T> {
 }
 
 impl<T: to_bytes::IterBytes> inferable<T> : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         match self {
           expl(ref t) =>
           to_bytes::iter_bytes_2(&0u8, t, lsb0, f),
@@ -577,7 +577,7 @@ impl<T:cmp::Eq> inferable<T> : cmp::Eq {
 enum rmode { by_ref, by_val, by_mutbl_ref, by_move, by_copy }
 
 impl rmode : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (self as u8).iter_bytes(lsb0, f)
     }
 }
@@ -937,7 +937,7 @@ enum trait_method {
 enum int_ty { ty_i, ty_char, ty_i8, ty_i16, ty_i32, ty_i64, }
 
 impl int_ty : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (self as u8).iter_bytes(lsb0, f)
     }
 }
@@ -966,7 +966,7 @@ impl int_ty : cmp::Eq {
 enum uint_ty { ty_u, ty_u8, ty_u16, ty_u32, ty_u64, }
 
 impl uint_ty : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (self as u8).iter_bytes(lsb0, f)
     }
 }
@@ -993,7 +993,7 @@ impl uint_ty : cmp::Eq {
 enum float_ty { ty_f, ty_f32, ty_f64, }
 
 impl float_ty : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (self as u8).iter_bytes(lsb0, f)
     }
 }
@@ -1102,7 +1102,7 @@ impl ty : cmp::Eq {
 }
 
 impl ty : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.span.lo, &self.span.hi, lsb0, f);
     }
 }
@@ -1126,7 +1126,7 @@ enum purity {
 }
 
 impl purity : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (self as u8).iter_bytes(lsb0, f)
     }
 }
@@ -1146,7 +1146,7 @@ enum ret_style {
 }
 
 impl ret_style : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (self as u8).iter_bytes(lsb0, f)
     }
 }
@@ -1443,7 +1443,7 @@ enum item_ {
 enum class_mutability { class_mutable, class_immutable }
 
 impl class_mutability : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (self as u8).iter_bytes(lsb0, f)
     }
 }
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 2431947184d..e8099de246c 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -254,7 +254,7 @@ pure fn is_call_expr(e: @expr) -> bool {
 // This makes def_id hashable
 impl def_id : core::to_bytes::IterBytes {
     #[inline(always)]
-    pure fn iter_bytes(lsb0: bool, f: core::to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: core::to_bytes::Cb) {
         core::to_bytes::iter_bytes_2(&self.crate, &self.node, lsb0, f);
     }
 }
diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
index 9cfa84ad9e0..782535f5c2b 100644
--- a/src/libsyntax/parse/obsolete.rs
+++ b/src/libsyntax/parse/obsolete.rs
@@ -36,7 +36,7 @@ impl ObsoleteSyntax : cmp::Eq {
 
 impl ObsoleteSyntax: to_bytes::IterBytes {
     #[inline(always)]
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (self as uint).iter_bytes(lsb0, f);
     }
 }
diff --git a/src/rt/rust_builtin.cpp b/src/rt/rust_builtin.cpp
index 91c5760d3e9..6f985601f8b 100644
--- a/src/rt/rust_builtin.cpp
+++ b/src/rt/rust_builtin.cpp
@@ -180,6 +180,11 @@ rand_new_seeded(rust_vec_box* seed) {
     return rctx;
 }
 
+extern "C" CDECL void *
+rand_new_seeded2(rust_vec_box** seed) {
+    return rand_new_seeded(*seed);
+}
+
 extern "C" CDECL size_t
 rand_next(randctx *rctx) {
     return isaac_rand(rctx);
@@ -371,6 +376,11 @@ rust_list_files(rust_str *path) {
   return vec;
 }
 
+extern "C" CDECL rust_vec_box*
+rust_list_files2(rust_str **path) {
+    return rust_list_files(*path);
+}
+
 extern "C" CDECL int
 rust_path_is_dir(char *path) {
     struct stat buf;
diff --git a/src/rt/rustrt.def.in b/src/rt/rustrt.def.in
index 43f24f4dd4f..551378a3d6c 100644
--- a/src/rt/rustrt.def.in
+++ b/src/rt/rustrt.def.in
@@ -27,6 +27,7 @@ rust_port_select
 rand_free
 rand_new
 rand_new_seeded
+rand_new_seeded2
 rand_next
 rand_seed
 rust_get_sched_id
@@ -40,6 +41,7 @@ rust_get_stdin
 rust_get_stdout
 rust_get_stderr
 rust_list_files
+rust_list_files2
 rust_log_console_on
 rust_log_console_off
 rust_port_begin_detach
diff --git a/src/rustc/middle/borrowck.rs b/src/rustc/middle/borrowck.rs
index 4906eb4a0a3..414890cbd7c 100644
--- a/src/rustc/middle/borrowck.rs
+++ b/src/rustc/middle/borrowck.rs
@@ -415,7 +415,7 @@ impl root_map_key : cmp::Eq {
 }
 
 impl root_map_key : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.id, &self.derefs, lsb0, f);
     }
 }
diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs
index d68bdb08221..6768f3e71a0 100644
--- a/src/rustc/middle/trans/common.rs
+++ b/src/rustc/middle/trans/common.rs
@@ -1142,7 +1142,7 @@ impl mono_id_ : cmp::Eq {
 }
 
 impl mono_param_id : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         match self {
           mono_precise(t, mids) =>
           to_bytes::iter_bytes_3(&0u8, &ty::type_id(t), &mids, lsb0, f),
@@ -1156,7 +1156,7 @@ impl mono_param_id : to_bytes::IterBytes {
 }
 
 impl mono_id_ : core::to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.def, &self.params, lsb0, f);
     }
 }
diff --git a/src/rustc/middle/trans/datum.rs b/src/rustc/middle/trans/datum.rs
index 59e8cd72025..241fa5e53af 100644
--- a/src/rustc/middle/trans/datum.rs
+++ b/src/rustc/middle/trans/datum.rs
@@ -146,7 +146,7 @@ impl DatumMode: cmp::Eq {
 }
 
 impl DatumMode: to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (self as uint).iter_bytes(lsb0, f)
     }
 }
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index 973db90ff66..a96388e9d77 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -248,7 +248,7 @@ impl creader_cache_key : cmp::Eq {
 }
 
 impl creader_cache_key : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_3(&self.cnum, &self.pos, &self.len, lsb0, f);
     }
 }
@@ -263,7 +263,7 @@ impl intern_key : cmp::Eq {
 }
 
 impl intern_key : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.sty, &self.o_def_id, lsb0, f);
     }
 }
@@ -406,7 +406,7 @@ enum closure_kind {
 }
 
 impl closure_kind : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (self as u8).iter_bytes(lsb0, f)
     }
 }
@@ -424,7 +424,7 @@ enum fn_proto {
 }
 
 impl fn_proto : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         match self {
           proto_bare =>
           0u8.iter_bytes(lsb0, f),
@@ -502,7 +502,7 @@ impl param_ty : cmp::Eq {
 }
 
 impl param_ty : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.idx, &self.def_id, lsb0, f)
     }
 }
@@ -676,7 +676,7 @@ enum InferTy {
 }
 
 impl InferTy : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         match self {
           TyVar(ref tv) => to_bytes::iter_bytes_2(&0u8, tv, lsb0, f),
           IntVar(ref iv) => to_bytes::iter_bytes_2(&1u8, iv, lsb0, f)
@@ -685,7 +685,7 @@ impl InferTy : to_bytes::IterBytes {
 }
 
 impl param_bound : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         match self {
           bound_copy => 0u8.iter_bytes(lsb0, f),
           bound_owned => 1u8.iter_bytes(lsb0, f),
@@ -749,25 +749,25 @@ impl purity: purity_to_str {
 }
 
 impl RegionVid : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (*self).iter_bytes(lsb0, f)
     }
 }
 
 impl TyVid : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (*self).iter_bytes(lsb0, f)
     }
 }
 
 impl IntVid : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (*self).iter_bytes(lsb0, f)
     }
 }
 
 impl FnVid : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (*self).iter_bytes(lsb0, f)
     }
 }
@@ -2505,7 +2505,7 @@ fn index_sty(cx: ctxt, sty: &sty) -> Option<mt> {
 }
 
 impl bound_region : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         match self {
           ty::br_self => 0u8.iter_bytes(lsb0, f),
 
@@ -2522,7 +2522,7 @@ impl bound_region : to_bytes::IterBytes {
 }
 
 impl region : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         match self {
           re_bound(ref br) =>
           to_bytes::iter_bytes_2(&0u8, br, lsb0, f),
@@ -2542,7 +2542,7 @@ impl region : to_bytes::IterBytes {
 }
 
 impl vstore : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         match self {
           vstore_fixed(ref u) =>
           to_bytes::iter_bytes_2(&0u8, u, lsb0, f),
@@ -2557,7 +2557,7 @@ impl vstore : to_bytes::IterBytes {
 }
 
 impl substs : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
           to_bytes::iter_bytes_3(&self.self_r,
                                  &self.self_ty,
                                  &self.tps, lsb0, f)
@@ -2565,28 +2565,28 @@ impl substs : to_bytes::IterBytes {
 }
 
 impl mt : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
           to_bytes::iter_bytes_2(&self.ty,
                                  &self.mutbl, lsb0, f)
     }
 }
 
 impl field : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
           to_bytes::iter_bytes_2(&self.ident,
                                  &self.mt, lsb0, f)
     }
 }
 
 impl arg : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
           to_bytes::iter_bytes_2(&self.mode,
                                  &self.ty, lsb0, f)
     }
 }
 
 impl sty : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         match self {
           ty_nil => 0u8.iter_bytes(lsb0, f),
           ty_bool => 1u8.iter_bytes(lsb0, f),
diff --git a/src/rustc/middle/typeck/infer/region_var_bindings.rs b/src/rustc/middle/typeck/infer/region_var_bindings.rs
index c86850e19d2..8bbdab74d23 100644
--- a/src/rustc/middle/typeck/infer/region_var_bindings.rs
+++ b/src/rustc/middle/typeck/infer/region_var_bindings.rs
@@ -350,7 +350,7 @@ impl Constraint : cmp::Eq {
 }
 
 impl Constraint : to_bytes::IterBytes {
-   pure  fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+   pure  fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         match self {
           ConstrainVarSubVar(ref v0, ref v1) =>
           to_bytes::iter_bytes_3(&0u8, v0, v1, lsb0, f),
@@ -377,7 +377,7 @@ impl TwoRegions : cmp::Eq {
 }
 
 impl TwoRegions : to_bytes::IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.a, &self.b, lsb0, f)
     }
 }
diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs
index f35a3ce735f..a34fcc89c04 100644
--- a/src/test/bench/graph500-bfs.rs
+++ b/src/test/bench/graph500-bfs.rs
@@ -251,7 +251,7 @@ fn pbfs(&&graph: arc::ARC<graph>, key: node_id) -> bfs_result {
         colors = do par::mapi_factory(*color_vec) {
             let colors = arc::clone(&color);
             let graph = arc::clone(&graph);
-            fn~(i: uint, c: color) -> color {
+            fn~(+i: uint, +c: color) -> color {
                 let c : color = c;
                 let colors = arc::get(&colors);
                 let graph = arc::get(&graph);
diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs
index d9859d54648..ee38b957b0c 100644
--- a/src/test/bench/shootout-mandelbrot.rs
+++ b/src/test/bench/shootout-mandelbrot.rs
@@ -94,7 +94,7 @@ type devnull = {dn: int};
 
 impl devnull: io::Writer {
     fn write(_b: &[const u8]) {}
-    fn seek(_i: int, _s: io::SeekStyle) {}
+    fn seek(+_i: int, +_s: io::SeekStyle) {}
     fn tell() -> uint {0_u}
     fn flush() -> int {0}
     fn get_type() -> io::WriterType { io::File }
-- 
cgit 1.4.1-3-g733a5


From f78cdcb6364cf938bfeb71da0c7eca62e257d537 Mon Sep 17 00:00:00 2001
From: Tim Chevalier <chevalier@alum.wellesley.edu>
Date: Tue, 2 Oct 2012 11:37:37 -0700
Subject: Removing explicit uses of + mode

This removes most explicit uses of the + argument mode. Pending a
snapshot, I had to remove the forbid(deprecated_modes) pragma from
a bunch of files. I'll put it back!

+ mode still has to be used in a few places for functions that get
moved (see task.rs)

The changes outside core and std are due to the to_bytes trait and
making the compiler (with legacy modes on) agree with the libraries
(with legacy modes off) about modes.
---
 src/libcore/at_vec.rs               | 18 +++----
 src/libcore/cast.rs                 | 18 +++----
 src/libcore/comm.rs                 | 10 ++--
 src/libcore/dlist.rs                | 32 ++++++-------
 src/libcore/dvec.rs                 | 28 +++++------
 src/libcore/either.rs               |  7 +--
 src/libcore/extfmt.rs               | 10 ++--
 src/libcore/future.rs               |  6 +--
 src/libcore/int-template.rs         |  4 +-
 src/libcore/io.rs                   | 18 +++----
 src/libcore/iter-trait.rs           | 10 ++--
 src/libcore/iter.rs                 | 27 +++++------
 src/libcore/mutable.rs              |  7 ++-
 src/libcore/ops.rs                  |  2 +-
 src/libcore/option.rs               | 32 ++++++-------
 src/libcore/os.rs                   |  6 +--
 src/libcore/pipes.rs                | 68 +++++++++++++-------------
 src/libcore/private.rs              | 10 ++--
 src/libcore/reflect.rs              |  2 +-
 src/libcore/result.rs               | 18 +++----
 src/libcore/run.rs                  |  6 +--
 src/libcore/send_map.rs             |  8 ++--
 src/libcore/stackwalk.rs            |  2 +
 src/libcore/str.rs                  |  2 +-
 src/libcore/sys.rs                  |  2 +-
 src/libcore/task.rs                 | 16 +++----
 src/libcore/task/local_data.rs      | 32 ++++++-------
 src/libcore/task/local_data_priv.rs |  2 +-
 src/libcore/task/spawn.rs           | 20 ++++----
 src/libcore/util.rs                 | 10 ++--
 src/libcore/vec.rs                  | 96 ++++++++++++++++++-------------------
 src/libstd/getopts.rs               |  2 +-
 src/libstd/net_tcp.rs               |  8 ++--
 src/libstd/net_url.rs               |  2 +-
 src/libstd/rope.rs                  |  4 +-
 src/libstd/std.rc                   |  3 ++
 src/rustc/middle/lint.rs            |  8 +++-
 src/test/bench/graph500-bfs.rs      |  2 +-
 38 files changed, 282 insertions(+), 276 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs
index 6936de2bccb..7d410c0337a 100644
--- a/src/libcore/at_vec.rs
+++ b/src/libcore/at_vec.rs
@@ -1,7 +1,7 @@
 //! Managed vectors
 
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+// tjc: re-forbid deprecated modes after snapshot
 #[forbid(deprecated_pattern)];
 
 use cast::transmute;
@@ -48,7 +48,7 @@ pub pure fn capacity<T>(v: @[const T]) -> uint {
  */
 #[inline(always)]
 pub pure fn build_sized<A>(size: uint,
-                           builder: &fn(push: pure fn(+v: A))) -> @[A] {
+                           builder: &fn(push: pure fn(v: A))) -> @[A] {
     let mut vec: @[const A] = @[];
     unsafe { raw::reserve(&mut vec, size); }
     builder(|+x| unsafe { raw::push(&mut vec, move x) });
@@ -66,7 +66,7 @@ pub pure fn build_sized<A>(size: uint,
  *             onto the vector being constructed.
  */
 #[inline(always)]
-pub pure fn build<A>(builder: &fn(push: pure fn(+v: A))) -> @[A] {
+pub pure fn build<A>(builder: &fn(push: pure fn(v: A))) -> @[A] {
     build_sized(4, builder)
 }
 
@@ -83,8 +83,8 @@ pub pure fn build<A>(builder: &fn(push: pure fn(+v: A))) -> @[A] {
  *             onto the vector being constructed.
  */
 #[inline(always)]
-pub pure fn build_sized_opt<A>(+size: Option<uint>,
-                               builder: &fn(push: pure fn(+v: A))) -> @[A] {
+pub pure fn build_sized_opt<A>(size: Option<uint>,
+                               builder: &fn(push: pure fn(v: A))) -> @[A] {
     build_sized(size.get_default(4), builder)
 }
 
@@ -126,7 +126,7 @@ pub pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> @[T] {
  * Creates an immutable vector of size `n_elts` and initializes the elements
  * to the value `t`.
  */
-pub pure fn from_elem<T: Copy>(n_elts: uint, +t: T) -> @[T] {
+pub pure fn from_elem<T: Copy>(n_elts: uint, t: T) -> @[T] {
     do build_sized(n_elts) |push| {
         let mut i: uint = 0u;
         while i < n_elts { push(copy t); i += 1u; }
@@ -166,7 +166,7 @@ pub mod raw {
     }
 
     #[inline(always)]
-    pub unsafe fn push<T>(v: &mut @[const T], +initval: T) {
+    pub unsafe fn push<T>(v: &mut @[const T], initval: T) {
         let repr: **VecRepr = ::cast::reinterpret_cast(&v);
         let fill = (**repr).unboxed.fill;
         if (**repr).unboxed.alloc > fill {
@@ -178,7 +178,7 @@ pub mod raw {
     }
     // This doesn't bother to make sure we have space.
     #[inline(always)] // really pretty please
-    pub unsafe fn push_fast<T>(v: &mut @[const T], +initval: T) {
+    pub unsafe fn push_fast<T>(v: &mut @[const T], initval: T) {
         let repr: **VecRepr = ::cast::reinterpret_cast(&v);
         let fill = (**repr).unboxed.fill;
         (**repr).unboxed.fill += sys::size_of::<T>();
@@ -187,7 +187,7 @@ pub mod raw {
         rusti::move_val_init(*p, move initval);
     }
 
-    pub unsafe fn push_slow<T>(v: &mut @[const T], +initval: T) {
+    pub unsafe fn push_slow<T>(v: &mut @[const T], initval: T) {
         reserve_at_least(v, v.len() + 1u);
         push_fast(v, move initval);
     }
diff --git a/src/libcore/cast.rs b/src/libcore/cast.rs
index 21f5861b89e..f4f0d7b6104 100644
--- a/src/libcore/cast.rs
+++ b/src/libcore/cast.rs
@@ -21,7 +21,7 @@ pub unsafe fn reinterpret_cast<T, U>(src: &T) -> U {
  * reinterpret_cast on managed pointer types.
  */
 #[inline(always)]
-pub unsafe fn forget<T>(+thing: T) { rusti::forget(move thing); }
+pub unsafe fn forget<T>(thing: T) { rusti::forget(move thing); }
 
 /**
  * Force-increment the reference count on a shared box. If used
@@ -29,7 +29,7 @@ pub unsafe fn forget<T>(+thing: T) { rusti::forget(move thing); }
  * and/or reinterpret_cast when such calls would otherwise scramble a box's
  * reference count
  */
-pub unsafe fn bump_box_refcount<T>(+t: @T) { forget(move t); }
+pub unsafe fn bump_box_refcount<T>(t: @T) { forget(move t); }
 
 /**
  * Transform a value of one type into a value of another type.
@@ -40,7 +40,7 @@ pub unsafe fn bump_box_refcount<T>(+t: @T) { forget(move t); }
  *     assert transmute("L") == ~[76u8, 0u8];
  */
 #[inline(always)]
-pub unsafe fn transmute<L, G>(+thing: L) -> G {
+pub unsafe fn transmute<L, G>(thing: L) -> G {
     let newthing: G = reinterpret_cast(&thing);
     forget(move thing);
     move newthing
@@ -48,33 +48,33 @@ pub unsafe fn transmute<L, G>(+thing: L) -> G {
 
 /// Coerce an immutable reference to be mutable.
 #[inline(always)]
-pub unsafe fn transmute_mut<T>(+ptr: &a/T) -> &a/mut T { transmute(move ptr) }
+pub unsafe fn transmute_mut<T>(ptr: &a/T) -> &a/mut T { transmute(move ptr) }
 
 /// Coerce a mutable reference to be immutable.
 #[inline(always)]
-pub unsafe fn transmute_immut<T>(+ptr: &a/mut T) -> &a/T {
+pub unsafe fn transmute_immut<T>(ptr: &a/mut T) -> &a/T {
     transmute(move ptr)
 }
 
 /// Coerce a borrowed pointer to have an arbitrary associated region.
 #[inline(always)]
-pub unsafe fn transmute_region<T>(+ptr: &a/T) -> &b/T { transmute(move ptr) }
+pub unsafe fn transmute_region<T>(ptr: &a/T) -> &b/T { transmute(move ptr) }
 
 /// Coerce an immutable reference to be mutable.
 #[inline(always)]
-pub unsafe fn transmute_mut_unsafe<T>(+ptr: *const T) -> *mut T {
+pub unsafe fn transmute_mut_unsafe<T>(ptr: *const T) -> *mut T {
     transmute(ptr)
 }
 
 /// Coerce an immutable reference to be mutable.
 #[inline(always)]
-pub unsafe fn transmute_immut_unsafe<T>(+ptr: *const T) -> *T {
+pub unsafe fn transmute_immut_unsafe<T>(ptr: *const T) -> *T {
     transmute(ptr)
 }
 
 /// Coerce a borrowed mutable pointer to have an arbitrary associated region.
 #[inline(always)]
-pub unsafe fn transmute_mut_region<T>(+ptr: &a/mut T) -> &b/mut T {
+pub unsafe fn transmute_mut_region<T>(ptr: &a/mut T) -> &b/mut T {
     transmute(move ptr)
 }
 
diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs
index ff9f9498a98..64c38d13e49 100644
--- a/src/libcore/comm.rs
+++ b/src/libcore/comm.rs
@@ -32,8 +32,8 @@ will once again be the preferred module for intertask communication.
 
 */
 
-// NB: transitionary, de-mode-ing.
-#[warn(deprecated_mode)];
+// NB: transitionary, de-mode-ing
+// tjc: re-forbid deprecated modes after snapshot
 #[forbid(deprecated_pattern)];
 
 use either::Either;
@@ -75,7 +75,7 @@ pub fn Port<T: Send>() -> Port<T> {
 impl<T: Send> Port<T> {
 
     fn chan() -> Chan<T> { Chan(self) }
-    fn send(+v: T) { self.chan().send(move v) }
+    fn send(v: T) { self.chan().send(move v) }
     fn recv() -> T { recv(self) }
     fn peek() -> bool { peek(self) }
 
@@ -84,7 +84,7 @@ impl<T: Send> Port<T> {
 impl<T: Send> Chan<T> {
 
     fn chan() -> Chan<T> { self }
-    fn send(+v: T) { send(self, move v) }
+    fn send(v: T) { send(self, move v) }
     fn recv() -> T { recv_chan(self) }
     fn peek() -> bool { peek_chan(self) }
 
@@ -174,7 +174,7 @@ pub fn Chan<T: Send>(&&p: Port<T>) -> Chan<T> {
  * Sends data over a channel. The sent data is moved into the channel,
  * whereupon the caller loses access to it.
  */
-pub fn send<T: Send>(ch: Chan<T>, +data: T) {
+pub fn send<T: Send>(ch: Chan<T>, data: T) {
     let Chan_(p) = ch;
     let data_ptr = ptr::addr_of(&data) as *();
     let res = rustrt::rust_port_id_send(p, data_ptr);
diff --git a/src/libcore/dlist.rs b/src/libcore/dlist.rs
index 4e08dd4c2f3..17ddd6ea73b 100644
--- a/src/libcore/dlist.rs
+++ b/src/libcore/dlist.rs
@@ -9,7 +9,7 @@ Do not use ==, !=, <, etc on doubly-linked lists -- it may not terminate.
 */
 
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+// tjc: re-forbid deprecated modes after snapshot
 #[forbid(deprecated_pattern)];
 
 type DListLink<T> = Option<DListNode<T>>;
@@ -80,7 +80,7 @@ impl<T> DListNode<T> {
 }
 
 /// Creates a new dlist node with the given data.
-pure fn new_dlist_node<T>(+data: T) -> DListNode<T> {
+pure fn new_dlist_node<T>(data: T) -> DListNode<T> {
     DListNode(@{data: move data, mut linked: false,
                  mut prev: None, mut next: None})
 }
@@ -91,13 +91,13 @@ pure fn DList<T>() -> DList<T> {
 }
 
 /// Creates a new dlist with a single element
-pub pure fn from_elem<T>(+data: T) -> DList<T> {
+pub pure fn from_elem<T>(data: T) -> DList<T> {
     let list = DList();
     unsafe { list.push(move data); }
     list
 }
 
-pub fn from_vec<T: Copy>(+vec: &[T]) -> DList<T> {
+pub fn from_vec<T: Copy>(vec: &[T]) -> DList<T> {
     do vec::foldl(DList(), vec) |list,data| {
         list.push(*data); // Iterating left-to-right -- add newly to the tail.
         list
@@ -115,7 +115,7 @@ fn concat<T>(lists: DList<DList<T>>) -> DList<T> {
 }
 
 priv impl<T> DList<T> {
-    pure fn new_link(+data: T) -> DListLink<T> {
+    pure fn new_link(data: T) -> DListLink<T> {
         Some(DListNode(@{data: move data, mut linked: true,
                           mut prev: None, mut next: None}))
     }
@@ -142,7 +142,7 @@ priv impl<T> DList<T> {
     // Link two nodes together. If either of them are 'none', also sets
     // the head and/or tail pointers appropriately.
     #[inline(always)]
-    fn link(+before: DListLink<T>, +after: DListLink<T>) {
+    fn link(before: DListLink<T>, after: DListLink<T>) {
         match before {
             Some(neighbour) => neighbour.next = after,
             None            => self.hd        = after
@@ -163,12 +163,12 @@ priv impl<T> DList<T> {
         self.size -= 1;
     }
 
-    fn add_head(+nobe: DListLink<T>) {
+    fn add_head(nobe: DListLink<T>) {
         self.link(nobe, self.hd); // Might set tail too.
         self.hd = nobe;
         self.size += 1;
     }
-    fn add_tail(+nobe: DListLink<T>) {
+    fn add_tail(nobe: DListLink<T>) {
         self.link(self.tl, nobe); // Might set head too.
         self.tl = nobe;
         self.size += 1;
@@ -198,27 +198,27 @@ impl<T> DList<T> {
     pure fn is_not_empty() -> bool { self.len() != 0 }
 
     /// Add data to the head of the list. O(1).
-    fn push_head(+data: T) {
+    fn push_head(data: T) {
         self.add_head(self.new_link(move data));
     }
     /**
      * Add data to the head of the list, and get the new containing
      * node. O(1).
      */
-    fn push_head_n(+data: T) -> DListNode<T> {
+    fn push_head_n(data: T) -> DListNode<T> {
         let mut nobe = self.new_link(move data);
         self.add_head(nobe);
         option::get(&nobe)
     }
     /// Add data to the tail of the list. O(1).
-    fn push(+data: T) {
+    fn push(data: T) {
         self.add_tail(self.new_link(move data));
     }
     /**
      * Add data to the tail of the list, and get the new containing
      * node. O(1).
      */
-    fn push_n(+data: T) -> DListNode<T> {
+    fn push_n(data: T) -> DListNode<T> {
         let mut nobe = self.new_link(move data);
         self.add_tail(nobe);
         option::get(&nobe)
@@ -227,7 +227,7 @@ impl<T> DList<T> {
      * Insert data into the middle of the list, left of the given node.
      * O(1).
      */
-    fn insert_before(+data: T, neighbour: DListNode<T>) {
+    fn insert_before(data: T, neighbour: DListNode<T>) {
         self.insert_left(self.new_link(move data), neighbour);
     }
     /**
@@ -242,7 +242,7 @@ impl<T> DList<T> {
      * Insert data in the middle of the list, left of the given node,
      * and get its containing node. O(1).
      */
-    fn insert_before_n(+data: T, neighbour: DListNode<T>) -> DListNode<T> {
+    fn insert_before_n(data: T, neighbour: DListNode<T>) -> DListNode<T> {
         let mut nobe = self.new_link(move data);
         self.insert_left(nobe, neighbour);
         option::get(&nobe)
@@ -251,7 +251,7 @@ impl<T> DList<T> {
      * Insert data into the middle of the list, right of the given node.
      * O(1).
      */
-    fn insert_after(+data: T, neighbour: DListNode<T>) {
+    fn insert_after(data: T, neighbour: DListNode<T>) {
         self.insert_right(neighbour, self.new_link(move data));
     }
     /**
@@ -266,7 +266,7 @@ impl<T> DList<T> {
      * Insert data in the middle of the list, right of the given node,
      * and get its containing node. O(1).
      */
-    fn insert_after_n(+data: T, neighbour: DListNode<T>) -> DListNode<T> {
+    fn insert_after_n(data: T, neighbour: DListNode<T>) -> DListNode<T> {
         let mut nobe = self.new_link(move data);
         self.insert_right(neighbour, nobe);
         option::get(&nobe)
diff --git a/src/libcore/dvec.rs b/src/libcore/dvec.rs
index 3ce5a7153fd..a2a70908797 100644
--- a/src/libcore/dvec.rs
+++ b/src/libcore/dvec.rs
@@ -10,7 +10,7 @@ Note that recursive use is not permitted.
 */
 
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+// tjc: re-forbid deprecated modes after snapshot
 #[forbid(deprecated_pattern)];
 
 use cast::reinterpret_cast;
@@ -61,17 +61,17 @@ pub fn DVec<A>() -> DVec<A> {
 }
 
 /// Creates a new dvec with a single element
-pub fn from_elem<A>(+e: A) -> DVec<A> {
+pub fn from_elem<A>(e: A) -> DVec<A> {
     DVec_({mut data: ~[move e]})
 }
 
 /// Creates a new dvec with the contents of a vector
-pub fn from_vec<A>(+v: ~[A]) -> DVec<A> {
+pub fn from_vec<A>(v: ~[A]) -> DVec<A> {
     DVec_({mut data: move v})
 }
 
 /// Consumes the vector and returns its contents
-pub fn unwrap<A>(+d: DVec<A>) -> ~[A] {
+pub fn unwrap<A>(d: DVec<A>) -> ~[A] {
     let DVec_({data: v}) <- d;
     move v
 }
@@ -87,7 +87,7 @@ priv impl<A> DVec<A> {
     }
 
     #[inline(always)]
-    fn check_out<B>(f: &fn(+v: ~[A]) -> B) -> B {
+    fn check_out<B>(f: &fn(v: ~[A]) -> B) -> B {
         unsafe {
             let mut data = cast::reinterpret_cast(&null::<()>());
             data <-> self.data;
@@ -98,7 +98,7 @@ priv impl<A> DVec<A> {
     }
 
     #[inline(always)]
-    fn give_back(+data: ~[A]) {
+    fn give_back(data: ~[A]) {
         unsafe {
             self.data = move data;
         }
@@ -120,7 +120,7 @@ impl<A> DVec<A> {
      * and return a new vector to replace it with.
      */
     #[inline(always)]
-    fn swap(f: &fn(+v: ~[A]) -> ~[A]) {
+    fn swap(f: &fn(v: ~[A]) -> ~[A]) {
         self.check_out(|v| self.give_back(f(move v)))
     }
 
@@ -130,7 +130,7 @@ impl<A> DVec<A> {
      * and return a new vector to replace it with.
      */
     #[inline(always)]
-    fn swap_mut(f: &fn(+v: ~[mut A]) -> ~[mut A]) {
+    fn swap_mut(f: &fn(v: ~[mut A]) -> ~[mut A]) {
         do self.swap |v| {
             vec::from_mut(f(vec::to_mut(move v)))
         }
@@ -148,7 +148,7 @@ impl<A> DVec<A> {
     }
 
     /// Overwrite the current contents
-    fn set(+w: ~[A]) {
+    fn set(w: ~[A]) {
         self.check_not_borrowed();
         self.data <- w;
     }
@@ -164,7 +164,7 @@ impl<A> DVec<A> {
     }
 
     /// Insert a single item at the front of the list
-    fn unshift(+t: A) {
+    fn unshift(t: A) {
         unsafe {
             let mut data = cast::reinterpret_cast(&null::<()>());
             data <-> self.data;
@@ -178,7 +178,7 @@ impl<A> DVec<A> {
     }
 
     /// Append a single item to the end of the list
-    fn push(+t: A) {
+    fn push(t: A) {
         self.check_not_borrowed();
         self.data.push(move t);
     }
@@ -295,7 +295,7 @@ impl<A: Copy> DVec<A> {
     }
 
     /// Overwrites the contents of the element at `idx` with `a`
-    fn set_elt(idx: uint, +a: A) {
+    fn set_elt(idx: uint, a: A) {
         self.check_not_borrowed();
         self.data[idx] = a;
     }
@@ -305,7 +305,7 @@ impl<A: Copy> DVec<A> {
      * growing the vector if necessary.  New elements will be initialized
      * with `initval`
      */
-    fn grow_set_elt(idx: uint, initval: &A, +val: A) {
+    fn grow_set_elt(idx: uint, initval: &A, val: A) {
         do self.swap |v| {
             let mut v = move v;
             v.grow_set(idx, initval, val);
@@ -354,7 +354,7 @@ impl<A: Copy> DVec<A> {
 }
 
 impl<A:Copy> DVec<A>: Index<uint,A> {
-    pure fn index(+idx: uint) -> A {
+    pure fn index(idx: uint) -> A {
         self.get_elt(idx)
     }
 }
diff --git a/src/libcore/either.rs b/src/libcore/either.rs
index dd3bcdfdf88..c64cd25e481 100644
--- a/src/libcore/either.rs
+++ b/src/libcore/either.rs
@@ -1,5 +1,5 @@
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+// tjc: re-forbid deprecated modes after snapshot
 #[forbid(deprecated_pattern)];
 
 //! A type that represents one of two alternatives
@@ -114,7 +114,8 @@ pub pure fn is_right<T, U>(eith: &Either<T, U>) -> bool {
     match *eith { Right(_) => true, _ => false }
 }
 
-pub pure fn unwrap_left<T,U>(+eith: Either<T,U>) -> T {
+// tjc: fix the next two after a snapshot
+pub pure fn unwrap_left<T,U>(eith: Either<T,U>) -> T {
     //! Retrieves the value in the left branch. Fails if the either is Right.
 
     match move eith {
@@ -122,7 +123,7 @@ pub pure fn unwrap_left<T,U>(+eith: Either<T,U>) -> T {
     }
 }
 
-pub pure fn unwrap_right<T,U>(+eith: Either<T,U>) -> U {
+pub pure fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
     //! Retrieves the value in the right branch. Fails if the either is Left.
 
     match move eith {
diff --git a/src/libcore/extfmt.rs b/src/libcore/extfmt.rs
index 25f92e61726..e10ff4bac71 100644
--- a/src/libcore/extfmt.rs
+++ b/src/libcore/extfmt.rs
@@ -87,7 +87,7 @@ mod ct {
         let mut pieces: ~[Piece] = ~[];
         let lim = str::len(s);
         let mut buf = ~"";
-        fn flush_buf(+buf: ~str, pieces: &mut ~[Piece]) -> ~str {
+        fn flush_buf(buf: ~str, pieces: &mut ~[Piece]) -> ~str {
             if buf.len() > 0 {
                 let piece = PieceString(move buf);
                 pieces.push(move piece);
@@ -323,7 +323,7 @@ mod rt {
         let mut s = str::from_char(c);
         return unsafe { pad(cv, s, PadNozero) };
     }
-    pure fn conv_str(cv: Conv, +s: &str) -> ~str {
+    pure fn conv_str(cv: Conv, s: &str) -> ~str {
         // For strings, precision is the maximum characters
         // displayed
         let mut unpadded = match cv.precision {
@@ -405,7 +405,7 @@ mod rt {
         pure fn ne(other: &PadMode) -> bool { !self.eq(other) }
     }
 
-    fn pad(cv: Conv, +s: ~str, mode: PadMode) -> ~str {
+    fn pad(cv: Conv, s: ~str, mode: PadMode) -> ~str {
         let mut s = move s; // sadtimes
         let uwidth : uint = match cv.width {
           CountImplied => return s,
@@ -518,7 +518,7 @@ mod rt2 {
         let mut s = str::from_char(c);
         return unsafe { pad(cv, s, PadNozero) };
     }
-    pure fn conv_str(cv: Conv, +s: &str) -> ~str {
+    pure fn conv_str(cv: Conv, s: &str) -> ~str {
         // For strings, precision is the maximum characters
         // displayed
         let mut unpadded = match cv.precision {
@@ -600,7 +600,7 @@ mod rt2 {
         pure fn ne(other: &PadMode) -> bool { !self.eq(other) }
     }
 
-    fn pad(cv: Conv, +s: ~str, mode: PadMode) -> ~str {
+    fn pad(cv: Conv, s: ~str, mode: PadMode) -> ~str {
         let mut s = move s; // sadtimes
         let uwidth : uint = match cv.width {
           CountImplied => return s,
diff --git a/src/libcore/future.rs b/src/libcore/future.rs
index db311ea3e82..11b6a2c0135 100644
--- a/src/libcore/future.rs
+++ b/src/libcore/future.rs
@@ -1,5 +1,5 @@
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+// tjc: re-forbid deprecated modes after snapshot
 #[forbid(deprecated_pattern)];
 
 /*!
@@ -55,7 +55,7 @@ impl<A> Future<A> {
     }
 }
 
-pub fn from_value<A>(+val: A) -> Future<A> {
+pub fn from_value<A>(val: A) -> Future<A> {
     /*!
      * Create a future from a value
      *
@@ -66,7 +66,7 @@ pub fn from_value<A>(+val: A) -> Future<A> {
     Future {state: Forced(~(move val))}
 }
 
-pub fn from_port<A:Send>(+port: future_pipe::client::waiting<A>) ->
+pub fn from_port<A:Send>(port: future_pipe::client::waiting<A>) ->
         Future<A> {
     /*!
      * Create a future from a port
diff --git a/src/libcore/int-template.rs b/src/libcore/int-template.rs
index ddd26205000..6942d38d5d3 100644
--- a/src/libcore/int-template.rs
+++ b/src/libcore/int-template.rs
@@ -1,5 +1,5 @@
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+// tjc: re-forbid deprecated modes after snapshot
 #[forbid(deprecated_pattern)];
 
 use T = inst::T;
@@ -231,7 +231,7 @@ fn test_to_str() {
 
 #[test]
 fn test_interfaces() {
-    fn test<U:num::Num cmp::Eq>(+ten: U) {
+    fn test<U:num::Num cmp::Eq>(ten: U) {
         assert (ten.to_int() == 10);
 
         let two: U = from_int(2);
diff --git a/src/libcore/io.rs b/src/libcore/io.rs
index f8f644a17ab..2efc96933da 100644
--- a/src/libcore/io.rs
+++ b/src/libcore/io.rs
@@ -813,7 +813,7 @@ pub mod fsync {
         }
     }
 
-    pub fn Res<t: Copy>(+arg: Arg<t>) -> Res<t>{
+    pub fn Res<t: Copy>(arg: Arg<t>) -> Res<t>{
         Res {
             arg: move arg
         }
@@ -822,17 +822,17 @@ pub mod fsync {
     pub type Arg<t> = {
         val: t,
         opt_level: Option<Level>,
-        fsync_fn: fn@(+f: t, Level) -> int
+        fsync_fn: fn@(f: t, Level) -> int
     };
 
     // fsync file after executing blk
     // FIXME (#2004) find better way to create resources within lifetime of
     // outer res
     pub fn FILE_res_sync(file: &FILERes, opt_level: Option<Level>,
-                         blk: fn(+v: Res<*libc::FILE>)) {
+                         blk: fn(v: Res<*libc::FILE>)) {
         blk(move Res({
             val: file.f, opt_level: opt_level,
-            fsync_fn: fn@(+file: *libc::FILE, l: Level) -> int {
+            fsync_fn: fn@(file: *libc::FILE, l: Level) -> int {
                 return os::fsync_fd(libc::fileno(file), l) as int;
             }
         }));
@@ -840,10 +840,10 @@ pub mod fsync {
 
     // fsync fd after executing blk
     pub fn fd_res_sync(fd: &FdRes, opt_level: Option<Level>,
-                       blk: fn(+v: Res<fd_t>)) {
+                       blk: fn(v: Res<fd_t>)) {
         blk(move Res({
             val: fd.fd, opt_level: opt_level,
-            fsync_fn: fn@(+fd: fd_t, l: Level) -> int {
+            fsync_fn: fn@(fd: fd_t, l: Level) -> int {
                 return os::fsync_fd(fd, l) as int;
             }
         }));
@@ -853,11 +853,11 @@ pub mod fsync {
     pub trait FSyncable { fn fsync(l: Level) -> int; }
 
     // Call o.fsync after executing blk
-    pub fn obj_sync(+o: FSyncable, opt_level: Option<Level>,
-                    blk: fn(+v: Res<FSyncable>)) {
+    pub fn obj_sync(o: FSyncable, opt_level: Option<Level>,
+                    blk: fn(v: Res<FSyncable>)) {
         blk(Res({
             val: o, opt_level: opt_level,
-            fsync_fn: fn@(+o: FSyncable, l: Level) -> int {
+            fsync_fn: fn@(o: FSyncable, l: Level) -> int {
                 return o.fsync(l);
             }
         }));
diff --git a/src/libcore/iter-trait.rs b/src/libcore/iter-trait.rs
index a2fb4698d7c..09bfe2eff36 100644
--- a/src/libcore/iter-trait.rs
+++ b/src/libcore/iter-trait.rs
@@ -16,7 +16,7 @@ impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
     pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(&self, blk) }
     pure fn all(blk: fn(&A) -> bool) -> bool { iter::all(&self, blk) }
     pure fn any(blk: fn(&A) -> bool) -> bool { iter::any(&self, blk) }
-    pure fn foldl<B>(+b0: B, blk: fn(&B, &A) -> B) -> B {
+    pure fn foldl<B>(b0: B, blk: fn(&B, &A) -> B) -> B {
         iter::foldl(&self, move b0, blk)
     }
     pure fn position(f: fn(&A) -> bool) -> Option<uint> {
@@ -30,20 +30,20 @@ impl<A: Eq> IMPL_T<A>: iter::EqIter<A> {
 }
 
 impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {
-    pure fn filter_to_vec(pred: fn(+a: A) -> bool) -> ~[A] {
+    pure fn filter_to_vec(pred: fn(a: A) -> bool) -> ~[A] {
         iter::filter_to_vec(&self, pred)
     }
-    pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B] {
+    pure fn map_to_vec<B>(op: fn(v: A) -> B) -> ~[B] {
         iter::map_to_vec(&self, op)
     }
     pure fn to_vec() -> ~[A] { iter::to_vec(&self) }
 
-    pure fn flat_map_to_vec<B:Copy,IB:BaseIter<B>>(op: fn(+a: A) -> IB)
+    pure fn flat_map_to_vec<B:Copy,IB:BaseIter<B>>(op: fn(a: A) -> IB)
         -> ~[B] {
         iter::flat_map_to_vec(&self, op)
     }
 
-    pure fn find(p: fn(+a: A) -> bool) -> Option<A> { iter::find(&self, p) }
+    pure fn find(p: fn(a: A) -> bool) -> Option<A> { iter::find(&self, p) }
 }
 
 impl<A: Copy Ord> IMPL_T<A>: iter::CopyableOrderedIter<A> {
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 5271555d299..bf3e91f7071 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -18,7 +18,7 @@ pub trait ExtendedIter<A> {
     pure fn eachi(blk: fn(uint, v: &A) -> bool);
     pure fn all(blk: fn(&A) -> bool) -> bool;
     pure fn any(blk: fn(&A) -> bool) -> bool;
-    pure fn foldl<B>(+b0: B, blk: fn(&B, &A) -> B) -> B;
+    pure fn foldl<B>(b0: B, blk: fn(&B, &A) -> B) -> B;
     pure fn position(f: fn(&A) -> bool) -> Option<uint>;
 }
 
@@ -36,10 +36,10 @@ pub trait TimesIx{
 }
 
 pub trait CopyableIter<A:Copy> {
-    pure fn filter_to_vec(pred: fn(+a: A) -> bool) -> ~[A];
-    pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B];
+    pure fn filter_to_vec(pred: fn(a: A) -> bool) -> ~[A];
+    pure fn map_to_vec<B>(op: fn(v: A) -> B) -> ~[B];
     pure fn to_vec() -> ~[A];
-    pure fn find(p: fn(+a: A) -> bool) -> Option<A>;
+    pure fn find(p: fn(a: A) -> bool) -> Option<A>;
 }
 
 pub trait CopyableOrderedIter<A:Copy Ord> {
@@ -64,7 +64,7 @@ pub trait Buildable<A> {
      *             onto the sequence being constructed.
      */
      static pure fn build_sized(size: uint,
-                                builder: fn(push: pure fn(+v: A))) -> self;
+                                builder: fn(push: pure fn(v: A))) -> self;
 }
 
 pub pure fn eachi<A,IA:BaseIter<A>>(self: &IA,
@@ -93,7 +93,7 @@ pub pure fn any<A,IA:BaseIter<A>>(self: &IA,
 }
 
 pub pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(
-    self: &IA, prd: fn(+a: A) -> bool) -> ~[A] {
+    self: &IA, prd: fn(a: A) -> bool) -> ~[A] {
     do vec::build_sized_opt(self.size_hint()) |push| {
         for self.each |a| {
             if prd(*a) { push(*a); }
@@ -102,7 +102,7 @@ pub pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(
 }
 
 pub pure fn map_to_vec<A:Copy,B,IA:BaseIter<A>>(self: &IA,
-                                                op: fn(+v: A) -> B)
+                                                op: fn(v: A) -> B)
     -> ~[B] {
     do vec::build_sized_opt(self.size_hint()) |push| {
         for self.each |a| {
@@ -112,8 +112,7 @@ pub pure fn map_to_vec<A:Copy,B,IA:BaseIter<A>>(self: &IA,
 }
 
 pub pure fn flat_map_to_vec<A:Copy,B:Copy,IA:BaseIter<A>,IB:BaseIter<B>>(
-    self: &IA, op: fn(+a: A) -> IB) -> ~[B] {
-
+    self: &IA, op: fn(a: A) -> IB) -> ~[B] {
     do vec::build |push| {
         for self.each |a| {
             for op(*a).each |b| {
@@ -123,7 +122,7 @@ pub pure fn flat_map_to_vec<A:Copy,B:Copy,IA:BaseIter<A>,IB:BaseIter<B>>(
     }
 }
 
-pub pure fn foldl<A,B,IA:BaseIter<A>>(self: &IA, +b0: B,
+pub pure fn foldl<A,B,IA:BaseIter<A>>(self: &IA, b0: B,
                                       blk: fn(&B, &A) -> B)
     -> B {
     let mut b <- b0;
@@ -206,7 +205,7 @@ pub pure fn max<A:Copy Ord,IA:BaseIter<A>>(self: &IA) -> A {
 }
 
 pub pure fn find<A: Copy,IA:BaseIter<A>>(self: &IA,
-                                     p: fn(+a: A) -> bool) -> Option<A> {
+                                     p: fn(a: A) -> bool) -> Option<A> {
     for self.each |i| {
         if p(*i) { return Some(*i) }
     }
@@ -226,7 +225,7 @@ pub pure fn find<A: Copy,IA:BaseIter<A>>(self: &IA,
  *             onto the sequence being constructed.
  */
 #[inline(always)]
-pub pure fn build<A,B: Buildable<A>>(builder: fn(push: pure fn(+v: A)))
+pub pure fn build<A,B: Buildable<A>>(builder: fn(push: pure fn(v: A)))
     -> B {
     build_sized(4, builder)
 }
@@ -247,7 +246,7 @@ pub pure fn build<A,B: Buildable<A>>(builder: fn(push: pure fn(+v: A)))
 #[inline(always)]
 pub pure fn build_sized_opt<A,B: Buildable<A>>(
     size: Option<uint>,
-    builder: fn(push: pure fn(+v: A))) -> B {
+    builder: fn(push: pure fn(v: A))) -> B {
 
     build_sized(size.get_default(4), builder)
 }
@@ -285,7 +284,7 @@ pub pure fn from_fn<T,BT: Buildable<T>>(n_elts: uint,
  * to the value `t`.
  */
 pub pure fn from_elem<T: Copy,BT: Buildable<T>>(n_elts: uint,
-                                                +t: T) -> BT {
+                                                t: T) -> BT {
     do build_sized(n_elts) |push| {
         let mut i: uint = 0;
         while i < n_elts { push(t); i += 1; }
diff --git a/src/libcore/mutable.rs b/src/libcore/mutable.rs
index a1f65117ecf..5948c630cd8 100644
--- a/src/libcore/mutable.rs
+++ b/src/libcore/mutable.rs
@@ -8,8 +8,7 @@ dynamic checks: your program will fail if you attempt to perform
 mutation when the data structure should be immutable.
 
 */
-
-#[forbid(deprecated_mode)];
+// tjc: re-forbid deprecated modes after snapshot
 #[forbid(deprecated_pattern)];
 
 use util::with;
@@ -24,11 +23,11 @@ struct Data<T> {
 
 pub type Mut<T> = Data<T>;
 
-pub fn Mut<T>(+t: T) -> Mut<T> {
+pub fn Mut<T>(t: T) -> Mut<T> {
     Data {value: t, mode: ReadOnly}
 }
 
-pub fn unwrap<T>(+m: Mut<T>) -> T {
+pub fn unwrap<T>(m: Mut<T>) -> T {
     // Borrowck should prevent us from calling unwrap while the value
     // is in use, as that would be a move from a borrowed value.
     assert (m.mode as uint) == (ReadOnly as uint);
diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index 994e010e452..038c117b8be 100644
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -77,6 +77,6 @@ pub trait Shr<RHS,Result> {
 
 #[lang="index"]
 pub trait Index<Index,Result> {
-    pure fn index(+index: Index) -> Result;
+    pure fn index(index: Index) -> Result;
 }
 
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index 87d6aeefbc3..6bd326186cb 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -49,7 +49,7 @@ pub pure fn get_ref<T>(opt: &r/Option<T>) -> &r/T {
     }
 }
 
-pub pure fn expect<T: Copy>(opt: &Option<T>, +reason: ~str) -> T {
+pub pure fn expect<T: Copy>(opt: &Option<T>, reason: ~str) -> T {
     /*!
      * Gets the value out of an option, printing a specified message on
      * failure
@@ -67,8 +67,8 @@ pub pure fn map<T, U>(opt: &Option<T>, f: fn(x: &T) -> U) -> Option<U> {
     match *opt { Some(ref x) => Some(f(x)), None => None }
 }
 
-pub pure fn map_consume<T, U>(+opt: Option<T>,
-                              f: fn(+v: T) -> U) -> Option<U> {
+pub pure fn map_consume<T, U>(opt: Option<T>,
+                              f: fn(v: T) -> U) -> Option<U> {
     /*!
      * As `map`, but consumes the option and gives `f` ownership to avoid
      * copying.
@@ -76,8 +76,8 @@ pub pure fn map_consume<T, U>(+opt: Option<T>,
     if opt.is_some() { Some(f(option::unwrap(move opt))) } else { None }
 }
 
-pub pure fn chain<T, U>(+opt: Option<T>,
-                        f: fn(+t: T) -> Option<U>) -> Option<U> {
+pub pure fn chain<T, U>(opt: Option<T>,
+                        f: fn(t: T) -> Option<U>) -> Option<U> {
     /*!
      * Update an optional value by optionally running its content through a
      * function that returns an option.
@@ -101,7 +101,7 @@ pub pure fn chain_ref<T, U>(opt: &Option<T>,
     match *opt { Some(ref x) => f(x), None => None }
 }
 
-pub pure fn or<T>(+opta: Option<T>, +optb: Option<T>) -> Option<T> {
+pub pure fn or<T>(opta: Option<T>, optb: Option<T>) -> Option<T> {
     /*!
      * Returns the leftmost some() value, or none if both are none.
      */
@@ -112,7 +112,7 @@ pub pure fn or<T>(+opta: Option<T>, +optb: Option<T>) -> Option<T> {
 }
 
 #[inline(always)]
-pub pure fn while_some<T>(+x: Option<T>, blk: fn(+v: T) -> Option<T>) {
+pub pure fn while_some<T>(x: Option<T>, blk: fn(v: T) -> Option<T>) {
     //! Applies a function zero or more times until the result is none.
 
     let mut opt <- x;
@@ -133,13 +133,13 @@ pub pure fn is_some<T>(opt: &Option<T>) -> bool {
     !is_none(opt)
 }
 
-pub pure fn get_default<T: Copy>(opt: &Option<T>, +def: T) -> T {
+pub pure fn get_default<T: Copy>(opt: &Option<T>, def: T) -> T {
     //! Returns the contained value or a default
 
     match *opt { Some(copy x) => x, None => def }
 }
 
-pub pure fn map_default<T, U>(opt: &Option<T>, +def: U,
+pub pure fn map_default<T, U>(opt: &Option<T>, def: U,
                               f: fn(x: &T) -> U) -> U {
     //! Applies a function to the contained value or returns a default
 
@@ -151,10 +151,8 @@ pub pure fn iter<T>(opt: &Option<T>, f: fn(x: &T)) {
     match *opt { None => (), Some(ref t) => f(t) }
 }
 
-// tjc: shouldn't this be - instead of +?
-// then could get rid of some superfluous moves
 #[inline(always)]
-pub pure fn unwrap<T>(+opt: Option<T>) -> T {
+pub pure fn unwrap<T>(opt: Option<T>) -> T {
     /*!
      * Moves a value out of an option type and returns it.
      *
@@ -174,7 +172,7 @@ pub fn swap_unwrap<T>(opt: &mut Option<T>) -> T {
     unwrap(util::replace(opt, None))
 }
 
-pub pure fn unwrap_expect<T>(+opt: Option<T>, reason: &str) -> T {
+pub pure fn unwrap_expect<T>(opt: Option<T>, reason: &str) -> T {
     //! As unwrap, but with a specified failure message.
     if opt.is_none() { fail reason.to_unique(); }
     unwrap(move opt)
@@ -197,7 +195,7 @@ impl<T> &Option<T> {
         chain_ref(self, f)
     }
     /// Applies a function to the contained value or returns a default
-    pure fn map_default<U>(+def: U, f: fn(x: &T) -> U) -> U
+    pure fn map_default<U>(def: U, f: fn(x: &T) -> U) -> U
         { map_default(self, move def, f) }
     /// Performs an operation on the contained value by reference
     pure fn iter(f: fn(x: &T)) { iter(self, f) }
@@ -216,7 +214,7 @@ impl<T: Copy> Option<T> {
      * Fails if the value equals `none`
      */
     pure fn get() -> T { get(&self) }
-    pure fn get_default(+def: T) -> T { get_default(&self, def) }
+    pure fn get_default(def: T) -> T { get_default(&self, def) }
     /**
      * Gets the value out of an option, printing a specified message on
      * failure
@@ -225,9 +223,9 @@ impl<T: Copy> Option<T> {
      *
      * Fails if the value equals `none`
      */
-    pure fn expect(+reason: ~str) -> T { expect(&self, reason) }
+    pure fn expect(reason: ~str) -> T { expect(&self, reason) }
     /// Applies a function zero or more times until the result is none.
-    pure fn while_some(blk: fn(+v: T) -> Option<T>) { while_some(self, blk) }
+    pure fn while_some(blk: fn(v: T) -> Option<T>) { while_some(self, blk) }
 }
 
 impl<T: Eq> Option<T> : Eq {
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
index 1cf4fbab6c9..f178502f6a0 100644
--- a/src/libcore/os.rs
+++ b/src/libcore/os.rs
@@ -1,5 +1,5 @@
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+// tjc: re-forbid
 #[forbid(deprecated_pattern)];
 
 /*!
@@ -768,7 +768,7 @@ struct OverriddenArgs {
     val: ~[~str]
 }
 
-fn overridden_arg_key(+_v: @OverriddenArgs) {}
+fn overridden_arg_key(_v: @OverriddenArgs) {}
 
 pub fn args() -> ~[~str] {
     unsafe {
@@ -779,7 +779,7 @@ pub fn args() -> ~[~str] {
     }
 }
 
-pub fn set_args(+new_args: ~[~str]) {
+pub fn set_args(new_args: ~[~str]) {
     unsafe {
         let overridden_args = @OverriddenArgs { val: copy new_args };
         task::local_data::local_data_set(overridden_arg_key, overridden_args);
diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs
index 4d446df9cd5..e34c0db35e9 100644
--- a/src/libcore/pipes.rs
+++ b/src/libcore/pipes.rs
@@ -73,7 +73,7 @@ bounded and unbounded protocols allows for less code duplication.
 */
 
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+// tjc: re-forbid deprecated modes after snapshot
 #[forbid(deprecated_pattern)];
 
 use cmp::Eq;
@@ -169,7 +169,7 @@ impl PacketHeader {
         reinterpret_cast(&self.buffer)
     }
 
-    fn set_buffer<T: Send>(+b: ~Buffer<T>) unsafe {
+    fn set_buffer<T: Send>(b: ~Buffer<T>) unsafe {
         self.buffer = reinterpret_cast(&b);
     }
 }
@@ -227,7 +227,7 @@ pub fn packet<T: Send>() -> *Packet<T> {
 
 #[doc(hidden)]
 pub fn entangle_buffer<T: Send, Tstart: Send>(
-    +buffer: ~Buffer<T>,
+    buffer: ~Buffer<T>,
     init: fn(*libc::c_void, x: &T) -> *Packet<Tstart>)
     -> (SendPacketBuffered<Tstart, T>, RecvPacketBuffered<Tstart, T>)
 {
@@ -239,12 +239,12 @@ pub fn entangle_buffer<T: Send, Tstart: Send>(
 #[abi = "rust-intrinsic"]
 #[doc(hidden)]
 extern mod rusti {
-    fn atomic_xchg(dst: &mut int, +src: int) -> int;
-    fn atomic_xchg_acq(dst: &mut int, +src: int) -> int;
-    fn atomic_xchg_rel(dst: &mut int, +src: int) -> int;
+    fn atomic_xchg(dst: &mut int, src: int) -> int;
+    fn atomic_xchg_acq(dst: &mut int, src: int) -> int;
+    fn atomic_xchg_rel(dst: &mut int, src: int) -> int;
 
-    fn atomic_xadd_acq(dst: &mut int, +src: int) -> int;
-    fn atomic_xsub_rel(dst: &mut int, +src: int) -> int;
+    fn atomic_xadd_acq(dst: &mut int, src: int) -> int;
+    fn atomic_xsub_rel(dst: &mut int, src: int) -> int;
 }
 
 // If I call the rusti versions directly from a polymorphic function,
@@ -265,7 +265,7 @@ pub fn atomic_sub_rel(dst: &mut int, src: int) -> int {
 }
 
 #[doc(hidden)]
-pub fn swap_task(+dst: &mut *rust_task, src: *rust_task) -> *rust_task {
+pub fn swap_task(dst: &mut *rust_task, src: *rust_task) -> *rust_task {
     // It might be worth making both acquire and release versions of
     // this.
     unsafe {
@@ -304,14 +304,14 @@ fn wait_event(this: *rust_task) -> *libc::c_void {
 }
 
 #[doc(hidden)]
-fn swap_state_acq(+dst: &mut State, src: State) -> State {
+fn swap_state_acq(dst: &mut State, src: State) -> State {
     unsafe {
         transmute(rusti::atomic_xchg_acq(transmute(move dst), src as int))
     }
 }
 
 #[doc(hidden)]
-fn swap_state_rel(+dst: &mut State, src: State) -> State {
+fn swap_state_rel(dst: &mut State, src: State) -> State {
     unsafe {
         transmute(rusti::atomic_xchg_rel(transmute(move dst), src as int))
     }
@@ -343,7 +343,7 @@ struct BufferResource<T: Send> {
     }
 }
 
-fn BufferResource<T: Send>(+b: ~Buffer<T>) -> BufferResource<T> {
+fn BufferResource<T: Send>(b: ~Buffer<T>) -> BufferResource<T> {
     //let p = ptr::addr_of(*b);
     //error!("take %?", p);
     atomic_add_acq(&mut b.header.ref_count, 1);
@@ -354,8 +354,8 @@ fn BufferResource<T: Send>(+b: ~Buffer<T>) -> BufferResource<T> {
 }
 
 #[doc(hidden)]
-pub fn send<T: Send, Tbuffer: Send>(+p: SendPacketBuffered<T, Tbuffer>,
-                                    +payload: T) -> bool {
+pub fn send<T: Send, Tbuffer: Send>(p: SendPacketBuffered<T, Tbuffer>,
+                                    payload: T) -> bool {
     let header = p.header();
     let p_ = p.unwrap();
     let p = unsafe { &*p_ };
@@ -398,7 +398,7 @@ pub fn send<T: Send, Tbuffer: Send>(+p: SendPacketBuffered<T, Tbuffer>,
 Fails if the sender closes the connection.
 
 */
-pub fn recv<T: Send, Tbuffer: Send>(+p: RecvPacketBuffered<T, Tbuffer>) -> T {
+pub fn recv<T: Send, Tbuffer: Send>(p: RecvPacketBuffered<T, Tbuffer>) -> T {
     option::unwrap_expect(try_recv(move p), "connection closed")
 }
 
@@ -408,7 +408,7 @@ Returns `none` if the sender has closed the connection without sending
 a message, or `Some(T)` if a message was received.
 
 */
-pub fn try_recv<T: Send, Tbuffer: Send>(+p: RecvPacketBuffered<T, Tbuffer>)
+pub fn try_recv<T: Send, Tbuffer: Send>(p: RecvPacketBuffered<T, Tbuffer>)
     -> Option<T>
 {
     let p_ = p.unwrap();
@@ -655,8 +655,8 @@ this case, `select2` may return either `left` or `right`.
 
 */
 pub fn select2<A: Send, Ab: Send, B: Send, Bb: Send>(
-    +a: RecvPacketBuffered<A, Ab>,
-    +b: RecvPacketBuffered<B, Bb>)
+    a: RecvPacketBuffered<A, Ab>,
+    b: RecvPacketBuffered<B, Bb>)
     -> Either<(Option<A>, RecvPacketBuffered<B, Bb>),
               (RecvPacketBuffered<A, Ab>, Option<B>)>
 {
@@ -697,7 +697,7 @@ pub fn select2i<A: Selectable, B: Selectable>(a: &A, b: &B) ->
  list of the remaining endpoints.
 
 */
-pub fn select<T: Send, Tb: Send>(+endpoints: ~[RecvPacketBuffered<T, Tb>])
+pub fn select<T: Send, Tb: Send>(endpoints: ~[RecvPacketBuffered<T, Tb>])
     -> (uint, Option<T>, ~[RecvPacketBuffered<T, Tb>])
 {
     let ready = wait_many(endpoints.map(|p| p.header()));
@@ -859,7 +859,7 @@ endpoint is passed to the new task.
 pub fn spawn_service<T: Send, Tb: Send>(
     init: extern fn() -> (SendPacketBuffered<T, Tb>,
                           RecvPacketBuffered<T, Tb>),
-    +service: fn~(+v: RecvPacketBuffered<T, Tb>))
+    +service: fn~(v: RecvPacketBuffered<T, Tb>))
     -> SendPacketBuffered<T, Tb>
 {
     let (client, server) = init();
@@ -883,7 +883,7 @@ receive state.
 pub fn spawn_service_recv<T: Send, Tb: Send>(
     init: extern fn() -> (RecvPacketBuffered<T, Tb>,
                           SendPacketBuffered<T, Tb>),
-    +service: fn~(+v: SendPacketBuffered<T, Tb>))
+    +service: fn~(v: SendPacketBuffered<T, Tb>))
     -> RecvPacketBuffered<T, Tb>
 {
     let (client, server) = init();
@@ -914,10 +914,10 @@ pub trait Channel<T: Send> {
     // built in send kind.
 
     /// Sends a message.
-    fn send(+x: T);
+    fn send(x: T);
 
     /// Sends a message, or report if the receiver has closed the connection.
-    fn try_send(+x: T) -> bool;
+    fn try_send(x: T) -> bool;
 }
 
 /// A trait for things that can receive multiple messages.
@@ -966,14 +966,14 @@ pub fn stream<T:Send>() -> (Chan<T>, Port<T>) {
 }
 
 impl<T: Send> Chan<T>: Channel<T> {
-    fn send(+x: T) {
+    fn send(x: T) {
         let mut endp = None;
         endp <-> self.endp;
         self.endp = Some(
             streamp::client::data(unwrap(move endp), move x))
     }
 
-    fn try_send(+x: T) -> bool {
+    fn try_send(x: T) -> bool {
         let mut endp = None;
         endp <-> self.endp;
         match move streamp::client::try_data(unwrap(move endp), move x) {
@@ -1041,7 +1041,7 @@ pub fn PortSet<T: Send>() -> PortSet<T>{
 
 impl<T: Send> PortSet<T> : Recv<T> {
 
-    fn add(+port: pipes::Port<T>) {
+    fn add(port: pipes::Port<T>) {
         self.ports.push(move port)
     }
 
@@ -1091,7 +1091,7 @@ impl<T: Send> PortSet<T> : Recv<T> {
 pub type SharedChan<T: Send> = private::Exclusive<Chan<T>>;
 
 impl<T: Send> SharedChan<T>: Channel<T> {
-    fn send(+x: T) {
+    fn send(x: T) {
         let mut xx = Some(move x);
         do self.with_imm |chan| {
             let mut x = None;
@@ -1100,7 +1100,7 @@ impl<T: Send> SharedChan<T>: Channel<T> {
         }
     }
 
-    fn try_send(+x: T) -> bool {
+    fn try_send(x: T) -> bool {
         let mut xx = Some(move x);
         do self.with_imm |chan| {
             let mut x = None;
@@ -1111,7 +1111,7 @@ impl<T: Send> SharedChan<T>: Channel<T> {
 }
 
 /// Converts a `chan` into a `shared_chan`.
-pub fn SharedChan<T:Send>(+c: Chan<T>) -> SharedChan<T> {
+pub fn SharedChan<T:Send>(c: Chan<T>) -> SharedChan<T> {
     private::exclusive(move c)
 }
 
@@ -1165,13 +1165,13 @@ pub fn oneshot<T: Send>() -> (ChanOne<T>, PortOne<T>) {
  * Receive a message from a oneshot pipe, failing if the connection was
  * closed.
  */
-pub fn recv_one<T: Send>(+port: PortOne<T>) -> T {
+pub fn recv_one<T: Send>(port: PortOne<T>) -> T {
     let oneshot::send(message) = recv(move port);
     move message
 }
 
 /// Receive a message from a oneshot pipe unless the connection was closed.
-pub fn try_recv_one<T: Send> (+port: PortOne<T>) -> Option<T> {
+pub fn try_recv_one<T: Send> (port: PortOne<T>) -> Option<T> {
     let message = try_recv(move port);
 
     if message.is_none() { None }
@@ -1182,7 +1182,7 @@ pub fn try_recv_one<T: Send> (+port: PortOne<T>) -> Option<T> {
 }
 
 /// Send a message on a oneshot pipe, failing if the connection was closed.
-pub fn send_one<T: Send>(+chan: ChanOne<T>, +data: T) {
+pub fn send_one<T: Send>(chan: ChanOne<T>, data: T) {
     oneshot::client::send(move chan, move data);
 }
 
@@ -1190,7 +1190,7 @@ pub fn send_one<T: Send>(+chan: ChanOne<T>, +data: T) {
  * Send a message on a oneshot pipe, or return false if the connection was
  * closed.
  */
-pub fn try_send_one<T: Send>(+chan: ChanOne<T>, +data: T)
+pub fn try_send_one<T: Send>(chan: ChanOne<T>, data: T)
         -> bool {
     oneshot::client::try_send(move chan, move data).is_some()
 }
@@ -1198,7 +1198,7 @@ pub fn try_send_one<T: Send>(+chan: ChanOne<T>, +data: T)
 pub mod rt {
     // These are used to hide the option constructors from the
     // compiler because their names are changing
-    pub fn make_some<T>(+val: T) -> Option<T> { Some(move val) }
+    pub fn make_some<T>(val: T) -> Option<T> { Some(move val) }
     pub fn make_none<T>() -> Option<T> { None }
 }
 
diff --git a/src/libcore/private.rs b/src/libcore/private.rs
index 025a6f28976..c1b2b32edaf 100644
--- a/src/libcore/private.rs
+++ b/src/libcore/private.rs
@@ -1,5 +1,5 @@
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+// tjc: re-forbid deprecated modes after snapshot
 #[forbid(deprecated_pattern)];
 
 #[doc(hidden)];
@@ -340,7 +340,7 @@ fn ArcDestruct<T>(data: *libc::c_void) -> ArcDestruct<T> {
     }
 }
 
-pub unsafe fn unwrap_shared_mutable_state<T: Send>(+rc: SharedMutableState<T>)
+pub unsafe fn unwrap_shared_mutable_state<T: Send>(rc: SharedMutableState<T>)
         -> T {
     struct DeathThroes<T> {
         mut ptr:      Option<~ArcData<T>>,
@@ -413,7 +413,7 @@ pub unsafe fn unwrap_shared_mutable_state<T: Send>(+rc: SharedMutableState<T>)
  */
 pub type SharedMutableState<T: Send> = ArcDestruct<T>;
 
-pub unsafe fn shared_mutable_state<T: Send>(+data: T) ->
+pub unsafe fn shared_mutable_state<T: Send>(data: T) ->
         SharedMutableState<T> {
     let data = ~ArcData { count: 1, unwrapper: 0, data: Some(move data) };
     unsafe {
@@ -502,7 +502,7 @@ struct ExData<T: Send> { lock: LittleLock, mut failed: bool, mut data: T, }
  */
 pub struct Exclusive<T: Send> { x: SharedMutableState<ExData<T>> }
 
-pub fn exclusive<T:Send >(+user_data: T) -> Exclusive<T> {
+pub fn exclusive<T:Send >(user_data: T) -> Exclusive<T> {
     let data = ExData {
         lock: LittleLock(), mut failed: false, mut data: user_data
     };
@@ -544,7 +544,7 @@ impl<T: Send> Exclusive<T> {
 }
 
 // FIXME(#2585) make this a by-move method on the exclusive
-pub fn unwrap_exclusive<T: Send>(+arc: Exclusive<T>) -> T {
+pub fn unwrap_exclusive<T: Send>(arc: Exclusive<T>) -> T {
     let Exclusive { x: x } <- arc;
     let inner = unsafe { unwrap_shared_mutable_state(move x) };
     let ExData { data: data, _ } <- inner;
diff --git a/src/libcore/reflect.rs b/src/libcore/reflect.rs
index af6a3f9b478..41006e1dfb5 100644
--- a/src/libcore/reflect.rs
+++ b/src/libcore/reflect.rs
@@ -27,7 +27,7 @@ fn align(size: uint, align: uint) -> uint {
 struct MovePtrAdaptor<V: TyVisitor MovePtr> {
     inner: V
 }
-pub fn MovePtrAdaptor<V: TyVisitor MovePtr>(+v: V) -> MovePtrAdaptor<V> {
+pub fn MovePtrAdaptor<V: TyVisitor MovePtr>(v: V) -> MovePtrAdaptor<V> {
     MovePtrAdaptor { inner: move v }
 }
 
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index e454c068d47..e61690d5b2c 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -1,7 +1,7 @@
 //! A type representing either success or failure
 
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+// tjc: re-forbid deprecated modes after snapshot
 #[forbid(deprecated_pattern)];
 
 use cmp::Eq;
@@ -102,7 +102,7 @@ pub pure fn to_either<T: Copy, U: Copy>(res: &Result<U, T>)
  *         ok(parse_bytes(buf))
  *     }
  */
-pub fn chain<T, U: Copy, V: Copy>(+res: Result<T, V>, op: fn(+t: T)
+pub fn chain<T, U: Copy, V: Copy>(res: Result<T, V>, op: fn(t: T)
     -> Result<U, V>) -> Result<U, V> {
     // XXX: Should be writable with move + match
     if res.is_ok() {
@@ -121,8 +121,8 @@ pub fn chain<T, U: Copy, V: Copy>(+res: Result<T, V>, op: fn(+t: T)
  * successful result while handling an error.
  */
 pub fn chain_err<T: Copy, U: Copy, V: Copy>(
-    +res: Result<T, V>,
-    op: fn(+t: V) -> Result<T, U>)
+    res: Result<T, V>,
+    op: fn(t: V) -> Result<T, U>)
     -> Result<T, U> {
     match move res {
       Ok(move t) => Ok(t),
@@ -247,12 +247,12 @@ impl<T, E: Copy> Result<T, E> {
 }
 
 impl<T: Copy, E: Copy> Result<T, E> {
-    fn chain<U:Copy>(op: fn(+t: T) -> Result<U,E>) -> Result<U,E> {
+    fn chain<U:Copy>(op: fn(t: T) -> Result<U,E>) -> Result<U,E> {
         // XXX: Bad copy
         chain(copy self, op)
     }
 
-    fn chain_err<F:Copy>(op: fn(+t: E) -> Result<T,F>) -> Result<T,F> {
+    fn chain_err<F:Copy>(op: fn(t: E) -> Result<T,F>) -> Result<T,F> {
         // XXX: Bad copy
         chain_err(copy self, op)
     }
@@ -348,7 +348,7 @@ pub fn iter_vec2<S,T,U:Copy>(ss: &[S], ts: &[T],
 }
 
 /// Unwraps a result, assuming it is an `ok(T)`
-pub fn unwrap<T, U>(+res: Result<T, U>) -> T {
+pub fn unwrap<T, U>(res: Result<T, U>) -> T {
     match move res {
       Ok(move t) => move t,
       Err(_) => fail ~"unwrap called on an err result"
@@ -356,7 +356,7 @@ pub fn unwrap<T, U>(+res: Result<T, U>) -> T {
 }
 
 /// Unwraps a result, assuming it is an `err(U)`
-pub fn unwrap_err<T, U>(+res: Result<T, U>) -> U {
+pub fn unwrap_err<T, U>(res: Result<T, U>) -> U {
     match move res {
       Err(move u) => move u,
       Ok(_) => fail ~"unwrap called on an ok result"
@@ -389,7 +389,7 @@ mod tests {
     #[legacy_exports];
     fn op1() -> result::Result<int, ~str> { result::Ok(666) }
 
-    fn op2(+i: int) -> result::Result<uint, ~str> {
+    fn op2(i: int) -> result::Result<uint, ~str> {
         result::Ok(i as uint + 1u)
     }
 
diff --git a/src/libcore/run.rs b/src/libcore/run.rs
index 40c2bc83351..f3e98f6ba82 100644
--- a/src/libcore/run.rs
+++ b/src/libcore/run.rs
@@ -1,5 +1,5 @@
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+// tjc: re-forbid deprecated modes after snapshot
 #[forbid(deprecated_pattern)];
 
 //! Process spawning
@@ -224,7 +224,7 @@ pub fn start_program(prog: &str, args: &[~str]) -> Program {
         drop { destroy_repr(&self.r); }
     }
 
-    fn ProgRes(+r: ProgRepr) -> ProgRes {
+    fn ProgRes(r: ProgRepr) -> ProgRes {
         ProgRes {
             r: r
         }
@@ -328,7 +328,7 @@ pub fn program_output(prog: &str, args: &[~str]) ->
     return {status: status, out: move outs, err: move errs};
 }
 
-fn writeclose(fd: c_int, +s: ~str) {
+fn writeclose(fd: c_int, s: ~str) {
     use io::WriterUtil;
 
     error!("writeclose %d, %s", fd as int, s);
diff --git a/src/libcore/send_map.rs b/src/libcore/send_map.rs
index 1b219e16e09..4a56ee5b896 100644
--- a/src/libcore/send_map.rs
+++ b/src/libcore/send_map.rs
@@ -15,7 +15,7 @@ use to_bytes::IterBytes;
 pub trait SendMap<K:Eq Hash, V: Copy> {
     // FIXME(#3148)  ^^^^ once find_ref() works, we can drop V:copy
 
-    fn insert(&mut self, +k: K, +v: V) -> bool;
+    fn insert(&mut self, k: K, +v: V) -> bool;
     fn remove(&mut self, k: &K) -> bool;
     fn clear(&mut self);
     pure fn len(&const self) -> uint;
@@ -161,7 +161,7 @@ pub mod linear {
             }
         }
 
-        fn insert_opt_bucket(&mut self, +bucket: Option<Bucket<K,V>>) {
+        fn insert_opt_bucket(&mut self, bucket: Option<Bucket<K,V>>) {
             match move bucket {
                 Some(Bucket {hash: move hash,
                              key: move key,
@@ -175,7 +175,7 @@ pub mod linear {
         /// Inserts the key value pair into the buckets.
         /// Assumes that there will be a bucket.
         /// True if there was no previous entry with that key
-        fn insert_internal(&mut self, hash: uint, +k: K, +v: V) -> bool {
+        fn insert_internal(&mut self, hash: uint, k: K, v: V) -> bool {
             match self.bucket_for_key_with_hash(self.buckets, hash, &k) {
                 TableFull => { fail ~"Internal logic error"; }
                 FoundHole(idx) => {
@@ -206,7 +206,7 @@ pub mod linear {
     }
 
     impl<K:Hash IterBytes Eq,V> LinearMap<K,V> {
-        fn insert(&mut self, +k: K, +v: V) -> bool {
+        fn insert(&mut self, k: K, v: V) -> bool {
             if self.size >= self.resize_at {
                 // n.b.: We could also do this after searching, so
                 // that we do not resize if this call to insert is
diff --git a/src/libcore/stackwalk.rs b/src/libcore/stackwalk.rs
index d0f8de136e2..09973148c8c 100644
--- a/src/libcore/stackwalk.rs
+++ b/src/libcore/stackwalk.rs
@@ -1,5 +1,7 @@
 #[doc(hidden)]; // FIXME #3538
 
+#[legacy_modes]; // tjc: remove after snapshot
+
 // NB: transitionary, de-mode-ing.
 // XXX: Can't do this because frame_address needs a deprecated mode.
 //#[forbid(deprecated_mode)];
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index e8a88f3bc1b..cf996a8b254 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -175,7 +175,7 @@ pub fn push_str(lhs: &const ~str, rhs: &str) {
 
 /// Concatenate two strings together
 #[inline(always)]
-pub pure fn append(+lhs: ~str, rhs: &str) -> ~str {
+pub pure fn append(lhs: ~str, rhs: &str) -> ~str {
     let mut v <- lhs;
     unsafe {
         push_str_no_overallocate(&mut v, rhs);
diff --git a/src/libcore/sys.rs b/src/libcore/sys.rs
index 9f13a6c2207..12329616fbf 100644
--- a/src/libcore/sys.rs
+++ b/src/libcore/sys.rs
@@ -83,7 +83,7 @@ pub pure fn pref_align_of<T>() -> uint {
 
 /// Returns the refcount of a shared box (as just before calling this)
 #[inline(always)]
-pub pure fn refcount<T>(+t: @T) -> uint {
+pub pure fn refcount<T>(t: @T) -> uint {
     unsafe {
         let ref_ptr: *uint = cast::reinterpret_cast(&t);
         *ref_ptr - 1
diff --git a/src/libcore/task.rs b/src/libcore/task.rs
index 912b7f712aa..5ca35a7f562 100644
--- a/src/libcore/task.rs
+++ b/src/libcore/task.rs
@@ -1,5 +1,5 @@
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+// tjc: re-forbid deprecated modes after snapshot
 #[forbid(deprecated_pattern)];
 
 /*!
@@ -232,7 +232,7 @@ pub enum TaskBuilder = {
 pub fn task() -> TaskBuilder {
     TaskBuilder({
         opts: default_task_opts(),
-        gen_body: |body| move body, // Identity function
+        gen_body: |+body| move body, // Identity function
         can_not_copy: None,
         mut consumed: false,
     })
@@ -347,7 +347,7 @@ impl TaskBuilder {
      * # Failure
      * Fails if a future_result was already set for this task.
      */
-    fn future_result(blk: fn(+v: future::Future<TaskResult>)) -> TaskBuilder {
+    fn future_result(blk: fn(v: future::Future<TaskResult>)) -> TaskBuilder {
         // FIXME (#1087, #1857): Once linked failure and notification are
         // handled in the library, I can imagine implementing this by just
         // registering an arbitrary number of task::on_exit handlers and
@@ -459,9 +459,9 @@ impl TaskBuilder {
         spawn::spawn_raw(move opts, x.gen_body(move f));
     }
     /// Runs a task, while transfering ownership of one argument to the child.
-    fn spawn_with<A: Send>(+arg: A, +f: fn~(+v: A)) {
+    fn spawn_with<A: Send>(arg: A, +f: fn~(+v: A)) {
         let arg = ~mut Some(move arg);
-        do self.spawn |move arg, move f|{
+        do self.spawn |move arg, move f| {
             f(option::swap_unwrap(arg))
         }
     }
@@ -473,7 +473,7 @@ impl TaskBuilder {
      * child task, passes the port to child's body, and returns a channel
      * linked to the port to the parent.
      *
-     * This encapsulates Some boilerplate handshaking logic that would
+     * This encapsulates some boilerplate handshaking logic that would
      * otherwise be required to establish communication from the parent
      * to the child.
      */
@@ -1149,7 +1149,7 @@ fn test_avoid_copying_the_body_spawn() {
 
 #[test]
 fn test_avoid_copying_the_body_spawn_listener() {
-    do avoid_copying_the_body |f| {
+    do avoid_copying_the_body |+f| {
         spawn_listener(fn~(move f, _po: comm::Port<int>) {
             f();
         });
@@ -1167,7 +1167,7 @@ fn test_avoid_copying_the_body_task_spawn() {
 
 #[test]
 fn test_avoid_copying_the_body_spawn_listener_1() {
-    do avoid_copying_the_body |f| {
+    do avoid_copying_the_body |+f| {
         task().spawn_listener(fn~(move f, _po: comm::Port<int>) {
             f();
         });
diff --git a/src/libcore/task/local_data.rs b/src/libcore/task/local_data.rs
index eda76518001..2130354229a 100644
--- a/src/libcore/task/local_data.rs
+++ b/src/libcore/task/local_data.rs
@@ -37,7 +37,7 @@ use local_data_priv::{
  *
  * These two cases aside, the interface is safe.
  */
-pub type LocalDataKey<T: Owned> = &fn(+v: @T);
+pub type LocalDataKey<T: Owned> = &fn(v: @T);
 
 /**
  * Remove a task-local data value from the table, returning the
@@ -62,7 +62,7 @@ pub unsafe fn local_data_get<T: Owned>(
  * that value is overwritten (and its destructor is run).
  */
 pub unsafe fn local_data_set<T: Owned>(
-    key: LocalDataKey<T>, +data: @T) {
+    key: LocalDataKey<T>, data: @T) {
 
     local_set(rt::rust_get_task(), key, data)
 }
@@ -79,7 +79,7 @@ pub unsafe fn local_data_modify<T: Owned>(
 
 #[test]
 pub fn test_tls_multitask() unsafe {
-    fn my_key(+_x: @~str) { }
+    fn my_key(_x: @~str) { }
     local_data_set(my_key, @~"parent data");
     do task::spawn unsafe {
         assert local_data_get(my_key).is_none(); // TLS shouldn't carry over.
@@ -95,7 +95,7 @@ pub fn test_tls_multitask() unsafe {
 
 #[test]
 pub fn test_tls_overwrite() unsafe {
-    fn my_key(+_x: @~str) { }
+    fn my_key(_x: @~str) { }
     local_data_set(my_key, @~"first data");
     local_data_set(my_key, @~"next data"); // Shouldn't leak.
     assert *(local_data_get(my_key).get()) == ~"next data";
@@ -103,7 +103,7 @@ pub fn test_tls_overwrite() unsafe {
 
 #[test]
 pub fn test_tls_pop() unsafe {
-    fn my_key(+_x: @~str) { }
+    fn my_key(_x: @~str) { }
     local_data_set(my_key, @~"weasel");
     assert *(local_data_pop(my_key).get()) == ~"weasel";
     // Pop must remove the data from the map.
@@ -112,7 +112,7 @@ pub fn test_tls_pop() unsafe {
 
 #[test]
 pub fn test_tls_modify() unsafe {
-    fn my_key(+_x: @~str) { }
+    fn my_key(_x: @~str) { }
     local_data_modify(my_key, |data| {
         match data {
             Some(@ref val) => fail ~"unwelcome value: " + *val,
@@ -136,7 +136,7 @@ pub fn test_tls_crust_automorestack_memorial_bug() unsafe {
     // jump over to the rust stack, which causes next_c_sp to get recorded as
     // Something within a rust stack segment. Then a subsequent upcall (esp.
     // for logging, think vsnprintf) would run on a stack smaller than 1 MB.
-    fn my_key(+_x: @~str) { }
+    fn my_key(_x: @~str) { }
     do task::spawn {
         unsafe { local_data_set(my_key, @~"hax"); }
     }
@@ -144,9 +144,9 @@ pub fn test_tls_crust_automorestack_memorial_bug() unsafe {
 
 #[test]
 pub fn test_tls_multiple_types() unsafe {
-    fn str_key(+_x: @~str) { }
-    fn box_key(+_x: @@()) { }
-    fn int_key(+_x: @int) { }
+    fn str_key(_x: @~str) { }
+    fn box_key(_x: @@()) { }
+    fn int_key(_x: @int) { }
     do task::spawn unsafe {
         local_data_set(str_key, @~"string data");
         local_data_set(box_key, @@());
@@ -156,9 +156,9 @@ pub fn test_tls_multiple_types() unsafe {
 
 #[test]
 pub fn test_tls_overwrite_multiple_types() {
-    fn str_key(+_x: @~str) { }
-    fn box_key(+_x: @@()) { }
-    fn int_key(+_x: @int) { }
+    fn str_key(_x: @~str) { }
+    fn box_key(_x: @@()) { }
+    fn int_key(_x: @int) { }
     do task::spawn unsafe {
         local_data_set(str_key, @~"string data");
         local_data_set(int_key, @42);
@@ -172,9 +172,9 @@ pub fn test_tls_overwrite_multiple_types() {
 #[should_fail]
 #[ignore(cfg(windows))]
 pub fn test_tls_cleanup_on_failure() unsafe {
-    fn str_key(+_x: @~str) { }
-    fn box_key(+_x: @@()) { }
-    fn int_key(+_x: @int) { }
+    fn str_key(_x: @~str) { }
+    fn box_key(_x: @@()) { }
+    fn int_key(_x: @int) { }
     local_data_set(str_key, @~"parent data");
     local_data_set(box_key, @@());
     do task::spawn unsafe { // spawn_linked
diff --git a/src/libcore/task/local_data_priv.rs b/src/libcore/task/local_data_priv.rs
index 0d3007286c5..499dd073060 100644
--- a/src/libcore/task/local_data_priv.rs
+++ b/src/libcore/task/local_data_priv.rs
@@ -117,7 +117,7 @@ unsafe fn local_get<T: Owned>(
 }
 
 unsafe fn local_set<T: Owned>(
-    task: *rust_task, key: LocalDataKey<T>, +data: @T) {
+    task: *rust_task, key: LocalDataKey<T>, data: @T) {
 
     let map = get_task_local_map(task);
     // Store key+data as *voids. Data is invisibly referenced once; key isn't.
diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs
index 982679f9398..786255fe7fa 100644
--- a/src/libcore/task/spawn.rs
+++ b/src/libcore/task/spawn.rs
@@ -82,7 +82,7 @@ fn taskset_remove(tasks: &mut TaskSet, task: *rust_task) {
     let was_present = tasks.remove(&task);
     assert was_present;
 }
-fn taskset_each(tasks: &TaskSet, blk: fn(+v: *rust_task) -> bool) {
+fn taskset_each(tasks: &TaskSet, blk: fn(v: *rust_task) -> bool) {
     tasks.each_key(|k| blk(*k))
 }
 
@@ -303,8 +303,8 @@ struct TCB {
     }
 }
 
-fn TCB(me: *rust_task, +tasks: TaskGroupArc, +ancestors: AncestorList,
-       is_main: bool, +notifier: Option<AutoNotify>) -> TCB {
+fn TCB(me: *rust_task, tasks: TaskGroupArc, ancestors: AncestorList,
+       is_main: bool, notifier: Option<AutoNotify>) -> TCB {
 
     let notifier = move notifier;
     notifier.iter(|x| { x.failed = false; });
@@ -327,7 +327,7 @@ struct AutoNotify {
     }
 }
 
-fn AutoNotify(+chan: Chan<Notification>) -> AutoNotify {
+fn AutoNotify(chan: Chan<Notification>) -> AutoNotify {
     AutoNotify {
         notify_chan: chan,
         failed: true // Un-set above when taskgroup successfully made.
@@ -377,13 +377,13 @@ fn kill_taskgroup(state: TaskGroupInner, me: *rust_task, is_main: bool) {
     // see 'None' if Somebody already failed and we got a kill signal.)
     if newstate.is_some() {
         let group = option::unwrap(move newstate);
-        for taskset_each(&group.members) |+sibling| {
+        for taskset_each(&group.members) |sibling| {
             // Skip self - killing ourself won't do much good.
             if sibling != me {
                 rt::rust_task_kill_other(sibling);
             }
         }
-        for taskset_each(&group.descendants) |+child| {
+        for taskset_each(&group.descendants) |child| {
             assert child != me;
             rt::rust_task_kill_other(child);
         }
@@ -486,7 +486,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
     }
 }
 
-fn spawn_raw(+opts: TaskOpts, +f: fn~()) {
+fn spawn_raw(opts: TaskOpts, +f: fn~()) {
     let (child_tg, ancestors, is_main) =
         gen_child_taskgroup(opts.linked, opts.supervised);
 
@@ -528,9 +528,9 @@ fn spawn_raw(+opts: TaskOpts, +f: fn~()) {
     // (3a) If any of those fails, it leaves all groups, and does nothing.
     // (3b) Otherwise it builds a task control structure and puts it in TLS,
     // (4) ...and runs the provided body function.
-    fn make_child_wrapper(child: *rust_task, +child_arc: TaskGroupArc,
-                          +ancestors: AncestorList, is_main: bool,
-                          +notify_chan: Option<Chan<Notification>>,
+    fn make_child_wrapper(child: *rust_task, child_arc: TaskGroupArc,
+                          ancestors: AncestorList, is_main: bool,
+                          notify_chan: Option<Chan<Notification>>,
                           +f: fn~()) -> fn~() {
         let child_data = ~mut Some((move child_arc, move ancestors));
         return fn~(move notify_chan, move child_data, move f) {
diff --git a/src/libcore/util.rs b/src/libcore/util.rs
index 9ba8b52f5da..aa1fe14ba88 100644
--- a/src/libcore/util.rs
+++ b/src/libcore/util.rs
@@ -5,25 +5,25 @@ Miscellaneous helpers for common patterns.
 */
 
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+// tjc: re-forbid deprecated modes after snapshot
 #[forbid(deprecated_pattern)];
 
 use cmp::Eq;
 
 /// The identity function.
 #[inline(always)]
-pub pure fn id<T>(+x: T) -> T { move x }
+pub pure fn id<T>(x: T) -> T { move x }
 
 /// Ignores a value.
 #[inline(always)]
-pub pure fn ignore<T>(+_x: T) { }
+pub pure fn ignore<T>(_x: T) { }
 
 /// Sets `*ptr` to `new_value`, invokes `op()`, and then restores the
 /// original value of `*ptr`.
 #[inline(always)]
 pub fn with<T: Copy, R>(
     ptr: &mut T,
-    +new_value: T,
+    new_value: T,
     op: &fn() -> R) -> R
 {
     // NDM: if swap operator were defined somewhat differently,
@@ -50,7 +50,7 @@ pub fn swap<T>(x: &mut T, y: &mut T) {
  * value, without deinitialising or copying either one.
  */
 #[inline(always)]
-pub fn replace<T>(dest: &mut T, +src: T) -> T {
+pub fn replace<T>(dest: &mut T, src: T) -> T {
     let mut tmp <- src;
     swap(dest, &mut tmp);
     move tmp
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index ce82215a87c..0c822bd0a03 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -47,7 +47,7 @@ pub pure fn same_length<T, U>(xs: &[const T], ys: &[const U]) -> bool {
  * * v - A vector
  * * n - The number of elements to reserve space for
  */
-pub fn reserve<T>(+v: &mut ~[T], +n: uint) {
+pub fn reserve<T>(v: &mut ~[T], n: uint) {
     // Only make the (slow) call into the runtime if we have to
     if capacity(v) < n {
         unsafe {
@@ -119,7 +119,7 @@ pub pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> ~[T] {
  * Creates an immutable vector of size `n_elts` and initializes the elements
  * to the value `t`.
  */
-pub pure fn from_elem<T: Copy>(n_elts: uint, +t: T) -> ~[T] {
+pub pure fn from_elem<T: Copy>(n_elts: uint, t: T) -> ~[T] {
     from_fn(n_elts, |_i| copy t)
 }
 
@@ -148,9 +148,9 @@ pub pure fn with_capacity<T>(capacity: uint) -> ~[T] {
  */
 #[inline(always)]
 pub pure fn build_sized<A>(size: uint,
-                       builder: fn(push: pure fn(+v: A))) -> ~[A] {
+                       builder: fn(push: pure fn(v: A))) -> ~[A] {
     let mut vec = with_capacity(size);
-    builder(|+x| unsafe { vec.push(move x) });
+    builder(|x| unsafe { vec.push(move x) });
     move vec
 }
 
@@ -165,7 +165,7 @@ pub pure fn build_sized<A>(size: uint,
  *             onto the vector being constructed.
  */
 #[inline(always)]
-pub pure fn build<A>(builder: fn(push: pure fn(+v: A))) -> ~[A] {
+pub pure fn build<A>(builder: fn(push: pure fn(v: A))) -> ~[A] {
     build_sized(4, builder)
 }
 
@@ -183,17 +183,17 @@ pub pure fn build<A>(builder: fn(push: pure fn(+v: A))) -> ~[A] {
  */
 #[inline(always)]
 pub pure fn build_sized_opt<A>(size: Option<uint>,
-                           builder: fn(push: pure fn(+v: A))) -> ~[A] {
+                           builder: fn(push: pure fn(v: A))) -> ~[A] {
     build_sized(size.get_default(4), builder)
 }
 
 /// Produces a mut vector from an immutable vector.
-pub pure fn to_mut<T>(+v: ~[T]) -> ~[mut T] {
+pub pure fn to_mut<T>(v: ~[T]) -> ~[mut T] {
     unsafe { ::cast::transmute(move v) }
 }
 
 /// Produces an immutable vector from a mut vector.
-pub pure fn from_mut<T>(+v: ~[mut T]) -> ~[T] {
+pub pure fn from_mut<T>(v: ~[mut T]) -> ~[T] {
     unsafe { ::cast::transmute(move v) }
 }
 
@@ -412,13 +412,13 @@ pub fn shift<T>(v: &mut ~[T]) -> T {
 }
 
 /// Prepend an element to the vector
-pub fn unshift<T>(v: &mut ~[T], +x: T) {
+pub fn unshift<T>(v: &mut ~[T], x: T) {
     let mut vv = ~[move x];
     *v <-> vv;
     v.push_all_move(vv);
 }
 
-pub fn consume<T>(+v: ~[T], f: fn(uint, +v: T)) unsafe {
+pub fn consume<T>(v: ~[T], f: fn(uint, v: T)) unsafe {
     let mut v = move v; // FIXME(#3488)
 
     do as_imm_buf(v) |p, ln| {
@@ -431,7 +431,7 @@ pub fn consume<T>(+v: ~[T], f: fn(uint, +v: T)) unsafe {
     raw::set_len(&mut v, 0);
 }
 
-pub fn consume_mut<T>(+v: ~[mut T], f: fn(uint, +v: T)) {
+pub fn consume_mut<T>(v: ~[mut T], f: fn(uint, v: T)) {
     consume(vec::from_mut(v), f)
 }
 
@@ -468,7 +468,7 @@ pub fn swap_remove<T>(v: &mut ~[T], index: uint) -> T {
 
 /// Append an element to a vector
 #[inline(always)]
-pub fn push<T>(v: &mut ~[T], +initval: T) {
+pub fn push<T>(v: &mut ~[T], initval: T) {
     unsafe {
         let repr: **raw::VecRepr = ::cast::transmute(copy v);
         let fill = (**repr).unboxed.fill;
@@ -483,7 +483,7 @@ pub fn push<T>(v: &mut ~[T], +initval: T) {
 
 // This doesn't bother to make sure we have space.
 #[inline(always)] // really pretty please
-unsafe fn push_fast<T>(+v: &mut ~[T], +initval: T) {
+unsafe fn push_fast<T>(v: &mut ~[T], initval: T) {
     let repr: **raw::VecRepr = ::cast::transmute(v);
     let fill = (**repr).unboxed.fill;
     (**repr).unboxed.fill += sys::size_of::<T>();
@@ -493,13 +493,13 @@ unsafe fn push_fast<T>(+v: &mut ~[T], +initval: T) {
 }
 
 #[inline(never)]
-fn push_slow<T>(+v: &mut ~[T], +initval: T) {
+fn push_slow<T>(v: &mut ~[T], initval: T) {
     reserve_at_least(v, v.len() + 1u);
     unsafe { push_fast(v, move initval) }
 }
 
 #[inline(always)]
-pub fn push_all<T: Copy>(+v: &mut ~[T], rhs: &[const T]) {
+pub fn push_all<T: Copy>(v: &mut ~[T], rhs: &[const T]) {
     reserve(v, v.len() + rhs.len());
 
     for uint::range(0u, rhs.len()) |i| {
@@ -508,7 +508,7 @@ pub fn push_all<T: Copy>(+v: &mut ~[T], rhs: &[const T]) {
 }
 
 #[inline(always)]
-pub fn push_all_move<T>(v: &mut ~[T], +rhs: ~[T]) {
+pub fn push_all_move<T>(v: &mut ~[T], rhs: ~[T]) {
     let mut rhs = move rhs; // FIXME(#3488)
     reserve(v, v.len() + rhs.len());
     unsafe {
@@ -573,7 +573,7 @@ pub fn dedup<T: Eq>(v: &mut ~[T]) unsafe {
 
 // Appending
 #[inline(always)]
-pub pure fn append<T: Copy>(+lhs: ~[T], rhs: &[const T]) -> ~[T] {
+pub pure fn append<T: Copy>(lhs: ~[T], rhs: &[const T]) -> ~[T] {
     let mut v <- lhs;
     unsafe {
         v.push_all(rhs);
@@ -582,14 +582,14 @@ pub pure fn append<T: Copy>(+lhs: ~[T], rhs: &[const T]) -> ~[T] {
 }
 
 #[inline(always)]
-pub pure fn append_one<T>(+lhs: ~[T], +x: T) -> ~[T] {
+pub pure fn append_one<T>(lhs: ~[T], x: T) -> ~[T] {
     let mut v <- lhs;
     unsafe { v.push(move x); }
     move v
 }
 
 #[inline(always)]
-pure fn append_mut<T: Copy>(+lhs: ~[mut T], rhs: &[const T]) -> ~[mut T] {
+pure fn append_mut<T: Copy>(lhs: ~[mut T], rhs: &[const T]) -> ~[mut T] {
     to_mut(append(from_mut(lhs), rhs))
 }
 
@@ -642,7 +642,7 @@ pub fn grow_fn<T>(v: &mut ~[T], n: uint, op: iter::InitOp<T>) {
  * of the vector, expands the vector by replicating `initval` to fill the
  * intervening space.
  */
-pub fn grow_set<T: Copy>(v: &mut ~[T], index: uint, initval: &T, +val: T) {
+pub fn grow_set<T: Copy>(v: &mut ~[T], index: uint, initval: &T, val: T) {
     let l = v.len();
     if index >= l { grow(v, index - l + 1u, initval); }
     v[index] = move val;
@@ -661,7 +661,7 @@ pub pure fn map<T, U>(v: &[T], f: fn(t: &T) -> U) -> ~[U] {
     move result
 }
 
-pub fn map_consume<T, U>(+v: ~[T], f: fn(+v: T) -> U) -> ~[U] {
+pub fn map_consume<T, U>(v: ~[T], f: fn(v: T) -> U) -> ~[U] {
     let mut result = ~[];
     do consume(move v) |_i, x| {
         result.push(f(move x));
@@ -758,7 +758,7 @@ pub pure fn connect<T: Copy>(v: &[~[T]], sep: &T) -> ~[T] {
 }
 
 /// Reduce a vector from left to right
-pub pure fn foldl<T: Copy, U>(+z: T, v: &[U], p: fn(+t: T, u: &U) -> T) -> T {
+pub pure fn foldl<T: Copy, U>(z: T, v: &[U], p: fn(t: T, u: &U) -> T) -> T {
     let mut accum = z;
     for each(v) |elt| {
         // it should be possible to move accum in, but the liveness analysis
@@ -769,7 +769,7 @@ pub pure fn foldl<T: Copy, U>(+z: T, v: &[U], p: fn(+t: T, u: &U) -> T) -> T {
 }
 
 /// Reduce a vector from right to left
-pub pure fn foldr<T, U: Copy>(v: &[T], +z: U, p: fn(t: &T, +u: U) -> U) -> U {
+pub pure fn foldr<T, U: Copy>(v: &[T], z: U, p: fn(t: &T, u: U) -> U) -> U {
     let mut accum = z;
     for rev_each(v) |elt| {
         accum = p(elt, accum);
@@ -992,7 +992,7 @@ pure fn unzip_slice<T: Copy, U: Copy>(v: &[(T, U)]) -> (~[T], ~[U]) {
  * and the i-th element of the second vector contains the second element
  * of the i-th tuple of the input vector.
  */
-pub pure fn unzip<T,U>(+v: ~[(T, U)]) -> (~[T], ~[U]) {
+pub pure fn unzip<T,U>(v: ~[(T, U)]) -> (~[T], ~[U]) {
     let mut ts = ~[], us = ~[];
     unsafe {
         do consume(move v) |_i, p| {
@@ -1023,7 +1023,7 @@ pub pure fn zip_slice<T: Copy, U: Copy>(v: &[const T], u: &[const U])
  * Returns a vector of tuples, where the i-th tuple contains contains the
  * i-th elements from each of the input vectors.
  */
-pub pure fn zip<T, U>(+v: ~[T], +u: ~[U]) -> ~[(T, U)] {
+pub pure fn zip<T, U>(v: ~[T], u: ~[U]) -> ~[(T, U)] {
     let mut v = move v, u = move u; // FIXME(#3488)
     let mut i = len(v);
     assert i == len(u);
@@ -1190,7 +1190,7 @@ pub fn each2<U, T>(v1: &[U], v2: &[T], f: fn(u: &U, t: &T) -> bool) {
  * The total number of permutations produced is `len(v)!`.  If `v` contains
  * repeated elements, then some permutations are repeated.
  */
-pure fn each_permutation<T: Copy>(+v: &[T], put: fn(ts: &[T]) -> bool) {
+pure fn each_permutation<T: Copy>(v: &[T], put: fn(ts: &[T]) -> bool) {
     let ln = len(v);
     if ln <= 1 {
         put(v);
@@ -1435,7 +1435,7 @@ impl<T: Copy> &[const T]: CopyableVector<T> {
 
 pub trait ImmutableVector<T> {
     pure fn view(start: uint, end: uint) -> &self/[T];
-    pure fn foldr<U: Copy>(+z: U, p: fn(t: &T, +u: U) -> U) -> U;
+    pure fn foldr<U: Copy>(z: U, p: fn(t: &T, u: U) -> U) -> U;
     pure fn map<U>(f: fn(t: &T) -> U) -> ~[U];
     pure fn mapi<U>(f: fn(uint, t: &T) -> U) -> ~[U];
     fn map_r<U>(f: fn(x: &T) -> U) -> ~[U];
@@ -1459,7 +1459,7 @@ impl<T> &[T]: ImmutableVector<T> {
     }
     /// Reduce a vector from right to left
     #[inline]
-    pure fn foldr<U: Copy>(+z: U, p: fn(t: &T, +u: U) -> U) -> U {
+    pure fn foldr<U: Copy>(z: U, p: fn(t: &T, u: U) -> U) -> U {
         foldr(self, z, p)
     }
     /// Apply a function to each element of a vector and return the results
@@ -1582,11 +1582,11 @@ impl<T: Copy> &[T]: ImmutableCopyableVector<T> {
 }
 
 pub trait MutableVector<T> {
-    fn push(&mut self, +t: T);
-    fn push_all_move(&mut self, +rhs: ~[T]);
+    fn push(&mut self, t: T);
+    fn push_all_move(&mut self, rhs: ~[T]);
     fn pop(&mut self) -> T;
     fn shift(&mut self) -> T;
-    fn unshift(&mut self, +x: T);
+    fn unshift(&mut self, x: T);
     fn swap_remove(&mut self, index: uint) -> T;
     fn truncate(&mut self, newlen: uint);
 }
@@ -1595,7 +1595,7 @@ pub trait MutableCopyableVector<T: Copy> {
     fn push_all(&mut self, rhs: &[const T]);
     fn grow(&mut self, n: uint, initval: &T);
     fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>);
-    fn grow_set(&mut self, index: uint, initval: &T, +val: T);
+    fn grow_set(&mut self, index: uint, initval: &T, val: T);
 }
 
 trait MutableEqVector<T: Eq> {
@@ -1603,11 +1603,11 @@ trait MutableEqVector<T: Eq> {
 }
 
 impl<T> ~[T]: MutableVector<T> {
-    fn push(&mut self, +t: T) {
+    fn push(&mut self, t: T) {
         push(self, move t);
     }
 
-    fn push_all_move(&mut self, +rhs: ~[T]) {
+    fn push_all_move(&mut self, rhs: ~[T]) {
         push_all_move(self, move rhs);
     }
 
@@ -1619,7 +1619,7 @@ impl<T> ~[T]: MutableVector<T> {
         shift(self)
     }
 
-    fn unshift(&mut self, +x: T) {
+    fn unshift(&mut self, x: T) {
         unshift(self, x)
     }
 
@@ -1645,7 +1645,7 @@ impl<T: Copy> ~[T]: MutableCopyableVector<T> {
         grow_fn(self, n, op);
     }
 
-    fn grow_set(&mut self, index: uint, initval: &T, +val: T) {
+    fn grow_set(&mut self, index: uint, initval: &T, val: T) {
         grow_set(self, index, initval, val);
     }
 }
@@ -1717,21 +1717,21 @@ pub mod raw {
      * would also make any pointers to it invalid.
      */
     #[inline(always)]
-    pub unsafe fn to_ptr<T>(+v: &[T]) -> *T {
+    pub unsafe fn to_ptr<T>(v: &[T]) -> *T {
         let repr: **SliceRepr = ::cast::transmute(&v);
         return ::cast::reinterpret_cast(&addr_of(&((**repr).data)));
     }
 
     /** see `to_ptr()` */
     #[inline(always)]
-    pub unsafe fn to_const_ptr<T>(+v: &[const T]) -> *const T {
+    pub unsafe fn to_const_ptr<T>(v: &[const T]) -> *const T {
         let repr: **SliceRepr = ::cast::transmute(&v);
         return ::cast::reinterpret_cast(&addr_of(&((**repr).data)));
     }
 
     /** see `to_ptr()` */
     #[inline(always)]
-    pub unsafe fn to_mut_ptr<T>(+v: &[mut T]) -> *mut T {
+    pub unsafe fn to_mut_ptr<T>(v: &[mut T]) -> *mut T {
         let repr: **SliceRepr = ::cast::transmute(&v);
         return ::cast::reinterpret_cast(&addr_of(&((**repr).data)));
     }
@@ -1764,7 +1764,7 @@ pub mod raw {
      * is newly allocated.
      */
     #[inline(always)]
-    pub unsafe fn init_elem<T>(v: &[mut T], i: uint, +val: T) {
+    pub unsafe fn init_elem<T>(v: &[mut T], i: uint, val: T) {
         let mut box = Some(move val);
         do as_mut_buf(v) |p, _len| {
             let mut box2 = None;
@@ -1896,7 +1896,7 @@ impl<A> &[A]: iter::ExtendedIter<A> {
     }
     pub pure fn all(blk: fn(&A) -> bool) -> bool { iter::all(&self, blk) }
     pub pure fn any(blk: fn(&A) -> bool) -> bool { iter::any(&self, blk) }
-    pub pure fn foldl<B>(+b0: B, blk: fn(&B, &A) -> B) -> B {
+    pub pure fn foldl<B>(b0: B, blk: fn(&B, &A) -> B) -> B {
         iter::foldl(&self, move b0, blk)
     }
     pub pure fn position(f: fn(&A) -> bool) -> Option<uint> {
@@ -1910,10 +1910,10 @@ impl<A: Eq> &[A]: iter::EqIter<A> {
 }
 
 impl<A: Copy> &[A]: iter::CopyableIter<A> {
-    pure fn filter_to_vec(pred: fn(+a: A) -> bool) -> ~[A] {
+    pure fn filter_to_vec(pred: fn(a: A) -> bool) -> ~[A] {
         iter::filter_to_vec(&self, pred)
     }
-    pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B] {
+    pure fn map_to_vec<B>(op: fn(v: A) -> B) -> ~[B] {
         iter::map_to_vec(&self, op)
     }
     pure fn to_vec() -> ~[A] { iter::to_vec(&self) }
@@ -1923,7 +1923,7 @@ impl<A: Copy> &[A]: iter::CopyableIter<A> {
     //     iter::flat_map_to_vec(self, op)
     // }
 
-    pub pure fn find(p: fn(+a: A) -> bool) -> Option<A> {
+    pub pure fn find(p: fn(a: A) -> bool) -> Option<A> {
         iter::find(&self, p)
     }
 }
@@ -1951,7 +1951,7 @@ mod tests {
         return if *n % 2u == 1u { Some(*n * *n) } else { None };
     }
 
-    fn add(+x: uint, y: &uint) -> uint { return x + *y; }
+    fn add(x: uint, y: &uint) -> uint { return x + *y; }
 
     #[test]
     fn test_unsafe_ptrs() {
@@ -2193,7 +2193,7 @@ mod tests {
 
     #[test]
     fn test_dedup() {
-        fn case(+a: ~[uint], +b: ~[uint]) {
+        fn case(a: ~[uint], b: ~[uint]) {
             let mut v = a;
             v.dedup();
             assert(v == b);
@@ -2323,7 +2323,7 @@ mod tests {
 
     #[test]
     fn test_foldl2() {
-        fn sub(+a: int, b: &int) -> int {
+        fn sub(a: int, b: &int) -> int {
             a - *b
         }
         let mut v = ~[1, 2, 3, 4];
@@ -2333,7 +2333,7 @@ mod tests {
 
     #[test]
     fn test_foldr() {
-        fn sub(a: &int, +b: int) -> int {
+        fn sub(a: &int, b: int) -> int {
             *a - b
         }
         let mut v = ~[1, 2, 3, 4];
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index a04eadb7732..67bbff7fb6a 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -232,7 +232,7 @@ type Result = result::Result<Matches, Fail_>;
  */
 fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
     let n_opts = vec::len::<Opt>(opts);
-    fn f(_x: uint) -> ~[Optval] { return ~[]; }
+    fn f(+_x: uint) -> ~[Optval] { return ~[]; }
     let vals = vec::to_mut(vec::from_fn(n_opts, f));
     let mut free: ~[~str] = ~[];
     let l = vec::len(args);
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index aedd53d41cc..59cb0d36f77 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -763,7 +763,7 @@ impl TcpSocket {
 
 /// Implementation of `io::reader` trait for a buffered `net::tcp::tcp_socket`
 impl TcpSocketBuf: io::Reader {
-    fn read(buf: &[mut u8], len: uint) -> uint {
+    fn read(buf: &[mut u8], +len: uint) -> uint {
         // Loop until our buffer has enough data in it for us to read from.
         while self.data.buf.len() < len {
             let read_result = read(&self.data.sock, 0u);
@@ -799,13 +799,13 @@ impl TcpSocketBuf: io::Reader {
         let mut bytes = ~[0];
         if self.read(bytes, 1u) == 0 { fail } else { bytes[0] as int }
     }
-    fn unread_byte(amt: int) {
+    fn unread_byte(+amt: int) {
         self.data.buf.unshift(amt as u8);
     }
     fn eof() -> bool {
         false // noop
     }
-    fn seek(dist: int, seek: io::SeekStyle) {
+    fn seek(+dist: int, +seek: io::SeekStyle) {
         log(debug, fmt!("tcp_socket_buf seek stub %? %?", dist, seek));
         // noop
     }
@@ -827,7 +827,7 @@ impl TcpSocketBuf: io::Writer {
                              err_data.err_name, err_data.err_msg));
         }
     }
-    fn seek(dist: int, seek: io::SeekStyle) {
+    fn seek(+dist: int, +seek: io::SeekStyle) {
       log(debug, fmt!("tcp_socket_buf seek stub %? %?", dist, seek));
         // noop
     }
diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs
index 00226c4e81e..920751d690f 100644
--- a/src/libstd/net_url.rs
+++ b/src/libstd/net_url.rs
@@ -735,7 +735,7 @@ impl Url : Eq {
 }
 
 impl Url: IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         unsafe { self.to_str() }.iter_bytes(lsb0, f)
     }
 }
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index 647560099e9..d14a4854555 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -379,7 +379,7 @@ Section: Iterating
  * `true` If execution proceeded correctly, `false` if it was interrupted,
  * that is if `it` returned `false` at any point.
  */
-pub fn loop_chars(rope: Rope, it: fn(char) -> bool) -> bool {
+pub fn loop_chars(rope: Rope, it: fn(+c: char) -> bool) -> bool {
    match (rope) {
       node::Empty => return true,
       node::Content(x) => return node::loop_chars(x, it)
@@ -1037,7 +1037,7 @@ mod node {
         return result;
     }
 
-    pub fn loop_chars(node: @Node, it: fn(char) -> bool) -> bool {
+    pub fn loop_chars(node: @Node, it: fn(+c: char) -> bool) -> bool {
         return loop_leaves(node,|leaf| {
             str::all_between(*leaf.content,
                              leaf.byte_offset,
diff --git a/src/libstd/std.rc b/src/libstd/std.rc
index aa26c4af29c..95af018e35a 100644
--- a/src/libstd/std.rc
+++ b/src/libstd/std.rc
@@ -18,6 +18,9 @@ not required in or otherwise suitable for the core library.
 
 #[no_core];
 
+// tjc: Added legacy_modes back in because it still uses + mode.
+// Remove once + mode gets expunged from std.
+#[legacy_modes];
 #[legacy_exports];
 
 #[allow(vecs_implicitly_copyable)];
diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs
index ebdc66156e3..0f31f2056a1 100644
--- a/src/rustc/middle/lint.rs
+++ b/src/rustc/middle/lint.rs
@@ -683,8 +683,12 @@ fn check_fn_deprecated_modes(tcx: ty::ctxt, fn_ty: ty::t, decl: ast::fn_decl,
                        mode_to_str(arg_ast.mode));
                 match arg_ast.mode {
                     ast::expl(ast::by_copy) => {
-                        // This should warn, but we can't yet
-                        // since it's still used. -- tjc
+                        if !tcx.legacy_modes {
+                            tcx.sess.span_lint(
+                                deprecated_mode, id, id, span,
+                                fmt!("argument %d uses by-copy mode",
+                                     counter));
+                        }
                     }
 
                     ast::expl(_) => {
diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs
index a34fcc89c04..f35a3ce735f 100644
--- a/src/test/bench/graph500-bfs.rs
+++ b/src/test/bench/graph500-bfs.rs
@@ -251,7 +251,7 @@ fn pbfs(&&graph: arc::ARC<graph>, key: node_id) -> bfs_result {
         colors = do par::mapi_factory(*color_vec) {
             let colors = arc::clone(&color);
             let graph = arc::clone(&graph);
-            fn~(+i: uint, +c: color) -> color {
+            fn~(i: uint, c: color) -> color {
                 let c : color = c;
                 let colors = arc::get(&colors);
                 let graph = arc::get(&graph);
-- 
cgit 1.4.1-3-g733a5


From 5e7ff924b5931bb90f381d2bf5936616224d4e85 Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Tue, 2 Oct 2012 15:29:16 -0700
Subject: rustc: Don't error out early when constructing a boxed trait.

This improves error messages a bit and helps pave the way for "@int as @Trait"
(as opposed to "int as @Trait").
---
 src/rustc/middle/typeck/check/vtable.rs | 55 +++++++++++++++++++++------------
 1 file changed, 35 insertions(+), 20 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/middle/typeck/check/vtable.rs b/src/rustc/middle/typeck/check/vtable.rs
index 0c9440f3ec2..550c32d0fa1 100644
--- a/src/rustc/middle/typeck/check/vtable.rs
+++ b/src/rustc/middle/typeck/check/vtable.rs
@@ -51,8 +51,13 @@ fn lookup_vtables(fcx: @fn_ctxt,
             match *bound {
               ty::bound_trait(i_ty) => {
                 let i_ty = ty::subst(tcx, substs, i_ty);
-                result.push(lookup_vtable(fcx, expr, *ty, i_ty,
-                                          allow_unsafe, is_early));
+                match lookup_vtable(fcx, expr, *ty, i_ty, allow_unsafe,
+                                    is_early) {
+                    None => {}
+                    Some(vtable) => {
+                        result.push(vtable);
+                    }
+                }
               }
               _ => ()
             }
@@ -91,7 +96,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                  trait_ty: ty::t,
                  allow_unsafe: bool,
                  is_early: bool)
-    -> vtable_origin
+    -> Option<vtable_origin>
 {
 
     debug!("lookup_vtable(ty=%s, trait_ty=%s)",
@@ -113,7 +118,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
             // The type has unconstrained type variables in it, so we can't
             // do early resolution on it. Return some completely bogus vtable
             // information: we aren't storing it anyways.
-            return vtable_param(0, 0);
+            return Some(vtable_param(0, 0));
         }
     };
 
@@ -135,7 +140,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                                            idid);
                                     relate_trait_tys(fcx, expr,
                                                      trait_ty, ity);
-                                    return vtable_param(n, n_bound);
+                                    return Some(vtable_param(n, n_bound));
                                 }
                             }
                             _ => tcx.sess.impossible_case(
@@ -170,7 +175,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                     }
                 }
             }
-            return vtable_trait(did, substs.tps);
+            return Some(vtable_trait(did, substs.tps));
         }
 
         _ => {
@@ -303,7 +308,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                                 None => {
                                     assert is_early;
                                     // Bail out with a bogus answer
-                                    return vtable_param(0, 0);
+                                    return Some(vtable_param(0, 0));
                                 }
                             };
 
@@ -341,23 +346,20 @@ fn lookup_vtable(fcx: @fn_ctxt,
 
             match found.len() {
                 0 => { /* fallthrough */ }
-                1 => { return found[0]; }
+                1 => { return Some(found[0]); }
                 _ => {
                     if !is_early {
                         fcx.ccx.tcx.sess.span_err(
                             expr.span,
                             ~"multiple applicable methods in scope");
                     }
-                    return found[0];
+                    return Some(found[0]);
                 }
             }
         }
     }
 
-    tcx.sess.span_fatal(
-        expr.span,
-        fmt!("failed to find an implementation of trait %s for %s",
-             ty_to_str(tcx, trait_ty), ty_to_str(tcx, ty)));
+    return None;
 }
 
 fn fixup_ty(fcx: @fn_ctxt,
@@ -459,13 +461,26 @@ fn early_resolve_expr(ex: @ast::expr, &&fcx: @fn_ctxt, is_early: bool) {
             Look up vtables for the type we're casting to,
             passing in the source and target type
             */
-            let vtable = lookup_vtable(fcx, ex, fcx.expr_ty(src),
-                                       target_ty, true, is_early);
-            /*
-            Map this expression to that vtable (that is: "ex has
-            vtable <vtable>")
-            */
-            if !is_early { cx.vtable_map.insert(ex.id, @~[vtable]); }
+            let ty = fcx.expr_ty(src);
+            let vtable_opt = lookup_vtable(fcx, ex, ty, target_ty, true,
+                                           is_early);
+            match vtable_opt {
+                None => {
+                    fcx.tcx().sess.span_err(
+                        ex.span,
+                        fmt!("failed to find an implementation of trait %s \
+                              for %s",
+                             ty_to_str(fcx.tcx(), target_ty),
+                             ty_to_str(fcx.tcx(), ty)));
+                }
+                Some(vtable) => {
+                    /*
+                    Map this expression to that vtable (that is: "ex has
+                    vtable <vtable>")
+                    */
+                    if !is_early { cx.vtable_map.insert(ex.id, @~[vtable]); }
+                }
+            }
           }
           _ => ()
         }
-- 
cgit 1.4.1-3-g733a5


From 4101d8c22d239eba5b2202faa28db54b5e1a4909 Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Tue, 2 Oct 2012 16:19:03 -0700
Subject: rustc: Add a side table for legacy boxed traits, not filled in.

This is part of the transition to "@int as @Trait".
---
 src/rustc/metadata/common.rs  | 3 ++-
 src/rustc/middle/astencode.rs | 8 ++++++++
 src/rustc/middle/ty.rs        | 6 ++++--
 3 files changed, 14 insertions(+), 3 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/metadata/common.rs b/src/rustc/metadata/common.rs
index 2d62bf7b4a2..1857abf2cf2 100644
--- a/src/rustc/metadata/common.rs
+++ b/src/rustc/metadata/common.rs
@@ -120,7 +120,8 @@ enum astencode_tag { // Reserves 0x50 -- 0x6f
     tag_table_spill = 0x5f,
     tag_table_method_map = 0x60,
     tag_table_vtable_map = 0x61,
-    tag_table_adjustments = 0x62
+    tag_table_adjustments = 0x62,
+    tag_table_legacy_boxed_trait = 0x63
 }
 
 type link_meta = {name: ~str, vers: ~str, extras_hash: ~str};
diff --git a/src/rustc/middle/astencode.rs b/src/rustc/middle/astencode.rs
index 9332ebe9770..92af75ef84a 100644
--- a/src/rustc/middle/astencode.rs
+++ b/src/rustc/middle/astencode.rs
@@ -832,6 +832,12 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
             }
         }
     }
+
+    do option::iter(&tcx.legacy_boxed_traits.find(id)) |_x| {
+        do ebml_w.tag(c::tag_table_legacy_boxed_trait) {
+            ebml_w.id(id);
+        }
+    }
 }
 
 trait doc_decoder_helpers {
@@ -963,6 +969,8 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
             } else if tag == (c::tag_table_adjustments as uint) {
                 let adj = @ty::deserialize_AutoAdjustment(val_dsr).tr(xcx);
                 dcx.tcx.adjustments.insert(id, adj);
+            } else if tag == (c::tag_table_legacy_boxed_trait as uint) {
+                dcx.tcx.legacy_boxed_traits.insert(id, ());
             } else {
                 xcx.dcx.tcx.sess.bug(
                     fmt!("unknown tag found in side tables: %x", tag));
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index a96388e9d77..5afc60f58ac 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -356,7 +356,8 @@ type ctxt =
       inferred_modes: HashMap<ast::node_id, ast::mode>,
       adjustments: HashMap<ast::node_id, @AutoAdjustment>,
       normalized_cache: HashMap<t, t>,
-      lang_items: middle::lang_items::LanguageItems};
+      lang_items: middle::lang_items::LanguageItems,
+      legacy_boxed_traits: HashMap<node_id, ()>};
 
 enum tbox_flag {
     has_params = 1,
@@ -875,7 +876,8 @@ fn mk_ctxt(s: session::session,
       inferred_modes: HashMap(),
       adjustments: HashMap(),
       normalized_cache: new_ty_hash(),
-      lang_items: move lang_items}
+      lang_items: move lang_items,
+      legacy_boxed_traits: HashMap()}
 }
 
 
-- 
cgit 1.4.1-3-g733a5


From 2f451a7bd7d856daad1e487f7bc7a14c40840c2d Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Tue, 2 Oct 2012 18:13:56 -0700
Subject: rustc: Only allow imports marked with "pub" to be imported from other
 modules

---
 src/libcore/gc.rs             |  2 +-
 src/libcore/os.rs             |  8 ++++----
 src/libcore/repr.rs           |  3 ++-
 src/libsyntax/parse/parser.rs |  6 +++---
 src/rustc/middle/resolve.rs   | 23 +++++++++++++++++++----
 5 files changed, 29 insertions(+), 13 deletions(-)

(limited to 'src/rustc')

diff --git a/src/libcore/gc.rs b/src/libcore/gc.rs
index de2e4412812..464600b9469 100644
--- a/src/libcore/gc.rs
+++ b/src/libcore/gc.rs
@@ -29,7 +29,7 @@ with destructors.
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
-use stackwalk::Word;
+pub use stackwalk::Word;
 use libc::size_t;
 use libc::uintptr_t;
 use send_map::linear::LinearMap;
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
index 1ffb27aaa36..d37bdabd48a 100644
--- a/src/libcore/os.rs
+++ b/src/libcore/os.rs
@@ -22,7 +22,7 @@
 
 use libc::{c_char, c_void, c_int, c_uint, size_t, ssize_t,
            mode_t, pid_t, FILE};
-use libc::{close, fclose};
+pub use libc::{close, fclose};
 
 use option::{Some, None};
 
@@ -225,7 +225,7 @@ mod global_env {
         pub fn setenv(n: &str, v: &str) {
             do str::as_c_str(n) |nbuf| {
                 do str::as_c_str(v) |vbuf| {
-                    libc::setenv(nbuf, vbuf, 1i32);
+                    libc::funcs::posix01::unistd::setenv(nbuf, vbuf, 1i32);
                 }
             }
         }
@@ -384,8 +384,8 @@ pub fn self_exe_path() -> Option<Path> {
     #[cfg(target_os = "macos")]
     fn load_self() -> Option<~str> {
         do fill_charp_buf() |buf, sz| {
-            libc::_NSGetExecutablePath(buf, ptr::mut_addr_of(&(sz as u32)))
-                == (0 as c_int)
+            libc::funcs::extra::_NSGetExecutablePath(
+                buf, ptr::mut_addr_of(&(sz as u32))) == (0 as c_int)
         }
     }
 
diff --git a/src/libcore/repr.rs b/src/libcore/repr.rs
index 30b43dd7f84..ff82ed3fb41 100644
--- a/src/libcore/repr.rs
+++ b/src/libcore/repr.rs
@@ -13,7 +13,8 @@ use cast::transmute;
 use intrinsic::{TyDesc, TyVisitor, visit_tydesc};
 use reflect::{MovePtr, MovePtrAdaptor};
 use vec::raw::{VecRepr, UnboxedVecRepr, SliceRepr};
-use box::raw::{BoxRepr, BoxHeaderRepr};
+pub use box::raw::BoxRepr;
+use box::raw::BoxHeaderRepr;
 
 /// Helpers
 
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index d81bd09f37a..8860d1b5cea 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -3511,8 +3511,8 @@ impl parser {
                 self.token_is_keyword(~"mod", next_tok))
     }
 
-    fn parse_view_item(+attrs: ~[attribute]) -> @view_item {
-        let lo = self.span.lo, vis = self.parse_visibility();
+    fn parse_view_item(+attrs: ~[attribute], vis: visibility) -> @view_item {
+        let lo = self.span.lo;
         let node = if self.eat_keyword(~"use") {
             self.parse_use()
         } else if self.eat_keyword(~"export") {
@@ -3644,7 +3644,7 @@ impl parser {
               _ => self.unexpected()
             }
         } else if self.is_view_item() {
-            let vi = self.parse_view_item(outer_attrs);
+            let vi = self.parse_view_item(outer_attrs, vis);
             return spanned(lo, vi.span.hi, cdir_view_item(vi));
         }
         return self.fatal(~"expected crate directive");
diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs
index fc66b5dc7a1..eca0687f2fd 100644
--- a/src/rustc/middle/resolve.rs
+++ b/src/rustc/middle/resolve.rs
@@ -367,8 +367,7 @@ struct ImportResolution {
     mut used: bool,
 }
 
-fn ImportResolution(privacy: Privacy,
-                    span: span) -> ImportResolution {
+fn ImportResolution(privacy: Privacy, span: span) -> ImportResolution {
     ImportResolution {
         privacy: privacy,
         span: span,
@@ -1639,11 +1638,20 @@ impl Resolver {
 
         match *subclass {
             SingleImport(target, _, _) => {
+                debug!("(building import directive) building import \
+                        directive: privacy %? %s::%s",
+                       privacy,
+                       self.idents_to_str(module_path.get()),
+                       self.session.str_of(target));
+
                 match module_.import_resolutions.find(target) {
                     Some(resolution) => {
+                        debug!("(building import directive) bumping \
+                                reference");
                         resolution.outstanding_references += 1u;
                     }
                     None => {
+                        debug!("(building import directive) creating new");
                         let resolution = @ImportResolution(privacy, span);
                         resolution.outstanding_references = 1u;
                         module_.import_resolutions.insert(target, resolution);
@@ -1967,6 +1975,12 @@ impl Resolver {
                                        namespace: Namespace)
                                     -> NamespaceResult {
 
+                            // Import resolutions must be declared with "pub"
+                            // in order to be exported.
+                            if import_resolution.privacy == Private {
+                                return UnboundResult;
+                            }
+
                             match (*import_resolution).
                                     target_for_namespace(namespace) {
                                 None => {
@@ -4229,7 +4243,8 @@ impl Resolver {
 
         // Next, search import resolutions.
         match containing_module.import_resolutions.find(name) {
-            Some(import_resolution) => {
+            Some(import_resolution) if import_resolution.privacy == Public ||
+                                       xray == Xray => {
                 match (*import_resolution).target_for_namespace(namespace) {
                     Some(target) => {
                         match (*target.bindings)
@@ -4252,7 +4267,7 @@ impl Resolver {
                     }
                 }
             }
-            None => {
+            Some(_) | None => {
                 return NoNameDefinition;
             }
         }
-- 
cgit 1.4.1-3-g733a5


From 9516e7b4b3ef82c2b2183e6d268c695ef5093fa2 Mon Sep 17 00:00:00 2001
From: Tim Chevalier <chevalier@alum.wellesley.edu>
Date: Wed, 3 Oct 2012 12:23:59 -0700
Subject: Revert "rustc: Don't error out early when constructing a boxed
 trait."

This reverts commit 5e7ff924b5931bb90f381d2bf5936616224d4e85.
---
 src/rustc/middle/typeck/check/vtable.rs | 55 ++++++++++++---------------------
 1 file changed, 20 insertions(+), 35 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/middle/typeck/check/vtable.rs b/src/rustc/middle/typeck/check/vtable.rs
index 550c32d0fa1..0c9440f3ec2 100644
--- a/src/rustc/middle/typeck/check/vtable.rs
+++ b/src/rustc/middle/typeck/check/vtable.rs
@@ -51,13 +51,8 @@ fn lookup_vtables(fcx: @fn_ctxt,
             match *bound {
               ty::bound_trait(i_ty) => {
                 let i_ty = ty::subst(tcx, substs, i_ty);
-                match lookup_vtable(fcx, expr, *ty, i_ty, allow_unsafe,
-                                    is_early) {
-                    None => {}
-                    Some(vtable) => {
-                        result.push(vtable);
-                    }
-                }
+                result.push(lookup_vtable(fcx, expr, *ty, i_ty,
+                                          allow_unsafe, is_early));
               }
               _ => ()
             }
@@ -96,7 +91,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                  trait_ty: ty::t,
                  allow_unsafe: bool,
                  is_early: bool)
-    -> Option<vtable_origin>
+    -> vtable_origin
 {
 
     debug!("lookup_vtable(ty=%s, trait_ty=%s)",
@@ -118,7 +113,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
             // The type has unconstrained type variables in it, so we can't
             // do early resolution on it. Return some completely bogus vtable
             // information: we aren't storing it anyways.
-            return Some(vtable_param(0, 0));
+            return vtable_param(0, 0);
         }
     };
 
@@ -140,7 +135,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                                            idid);
                                     relate_trait_tys(fcx, expr,
                                                      trait_ty, ity);
-                                    return Some(vtable_param(n, n_bound));
+                                    return vtable_param(n, n_bound);
                                 }
                             }
                             _ => tcx.sess.impossible_case(
@@ -175,7 +170,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                     }
                 }
             }
-            return Some(vtable_trait(did, substs.tps));
+            return vtable_trait(did, substs.tps);
         }
 
         _ => {
@@ -308,7 +303,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                                 None => {
                                     assert is_early;
                                     // Bail out with a bogus answer
-                                    return Some(vtable_param(0, 0));
+                                    return vtable_param(0, 0);
                                 }
                             };
 
@@ -346,20 +341,23 @@ fn lookup_vtable(fcx: @fn_ctxt,
 
             match found.len() {
                 0 => { /* fallthrough */ }
-                1 => { return Some(found[0]); }
+                1 => { return found[0]; }
                 _ => {
                     if !is_early {
                         fcx.ccx.tcx.sess.span_err(
                             expr.span,
                             ~"multiple applicable methods in scope");
                     }
-                    return Some(found[0]);
+                    return found[0];
                 }
             }
         }
     }
 
-    return None;
+    tcx.sess.span_fatal(
+        expr.span,
+        fmt!("failed to find an implementation of trait %s for %s",
+             ty_to_str(tcx, trait_ty), ty_to_str(tcx, ty)));
 }
 
 fn fixup_ty(fcx: @fn_ctxt,
@@ -461,26 +459,13 @@ fn early_resolve_expr(ex: @ast::expr, &&fcx: @fn_ctxt, is_early: bool) {
             Look up vtables for the type we're casting to,
             passing in the source and target type
             */
-            let ty = fcx.expr_ty(src);
-            let vtable_opt = lookup_vtable(fcx, ex, ty, target_ty, true,
-                                           is_early);
-            match vtable_opt {
-                None => {
-                    fcx.tcx().sess.span_err(
-                        ex.span,
-                        fmt!("failed to find an implementation of trait %s \
-                              for %s",
-                             ty_to_str(fcx.tcx(), target_ty),
-                             ty_to_str(fcx.tcx(), ty)));
-                }
-                Some(vtable) => {
-                    /*
-                    Map this expression to that vtable (that is: "ex has
-                    vtable <vtable>")
-                    */
-                    if !is_early { cx.vtable_map.insert(ex.id, @~[vtable]); }
-                }
-            }
+            let vtable = lookup_vtable(fcx, ex, fcx.expr_ty(src),
+                                       target_ty, true, is_early);
+            /*
+            Map this expression to that vtable (that is: "ex has
+            vtable <vtable>")
+            */
+            if !is_early { cx.vtable_map.insert(ex.id, @~[vtable]); }
           }
           _ => ()
         }
-- 
cgit 1.4.1-3-g733a5


From 53906bb4fb9b2a99878fc6a5cc5cc174ffdea25c Mon Sep 17 00:00:00 2001
From: Tim Chevalier <chevalier@alum.wellesley.edu>
Date: Wed, 3 Oct 2012 16:34:14 -0700
Subject: Change default mode for fns to be by-copy, except for fn&

---
 src/rustc/middle/ty.rs | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index 5afc60f58ac..109db9ace09 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -1093,12 +1093,15 @@ pure fn mach_sty(cfg: @session::config, t: t) -> sty {
 }
 
 fn default_arg_mode_for_ty(tcx: ctxt, ty: ty::t) -> ast::rmode {
-    return if type_is_fn(ty) {
-        //    ^^^^^^^^^^^^^^
-        // FIXME(#2202) --- We retain by-ref by default to workaround a memory
-        // leak that otherwise results when @fn is upcast to &fn.
-        ast::by_ref
-    } else if tcx.legacy_modes {
+        // FIXME(#2202) --- We retain by-ref for fn& things to workaround a
+        // memory leak that otherwise results when @fn is upcast to &fn.
+    if type_is_fn(ty) {
+        match ty_fn_proto(ty) {
+           proto_vstore(vstore_slice(_)) => return ast::by_ref,
+            _ => ()
+        }
+    }
+    return if tcx.legacy_modes {
         if type_is_borrowed(ty) {
             // the old mode default was ++ for things like &ptr, but to be
             // forward-compatible with non-legacy, we should use +
-- 
cgit 1.4.1-3-g733a5


From b34327be0dba2034afe8c14b014ba8da22d5c9f5 Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Wed, 3 Oct 2012 15:18:50 -0700
Subject: rustc: Implement "@Foo as @Bar" for boxed traits

---
 src/rustc/middle/astencode.rs           |  4 +-
 src/rustc/middle/trans/meth.rs          | 27 ++++++----
 src/rustc/middle/typeck/check/vtable.rs | 89 +++++++++++++++++++++++++--------
 3 files changed, 89 insertions(+), 31 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/middle/astencode.rs b/src/rustc/middle/astencode.rs
index 92af75ef84a..29368ae95b8 100644
--- a/src/rustc/middle/astencode.rs
+++ b/src/rustc/middle/astencode.rs
@@ -929,6 +929,8 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
 
         if tag == (c::tag_table_mutbl as uint) {
             dcx.maps.mutbl_map.insert(id, ());
+        } else if tag == (c::tag_table_legacy_boxed_trait as uint) {
+            dcx.tcx.legacy_boxed_traits.insert(id, ());
         } else {
             let val_doc = entry_doc[c::tag_table_val as uint];
             let val_dsr = ebml::ebml_deserializer(val_doc);
@@ -969,8 +971,6 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
             } else if tag == (c::tag_table_adjustments as uint) {
                 let adj = @ty::deserialize_AutoAdjustment(val_dsr).tr(xcx);
                 dcx.tcx.adjustments.insert(id, adj);
-            } else if tag == (c::tag_table_legacy_boxed_trait as uint) {
-                dcx.tcx.legacy_boxed_traits.insert(id, ());
             } else {
                 xcx.dcx.tcx.sess.bug(
                     fmt!("unknown tag found in side tables: %x", tag));
diff --git a/src/rustc/middle/trans/meth.rs b/src/rustc/middle/trans/meth.rs
index ebc1645e3d8..5bf62466595 100644
--- a/src/rustc/middle/trans/meth.rs
+++ b/src/rustc/middle/trans/meth.rs
@@ -536,6 +536,7 @@ fn trans_trait_cast(bcx: block,
                     dest: expr::Dest)
     -> block
 {
+    let mut bcx = bcx;
     let _icx = bcx.insn_ctxt("impl::trans_cast");
 
     let lldest = match dest {
@@ -548,16 +549,24 @@ fn trans_trait_cast(bcx: block,
     let ccx = bcx.ccx();
     let v_ty = expr_ty(bcx, val);
 
-    // Allocate an @ box and store the value into it
-    let {bcx: bcx, box: llbox, body: body} = malloc_boxed(bcx, v_ty);
-    add_clean_free(bcx, llbox, heap_shared);
-    let bcx = expr::trans_into(bcx, val, SaveIn(body));
-    revoke_clean(bcx, llbox);
+    let mut llboxdest = GEPi(bcx, lldest, [0u, 1u]);
+    llboxdest = PointerCast(bcx, llboxdest,
+                            T_ptr(type_of::type_of(bcx.ccx(), v_ty)));
+
+    if bcx.tcx().legacy_boxed_traits.contains_key(id) {
+        // Allocate an @ box and store the value into it
+        let {bcx: new_bcx, box: llbox, body: body} = malloc_boxed(bcx, v_ty);
+        bcx = new_bcx;
+        add_clean_free(bcx, llbox, heap_shared);
+        bcx = expr::trans_into(bcx, val, SaveIn(body));
+        revoke_clean(bcx, llbox);
 
-    // Store the @ box into the pair
-    Store(bcx, llbox, PointerCast(bcx,
-                                  GEPi(bcx, lldest, [0u, 1u]),
-                                  T_ptr(val_ty(llbox))));
+        // Store the @ box into the pair
+        Store(bcx, llbox, llboxdest);
+    } else {
+        // Just store the @ box into the pair.
+        bcx = expr::trans_into(bcx, val, SaveIn(llboxdest));
+    }
 
     // Store the vtable into the pair
     let orig = ccx.maps.vtable_map.get(id)[0];
diff --git a/src/rustc/middle/typeck/check/vtable.rs b/src/rustc/middle/typeck/check/vtable.rs
index 0c9440f3ec2..e8595b2f50a 100644
--- a/src/rustc/middle/typeck/check/vtable.rs
+++ b/src/rustc/middle/typeck/check/vtable.rs
@@ -51,8 +51,18 @@ fn lookup_vtables(fcx: @fn_ctxt,
             match *bound {
               ty::bound_trait(i_ty) => {
                 let i_ty = ty::subst(tcx, substs, i_ty);
-                result.push(lookup_vtable(fcx, expr, *ty, i_ty,
-                                          allow_unsafe, is_early));
+                match lookup_vtable(fcx, expr, *ty, i_ty, allow_unsafe,
+                                    is_early) {
+                    Some(vtable) => result.push(vtable),
+                    None => {
+                        fcx.tcx().sess.span_fatal(
+                            expr.span,
+                            fmt!("failed to find an implementation of trait \
+                                  %s for %s",
+                                 ty_to_str(fcx.tcx(), i_ty),
+                                 ty_to_str(fcx.tcx(), *ty)));
+                    }
+                }
               }
               _ => ()
             }
@@ -91,7 +101,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                  trait_ty: ty::t,
                  allow_unsafe: bool,
                  is_early: bool)
-    -> vtable_origin
+    -> Option<vtable_origin>
 {
 
     debug!("lookup_vtable(ty=%s, trait_ty=%s)",
@@ -113,7 +123,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
             // The type has unconstrained type variables in it, so we can't
             // do early resolution on it. Return some completely bogus vtable
             // information: we aren't storing it anyways.
-            return vtable_param(0, 0);
+            return Some(vtable_param(0, 0));
         }
     };
 
@@ -135,7 +145,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                                            idid);
                                     relate_trait_tys(fcx, expr,
                                                      trait_ty, ity);
-                                    return vtable_param(n, n_bound);
+                                    return Some(vtable_param(n, n_bound));
                                 }
                             }
                             _ => tcx.sess.impossible_case(
@@ -170,7 +180,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                     }
                 }
             }
-            return vtable_trait(did, substs.tps);
+            return Some(vtable_trait(did, substs.tps));
         }
 
         _ => {
@@ -303,7 +313,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                                 None => {
                                     assert is_early;
                                     // Bail out with a bogus answer
-                                    return vtable_param(0, 0);
+                                    return Some(vtable_param(0, 0));
                                 }
                             };
 
@@ -341,23 +351,20 @@ fn lookup_vtable(fcx: @fn_ctxt,
 
             match found.len() {
                 0 => { /* fallthrough */ }
-                1 => { return found[0]; }
+                1 => { return Some(found[0]); }
                 _ => {
                     if !is_early {
                         fcx.ccx.tcx.sess.span_err(
                             expr.span,
                             ~"multiple applicable methods in scope");
                     }
-                    return found[0];
+                    return Some(found[0]);
                 }
             }
         }
     }
 
-    tcx.sess.span_fatal(
-        expr.span,
-        fmt!("failed to find an implementation of trait %s for %s",
-             ty_to_str(tcx, trait_ty), ty_to_str(tcx, ty)));
+    return None;
 }
 
 fn fixup_ty(fcx: @fn_ctxt,
@@ -459,13 +466,55 @@ fn early_resolve_expr(ex: @ast::expr, &&fcx: @fn_ctxt, is_early: bool) {
             Look up vtables for the type we're casting to,
             passing in the source and target type
             */
-            let vtable = lookup_vtable(fcx, ex, fcx.expr_ty(src),
-                                       target_ty, true, is_early);
-            /*
-            Map this expression to that vtable (that is: "ex has
-            vtable <vtable>")
-            */
-            if !is_early { cx.vtable_map.insert(ex.id, @~[vtable]); }
+            let ty = fcx.expr_ty(src);
+            let vtable_opt = lookup_vtable(fcx, ex, ty, target_ty, true,
+                                           is_early);
+            match vtable_opt {
+                None => {
+                    // Try the new-style boxed trait; "@int as @Trait".
+                    let mut err = false;
+                    let ty = structurally_resolved_type(fcx, ex.span, ty);
+                    match ty::get(ty).sty {
+                        ty::ty_box(boxed_ty) => {
+                            let vtable_opt = lookup_vtable(fcx, ex,
+                                                           boxed_ty.ty,
+                                                           target_ty, true,
+                                                           is_early);
+                            match vtable_opt {
+                                Some(vtable) => {
+                                    /*
+                                    Map this expression to that vtable (that
+                                    is: "ex has vtable <vtable>")
+                                    */
+                                    if !is_early {
+                                        cx.vtable_map.insert(ex.id,
+                                                             @~[vtable]);
+                                    }
+                                }
+                                None => err = true
+                            }
+                        }
+                        _ => err = true
+                    }
+
+                    if err {
+                        fcx.tcx().sess.span_fatal(
+                            ex.span,
+                            fmt!("failed to find an implementation of trait \
+                                  %s for %s",
+                                 ty_to_str(fcx.tcx(), target_ty),
+                                 ty_to_str(fcx.tcx(), ty)));
+                    }
+                }
+                Some(vtable) => {
+                    /*
+                    Map this expression to that vtable (that is: "ex has
+                    vtable <vtable>")
+                    */
+                    if !is_early { cx.vtable_map.insert(ex.id, @~[vtable]); }
+                    fcx.tcx().legacy_boxed_traits.insert(ex.id, ());
+                }
+            }
           }
           _ => ()
         }
-- 
cgit 1.4.1-3-g733a5


From f885205b1bb57f270f533aa5e8dc9951c1be603c Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Wed, 3 Oct 2012 17:18:24 -0700
Subject: rustc: Unbreak old-style boxed traits

---
 src/rustc/middle/trans/base.rs | 2 +-
 src/rustc/middle/trans/meth.rs | 7 +++----
 2 files changed, 4 insertions(+), 5 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs
index 70231357003..a23baa8afde 100644
--- a/src/rustc/middle/trans/base.rs
+++ b/src/rustc/middle/trans/base.rs
@@ -2348,7 +2348,7 @@ fn trap(bcx: block) {
 
 fn push_rtcall(ccx: @crate_ctxt, name: ~str, did: ast::def_id) {
     if ccx.rtcalls.contains_key(name) {
-        fail fmt!("multiple definitions for runtime call %s", name);
+        ccx.sess.bug(fmt!("multiple definitions for runtime call %s", name));
     }
     ccx.rtcalls.insert(name, did);
 }
diff --git a/src/rustc/middle/trans/meth.rs b/src/rustc/middle/trans/meth.rs
index 5bf62466595..a94519306a4 100644
--- a/src/rustc/middle/trans/meth.rs
+++ b/src/rustc/middle/trans/meth.rs
@@ -550,9 +550,6 @@ fn trans_trait_cast(bcx: block,
     let v_ty = expr_ty(bcx, val);
 
     let mut llboxdest = GEPi(bcx, lldest, [0u, 1u]);
-    llboxdest = PointerCast(bcx, llboxdest,
-                            T_ptr(type_of::type_of(bcx.ccx(), v_ty)));
-
     if bcx.tcx().legacy_boxed_traits.contains_key(id) {
         // Allocate an @ box and store the value into it
         let {bcx: new_bcx, box: llbox, body: body} = malloc_boxed(bcx, v_ty);
@@ -562,9 +559,11 @@ fn trans_trait_cast(bcx: block,
         revoke_clean(bcx, llbox);
 
         // Store the @ box into the pair
-        Store(bcx, llbox, llboxdest);
+        Store(bcx, llbox, PointerCast(bcx, llboxdest, T_ptr(val_ty(llbox))));
     } else {
         // Just store the @ box into the pair.
+        llboxdest = PointerCast(bcx, llboxdest,
+                                T_ptr(type_of::type_of(bcx.ccx(), v_ty)));
         bcx = expr::trans_into(bcx, val, SaveIn(llboxdest));
     }
 
-- 
cgit 1.4.1-3-g733a5


From ae4f8fb87a146fc716b4ad3222b01b7ef7536a30 Mon Sep 17 00:00:00 2001
From: Orphée Lafond-Lummis <o@orftz.com>
Date: Wed, 3 Oct 2012 19:55:47 -0400
Subject: rustc man page and usage text update.

* Mark --static as experimental;
* Remove --stats, as the option isn't implemented.
* Bold and surround by pointy brackets (<>) all the URLs of rustc man page, for
  consistency.
---
 man/rustc.1               | 14 +++++---------
 src/rustc/driver/rustc.rs |  2 +-
 2 files changed, 6 insertions(+), 10 deletions(-)

(limited to 'src/rustc')

diff --git a/man/rustc.1 b/man/rustc.1
index f1a0a0131e1..f5888015944 100644
--- a/man/rustc.1
+++ b/man/rustc.1
@@ -75,10 +75,7 @@ Write intermediate files (.bc, .opt.bc, .o)
 in addition to normal output
 .TP
 \fB\-\-static\fR
-Use or produce static libraries or binaries
-.TP
-\fB\-\-stats\fR
-Print compilation statistics
+Use or produce static libraries or binaries (experimental)
 .TP
 \fB\-\-sysroot\fR <path>
 Override the system root
@@ -87,10 +84,9 @@ Override the system root
 Build a test harness
 .TP
 \fB\-\-target\fR <triple>
-Target cpu\-manufacturer\-kernel[\-os] to compile for
-(default: host triple)
-(see http://sources.redhat.com/autobook/autobook/
-autobook_17.html for detail)
+Target cpu\-manufacturer\-kernel[\-os] to compile for (default: host triple)
+(see <\fBhttp://sources.redhat.com/autobook/autobook/autobook_17.html\fR> for
+detail)
 .TP
 \fB\-W\fR <foo>
 enable warning <foo>
@@ -121,7 +117,7 @@ To build either with a crate (.rc) file:
     $ rustc hello.rc
 
 .SH "BUGS"
-See \fBhttps://github.com/mozilla/rust/issues\fR for a list of known bugs.
+See <\fBhttps://github.com/mozilla/rust/issues\fR> for a list of known bugs.
 
 .SH "AUTHOR"
 See \fBAUTHORS.txt\fR in the rust source distribution. Graydon Hoare
diff --git a/src/rustc/driver/rustc.rs b/src/rustc/driver/rustc.rs
index 7db9261d133..c6b93fc0603 100644
--- a/src/rustc/driver/rustc.rs
+++ b/src/rustc/driver/rustc.rs
@@ -61,7 +61,7 @@ Options:
     --save-temps       Write intermediate files (.bc, .opt.bc, .o)
                        in addition to normal output
     --static           Use or produce static libraries or binaries
-    --stats            Print compilation statistics
+                       (experimental)
     --sysroot <path>   Override the system root
     --test             Build a test harness
     --target <triple>  Target cpu-manufacturer-kernel[-os] to compile for
-- 
cgit 1.4.1-3-g733a5


From d4351c9d395f6200616450ab5b6999171a28ad9f Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Wed, 3 Oct 2012 18:14:53 -0700
Subject: rustc: Fix ICE when de-exporting rt

---
 src/rustc/middle/trans/base.rs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

(limited to 'src/rustc')

diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs
index a23baa8afde..0631d7b1ea4 100644
--- a/src/rustc/middle/trans/base.rs
+++ b/src/rustc/middle/trans/base.rs
@@ -2347,10 +2347,15 @@ fn trap(bcx: block) {
 }
 
 fn push_rtcall(ccx: @crate_ctxt, name: ~str, did: ast::def_id) {
-    if ccx.rtcalls.contains_key(name) {
-        ccx.sess.bug(fmt!("multiple definitions for runtime call %s", name));
+    match ccx.rtcalls.find(name) {
+        Some(existing_did) if did != existing_did => {
+            ccx.sess.fatal(fmt!("multiple definitions for runtime call %s",
+                                name));
+        }
+        Some(_) | None => {
+            ccx.rtcalls.insert(name, did);
+        }
     }
-    ccx.rtcalls.insert(name, did);
 }
 
 fn gather_local_rtcalls(ccx: @crate_ctxt, crate: @ast::crate) {
-- 
cgit 1.4.1-3-g733a5