---

yaml
---
r: 136063
b: refs/heads/master
c: 0d94fda
h: refs/heads/master
i:
  136061: 0f3147a
  136059: b53a4d1
  136055: bd543cb
  136047: af409e0
  136031: fb7c7bd
  135999: 0143691
  135935: 73b2e1b
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 893a114db54ec95c20596e485bc70dfeeeb2b66d
+refs/heads/master: 0d94fdaeb8b16b0f34c4bc03e7f95a18ffffba75
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 749ff5e76a0d08837964e44c66654679a3a88bb8
 refs/heads/try: ca87704735687dad44b26788c773df2d87b3b710

trunk/src/compiletest/runtest.rs

@@ -1196,7 +1196,7 @@ fn compose_and_run_compiler(
 
 fn ensure_dir(path: &Path) {
     if path.is_dir() { return; }
-    fs::mkdir(path, io::UserRWX).unwrap();
+    fs::mkdir(path, io::USER_RWX).unwrap();
 }
 
 fn compose_and_run(config: &Config, testfile: &Path,

trunk/src/jemalloc

@@ -1 +1 @@
-Subproject commit 2dba541881fb8e35246d653bbe2e7c7088777a4a
+Subproject commit b001609960ca33047e5cbc5a231c1e24b6041d4b

trunk/src/librustc/back/link.rs

@@ -466,7 +466,7 @@ pub fn invalid_output_for_target(sess: &Session,
 fn is_writeable(p: &Path) -> bool {
     match p.stat() {
         Err(..) => true,
-        Ok(m) => m.perm & io::UserWrite == io::UserWrite
+        Ok(m) => m.perm & io::USER_WRITE == io::USER_WRITE
     }
 }
 
@@ -1322,7 +1322,7 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session,
                 // Fix up permissions of the copy, as fs::copy() preserves
                 // permissions, but the original file may have been installed
                 // by a package manager and may be read-only.
-                match fs::chmod(&dst, io::UserRead | io::UserWrite) {
+                match fs::chmod(&dst, io::USER_READ | io::USER_WRITE) {
                     Ok(..) => {}
                     Err(e) => {
                         sess.err(format!("failed to chmod {} when preparing \

trunk/src/librustc/diagnostics.rs

@@ -38,7 +38,6 @@ register_diagnostics!(
     E0017,
     E0019,
     E0020,
-    E0021,
     E0022,
     E0023,
     E0024,
@@ -62,7 +61,6 @@ register_diagnostics!(
     E0045,
     E0046,
     E0047,
-    E0048,
     E0049,
     E0050,
     E0051,
@@ -117,8 +115,6 @@ register_diagnostics!(
     E0109,
     E0110,
     E0113,
-    E0114,
-    E0115,
     E0116,
     E0117,
     E0118,
@@ -152,5 +148,7 @@ register_diagnostics!(
     E0158,
     E0159,
     E0161,
-    E0162
+    E0162,
+    E0163,
+    E0164
 )

trunk/src/librustc/middle/save/mod.rs

@@ -1467,7 +1467,7 @@ pub fn process_crate(sess: &Session,
         },
     };
 
-    match fs::mkdir_recursive(&root_path, io::UserRWX) {
+    match fs::mkdir_recursive(&root_path, io::USER_RWX) {
         Err(e) => sess.err(format!("Could not create directory {}: {}",
                            root_path.display(), e).as_slice()),
         _ => (),

trunk/src/librustc/middle/trans/debuginfo.rs

@@ -456,60 +456,17 @@ impl TypeMap {
                 let return_type_id = self.get_unique_type_id_as_string(return_type_id);
                 unique_type_id.push_str(return_type_id.as_slice());
             },
-            ty::ty_closure(box ty::ClosureTy { fn_style,
-                                               onceness,
-                                               store,
-                                               ref bounds,
-                                               ref sig,
-                                               abi: _ }) => {
-                if fn_style == ast::UnsafeFn {
-                    unique_type_id.push_str("unsafe ");
-                }
-
-                if onceness == ast::Once {
-                    unique_type_id.push_str("once ");
-                }
-
-                match store {
-                    ty::UniqTraitStore => unique_type_id.push_str("~|"),
-                    ty::RegionTraitStore(_, ast::MutMutable) => {
-                        unique_type_id.push_str("&mut|")
-                    }
-                    ty::RegionTraitStore(_, ast::MutImmutable) => {
-                        unique_type_id.push_str("&|")
-                    }
-                };
-
-                for &parameter_type in sig.inputs.iter() {
-                    let parameter_type_id =
-                        self.get_unique_type_id_of_type(cx, parameter_type);
-                    let parameter_type_id =
-                        self.get_unique_type_id_as_string(parameter_type_id);
-                    unique_type_id.push_str(parameter_type_id.as_slice());
-                    unique_type_id.push_char(',');
-                }
-
-                if sig.variadic {
-                    unique_type_id.push_str("...");
-                }
-
-                unique_type_id.push_str("|->");
-
-                let return_type_id = self.get_unique_type_id_of_type(cx, sig.output);
-                let return_type_id = self.get_unique_type_id_as_string(return_type_id);
-                unique_type_id.push_str(return_type_id.as_slice());
-
-                unique_type_id.push_char(':');
-
-                for bound in bounds.builtin_bounds.iter() {
-                    match bound {
-                        ty::BoundSend => unique_type_id.push_str("Send"),
-                        ty::BoundSized => unique_type_id.push_str("Sized"),
-                        ty::BoundCopy => unique_type_id.push_str("Copy"),
-                        ty::BoundSync => unique_type_id.push_str("Sync"),
-                    };
-                    unique_type_id.push_char('+');
-                }
+            ty::ty_closure(box ref closure_ty) => {
+                self.get_unique_type_id_of_closure_type(cx,
+                                                        closure_ty.clone(),
+                                                        &mut unique_type_id);
+            },
+            ty::ty_unboxed_closure(ref def_id, _) => {
+                let closure_ty = cx.tcx().unboxed_closures.borrow()
+                                   .find(def_id).unwrap().closure_type.clone();
+                self.get_unique_type_id_of_closure_type(cx,
+                                                        closure_ty,
+                                                        &mut unique_type_id);
             },
             _ => {
                 cx.sess().bug(format!("get_unique_type_id_of_type() - unexpected type: {}, {:?}",
@@ -581,6 +538,66 @@ impl TypeMap {
         }
     }
 
+    fn get_unique_type_id_of_closure_type(&mut self,
+                                          cx: &CrateContext,
+                                          closure_ty: ty::ClosureTy,
+                                          unique_type_id: &mut String) {
+        let ty::ClosureTy { fn_style,
+                            onceness,
+                            store,
+                            ref bounds,
+                            ref sig,
+                            abi: _ } = closure_ty;
+        if fn_style == ast::UnsafeFn {
+            unique_type_id.push_str("unsafe ");
+        }
+
+        if onceness == ast::Once {
+            unique_type_id.push_str("once ");
+        }
+
+        match store {
+            ty::UniqTraitStore => unique_type_id.push_str("~|"),
+            ty::RegionTraitStore(_, ast::MutMutable) => {
+                unique_type_id.push_str("&mut|")
+            }
+            ty::RegionTraitStore(_, ast::MutImmutable) => {
+                unique_type_id.push_str("&|")
+            }
+        };
+
+        for &parameter_type in sig.inputs.iter() {
+            let parameter_type_id =
+                self.get_unique_type_id_of_type(cx, parameter_type);
+            let parameter_type_id =
+                self.get_unique_type_id_as_string(parameter_type_id);
+            unique_type_id.push_str(parameter_type_id.as_slice());
+            unique_type_id.push_char(',');
+        }
+
+        if sig.variadic {
+            unique_type_id.push_str("...");
+        }
+
+        unique_type_id.push_str("|->");
+
+        let return_type_id = self.get_unique_type_id_of_type(cx, sig.output);
+        let return_type_id = self.get_unique_type_id_as_string(return_type_id);
+        unique_type_id.push_str(return_type_id.as_slice());
+
+        unique_type_id.push_char(':');
+
+        for bound in bounds.builtin_bounds.iter() {
+            match bound {
+                ty::BoundSend => unique_type_id.push_str("Send"),
+                ty::BoundSized => unique_type_id.push_str("Sized"),
+                ty::BoundCopy => unique_type_id.push_str("Copy"),
+                ty::BoundSync => unique_type_id.push_str("Sync"),
+            };
+            unique_type_id.push_char('+');
+        }
+    }
+
     // Get the UniqueTypeId for an enum variant. Enum variants are not really
     // types of their own, so they need special handling. We still need a
     // UniqueTypeId for them, since to debuginfo they *are* real types.
@@ -2903,6 +2920,11 @@ fn type_metadata(cx: &CrateContext,
         ty::ty_closure(ref closurety) => {
             subroutine_type_metadata(cx, unique_type_id, &closurety.sig, usage_site_span)
         }
+        ty::ty_unboxed_closure(ref def_id, _) => {
+            let sig = cx.tcx().unboxed_closures.borrow()
+                        .find(def_id).unwrap().closure_type.sig.clone();
+            subroutine_type_metadata(cx, unique_type_id, &sig, usage_site_span)
+        }
         ty::ty_struct(def_id, ref substs) => {
             prepare_struct_metadata(cx,
                                     t,

trunk/src/librustc/middle/typeck/check/_match.rs

@@ -382,26 +382,43 @@ pub fn check_struct_like_enum_variant_pat(pcx: &pat_ctxt,
 
     // Find the variant that was specified.
     match tcx.def_map.borrow().find(&pat_id) {
-        Some(&def::DefVariant(found_enum_id, variant_id, _))
+        Some(&def::DefVariant(found_enum_id, variant_id, true))
                 if found_enum_id == enum_id => {
             // Get the struct fields from this struct-like enum variant.
-            let class_fields = ty::lookup_struct_fields(tcx, variant_id);
-
-            check_struct_pat_fields(pcx, span, fields, class_fields,
+            let struct_fields = ty::lookup_struct_fields(tcx, variant_id);
+            check_struct_pat_fields(pcx, span, fields, struct_fields,
                                     variant_id, substitutions, etc);
+            fcx.write_ty(pat_id, expected);
+        }
+        Some(&def::DefVariant(_, _, false)) => {
+            let name = pprust::path_to_string(path);
+            span_err!(tcx.sess, span, E0163,
+                "`{}` does not name a struct variant", name);
+            fcx.write_error(pat_id);
+        }
+        Some(&def::DefVariant(_, _, true)) => {
+            let name = pprust::path_to_string(path);
+            span_err!(tcx.sess, span, E0164,
+                "`{}` does not name a variant of the type being matched against", name);
+            fcx.write_error(pat_id);
         }
         Some(&def::DefStruct(..)) |
-        Some(&def::DefVariant(..)) |
         Some(&def::DefTy(..)) => {
             let name = pprust::path_to_string(path);
             span_err!(tcx.sess, span, E0028,
-                "mismatched types: expected `{}`, found `{}`",
-                fcx.infcx().ty_to_string(expected), name);
+                "`{}` does not name a variant", name);
+            fcx.write_error(pat_id);
         }
         _ => {
             tcx.sess.span_bug(span, "resolve didn't write in variant");
         }
     }
+
+    if ty::type_is_error(fcx.node_ty(pat_id)) {
+        for field in fields.iter() {
+            check_pat(pcx, &*field.pat, ty::mk_err());
+        }
+    }
 }
 
 // Pattern checking is top-down rather than bottom-up so that bindings get

trunk/src/librustc/middle/typeck/check/mod.rs

@@ -4330,7 +4330,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
         // Resolve the path.
         let def = tcx.def_map.borrow().find(&id).map(|i| *i);
         let struct_id = match def {
-            Some(def::DefVariant(enum_id, variant_id, _)) => {
+            Some(def::DefVariant(enum_id, variant_id, true)) => {
                 check_struct_enum_variant(fcx, id, expr.span, enum_id,
                                           variant_id, fields.as_slice());
                 enum_id

trunk/src/librustc_back/fs.rs

@@ -68,7 +68,7 @@ mod test {
         let linkdir = tmpdir.join("test3");
 
         File::create(&file).unwrap();
-        mkdir(&dir, io::UserRWX).unwrap();
+        mkdir(&dir, io::USER_RWX).unwrap();
         symlink(&file, &link).unwrap();
         symlink(&dir, &linkdir).unwrap();
 
@@ -91,8 +91,8 @@ mod test {
         let e = d.join("e");
         let f = a.join("f");
 
-        mkdir_recursive(&b, io::UserRWX).unwrap();
-        mkdir_recursive(&d, io::UserRWX).unwrap();
+        mkdir_recursive(&b, io::USER_RWX).unwrap();
+        mkdir_recursive(&d, io::USER_RWX).unwrap();
         File::create(&f).unwrap();
         symlink(&Path::new("../d/e"), &c).unwrap();
         symlink(&Path::new("../f"), &e).unwrap();

trunk/src/librustdoc/html/render.rs

@@ -618,7 +618,7 @@ fn write(dst: Path, contents: &[u8]) -> io::IoResult<()> {
 /// skipping if the directory already exists.
 fn mkdir(path: &Path) -> io::IoResult<()> {
     if !path.exists() {
-        fs::mkdir(path, io::UserRWX)
+        fs::mkdir(path, io::USER_RWX)
     } else {
         Ok(())
     }