---

yaml
---
r: 23120
b: refs/heads/master
c: 1b2d91c
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: fe8c8ad5827e0156490d78257b5e33cf9bc1281a
+refs/heads/master: 1b2d91c79da93461563428d25ae09bbeb59ed292
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/src/libcore/result.rs

@@ -250,7 +250,7 @@ impl<T: copy, E: copy> result<T, E> {
  *     }
  */
 fn map_vec<T,U:copy,V:copy>(
-    ts: ~[T], op: fn(T) -> result<V,U>) -> result<~[V],U> {
+    ts: &[T], op: fn(T) -> result<V,U>) -> result<~[V],U> {
 
     let mut vs: ~[V] = ~[];
     vec::reserve(vs, vec::len(ts));
@@ -284,7 +284,7 @@ fn map_opt<T,U:copy,V:copy>(
  * used in 'careful' code contexts where it is both appropriate and easy
  * to accommodate an error like the vectors being of different lengths.
  */
-fn map_vec2<S,T,U:copy,V:copy>(ss: ~[S], ts: ~[T],
+fn map_vec2<S,T,U:copy,V:copy>(ss: &[S], ts: &[T],
                                op: fn(S,T) -> result<V,U>) -> result<~[V],U> {
 
     assert vec::same_length(ss, ts);
@@ -307,7 +307,7 @@ fn map_vec2<S,T,U:copy,V:copy>(ss: ~[S], ts: ~[T],
  * error.  This could be implemented using `map2()` but it is more efficient
  * on its own as no result vector is built.
  */
-fn iter_vec2<S,T,U:copy>(ss: ~[S], ts: ~[T],
+fn iter_vec2<S,T,U:copy>(ss: &[S], ts: &[T],
                          op: fn(S,T) -> result<(),U>) -> result<(),U> {
 
     assert vec::same_length(ss, ts);

trunk/src/libcore/vec.rs

@@ -17,6 +17,7 @@ export capacity;
 export len;
 export from_fn;
 export from_elem;
+export from_slice;
 export build, build_sized;
 export to_mut;
 export from_mut;
@@ -211,6 +212,11 @@ pure fn from_elem<T: copy>(n_elts: uint, t: T) -> ~[T] {
     return v;
 }
 
+/// Creates a new unique vector with the same contents as the slice
+pure fn from_slice<T: copy>(t: &[T]) -> ~[T] {
+    from_fn(t.len(), |i| t[i])
+}
+
 /**
  * Builds a vector by calling a provided function with an argument
  * function that pushes an element to the back of a vector.

trunk/src/rustc/middle/ty.rs

@@ -532,6 +532,16 @@ fn param_bounds_to_kind(bounds: param_bounds) -> kind {
     kind
 }
 
+/// A polytype.
+///
+/// - `bounds`: The list of bounds for each type parameter.  The length of the
+///   list also tells you how many type parameters there are.
+///
+/// - `rp`: true if the type is region-parameterized.  Types can have at
+///   most one region parameter, always called `&self`.
+///
+/// - `ty`: the base type.  May have reference to the (unsubstituted) bound
+///   region `&self` or to (unsubstituted) ty_param types
 type ty_param_bounds_and_ty = {bounds: @~[param_bounds],
                                rp: bool,
                                ty: t};
@@ -1532,7 +1542,7 @@ pure fn kind_is_owned(k: kind) -> bool {
 
 fn proto_kind(p: proto) -> kind {
     match p {
-      ast::proto_block => kind_noncopyable(),
+      ast::proto_block => kind_noncopyable() | kind_(KIND_MASK_DEFAULT_MODE),
       ast::proto_box => kind_safe_for_default_mode() | kind_owned(),
       ast::proto_uniq => kind_send_copy() | kind_owned(),
       ast::proto_bare => kind_safe_for_default_mode_send() | kind_const() |

trunk/src/rustc/middle/typeck/check.rs

@@ -175,13 +175,16 @@ fn check_bare_fn(ccx: @crate_ctxt,
                  id: ast::node_id,
                  self_info: option<self_info>) {
     let fty = ty::node_id_to_type(ccx.tcx, id);
-    let fn_ty = match check ty::get(fty).struct { ty::ty_fn(f) => f };
-    check_fn(ccx, self_info, fn_ty, decl, body, false, none);
+    match check ty::get(fty).struct {
+        ty::ty_fn(ref fn_ty) => {
+            check_fn(ccx, self_info, fn_ty, decl, body, false, none)
+        }
+    }
 }
 
 fn check_fn(ccx: @crate_ctxt,
             self_info: option<self_info>,
-            fn_ty: ty::fn_ty,
+            fn_ty: &ty::fn_ty,
             decl: ast::fn_decl,
             body: ast::blk,
             indirect_ret: bool,
@@ -620,13 +623,15 @@ impl @fn_ctxt {
 
     fn mk_assignty(expr: @ast::expr, borrow_lb: ast::node_id,
                    sub: ty::t, sup: ty::t) -> result<(), ty::type_err> {
-        let anmnt = {expr_id: expr.id, span: expr.span, borrow_lb: borrow_lb};
+        let anmnt = &{expr_id: expr.id, span: expr.span,
+                      borrow_lb: borrow_lb};
         infer::mk_assignty(self.infcx, anmnt, sub, sup)
     }
 
     fn can_mk_assignty(expr: @ast::expr, borrow_lb: ast::node_id,
                        sub: ty::t, sup: ty::t) -> result<(), ty::type_err> {
-        let anmnt = {expr_id: expr.id, span: expr.span, borrow_lb: borrow_lb};
+        let anmnt = &{expr_id: expr.id, span: expr.span,
+                      borrow_lb: borrow_lb};
         infer::can_mk_assignty(self.infcx, anmnt, sub, sup)
     }
 
@@ -821,7 +826,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
         // functions.  Therefore, we match one level of structure.
         let fn_ty =
             match structure_of(fcx, sp, in_fty) {
-              sty @ ty::ty_fn(fn_ty) => {
+              sty @ ty::ty_fn(ref fn_ty) => {
                 replace_bound_regions_in_fn_ty(
                     fcx.ccx.tcx, @nil, none, fn_ty,
                     |_br| fcx.infcx.next_region_var_nb()).fn_ty
@@ -1124,7 +1129,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
         // what's going on here.
         let expected_tys = do unpack_expected(fcx, expected) |sty| {
             match sty {
-              ty::ty_fn(fn_ty) => {
+              ty::ty_fn(ref fn_ty) => {
                 let {fn_ty, _} =
                     replace_bound_regions_in_fn_ty(
                         tcx, @nil, none, fn_ty,
@@ -1146,7 +1151,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
 
         fcx.write_ty(expr.id, fty);
 
-        check_fn(fcx.ccx, fcx.self_info, fn_ty, decl, body,
+        check_fn(fcx.ccx, fcx.self_info, &fn_ty, decl, body,
                  is_loop_body, some(fcx));
     }
 

trunk/src/rustc/middle/typeck/check/regionmanip.rs

@@ -1,3 +1,6 @@
+// #[warn(deprecated_mode)];
+// #[warn(deprecated_pattern)];
+
 import syntax::print::pprust::{expr_to_str};
 
 // Helper functions related to manipulating region types.
@@ -6,7 +9,7 @@ fn replace_bound_regions_in_fn_ty(
     tcx: ty::ctxt,
     isr: isr_alist,
     self_info: option<self_info>,
-    fn_ty: ty::fn_ty,
+    fn_ty: &ty::fn_ty,
     mapf: fn(ty::bound_region) -> ty::region) ->
     {isr: isr_alist, self_info: option<self_info>, fn_ty: ty::fn_ty} {
 
@@ -17,22 +20,22 @@ fn replace_bound_regions_in_fn_ty(
       none => none
     };
 
-    let mut all_tys = ty::tys_in_fn_ty(fn_ty);
+    let mut all_tys = ty::tys_in_fn_ty(*fn_ty);
 
     for self_ty.each |t| { vec::push(all_tys, t) }
 
     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)),
-           ty_to_str(tcx, ty::mk_fn(tcx, fn_ty)),
+           ty_to_str(tcx, ty::mk_fn(tcx, *fn_ty)),
            all_tys.map(|t| ty_to_str(tcx, t))};
     let _i = indenter();
 
     let isr = do create_bound_region_mapping(tcx, isr, all_tys) |br| {
         debug!{"br=%?", br};
         mapf(br)
     };
-    let t_fn = ty::fold_sty_to_ty(tcx, ty::ty_fn(fn_ty), |t| {
+    let t_fn = ty::fold_sty_to_ty(tcx, ty::ty_fn(*fn_ty), |t| {
         replace_bound_regions(tcx, isr, t)
     });
     let t_self = self_ty.map(|t| replace_bound_regions(tcx, isr, t));