---

yaml
---
r: 71911
b: refs/heads/dist-snap
c: 49de82c
h: refs/heads/master
i:
  71909: e852396
  71907: b21778b
  71903: ca43ca0
v: v3

Author: nikomatsakis

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: b50030718cf28f2a5a81857a26b57442734fe854
-refs/heads/dist-snap: 26ecb30f550a46d52528a7d45d9327ebce938e81
+refs/heads/dist-snap: 49de82cdca2064a909d3104f4e5eccacb0425fd0
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/tutorial.md

@@ -495,11 +495,7 @@ omitted.
 
 A powerful application of pattern matching is *destructuring*:
 matching in order to bind names to the contents of data
-types.
-
-> ***Note:*** The following code makes use of tuples (`(float, float)`) which
-> are explained in section 5.3. For now you can think of tuples as a list of
-> items.
+types. Assuming that `(float, float)` is a tuple of two floats:
 
 ~~~~
 fn angle(vector: (float, float)) -> float {

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

@@ -116,6 +116,19 @@ totalord_impl!(i64)
 totalord_impl!(int)
 totalord_impl!(uint)
 
+pub fn cmp2<A:TotalOrd,B:TotalOrd>(
+    a1: &A, b1: &B,
+    a2: &A, b2: &B) -> Ordering
+{
+    //! Compares (a1, b1) against (a2, b2), where the a values are more significant.
+
+    match a1.cmp(a2) {
+        Less => Less,
+        Greater => Greater,
+        Equal => b1.cmp(b2)
+    }
+}
+
 /**
 * Trait for values that can be compared for a sort-order.
 *
@@ -193,6 +206,14 @@ mod test {
         assert_eq!(12.cmp(-5), Greater);
     }
 
+    #[test]
+    fn test_cmp2() {
+        assert_eq!(cmp2(1, 2, 3, 4), Less);
+        assert_eq!(cmp2(3, 2, 3, 4), Less);
+        assert_eq!(cmp2(5, 2, 3, 4), Greater);
+        assert_eq!(cmp2(5, 5, 5, 4), Greater);
+    }
+
     #[test]
     fn test_int_totaleq() {
         assert!(5.equals(&5));

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

@@ -344,29 +344,3 @@ pub fn copy_seq<T:Copy,IT:BaseIter<T>,BT:Buildable<T>>(v: &IT) -> BT {
         for v.each |x| { push(*x); }
     }
 }
-
-/**
- * Helper function to transform an internal iterator into an owned vector.
- *
- * # Example:
- *
- * ~~~
- * let v = ~[1, 2, 3];
- * let v2 = do iter_to_vec |f| { v.each(|e| f(*e)) };
- * if v != v2 { fail!() }
- * ~~~
- */
-#[inline(always)]
-pub fn iter_to_vec<T>(pusher: &fn(it: &fn(T) -> bool)) -> ~[T] {
-    let mut v = ~[];
-    let pushf = |e| {v.push(e); true};
-    pusher(pushf);
-    v
-}
-
-#[test]
-fn test_iter_to_vec() {
-    let v = ~[1, 2, 3];
-    let v2 = do iter_to_vec |f| { v.each(|e| f(*e)) };
-    if v != v2 { fail!() }
-}

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

@@ -301,7 +301,11 @@ pub fn slice_shift_char<'a>(s: &'a str) -> (char, &'a str) {
 
 /// Prepend a char to a string
 pub fn unshift_char(s: &mut ~str, ch: char) {
-    *s = from_char(ch) + *s;
+    // This could be more efficient.
+    let mut new_str = ~"";
+    new_str.push_char(ch);
+    new_str.push_str(*s);
+    *s = new_str;
 }
 
 /**

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

@@ -161,7 +161,6 @@ impl<A:Ord> Ord for (A,) {
     fn gt(&self, other: &(A,)) -> bool { other.lt(&(*self))  }
 }
 
-
 #[cfg(notest)]
 impl<A:Eq,B:Eq> Eq for (A, B) {
     #[inline(always)]

branches/dist-snap/src/librustc/front/core_inject.rs

@@ -77,7 +77,7 @@ fn inject_libcore_ref(sess: Session,
         fold_mod: |module, fld| {
             let n2 = sess.next_node_id();
 
-            let prelude_path = @ast::Path {
+            let prelude_path = @ast::path {
                 span: dummy_sp(),
                 global: false,
                 idents: ~[

branches/dist-snap/src/librustc/front/test.rs

@@ -336,16 +336,16 @@ fn nospan<T:Copy>(t: T) -> codemap::spanned<T> {
     codemap::spanned { node: t, span: dummy_sp() }
 }
 
-fn path_node(+ids: ~[ast::ident]) -> @ast::Path {
-    @ast::Path { span: dummy_sp(),
+fn path_node(+ids: ~[ast::ident]) -> @ast::path {
+    @ast::path { span: dummy_sp(),
                 global: false,
                 idents: ids,
                 rp: None,
                 types: ~[] }
 }
 
-fn path_node_global(+ids: ~[ast::ident]) -> @ast::Path {
-    @ast::Path { span: dummy_sp(),
+fn path_node_global(+ids: ~[ast::ident]) -> @ast::path {
+    @ast::path { span: dummy_sp(),
                  global: true,
                  idents: ids,
                  rp: None,

branches/dist-snap/src/librustc/metadata/tydecode.rs

@@ -137,7 +137,7 @@ pub fn parse_arg_data(data: @~[u8], crate_num: int, pos: uint, tcx: ty::ctxt,
     parse_arg(st, conv)
 }
 
-fn parse_path(st: @mut PState) -> @ast::Path {
+fn parse_path(st: @mut PState) -> @ast::path {
     let mut idents: ~[ast::ident] = ~[];
     fn is_last(c: char) -> bool { return c == '(' || c == ':'; }
     idents.push(parse_ident_(st, is_last));
@@ -146,7 +146,7 @@ fn parse_path(st: @mut PState) -> @ast::Path {
           ':' => { next(st); next(st); }
           c => {
             if c == '(' {
-                return @ast::Path { span: dummy_sp(),
+                return @ast::path { span: dummy_sp(),
                                     global: false,
                                     idents: idents,
                                     rp: None,
@@ -239,7 +239,8 @@ fn parse_region(st: @mut PState) -> ty::Region {
         assert!(next(st) == '|');
         let br = parse_bound_region(st);
         assert!(next(st) == ']');
-        ty::re_free(id, br)
+        ty::re_free(ty::FreeRegion {scope_id: id,
+                                    bound_region: br})
       }
       's' => {
         let id = parse_int(st);

branches/dist-snap/src/librustc/metadata/tyencode.rs

@@ -146,12 +146,12 @@ fn enc_region(w: @io::Writer, cx: @ctxt, r: ty::Region) {
         w.write_char('b');
         enc_bound_region(w, cx, br);
       }
-      ty::re_free(id, br) => {
+      ty::re_free(ref fr) => {
         w.write_char('f');
         w.write_char('[');
-        w.write_int(id);
+        w.write_int(fr.scope_id);
         w.write_char('|');
-        enc_bound_region(w, cx, br);
+        enc_bound_region(w, cx, fr.bound_region);
         w.write_char(']');
       }
       ty::re_scope(nid) => {

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

@@ -475,9 +475,12 @@ impl tr for ty::Region {
     fn tr(&self, xcx: @ExtendedDecodeContext) -> ty::Region {
         match *self {
             ty::re_bound(br) => ty::re_bound(br.tr(xcx)),
-            ty::re_free(id, br) => ty::re_free(xcx.tr_id(id), br.tr(xcx)),
             ty::re_scope(id) => ty::re_scope(xcx.tr_id(id)),
             ty::re_static | ty::re_infer(*) => *self,
+            ty::re_free(ref fr) => {
+                ty::re_free(ty::FreeRegion {scope_id: xcx.tr_id(fr.scope_id),
+                                            bound_region: fr.bound_region.tr(xcx)})
+            }
         }
     }
 }
@@ -556,7 +559,6 @@ trait read_method_map_entry_helper {
                             -> method_map_entry;
 }
 
-#[cfg(stage0)]
 fn encode_method_map_entry(ecx: @e::EncodeContext,
                               ebml_w: writer::Encoder,
                               mme: method_map_entry) {
@@ -573,27 +575,7 @@ fn encode_method_map_entry(ecx: @e::EncodeContext,
     }
 }
 
-#[cfg(stage1)]
-#[cfg(stage2)]
-#[cfg(stage3)]
-fn encode_method_map_entry(ecx: @e::EncodeContext,
-                              ebml_w: writer::Encoder,
-                              mme: method_map_entry) {
-    do ebml_w.emit_struct("method_map_entry", 3) {
-        do ebml_w.emit_struct_field("self_arg", 0u) {
-            ebml_w.emit_arg(ecx, mme.self_arg);
-        }
-        do ebml_w.emit_struct_field("explicit_self", 2u) {
-            mme.explicit_self.encode(&ebml_w);
-        }
-        do ebml_w.emit_struct_field("origin", 1u) {
-            mme.origin.encode(&ebml_w);
-        }
-    }
-}
-
 impl read_method_map_entry_helper for reader::Decoder {
-    #[cfg(stage0)]
     fn read_method_map_entry(&self, xcx: @ExtendedDecodeContext)
         -> method_map_entry {
         do self.read_struct("method_map_entry", 3) {
@@ -613,29 +595,6 @@ impl read_method_map_entry_helper for reader::Decoder {
             }
         }
     }
-
-    #[cfg(stage1)]
-    #[cfg(stage2)]
-    #[cfg(stage3)]
-    fn read_method_map_entry(&self, xcx: @ExtendedDecodeContext)
-        -> method_map_entry {
-        do self.read_struct("method_map_entry", 3) {
-            method_map_entry {
-                self_arg: self.read_struct_field("self_arg", 0u, || {
-                    self.read_arg(xcx)
-                }),
-                explicit_self: self.read_struct_field("explicit_self", 2u, || {
-                    let self_type: ast::self_ty_ = Decodable::decode(self);
-                    self_type
-                }),
-                origin: self.read_struct_field("origin", 1u, || {
-                    let method_origin: method_origin =
-                        Decodable::decode(self);
-                    method_origin.tr(xcx)
-                }),
-            }
-        }
-    }
 }
 
 impl tr for method_origin {
@@ -826,7 +785,6 @@ impl ebml_writer_helpers for writer::Encoder {
         }
     }
 
-    #[cfg(stage0)]
     fn emit_tpbt(&self, ecx: @e::EncodeContext,
                  tpbt: ty::ty_param_bounds_and_ty) {
         do self.emit_struct("ty_param_bounds_and_ty", 2) {
@@ -849,32 +807,6 @@ impl ebml_writer_helpers for writer::Encoder {
             }
         }
     }
-
-    #[cfg(stage1)]
-    #[cfg(stage2)]
-    #[cfg(stage3)]
-    fn emit_tpbt(&self, ecx: @e::EncodeContext,
-                 tpbt: ty::ty_param_bounds_and_ty) {
-        do self.emit_struct("ty_param_bounds_and_ty", 2) {
-            do self.emit_struct_field("generics", 0) {
-                do self.emit_struct("Generics", 2) {
-                    do self.emit_struct_field("type_param_defs", 0) {
-                        do self.emit_from_vec(*tpbt.generics.type_param_defs)
-                            |type_param_def|
-                        {
-                            self.emit_type_param_def(ecx, type_param_def);
-                        }
-                    }
-                    do self.emit_struct_field("region_param", 1) {
-                        tpbt.generics.region_param.encode(self);
-                    }
-                }
-            }
-            do self.emit_struct_field("ty", 1) {
-                self.emit_ty(ecx, tpbt.ty);
-            }
-        }
-    }
 }
 
 trait write_tag_and_id {
@@ -1124,7 +1056,6 @@ impl ebml_decoder_decoder_helpers for reader::Decoder {
         }
     }
 
-    #[cfg(stage0)]
     fn read_ty_param_bounds_and_ty(&self, xcx: @ExtendedDecodeContext)
         -> ty::ty_param_bounds_and_ty
     {
@@ -1147,31 +1078,6 @@ impl ebml_decoder_decoder_helpers for reader::Decoder {
         }
     }
 
-    #[cfg(stage1)]
-    #[cfg(stage2)]
-    #[cfg(stage3)]
-    fn read_ty_param_bounds_and_ty(&self, xcx: @ExtendedDecodeContext)
-        -> ty::ty_param_bounds_and_ty
-    {
-        do self.read_struct("ty_param_bounds_and_ty", 2) {
-            ty::ty_param_bounds_and_ty {
-                generics: do self.read_struct("Generics", 2) {
-                    ty::Generics {
-                        type_param_defs: self.read_struct_field("type_param_defs", 0, || {
-                            @self.read_to_vec(|| self.read_type_param_def(xcx))
-                        }),
-                        region_param: self.read_struct_field(~"region_param", 1, || {
-                            Decodable::decode(self)
-                        })
-                    }
-                },
-                ty: self.read_struct_field("ty", 1, || {
-                    self.read_ty(xcx)
-                })
-            }
-        }
-    }
-
     fn convert_def_id(&self, xcx: @ExtendedDecodeContext,
                       source: tydecode::DefIdSource,
                       did: ast::def_id) -> ast::def_id {

branches/dist-snap/src/librustc/middle/borrowck/check_loans.rs

@@ -128,9 +128,9 @@ pub impl CheckLoanCtxt {
               Some(e) => return Some(pc_cmt(*e))
             }
 
-            match self.tcx().region_map.find(&scope_id) {
+            match self.tcx().region_maps.opt_encl_scope(scope_id) {
               None => return default_purity,
-              Some(&next_scope_id) => scope_id = next_scope_id
+              Some(next_scope_id) => scope_id = next_scope_id
             }
         }
     }
@@ -146,9 +146,9 @@ pub impl CheckLoanCtxt {
                 }
             }
 
-            match self.tcx().region_map.find(&scope_id) {
+            match self.tcx().region_maps.opt_encl_scope(scope_id) {
               None => return,
-              Some(&next_scope_id) => scope_id = next_scope_id,
+              Some(next_scope_id) => scope_id = next_scope_id,
             }
         }
     }
@@ -270,7 +270,7 @@ pub impl CheckLoanCtxt {
 
         debug!("new_loans has length %?", new_loans.len());
 
-        let par_scope_id = *self.tcx().region_map.get(&scope_id);
+        let par_scope_id = self.tcx().region_maps.encl_scope(scope_id);
         for self.walk_loans(par_scope_id) |old_loan| {
             debug!("old_loan=%?", self.bccx.loan_to_repr(old_loan));
 

branches/dist-snap/src/librustc/middle/borrowck/gather_loans.rs

@@ -242,7 +242,7 @@ fn req_loans_in_expr(ex: @ast::expr,
         // (if used like `a.b(...)`), the call where it's an argument
         // (if used like `x(a.b)`), or the block (if used like `let x
         // = a.b`).
-        let scope_r = ty::re_scope(*self.tcx().region_map.get(&ex.id));
+        let scope_r = self.tcx().region_maps.encl_region(ex.id);
         let rcvr_cmt = self.bccx.cat_expr(rcvr);
         self.guarantee_valid(rcvr_cmt, m_imm, scope_r);
         visit::visit_expr(ex, self, vt);
@@ -524,7 +524,10 @@ pub impl GatherLoanCtxt {
         // immutable structures, this is just the converse I suppose)
 
         let scope_id = match scope_r {
-            ty::re_scope(scope_id) | ty::re_free(scope_id, _) => scope_id,
+            ty::re_scope(scope_id) |
+            ty::re_free(ty::FreeRegion {scope_id, _}) => {
+                scope_id
+            }
             _ => {
                 self.bccx.tcx.sess.span_bug(
                     cmt.span,