---

yaml
---
r: 59293
b: refs/heads/snap-stage3
c: c15fa3a
h: refs/heads/master
i:
  59291: c615ddf
v: v3

Author: nikomatsakis

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: c081ffbd1e845687202a975ea2e698b623e5722f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 32b3d3e9ebd8dbc1073445b3be9676da85b6410c
+refs/heads/snap-stage3: c15fa3a02aa3e7e5111f0410abf7321387a7a97f
 refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libcore/cleanup.rs

@@ -126,22 +126,29 @@ struct AnnihilateStats {
     n_bytes_freed: uint
 }
 
-unsafe fn each_live_alloc(f: &fn(box: *mut BoxRepr, uniq: bool) -> bool) {
+unsafe fn each_live_alloc(read_next_before: bool,
+                          f: &fn(box: *mut BoxRepr, uniq: bool) -> bool) {
+    //! Walks the internal list of allocations
+
     use managed;
 
     let task: *Task = transmute(rustrt::rust_get_task());
     let box = (*task).boxed_region.live_allocs;
     let mut box: *mut BoxRepr = transmute(copy box);
     while box != mut_null() {
-        let next = transmute(copy (*box).header.next);
+        let next_before = transmute(copy (*box).header.next);
         let uniq =
             (*box).header.ref_count == managed::raw::RC_MANAGED_UNIQUE;
 
         if ! f(box, uniq) {
             break
         }
 
-        box = next
+        if read_next_before {
+            box = next_before;
+        } else {
+            box = transmute(copy (*box).header.next);
+        }
     }
 }
 
@@ -173,7 +180,10 @@ pub unsafe fn annihilate() {
     };
 
     // Pass 1: Make all boxes immortal.
-    for each_live_alloc |box, uniq| {
+    //
+    // In this pass, nothing gets freed, so it does not matter whether
+    // we read the next field before or after the callback.
+    for each_live_alloc(true) |box, uniq| {
         stats.n_total_boxes += 1;
         if uniq {
             stats.n_unique_boxes += 1;
@@ -183,7 +193,11 @@ pub unsafe fn annihilate() {
     }
 
     // Pass 2: Drop all boxes.
-    for each_live_alloc |box, uniq| {
+    //
+    // In this pass, unique-managed boxes may get freed, but not
+    // managed boxes, so we must read the `next` field *after* the
+    // callback, as the original value may have been freed.
+    for each_live_alloc(false) |box, uniq| {
         if !uniq {
             let tydesc: *TypeDesc = transmute(copy (*box).header.type_desc);
             let drop_glue: DropGlue = transmute(((*tydesc).drop_glue, 0));
@@ -192,7 +206,12 @@ pub unsafe fn annihilate() {
     }
 
     // Pass 3: Free all boxes.
-    for each_live_alloc |box, uniq| {
+    //
+    // In this pass, managed boxes may get freed (but not
+    // unique-managed boxes, though I think that none of those are
+    // left), so we must read the `next` field before, since it will
+    // not be valid after.
+    for each_live_alloc(true) |box, uniq| {
         if !uniq {
             stats.n_bytes_freed +=
                 (*((*box).header.type_desc)).size

branches/snap-stage3/src/libcore/prelude.rs

@@ -31,7 +31,7 @@ pub use io::{print, println};
 /* Reexported types and traits */
 
 pub use clone::Clone;
-pub use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater, Equiv};
+pub use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
 pub use container::{Container, Mutable, Map, Set};
 pub use hash::Hash;
 pub use old_iter::{BaseIter, ReverseIter, MutableIter, ExtendedIter, EqIter};

branches/snap-stage3/src/libcore/str/ascii.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Operations on ASCII strings and characters.
-
 use to_str::{ToStr,ToStrConsume};
 use str;
 use cast;

branches/snap-stage3/src/librustc/middle/typeck/check/_match.rs

@@ -114,53 +114,37 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: @ast::Path,
         ty::ty_enum(_, ref expected_substs) => {
             // Lookup the enum and variant def ids:
             let v_def = lookup_def(pcx.fcx, pat.span, pat.id);
-            match ast_util::variant_def_ids(v_def) {
-                Some((enm, var)) => {
-                    // Assign the pattern the type of the *enum*, not the variant.
-                    let enum_tpt = ty::lookup_item_type(tcx, enm);
-                    instantiate_path(pcx.fcx, path, enum_tpt, pat.span, pat.id,
-                                     pcx.block_region);
-
-                    // check that the type of the value being matched is a subtype
-                    // of the type of the pattern:
-                    let pat_ty = fcx.node_ty(pat.id);
-                    demand::subtype(fcx, pat.span, expected, pat_ty);
-
-                    // Get the expected types of the arguments.
-                    arg_types = {
-                        let vinfo =
-                            ty::enum_variant_with_id(tcx, enm, var);
-                        let var_tpt = ty::lookup_item_type(tcx, var);
-                        vinfo.args.map(|t| {
-                            if var_tpt.generics.type_param_defs.len() ==
-                                expected_substs.tps.len()
-                            {
-                                ty::subst(tcx, expected_substs, *t)
-                            }
-                            else {
-                                *t // In this case, an error was already signaled
-                                    // anyway
-                            }
-                        })
-                    };
-
-                    kind_name = "variant";
-                }
-                None => {
-                    let resolved_expected =
-                        fcx.infcx().ty_to_str(fcx.infcx().resolve_type_vars_if_possible(expected));
-                    fcx.infcx().type_error_message_str(pat.span,
-                                                       |actual| {
-                        fmt!("mismatched types: expected `%s` but found %s",
-                             resolved_expected, actual)},
-                             ~"a structure pattern",
-                             None);
-                    fcx.write_error(pat.id);
-                    kind_name = "[error]";
-                    arg_types = (copy subpats).get_or_default(~[]).map(|_|
-                                                                       ty::mk_err());
-                }
-            }
+            let (enm, var) = ast_util::variant_def_ids(v_def);
+
+            // Assign the pattern the type of the *enum*, not the variant.
+            let enum_tpt = ty::lookup_item_type(tcx, enm);
+            instantiate_path(pcx.fcx, path, enum_tpt, pat.span, pat.id,
+                             pcx.block_region);
+
+            // check that the type of the value being matched is a subtype
+            // of the type of the pattern:
+            let pat_ty = fcx.node_ty(pat.id);
+            demand::subtype(fcx, pat.span, expected, pat_ty);
+
+            // Get the expected types of the arguments.
+            arg_types = {
+                let vinfo =
+                    ty::enum_variant_with_id(tcx, enm, var);
+                let var_tpt = ty::lookup_item_type(tcx, var);
+                vinfo.args.map(|t| {
+                    if var_tpt.generics.type_param_defs.len() ==
+                        expected_substs.tps.len()
+                    {
+                        ty::subst(tcx, expected_substs, *t)
+                    }
+                    else {
+                        *t // In this case, an error was already signaled
+                           // anyway
+                    }
+                })
+            };
+
+            kind_name = "variant";
         }
         ty::ty_struct(struct_def_id, ref expected_substs) => {
             // Lookup the struct ctor def id

branches/snap-stage3/src/libsyntax/ast_util.rs

@@ -41,12 +41,12 @@ pub fn stmt_id(s: &stmt) -> node_id {
     }
 }
 
-pub fn variant_def_ids(d: def) -> Option<(def_id, def_id)> {
+pub fn variant_def_ids(d: def) -> (def_id, def_id) {
     match d {
       def_variant(enum_id, var_id) => {
-          Some((enum_id, var_id))
+        return (enum_id, var_id);
       }
-      _ => None
+      _ => fail!(~"non-variant in variant_def_ids")
     }
 }