---

yaml
---
r: 55195
b: refs/heads/snap-stage3
c: 782e06e
h: refs/heads/master
i:
  55193: e0776bf
  55191: abc4298
v: v3

Author: catamorphism

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 7a857673ff76c966ceb061e3794b119e2e498c40
+refs/heads/snap-stage3: 782e06e0e379768d03e35acae16e7ee1e1841633
 refs/heads/try: 8eb2bab100b42f0ba751552d8eff00eb2134c55a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/rust.md

@@ -2393,7 +2393,7 @@ variables in the arm's block, and control enters the block.
 An example of an `match` expression:
 
 
-~~~~
+~~~~ {.xfail-test}
 # fn process_pair(a: int, b: int) { }
 # fn process_ten() { }
 

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

@@ -818,6 +818,36 @@ pub fn change_dir(p: &Path) -> bool {
     }
 }
 
+/// Changes the current working directory to the specified
+/// path while acquiring a global lock, then calls `action`.
+/// If the change is successful, releases the lock and restores the
+/// CWD to what it was before, returning true.
+/// Returns false if the directory doesn't exist or if the directory change
+/// is otherwise unsuccessful.
+pub fn change_dir_locked(p: &Path, action: &fn()) -> bool {
+    use unstable::global::global_data_clone_create;
+    use unstable::{Exclusive, exclusive};
+
+    fn key(_: Exclusive<()>) { }
+
+    let result = unsafe {
+        global_data_clone_create(key, || {
+            ~exclusive(())
+        })
+    };
+
+    do result.with_imm() |_| {
+        let old_dir = os::getcwd();
+        if change_dir(p) {
+            action();
+            change_dir(&old_dir)
+        }
+        else {
+            false
+        }
+    }
+}
+
 /// Copies a file from one location to another
 pub fn copy_file(from: &Path, to: &Path) -> bool {
     return do_copy_file(from, to);

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

@@ -175,18 +175,11 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: @ast::Path,
             kind_name = "structure";
         }
         _ => {
-            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)},
-                    ~"an enum or structure pattern",
-                    None);
-            fcx.write_error(pat.id);
-            kind_name = "[error]";
-            arg_types = (copy subpats).get_or_default(~[]).map(|_|
-                                                               ty::mk_err());
+            tcx.sess.span_fatal(
+                pat.span,
+                fmt!("mismatched types: expected `%s` but found enum or \
+                      structure",
+                     fcx.infcx().ty_to_str(expected)));
         }
     }
 
@@ -493,44 +486,74 @@ pub fn check_pat(pcx: &pat_ctxt, pat: @ast::pat, expected: ty::t) {
       }
       ast::pat_tup(ref elts) => {
         let s = structure_of(fcx, pat.span, expected);
+        let ex_elts = match s {
+          ty::ty_tup(ref elts) => elts,
+          _ => {
+            tcx.sess.span_fatal
+                (pat.span,
+                 fmt!("mismatched types: expected `%s`, found tuple",
+                      fcx.infcx().ty_to_str(expected)));
+          }
+        };
         let e_count = elts.len();
-        match s {
-            ty::ty_tup(ref ex_elts) if e_count == ex_elts.len() => {
-                for elts.eachi |i, elt| {
-                    check_pat(pcx, *elt, ex_elts[i]);
-                }
-                fcx.write_ty(pat.id, expected);
-            }
-            _ => {
-                for elts.each |elt| {
-                    check_pat(pcx, *elt, ty::mk_err());
-                }
-                let actual = ty::mk_tup(tcx, elts.map(|pat_var| {
-                    fcx.node_ty(pat_var.id)
-                }));
-                // use terr_tuple_size if both types are tuples
-                let type_error = match s {
-                    ty::ty_tup(ref ex_elts) =>
-                        ty::terr_tuple_size(ty::expected_found{expected: ex_elts.len(),
-                                                           found: e_count}),
-                    _ => ty::terr_mismatch
-                };
-                fcx.infcx().report_mismatched_types(pat.span,
-                                                    expected,
-                                                    actual,
-                                                    &type_error);
-                fcx.write_error(pat.id);
-            }
+        if e_count != ex_elts.len() {
+            tcx.sess.span_fatal
+                (pat.span, fmt!("mismatched types: expected a tuple \
+                      with %u fields, found one with %u \
+                      fields", ex_elts.len(), e_count));
         }
+        let mut i = 0u;
+        for elts.each |elt| {
+            check_pat(pcx, *elt, ex_elts[i]);
+            i += 1u;
+        }
+
+        fcx.write_ty(pat.id, expected);
       }
       ast::pat_box(inner) => {
-          check_pointer_pat(pcx, Managed, inner, pat.id, pat.span, expected);
+        match structure_of(fcx, pat.span, expected) {
+          ty::ty_box(e_inner) => {
+            check_pat(pcx, inner, e_inner.ty);
+            fcx.write_ty(pat.id, expected);
+          }
+          _ => {
+            tcx.sess.span_fatal(
+                pat.span,
+                ~"mismatched types: expected `" +
+                fcx.infcx().ty_to_str(expected) +
+                ~"` found box");
+          }
+        }
       }
       ast::pat_uniq(inner) => {
-          check_pointer_pat(pcx, Owned, inner, pat.id, pat.span, expected);
+        match structure_of(fcx, pat.span, expected) {
+          ty::ty_uniq(e_inner) => {
+            check_pat(pcx, inner, e_inner.ty);
+            fcx.write_ty(pat.id, expected);
+          }
+          _ => {
+            tcx.sess.span_fatal(
+                pat.span,
+                ~"mismatched types: expected `" +
+                fcx.infcx().ty_to_str(expected) +
+                ~"` found uniq");
+          }
+        }
       }
       ast::pat_region(inner) => {
-          check_pointer_pat(pcx, Borrowed, inner, pat.id, pat.span, expected);
+        match structure_of(fcx, pat.span, expected) {
+          ty::ty_rptr(_, e_inner) => {
+            check_pat(pcx, inner, e_inner.ty);
+            fcx.write_ty(pat.id, expected);
+          }
+          _ => {
+            tcx.sess.span_fatal(
+                pat.span,
+                ~"mismatched types: expected `" +
+                fcx.infcx().ty_to_str(expected) +
+                ~"` found borrowed pointer");
+          }
+        }
       }
       ast::pat_vec(ref before, slice, ref after) => {
         let default_region_var =
@@ -554,25 +577,11 @@ pub fn check_pat(pcx: &pat_ctxt, pat: @ast::pat, expected: ty::t) {
             (mt, default_region_var)
           },
           _ => {
-              for before.each |&elt| {
-                  check_pat(pcx, elt, ty::mk_err());
-              }
-              for slice.each |&elt| {
-                  check_pat(pcx, elt, ty::mk_err());
-              }
-              for after.each |&elt| {
-                  check_pat(pcx, elt, ty::mk_err());
-              }
-              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 vector pattern",
-                                                 None);
-              fcx.write_error(pat.id);
-              return;
+            tcx.sess.span_fatal(
+                pat.span,
+                fmt!("mismatched type: expected `%s` but found vector",
+                     fcx.infcx().ty_to_str(expected))
+            );
           }
         };
         for before.each |elt| {
@@ -596,46 +605,3 @@ pub fn check_pat(pcx: &pat_ctxt, pat: @ast::pat, expected: ty::t) {
     }
 }
 
-// Helper function to check @, ~ and & patterns
-pub fn check_pointer_pat(pcx: &pat_ctxt,
-                         pointer_kind: PointerKind,
-                         inner: @ast::pat,
-                         pat_id: ast::node_id,
-                         span: span,
-                         expected: ty::t) {
-    let fcx = pcx.fcx;
-    let check_inner: &fn(ty::mt) = |e_inner| {
-        check_pat(pcx, inner, e_inner.ty);
-        fcx.write_ty(pat_id, expected);
-    };
-    match structure_of(fcx, span, expected) {
-        ty::ty_box(e_inner) if pointer_kind == Managed => {
-            check_inner(e_inner);
-        }
-        ty::ty_uniq(e_inner) if pointer_kind == Owned => {
-            check_inner(e_inner);
-        }
-        ty::ty_rptr(_, e_inner) if pointer_kind == Borrowed => {
-            check_inner(e_inner);
-        }
-        _ => {
-            check_pat(pcx, inner, ty::mk_err());
-            let resolved_expected =
-                fcx.infcx().ty_to_str(fcx.infcx().resolve_type_vars_if_possible(expected));
-            fcx.infcx().type_error_message_str(span, |actual| {
-                    fmt!("mismatched types: expected `%s` but found %s",
-                         resolved_expected, actual)},
-                                               fmt!("%s pattern", match pointer_kind {
-                                                   Managed => "an @-box",
-                                                   Owned => "a ~-box",
-                                                   Borrowed => "an &-pointer"
-                                               }),
-                    None);
-            fcx.write_error(pat_id);
-          }
-    }
-}
-
-#[deriving(Eq)]
-enum PointerKind { Managed, Owned, Borrowed }
-

branches/snap-stage3/src/librustc/middle/typeck/infer/mod.rs

@@ -749,19 +749,6 @@ pub impl InferCtxt {
         }
     }
 
-
-    fn type_error_message_str(@mut self, sp: span, mk_msg: &fn(~str) -> ~str,
-                          actual_ty: ~str, err: Option<&ty::type_err>) {
-        let error_str = err.map_default(~"", |t_err|
-                         fmt!(" (%s)",
-                              ty::type_err_to_str(self.tcx, *t_err)));
-        self.tcx.sess.span_err(sp,
-           fmt!("%s%s", mk_msg(actual_ty), error_str));
-        for err.each |err| {
-            ty::note_and_explain_type_err(self.tcx, *err)
-        }
-    }
-
     fn type_error_message(@mut self, sp: span, mk_msg: &fn(~str) -> ~str,
                           actual_ty: ty::t, err: Option<&ty::type_err>) {
         let actual_ty = self.resolve_type_vars_if_possible(actual_ty);
@@ -770,9 +757,15 @@ pub impl InferCtxt {
         if ty::type_is_error(actual_ty) {
             return;
         }
-
-        self.type_error_message_str(sp, mk_msg, self.ty_to_str(actual_ty),
-                                    err);
+        let error_str = err.map_default(~"", |t_err|
+                         fmt!(" (%s)",
+                              ty::type_err_to_str(self.tcx, *t_err)));
+        self.tcx.sess.span_err(sp,
+           fmt!("%s%s", mk_msg(self.ty_to_str(actual_ty)),
+                error_str));
+        for err.each |err| {
+            ty::note_and_explain_type_err(self.tcx, *err)
+        }
     }
 
     fn report_mismatched_types(@mut self, sp: span, e: ty::t, a: ty::t,

branches/snap-stage3/src/libstd/tempfile.rs

@@ -42,13 +42,18 @@ mod tests {
         use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
         use core::os;
 
-        let root = mkdtemp(&os::tmpdir(), "temp").expect("recursive_mkdir_rel");
-        os::change_dir(&root);
-        let path = Path("frob");
-        assert!(os::mkdir_recursive(&path,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
-        assert!(os::path_is_dir(&path));
-        assert!(os::mkdir_recursive(&path,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
-        assert!(os::path_is_dir(&path));
+        let root = mkdtemp(&os::tmpdir(), "recursive_mkdir_rel").
+            expect("recursive_mkdir_rel");
+        assert!(do os::change_dir_locked(&root) {
+            let path = Path("frob");
+            debug!("recursive_mkdir_rel: Making: %s in cwd %s [%?]", path.to_str(),
+                   os::getcwd().to_str(),
+                   os::path_exists(&path));
+            assert!(os::mkdir_recursive(&path,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+            assert!(os::path_is_dir(&path));
+            assert!(os::mkdir_recursive(&path,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+            assert!(os::path_is_dir(&path));
+        });
     }
 
     #[test]
@@ -67,18 +72,21 @@ mod tests {
         use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
         use core::os;
 
-        let root = mkdtemp(&os::tmpdir(), "temp").expect("recursive_mkdir_rel_2");
-        os::change_dir(&root);
-        let path = Path("./frob/baz");
-        debug!("...Making: %s in cwd %s", path.to_str(), os::getcwd().to_str());
-        assert!(os::mkdir_recursive(&path, (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
-        assert!(os::path_is_dir(&path));
-        assert!(os::path_is_dir(&path.pop()));
-        let path2 = Path("quux/blat");
-        debug!("Making: %s in cwd %s", path2.to_str(), os::getcwd().to_str());
-        assert!(os::mkdir_recursive(&path2, (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
-        assert!(os::path_is_dir(&path2));
-        assert!(os::path_is_dir(&path2.pop()));
+        let root = mkdtemp(&os::tmpdir(), "recursive_mkdir_rel_2").
+            expect("recursive_mkdir_rel_2");
+        assert!(do os::change_dir_locked(&root) {
+            let path = Path("./frob/baz");
+            debug!("recursive_mkdir_rel_2: Making: %s in cwd %s [%?]", path.to_str(),
+                   os::getcwd().to_str(), os::path_exists(&path));
+            assert!(os::mkdir_recursive(&path, (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+                assert!(os::path_is_dir(&path));
+            assert!(os::path_is_dir(&path.pop()));
+            let path2 = Path("quux/blat");
+            debug!("recursive_mkdir_rel_2: Making: %s in cwd %s", path2.to_str(),
+                   os::getcwd().to_str());
+            assert!(os::mkdir_recursive(&path2, (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+                assert!(os::path_is_dir(&path2));
+            assert!(os::path_is_dir(&path2.pop()));
+        });
     }
-
-}
+}

branches/snap-stage3/src/llvm

@@ -1 +1 @@
-Subproject commit 2e9f0d21fe321849a4759a01fc28eae82ef196d6
+Subproject commit 56dd407f4f97a01b8df6554c569170d2fc276fcb

branches/snap-stage3/src/test/compile-fail/alt-vec-mismatch-2.rs

@@ -1,5 +1,5 @@
 fn main() {
     match () {
-        [()] => { } //~ ERROR mismatched types: expected `()` but found a vector pattern
+        [()] => { } //~ ERROR mismatched type: expected `()` but found vector
     }
 }

branches/snap-stage3/src/test/compile-fail/alt-vec-mismatch.rs

@@ -1,6 +1,6 @@
 fn main() {
     match ~"foo" {
-        ['f', 'o', .._] => { } //~ ERROR mismatched types: expected `~str` but found a vector pattern
+        ['f', 'o', .._] => { } //~ ERROR mismatched type: expected `~str` but found vector
         _ => { }
     }
 }