renamed vec::from_slice to vec::to_owned

sonwow · sonwow · commit b7da97504943 · 2013-05-10T18:38:54.000+09:00
diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs
@@ -568,7 +568,7 @@ impl<R: Rng> RngUtil for R {
 
     /// Shuffle a vec
     fn shuffle<T:Copy>(&mut self, values: &[T]) -> ~[T] {
-        let mut m = vec::from_slice(values);
+        let mut m = vec::to_owned(values);
         self.shuffle_mut(m);
         m
     }
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
@@ -166,7 +166,7 @@ pub fn from_elem<T:Copy>(n_elts: uint, t: T) -> ~[T] {
 }
 
 /// Creates a new unique vector with the same contents as the slice
-pub fn from_slice<T:Copy>(t: &[T]) -> ~[T] {
+pub fn to_owned<T:Copy>(t: &[T]) -> ~[T] {
     from_fn(t.len(), |i| t[i])
 }
 
@@ -3451,19 +3451,19 @@ mod tests {
         let mut results: ~[~[int]];
 
         results = ~[];
-        for each_permutation(~[]) |v| { results.push(from_slice(v)); }
+        for each_permutation(~[]) |v| { results.push(to_owned(v)); }
         assert!(results == ~[~[]]);
 
         results = ~[];
-        for each_permutation(~[7]) |v| { results.push(from_slice(v)); }
+        for each_permutation(~[7]) |v| { results.push(to_owned(v)); }
         assert!(results == ~[~[7]]);
 
         results = ~[];
-        for each_permutation(~[1,1]) |v| { results.push(from_slice(v)); }
+        for each_permutation(~[1,1]) |v| { results.push(to_owned(v)); }
         assert!(results == ~[~[1,1],~[1,1]]);
 
         results = ~[];
-        for each_permutation(~[5,2,0]) |v| { results.push(from_slice(v)); }
+        for each_permutation(~[5,2,0]) |v| { results.push(to_owned(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/librust/rust.rc b/src/librust/rust.rc
@@ -192,7 +192,7 @@ fn do_command(command: &Command, args: &[~str]) -> ValidUsage {
             let (prog, prog_args) = (words.head(), words.tail());
             let exitstatus = run::run_program(
                 *prog,
-                vec::append(vec::from_slice(prog_args), args)
+                vec::append(vec::to_owned(prog_args), args)
             );
             os::set_exit_status(exitstatus);
             Valid
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
@@ -580,7 +580,7 @@ pub fn maybe_get_item_ast(intr: @ident_interner, cdata: cmd, tcx: ty::ctxt,
     let item_doc = lookup_item(id, cdata.data);
     let path = {
         let item_path = item_path(intr, item_doc);
-        vec::from_slice(item_path.init())
+        vec::to_owned(item_path.init())
     };
     match decode_inlined_item(cdata, tcx, copy path, item_doc) {
       Some(ref ii) => csearch::found((/*bad*/copy *ii)),
diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
@@ -1420,7 +1420,7 @@ pub fn encode_metadata(parms: EncodeParams, crate: &crate) -> ~[u8] {
     //
     // Should be:
     //
-    //   vec::from_slice(metadata_encoding_version) +
+    //   vec::to_owned(metadata_encoding_version) +
 
     let writer_bytes: &mut ~[u8] = wr.bytes;
 
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
@@ -488,7 +488,7 @@ pub fn specialize(cx: @MatchCheckCtxt,
                 match cx.tcx.def_map.find(&pat_id) {
                     Some(&def_variant(_, id)) => {
                         if variant(id) == *ctor_id {
-                            Some(vec::from_slice(r.tail()))
+                            Some(vec::to_owned(r.tail()))
                         } else {
                             None
                         }
@@ -507,7 +507,7 @@ pub fn specialize(cx: @MatchCheckCtxt,
                             _ => fail!(~"type error")
                         };
                         if match_ {
-                            Some(vec::from_slice(r.tail()))
+                            Some(vec::to_owned(r.tail()))
                         } else {
                             None
                         }
@@ -538,7 +538,7 @@ pub fn specialize(cx: @MatchCheckCtxt,
                             _ => fail!(~"type error")
                         };
                         if match_ {
-                            Some(vec::from_slice(r.tail()))
+                            Some(vec::to_owned(r.tail()))
                         } else {
                             None
                         }
@@ -548,7 +548,7 @@ pub fn specialize(cx: @MatchCheckCtxt,
                             Some(args) => args,
                             None => vec::from_elem(arity, wild())
                         };
-                        Some(vec::append(args, vec::from_slice(r.tail())))
+                        Some(vec::append(args, vec::to_owned(r.tail())))
                     }
                     def_variant(_, _) => None,
 
@@ -560,7 +560,7 @@ pub fn specialize(cx: @MatchCheckCtxt,
                             Some(args) => new_args = args,
                             None => new_args = vec::from_elem(arity, wild())
                         }
-                        Some(vec::append(new_args, vec::from_slice(r.tail())))
+                        Some(vec::append(new_args, vec::to_owned(r.tail())))
                     }
                     _ => None
                 }
@@ -578,7 +578,7 @@ pub fn specialize(cx: @MatchCheckCtxt,
                                     _ => wild()
                                 }
                             });
-                            Some(vec::append(args, vec::from_slice(r.tail())))
+                            Some(vec::append(args, vec::to_owned(r.tail())))
                         } else {
                             None
                         }
@@ -608,7 +608,7 @@ pub fn specialize(cx: @MatchCheckCtxt,
                                 _ => wild()
                             }
                         });
-                        Some(vec::append(args, vec::from_slice(r.tail())))
+                        Some(vec::append(args, vec::to_owned(r.tail())))
                     }
                 }
             }
@@ -627,21 +627,21 @@ pub fn specialize(cx: @MatchCheckCtxt,
                     single => true,
                     _ => fail!(~"type error")
                 };
-                if match_ { Some(vec::from_slice(r.tail())) } else { None }
+                if match_ { Some(vec::to_owned(r.tail())) } else { None }
             }
             pat_range(lo, hi) => {
                 let (c_lo, c_hi) = match *ctor_id {
                     val(ref v) => ((/*bad*/copy *v), (/*bad*/copy *v)),
                     range(ref lo, ref hi) =>
                         ((/*bad*/copy *lo), (/*bad*/copy *hi)),
-                    single => return Some(vec::from_slice(r.tail())),
+                    single => return Some(vec::to_owned(r.tail())),
                     _ => fail!(~"type error")
                 };
                 let v_lo = eval_const_expr(cx.tcx, lo),
                 v_hi = eval_const_expr(cx.tcx, hi);
                 let match_ = compare_const_vals(&c_lo, &v_lo) >= 0 &&
                     compare_const_vals(&c_hi, &v_hi) <= 0;
-          if match_ { Some(vec::from_slice(r.tail())) } else { None }
+          if match_ { Some(vec::to_owned(r.tail())) } else { None }
       }
             pat_vec(before, slice, after) => {
                 match *ctor_id {
@@ -674,7 +674,7 @@ pub fn specialize(cx: @MatchCheckCtxt,
 }
 
 pub fn default(cx: @MatchCheckCtxt, r: &[@pat]) -> Option<~[@pat]> {
-    if is_wild(cx, r[0]) { Some(vec::from_slice(r.tail())) }
+    if is_wild(cx, r[0]) { Some(vec::to_owned(r.tail())) }
     else { None }
 }
 
diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs
@@ -217,7 +217,7 @@ fn mk_struct(cx: @CrateContext, tys: &[ty::t], packed: bool) -> Struct {
         size: machine::llsize_of_alloc(cx, llty_rec) /*bad*/as u64,
         align: machine::llalign_of_min(cx, llty_rec) /*bad*/as u64,
         packed: packed,
-        fields: vec::from_slice(tys)
+        fields: vec::to_owned(tys)
     }
 }
 
diff --git a/src/librustc/middle/trans/cabi.rs b/src/librustc/middle/trans/cabi.rs
@@ -71,8 +71,8 @@ pub impl FnType {
             let llretptr = GEPi(bcx, llargbundle, [0u, n]);
             let llretloc = Load(bcx, llretptr);
                 llargvals = ~[llretloc];
-                atys = vec::from_slice(atys.tail());
-                attrs = vec::from_slice(attrs.tail());
+                atys = vec::to_owned(atys.tail());
+                attrs = vec::to_owned(attrs.tail());
         }
 
         while i < n {
@@ -137,8 +137,8 @@ pub impl FnType {
         let mut attrs = /*bad*/copy self.attrs;
         let mut j = 0u;
         let llretptr = if self.sret {
-            atys = vec::from_slice(atys.tail());
-            attrs = vec::from_slice(attrs.tail());
+            atys = vec::to_owned(atys.tail());
+            attrs = vec::to_owned(attrs.tail());
             j = 1u;
             get_param(llwrapfn, 0u)
         } else if self.ret_ty.cast {
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
@@ -3813,7 +3813,7 @@ pub fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path {
           }
 
           ast_map::node_variant(ref variant, _, path) => {
-            vec::append_one(vec::from_slice(vec::init(*path)),
+            vec::append_one(vec::to_owned(vec::init(*path)),
                             ast_map::path_name((*variant).node.name))
           }
 
diff --git a/src/libstd/flatpipes.rs b/src/libstd/flatpipes.rs
@@ -442,7 +442,7 @@ pub mod flatteners {
                               T: Decodable<D>>(
                               buf: &[u8])
                               -> T {
-        let buf = vec::from_slice(buf);
+        let buf = vec::to_owned(buf);
         let buf_reader = @BufReader::new(buf);
         let reader = buf_reader as @Reader;
         let mut deser: D = FromReader::from_reader(reader);
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
@@ -339,7 +339,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
         }
         i += 1;
     }
-    return Ok(Matches {opts: vec::from_slice(opts),
+    return Ok(Matches {opts: vec::to_owned(opts),
                vals: vals,
                free: free});
 }
diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs
@@ -26,7 +26,7 @@ pub fn md4(msg: &[u8]) -> Quad {
     let orig_len: u64 = (vec::len(msg) * 8u) as u64;
 
     // pad message
-    let mut msg = vec::append(vec::from_slice(msg), ~[0x80u8]);
+    let mut msg = vec::append(vec::to_owned(msg), ~[0x80u8]);
     let mut bitlen = orig_len + 8u64;
     while (bitlen + 64u64) % 512u64 > 0u64 {
         msg.push(0u8);
diff --git a/src/libstd/num/bigint.rs b/src/libstd/num/bigint.rs
@@ -541,7 +541,7 @@ impl BigUint {
     /// Creates and initializes an BigUint.
     #[inline(always)]
     pub fn from_slice(slice: &[BigDigit]) -> BigUint {
-        return BigUint::new(vec::from_slice(slice));
+        return BigUint::new(vec::to_owned(slice));
     }
 
     /// Creates and initializes an BigUint.
diff --git a/src/libstd/stats.rs b/src/libstd/stats.rs
@@ -52,7 +52,7 @@ impl<'self> Stats for &'self [f64] {
 
     fn median(self) -> f64 {
         assert!(self.len() != 0);
-        let mut tmp = vec::from_slice(self);
+        let mut tmp = vec::to_owned(self);
         sort::tim_sort(tmp);
         if tmp.len() & 1 == 0 {
             let m = tmp.len() / 2;
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
@@ -255,7 +255,7 @@ pub fn last_meta_item_list_by_name(items: ~[@ast::meta_item], name: &str)
 
 pub fn sort_meta_items(items: &[@ast::meta_item]) -> ~[@ast::meta_item] {
     // This is sort of stupid here, converting to a vec of mutables and back
-    let mut v = vec::from_slice(items);
+    let mut v = vec::to_owned(items);
     do std::sort::quick_sort(v) |ma, mb| {
         get_meta_item_name(*ma) <= get_meta_item_name(*mb)
     }
diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs
@@ -41,7 +41,7 @@ pub fn expand_asm(cx: @ext_ctxt, sp: span, tts: &[ast::token_tree])
                -> base::MacResult {
     let p = parse::new_parser_from_tts(cx.parse_sess(),
                                        cx.cfg(),
-                                       vec::from_slice(tts));
+                                       vec::to_owned(tts));
 
     let mut asm = ~"";
     let mut outputs = ~[];
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
@@ -386,7 +386,7 @@ pub fn get_exprs_from_tts(cx: @ext_ctxt, tts: &[ast::token_tree])
                        -> ~[@ast::expr] {
     let p = parse::new_parser_from_tts(cx.parse_sess(),
                                        cx.cfg(),
-                                       vec::from_slice(tts));
+                                       vec::to_owned(tts));
     let mut es = ~[];
     while *p.token != token::EOF {
         if es.len() != 0 {
diff --git a/src/libsyntax/ext/log_syntax.rs b/src/libsyntax/ext/log_syntax.rs
@@ -22,7 +22,7 @@ pub fn expand_syntax_ext(cx: @ext_ctxt,
     cx.print_backtrace();
     io::stdout().write_line(
         print::pprust::tt_to_str(
-            ast::tt_delim(vec::from_slice(tt)),
+            ast::tt_delim(vec::to_owned(tt)),
             cx.parse_sess().interner));
 
     //trivial expression
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
@@ -669,7 +669,7 @@ fn expand_tts(cx: @ext_ctxt,
     let p = parse::new_parser_from_tts(
         cx.parse_sess(),
         cx.cfg(),
-        vec::from_slice(tts)
+        vec::to_owned(tts)
     );
     *p.quote_depth += 1u;
     let tts = p.parse_all_token_trees();
diff --git a/src/libsyntax/ext/trace_macros.rs b/src/libsyntax/ext/trace_macros.rs
@@ -25,7 +25,7 @@ pub fn expand_trace_macros(cx: @ext_ctxt,
         copy cx.parse_sess().span_diagnostic,
         cx.parse_sess().interner,
         None,
-        vec::from_slice(tt)
+        vec::to_owned(tt)
     );
     let rdr = tt_rdr as @reader;
     let rust_parser = Parser(
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
@@ -82,7 +82,7 @@ pub fn add_new_extension(cx: @ext_ctxt,
             io::println(fmt!("%s! { %s }",
                              cx.str_of(name),
                              print::pprust::tt_to_str(
-                                 ast::tt_delim(vec::from_slice(arg)),
+                                 ast::tt_delim(vec::to_owned(arg)),
                                  cx.parse_sess().interner)));
         }
 
@@ -101,7 +101,7 @@ pub fn add_new_extension(cx: @ext_ctxt,
                     s_d,
                     itr,
                     None,
-                    vec::from_slice(arg)
+                    vec::to_owned(arg)
                 ) as @reader;
                 match parse(cx.parse_sess(), cx.cfg(), arg_rdr, (*mtcs)) {
                   success(named_matches) => {

Original file line number	Diff line number	Diff line change
`@@ -568,7 +568,7 @@ impl<R: Rng> RngUtil for R {`
`568`	`568`
`569`	`569`	`/// Shuffle a vec`
`570`	`570`	`fn shuffle<T:Copy>(&mut self, values: &[T]) -> ~[T] {`
`571`		`- let mut m = vec::from_slice(values);`
	`571`	`+ let mut m = vec::to_owned(values);`
`572`	`572`	`self.shuffle_mut(m);`
`573`	`573`	`m`
`574`	`574`	`}`
Original file line number	Diff line number	Diff line change
`@@ -488,7 +488,7 @@ pub fn specialize(cx: @MatchCheckCtxt,`
`488`	`488`	`match cx.tcx.def_map.find(&pat_id) {`
`489`	`489`	`Some(&def_variant(_, id)) => {`
`490`	`490`	`if variant(id) == *ctor_id {`
`491`		`- Some(vec::from_slice(r.tail()))`
	`491`	`+ Some(vec::to_owned(r.tail()))`
`492`	`492`	`} else {`
`493`	`493`	`None`
`494`	`494`	`}`
`@@ -507,7 +507,7 @@ pub fn specialize(cx: @MatchCheckCtxt,`
`507`	`507`	`_ => fail!(~"type error")`
`508`	`508`	`};`
`509`	`509`	`if match_ {`
`510`		`- Some(vec::from_slice(r.tail()))`
	`510`	`+ Some(vec::to_owned(r.tail()))`
`511`	`511`	`} else {`
`512`	`512`	`None`
`513`	`513`	`}`
`@@ -538,7 +538,7 @@ pub fn specialize(cx: @MatchCheckCtxt,`
`538`	`538`	`_ => fail!(~"type error")`
`539`	`539`	`};`
`540`	`540`	`if match_ {`
`541`		`- Some(vec::from_slice(r.tail()))`
	`541`	`+ Some(vec::to_owned(r.tail()))`
`542`	`542`	`} else {`
`543`	`543`	`None`
`544`	`544`	`}`
`@@ -548,7 +548,7 @@ pub fn specialize(cx: @MatchCheckCtxt,`
`548`	`548`	`Some(args) => args,`
`549`	`549`	`None => vec::from_elem(arity, wild())`
`550`	`550`	`};`
`551`		`- Some(vec::append(args, vec::from_slice(r.tail())))`
	`551`	`+ Some(vec::append(args, vec::to_owned(r.tail())))`
`552`	`552`	`}`
`553`	`553`	`def_variant(_, _) => None,`
`554`	`554`
`@@ -560,7 +560,7 @@ pub fn specialize(cx: @MatchCheckCtxt,`
`560`	`560`	`Some(args) => new_args = args,`
`561`	`561`	`None => new_args = vec::from_elem(arity, wild())`
`562`	`562`	`}`
`563`		`- Some(vec::append(new_args, vec::from_slice(r.tail())))`
	`563`	`+ Some(vec::append(new_args, vec::to_owned(r.tail())))`
`564`	`564`	`}`
`565`	`565`	`_ => None`
`566`	`566`	`}`
`@@ -578,7 +578,7 @@ pub fn specialize(cx: @MatchCheckCtxt,`
`578`	`578`	`_ => wild()`
`579`	`579`	`}`
`580`	`580`	`});`
`581`		`- Some(vec::append(args, vec::from_slice(r.tail())))`
	`581`	`+ Some(vec::append(args, vec::to_owned(r.tail())))`
`582`	`582`	`} else {`
`583`	`583`	`None`
`584`	`584`	`}`
`@@ -608,7 +608,7 @@ pub fn specialize(cx: @MatchCheckCtxt,`
`608`	`608`	`_ => wild()`
`609`	`609`	`}`
`610`	`610`	`});`
`611`		`- Some(vec::append(args, vec::from_slice(r.tail())))`
	`611`	`+ Some(vec::append(args, vec::to_owned(r.tail())))`
`612`	`612`	`}`
`613`	`613`	`}`
`614`	`614`	`}`
`@@ -627,21 +627,21 @@ pub fn specialize(cx: @MatchCheckCtxt,`
`627`	`627`	`single => true,`
`628`	`628`	`_ => fail!(~"type error")`
`629`	`629`	`};`
`630`		`- if match_ { Some(vec::from_slice(r.tail())) } else { None }`
	`630`	`+ if match_ { Some(vec::to_owned(r.tail())) } else { None }`
`631`	`631`	`}`
`632`	`632`	`pat_range(lo, hi) => {`
`633`	`633`	`let (c_lo, c_hi) = match *ctor_id {`
`634`	`634`	`val(ref v) => ((/bad/copy v), (/bad/copy v)),`
`635`	`635`	`range(ref lo, ref hi) =>`
`636`	`636`	`((/bad/copy lo), (/bad/copy hi)),`
`637`		`- single => return Some(vec::from_slice(r.tail())),`
	`637`	`+ single => return Some(vec::to_owned(r.tail())),`
`638`	`638`	`_ => fail!(~"type error")`
`639`	`639`	`};`
`640`	`640`	`let v_lo = eval_const_expr(cx.tcx, lo),`
`641`	`641`	`v_hi = eval_const_expr(cx.tcx, hi);`
`642`	`642`	`let match_ = compare_const_vals(&c_lo, &v_lo) >= 0 &&`
`643`	`643`	`compare_const_vals(&c_hi, &v_hi) <= 0;`
`644`		`- if match_ { Some(vec::from_slice(r.tail())) } else { None }`
	`644`	`+ if match_ { Some(vec::to_owned(r.tail())) } else { None }`
`645`	`645`	`}`
`646`	`646`	`pat_vec(before, slice, after) => {`
`647`	`647`	`match *ctor_id {`
`@@ -674,7 +674,7 @@ pub fn specialize(cx: @MatchCheckCtxt,`
`674`	`674`	`}`
`675`	`675`
`676`	`676`	`pub fn default(cx: @MatchCheckCtxt, r: &[@pat]) -> Option<~[@pat]> {`
`677`		`- if is_wild(cx, r[0]) { Some(vec::from_slice(r.tail())) }`
	`677`	`+ if is_wild(cx, r[0]) { Some(vec::to_owned(r.tail())) }`
`678`	`678`	`else { None }`
`679`	`679`	`}`
`680`	`680`
Original file line number	Diff line number	Diff line change
`@@ -217,7 +217,7 @@ fn mk_struct(cx: @CrateContext, tys: &[ty::t], packed: bool) -> Struct {`
`217`	`217`	`size: machine::llsize_of_alloc(cx, llty_rec) /bad/as u64,`
`218`	`218`	`align: machine::llalign_of_min(cx, llty_rec) /bad/as u64,`
`219`	`219`	`packed: packed,`
`220`		`- fields: vec::from_slice(tys)`
	`220`	`+ fields: vec::to_owned(tys)`
`221`	`221`	`}`
`222`	`222`	`}`
`223`	`223`
Original file line number	Diff line number	Diff line change
`@@ -3813,7 +3813,7 @@ pub fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path {`
`3813`	`3813`	`}`
`3814`	`3814`
`3815`	`3815`	`ast_map::node_variant(ref variant, _, path) => {`
`3816`		`- vec::append_one(vec::from_slice(vec::init(*path)),`
	`3816`	`+ vec::append_one(vec::to_owned(vec::init(*path)),`
`3817`	`3817`	`ast_map::path_name((*variant).node.name))`
`3818`	`3818`	`}`
`3819`	`3819`