---

yaml
---
r: 52453
b: refs/heads/dist-snap
c: 92e52bc
h: refs/heads/master
i:
  52451: aa041d0
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: 9dc8e96c5fac7812039bf6ddf640dcbb77f1a2f0
+refs/heads/dist-snap: 92e52bc95e554fc61e4b058850d878eb01de4bbd
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/tutorial.md

@@ -1226,6 +1226,18 @@ match crayons[0] {
 }
 ~~~~
 
+A vector can be destructured using pattern matching:
+
+~~~~
+let numbers: [int * 3] = [1, 2, 3];
+let score = match numbers {
+    [] => 0,
+    [a] => a * 10,
+    [a, b] => a * 6 + b * 4,
+    [a, b, c, ..rest] => a * 5 + b * 3 + c * 2 + rest.len() as int
+};
+~~~~
+
 The elements of a vector _inherit the mutability of the vector_,
 and as such, individual elements may not be reassigned when the
 vector lives in an immutable slot.

branches/dist-snap/src/compiletest/runtest.rs

@@ -273,7 +273,7 @@ fn check_expected_errors(expected_errors: ~[errors::expected_error],
                          procres: procres) {
 
     // true if we found the error in question
-    let found_flags = vec::cast_to_mut(vec::from_elem(
+    let found_flags = vec::to_mut(vec::from_elem(
         vec::len(expected_errors), false));
 
     if procres.status == 0 {

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

@@ -145,7 +145,7 @@ impl<A> DVec<A> {
     #[inline(always)]
     fn swap_mut(f: &fn(v: ~[mut A]) -> ~[mut A]) {
         do self.swap |v| {
-            vec::cast_from_mut(f(vec::cast_to_mut(move v)))
+            vec::from_mut(f(vec::to_mut(move v)))
         }
     }
 

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

@@ -84,7 +84,7 @@ pub fn as_c_charp<T>(s: &str, f: fn(*c_char) -> T) -> T {
 
 pub fn fill_charp_buf(f: fn(*mut c_char, size_t) -> bool)
     -> Option<~str> {
-    let buf = vec::cast_to_mut(vec::from_elem(tmpbuf_sz, 0u8 as c_char));
+    let buf = vec::to_mut(vec::from_elem(tmpbuf_sz, 0u8 as c_char));
     do vec::as_mut_buf(buf) |b, sz| {
         if f(b, sz as size_t) unsafe {
             Some(str::raw::from_buf(b as *u8))
@@ -111,7 +111,7 @@ pub mod win32 {
             let mut res = None;
             let mut done = false;
             while !done {
-                let buf = vec::cast_to_mut(vec::from_elem(n as uint, 0u16));
+                let buf = vec::to_mut(vec::from_elem(n as uint, 0u16));
                 do vec::as_mut_buf(buf) |b, _sz| {
                     let k : DWORD = f(b, tmpbuf_sz as DWORD);
                     if k == (0 as DWORD) {
@@ -1269,7 +1269,7 @@ mod tests {
           };
           assert (ostream as uint != 0u);
           let s = ~"hello";
-          let mut buf = vec::cast_to_mut(str::to_bytes(s) + ~[0 as u8]);
+          let mut buf = vec::to_mut(str::to_bytes(s) + ~[0 as u8]);
           do vec::as_mut_buf(buf) |b, _len| {
               assert (libc::fwrite(b as *c_void, 1u as size_t,
                                    (str::len(s) + 1u) as size_t, ostream)

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

@@ -209,12 +209,12 @@ pub pure fn build_sized_opt<A>(size: Option<uint>,
 }
 
 /// Produces a mut vector from an immutable vector.
-pub pure fn cast_to_mut<T>(v: ~[T]) -> ~[mut T] {
+pub pure fn to_mut<T>(v: ~[T]) -> ~[mut T] {
     unsafe { ::cast::transmute(v) }
 }
 
 /// Produces an immutable vector from a mut vector.
-pub pure fn cast_from_mut<T>(v: ~[mut T]) -> ~[T] {
+pub pure fn from_mut<T>(v: ~[mut T]) -> ~[T] {
     unsafe { ::cast::transmute(v) }
 }
 
@@ -552,7 +552,7 @@ pub fn consume<T>(v: ~[T], f: fn(uint, v: T)) unsafe {
 }
 
 pub fn consume_mut<T>(v: ~[mut T], f: fn(uint, v: T)) {
-    consume(vec::cast_from_mut(v), f)
+    consume(vec::from_mut(v), f)
 }
 
 /// Remove the last element from a vector and return it
@@ -718,7 +718,7 @@ pub pure fn append_one<T>(lhs: ~[T], x: T) -> ~[T] {
 
 #[inline(always)]
 pub pure fn append_mut<T: Copy>(lhs: ~[mut T], rhs: &[const T]) -> ~[mut T] {
-    cast_to_mut(append(cast_from_mut(lhs), rhs))
+    to_mut(append(from_mut(lhs), rhs))
 }
 
 /**
@@ -3271,22 +3271,22 @@ mod tests {
     }
 
     #[test]
-    fn cast_to_mut_no_copy() {
+    fn to_mut_no_copy() {
         unsafe {
             let x = ~[1, 2, 3];
             let addr = raw::to_ptr(x);
-            let x_mut = cast_to_mut(x);
+            let x_mut = to_mut(x);
             let addr_mut = raw::to_ptr(x_mut);
             assert addr == addr_mut;
         }
     }
 
     #[test]
-    fn cast_from_mut_no_copy() {
+    fn from_mut_no_copy() {
         unsafe {
             let x = ~[mut 1, 2, 3];
             let addr = raw::to_ptr(x);
-            let x_imm = cast_from_mut(x);
+            let x_imm = from_mut(x);
             let addr_imm = raw::to_ptr(x_imm);
             assert addr == addr_imm;
         }

branches/dist-snap/src/librustc/middle/astencode.rs

@@ -415,7 +415,7 @@ impl ast::def: tr {
           ast::def_mod(did) => { ast::def_mod(did.tr(xcx)) }
           ast::def_foreign_mod(did) => { ast::def_foreign_mod(did.tr(xcx)) }
           ast::def_const(did) => { ast::def_const(did.tr(xcx)) }
-          ast::def_arg(nid, m) => { ast::def_arg(xcx.tr_id(nid), m) }
+          ast::def_arg(nid, m, b) => { ast::def_arg(xcx.tr_id(nid), m, b) }
           ast::def_local(nid, b) => { ast::def_local(xcx.tr_id(nid), b) }
           ast::def_variant(e_did, v_did) => {
             ast::def_variant(e_did.tr(xcx), v_did.tr(xcx))

branches/dist-snap/src/librustc/middle/liveness.rs

@@ -286,7 +286,7 @@ enum VarKind {
 fn relevant_def(def: def) -> Option<node_id> {
     match def {
       def_binding(nid, _) |
-      def_arg(nid, _) |
+      def_arg(nid, _, _) |
       def_local(nid, _) |
       def_self(nid, _) => Some(nid),
 
@@ -661,11 +661,11 @@ fn Liveness(ir: @IrMaps, specials: Specials) -> Liveness {
         tcx: ir.tcx,
         s: specials,
         successors:
-            vec::cast_to_mut(
+            vec::to_mut(
                 vec::from_elem(ir.num_live_nodes,
                                invalid_node())),
         users:
-            vec::cast_to_mut(
+            vec::to_mut(
                 vec::from_elem(ir.num_live_nodes * ir.num_vars,
                                invalid_users())),
         loop_scope: DVec(),

branches/dist-snap/src/librustc/middle/mem_categorization.rs

@@ -453,26 +453,27 @@ impl &mem_categorization_ctxt {
               mutbl:m_imm, ty:expr_ty}
           }
 
-          ast::def_arg(vid, mode) => {
+          ast::def_arg(vid, mode, mutbl) => {
             // Idea: make this could be rewritten to model by-ref
             // stuff as `&const` and `&mut`?
 
             // m: mutability of the argument
             // lp: loan path, must be none for aliasable things
-            let {m,lp} = match ty::resolved_mode(self.tcx, mode) {
+            let m = if mutbl {m_mutbl} else {m_imm};
+            let lp = match ty::resolved_mode(self.tcx, mode) {
               ast::by_move | ast::by_copy => {
-                {m: m_imm, lp: Some(@lp_arg(vid))}
+                Some(@lp_arg(vid))
               }
               ast::by_ref => {
-                {m: m_imm, lp: None}
+                None
               }
               ast::by_val => {
                 // by-value is this hybrid mode where we have a
                 // pointer but we do not own it.  This is not
                 // considered loanable because, for example, a by-ref
                 // and and by-val argument might both actually contain
                 // the same unique ptr.
-                {m: m_imm, lp: None}
+                None
               }
             };
             @{id:id, span:span,

branches/dist-snap/src/librustc/middle/resolve.rs

@@ -4104,9 +4104,11 @@ impl Resolver {
                     for declaration.inputs.each |argument| {
                         let binding_mode =
                             ArgumentIrrefutableMode(argument.mode);
+                        let mutability =
+                            if argument.is_mutbl {Mutable} else {Immutable};
                         self.resolve_pattern(argument.pat,
                                              binding_mode,
-                                             Immutable,
+                                             mutability,
                                              None,
                                              visitor);
 
@@ -4295,12 +4297,7 @@ impl Resolver {
     }
 
     fn resolve_local(local: @local, visitor: ResolveVisitor) {
-        let mut mutability;
-        if local.node.is_mutbl {
-            mutability = Mutable;
-        } else {
-            mutability = Immutable;
-        }
+        let mutability = if local.node.is_mutbl {Mutable} else {Immutable};
 
         // Resolve the type.
         self.resolve_type(local.node.ty, visitor);
@@ -4561,7 +4558,8 @@ impl Resolver {
                                 }
                                 ArgumentIrrefutableMode(argument_mode) => {
                                     // And for function arguments, `def_arg`.
-                                    def_arg(pattern.id, argument_mode)
+                                    def_arg(pattern.id, argument_mode,
+                                            is_mutable)
                                 }
                             };
 

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

@@ -985,7 +985,7 @@ fn pick_col(m: &[@Match]) -> uint {
           _ => 0u
         }
     }
-    let scores = vec::cast_to_mut(vec::from_elem(m[0].pats.len(), 0u));
+    let scores = vec::to_mut(vec::from_elem(m[0].pats.len(), 0u));
     for vec::each(m) |br| {
         let mut i = 0u;
         for vec::each(br.pats) |p| { scores[i] += score(*p); i += 1u; }

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

@@ -1845,6 +1845,7 @@ fn trans_enum_variant(ccx: @crate_ctxt,
     let fn_args = do args.map |varg| {
         ast::arg {
             mode: ast::expl(ast::by_copy),
+            is_mutbl: false,
             ty: varg.ty,
             pat: ast_util::ident_to_pat(
                 ccx.tcx.sess.next_node_id(),
@@ -1908,6 +1909,7 @@ fn trans_tuple_struct(ccx: @crate_ctxt,
     let fn_args = do fields.map |field| {
         ast::arg {
             mode: ast::expl(ast::by_copy),
+            is_mutbl: false,
             ty: field.node.ty,
             pat: ast_util::ident_to_pat(ccx.tcx.sess.next_node_id(),
                                         ast_util::dummy_sp(),

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

@@ -854,7 +854,7 @@ fn trans_local_var(bcx: block,
                 }
             }
         }
-        ast::def_arg(nid, _) => {
+        ast::def_arg(nid, _, _) => {
             take_local(bcx, bcx.fcx.llargs, nid, expr_id_opt)
         }
         ast::def_local(nid, _) | ast::def_binding(nid, _) => {

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

@@ -297,14 +297,14 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] {
     }
 
     let words = (ty_size(ty) + 7) / 8;
-    let cls = vec::cast_to_mut(vec::from_elem(words, no_class));
+    let cls = vec::to_mut(vec::from_elem(words, no_class));
     if words > 4 {
         all_mem(cls);
-        return vec::cast_from_mut(move cls);
+        return vec::from_mut(move cls);
     }
     classify(ty, cls, 0, 0);
     fixup(ty, cls);
-    return vec::cast_from_mut(move cls);
+    return vec::from_mut(move cls);
 }
 
 fn llreg_ty(cls: &[x86_64_reg_class]) -> TypeRef {

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

@@ -68,7 +68,7 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint)
     // Conservatively assume full use for recursive loops
     ccx.type_use_cache.insert(fn_id, vec::from_elem(n_tps, 3u));
 
-    let cx = {ccx: ccx, uses: vec::cast_to_mut(vec::from_elem(n_tps, 0u))};
+    let cx = {ccx: ccx, uses: vec::to_mut(vec::from_elem(n_tps, 0u))};
     match ty::get(ty::lookup_item_type(cx.ccx.tcx, fn_id).ty).sty {
         ty::ty_fn(ref fn_ty) => {
             for vec::each(fn_ty.sig.inputs) |arg| {
@@ -84,7 +84,7 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint)
     }
 
     if fn_id_loc.crate != local_crate {
-        let uses = vec::cast_from_mut(copy cx.uses);
+        let uses = vec::from_mut(copy cx.uses);
         ccx.type_use_cache.insert(fn_id, copy uses);
         return uses;
     }
@@ -167,7 +167,7 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint)
                                 ccx.tcx.sess.parse_sess.interner)));
       }
     }
-    let uses = vec::cast_from_mut(copy cx.uses);
+    let uses = vec::from_mut(copy cx.uses);
     // XXX: Bad copy, use @vec instead?
     ccx.type_use_cache.insert(fn_id, copy uses);
     uses

branches/dist-snap/src/librustc/middle/typeck/check/mod.rs

@@ -2818,7 +2818,7 @@ fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) ->
     ty_param_bounds_and_ty {
 
     match defn {
-      ast::def_arg(nid, _) | ast::def_local(nid, _) |
+      ast::def_arg(nid, _, _) | ast::def_local(nid, _) |
       ast::def_self(nid, _) | ast::def_binding(nid, _) => {
         assert (fcx.inh.locals.contains_key(nid));
         let typ = ty::mk_var(fcx.ccx.tcx, lookup_local(fcx, sp, nid));
@@ -3024,7 +3024,7 @@ fn check_bounds_are_used(ccx: @crate_ctxt,
 
     // make a vector of booleans initially false, set to true when used
     if tps.len() == 0u { return; }
-    let tps_used = vec::cast_to_mut(vec::from_elem(tps.len(), false));
+    let tps_used = vec::to_mut(vec::from_elem(tps.len(), false));
 
     ty::walk_regions_and_ty(
         ccx.tcx, ty,

branches/dist-snap/src/librustc/middle/typeck/check/regionck.rs

@@ -55,8 +55,8 @@ type rvt = visit::vt<@rcx>;
 fn encl_region_of_def(fcx: @fn_ctxt, def: ast::def) -> ty::Region {
     let tcx = fcx.tcx();
     match def {
-        def_local(node_id, _) | def_arg(node_id, _) | def_self(node_id, _) |
-        def_binding(node_id, _) =>
+        def_local(node_id, _) | def_arg(node_id, _, _) |
+        def_self(node_id, _) | def_binding(node_id, _) =>
             return encl_region(tcx, node_id),
         def_upvar(_, subdef, closure_id, body_id) => {
             match ty_fn_proto(fcx.node_ty(closure_id)) {

branches/dist-snap/src/libstd/bitv.rs

@@ -13,7 +13,7 @@
 use core::ops;
 use core::prelude::*;
 use core::uint;
-use core::vec::{cast_to_mut, from_elem};
+use core::vec::{to_mut, from_elem};
 use core::vec;
 
 struct SmallBitv {
@@ -231,7 +231,7 @@ pub fn Bitv (nbits: uint, init: bool) -> Bitv {
         let nelems = nbits/uint_bits +
                      if nbits % uint_bits == 0 {0} else {1};
         let elem = if init {!0} else {0};
-        let s = cast_to_mut(from_elem(nelems, elem));
+        let s = to_mut(from_elem(nelems, elem));
         Big(~BigBitv(move s))
     };
     Bitv {rep: move rep, nbits: nbits}
@@ -516,7 +516,7 @@ impl Bitv: Clone {
             Bitv{nbits: self.nbits, rep: Small(~SmallBitv{bits: b.bits})}
           }
           Big(ref b) => {
-            let st = cast_to_mut(from_elem(self.nbits / uint_bits + 1, 0));
+            let st = to_mut(from_elem(self.nbits / uint_bits + 1, 0));
             let len = st.len();
             for uint::range(0, len) |i| { st[i] = b.storage[i]; };
             Bitv{nbits: self.nbits, rep: Big(~BigBitv{storage: move st})}

branches/dist-snap/src/libstd/getopts.rs

@@ -222,7 +222,7 @@ pub type Result = result::Result<Matches, Fail_>;
 pub fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
     let n_opts = opts.len();
     fn f(_x: uint) -> ~[Optval] { return ~[]; }
-    let vals = vec::cast_to_mut(vec::from_fn(n_opts, f));
+    let vals = vec::to_mut(vec::from_fn(n_opts, f));
     let mut free: ~[~str] = ~[];
     let l = args.len();
     let mut i = 0;
@@ -337,7 +337,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
         i += 1;
     }
     return Ok(Matches {opts: vec::from_slice(opts),
-               vals: vec::cast_from_mut(move vals),
+               vals: vec::from_mut(move vals),
                free: free});
 }
 

branches/dist-snap/src/libstd/map.rs

@@ -450,7 +450,7 @@ pub mod chained {
     }
 
     fn chains<K,V>(nchains: uint) -> ~[mut Option<@Entry<K,V>>] {
-        vec::cast_to_mut(vec::from_elem(nchains, None))
+        vec::to_mut(vec::from_elem(nchains, None))
     }
 
     pub fn mk<K:Eq IterBytes Hash, V: Copy>() -> T<K,V> {