---

yaml
---
r: 52731
b: refs/heads/dist-snap
c: 7b268e8
h: refs/heads/master
i:
  52729: 367d126
  52727: 76b2d61
v: v3

Author: sanxiyn

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: 0d1058a62e728f0dfed04fe93cc38dcf6be38f0b
+refs/heads/dist-snap: 7b268e83167a9dc914dfea9ec4d0448cce8ee6e2
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcore/vec.rs

@@ -541,10 +541,8 @@ pub fn remove<T>(v: &mut ~[T], i: uint) -> T {
     v.pop()
 }
 
-pub fn consume<T>(v: ~[T], f: fn(uint, v: T)) {
+pub fn consume<T>(mut v: ~[T], f: fn(uint, v: T)) {
     unsafe {
-        let mut v = v; // FIXME(#3488)
-
         do as_mut_buf(v) |p, ln| {
             for uint::range(0, ln) |i| {
                 // NB: This unsafe operation counts on init writing 0s to the
@@ -641,8 +639,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]) {
-    let mut rhs = rhs; // FIXME(#3488)
+pub fn push_all_move<T>(v: &mut ~[T], mut rhs: ~[T]) {
     reserve(&mut *v, v.len() + rhs.len());
     unsafe {
         do as_mut_buf(rhs) |p, len| {
@@ -1241,8 +1238,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)] {
-    let mut v = v, u = u; // FIXME(#3488)
+pub pure fn zip<T, U>(mut v: ~[T], mut u: ~[U]) -> ~[(T, U)] {
     let mut i = len(v);
     assert i == len(u);
     let mut w = with_capacity(i);

branches/dist-snap/src/librustc/middle/trans/base.rs

@@ -1986,7 +1986,7 @@ pub fn trans_struct_dtor(ccx: @crate_ctxt,
 }
 
 pub fn trans_enum_def(ccx: @crate_ctxt, enum_definition: ast::enum_def,
-                      id: ast::node_id, degen: bool,
+                      id: ast::node_id, tps: ~[ast::ty_param], degen: bool,
                       path: @ast_map::path, vi: @~[ty::VariantInfo],
                       i: &mut uint) {
     for vec::each(enum_definition.variants) |variant| {
@@ -2003,13 +2003,14 @@ pub fn trans_enum_def(ccx: @crate_ctxt, enum_definition: ast::enum_def,
                 // Nothing to do.
             }
             ast::struct_variant_kind(struct_def) => {
-                trans_struct_def(ccx, struct_def, path,
+                trans_struct_def(ccx, struct_def, /*bad*/copy tps, path,
                                  variant.node.id);
             }
             ast::enum_variant_kind(ref enum_definition) => {
                 trans_enum_def(ccx,
                                *enum_definition,
                                id,
+                               /*bad*/copy tps,
                                degen,
                                path,
                                vi,
@@ -2061,11 +2062,11 @@ pub fn trans_item(ccx: @crate_ctxt, item: ast::item) {
         trans_mod(ccx, m);
       }
       ast::item_enum(ref enum_definition, ref tps) => {
-        if tps.is_empty() {
+        if tps.len() == 0u {
             let degen = (*enum_definition).variants.len() == 1u;
             let vi = ty::enum_variants(ccx.tcx, local_def(item.id));
             let mut i = 0;
-            trans_enum_def(ccx, (*enum_definition), item.id,
+            trans_enum_def(ccx, (*enum_definition), item.id, /*bad*/copy *tps,
                            degen, path, vi, &mut i);
         }
       }
@@ -2079,33 +2080,35 @@ pub fn trans_item(ccx: @crate_ctxt, item: ast::item) {
         foreign::trans_foreign_mod(ccx, foreign_mod, abi);
       }
       ast::item_struct(struct_def, tps) => {
-        if tps.is_empty() {
-            trans_struct_def(ccx, struct_def, path, item.id);
-        }
+        trans_struct_def(ccx, struct_def, tps, path, item.id);
       }
       _ => {/* fall through */ }
     }
 }
 
 pub fn trans_struct_def(ccx: @crate_ctxt, struct_def: @ast::struct_def,
-                        path: @ast_map::path,
+                        tps: ~[ast::ty_param], path: @ast_map::path,
                         id: ast::node_id) {
-    // Translate the destructor.
-    do option::iter(&struct_def.dtor) |dtor| {
-        trans_struct_dtor(ccx, /*bad*/copy *path, dtor.node.body,
-                         dtor.node.id, None, None, local_def(id));
-    };
+    // If there are type parameters, the destructor and constructor will be
+    // monomorphized, so we don't translate them here.
+    if tps.len() == 0u {
+        // Translate the destructor.
+        do option::iter(&struct_def.dtor) |dtor| {
+            trans_struct_dtor(ccx, /*bad*/copy *path, dtor.node.body,
+                             dtor.node.id, None, None, local_def(id));
+        };
 
-    // If this is a tuple-like struct, translate the constructor.
-    match struct_def.ctor_id {
-        // We only need to translate a constructor if there are fields;
-        // otherwise this is a unit-like struct.
-        Some(ctor_id) if struct_def.fields.len() > 0 => {
-            let llfndecl = get_item_val(ccx, ctor_id);
-            trans_tuple_struct(ccx, /*bad*/copy struct_def.fields,
-                               ctor_id, None, llfndecl);
+        // If this is a tuple-like struct, translate the constructor.
+        match struct_def.ctor_id {
+            // We only need to translate a constructor if there are fields;
+            // otherwise this is a unit-like struct.
+            Some(ctor_id) if struct_def.fields.len() > 0 => {
+                let llfndecl = get_item_val(ccx, ctor_id);
+                trans_tuple_struct(ccx, /*bad*/copy struct_def.fields,
+                                   ctor_id, None, llfndecl);
+            }
+            Some(_) | None => {}
         }
-        Some(_) | None => {}
     }
 }