---

yaml
---
r: 136062
b: refs/heads/master
c: 893a114
h: refs/heads/master
v: v3

Author: vhbit

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 7ce1a17caddb5dc21b2aa2d457f8a5ddf019ba39
+refs/heads/master: 893a114db54ec95c20596e485bc70dfeeeb2b66d
 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::USER_RWX).unwrap();
+    fs::mkdir(path, io::UserRWX).unwrap();
 }
 
 fn compose_and_run(config: &Config, testfile: &Path,

trunk/src/jemalloc

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

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::USER_WRITE == io::USER_WRITE
+        Ok(m) => m.perm & io::UserWrite == io::UserWrite
     }
 }
 
@@ -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::USER_READ | io::USER_WRITE) {
+                match fs::chmod(&dst, io::UserRead | io::UserWrite) {
                     Ok(..) => {}
                     Err(e) => {
                         sess.err(format!("failed to chmod {} when preparing \

trunk/src/librustc/diagnostics.rs

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

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

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

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

@@ -456,17 +456,60 @@ 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 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);
+            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('+');
+                }
             },
             _ => {
                 cx.sess().bug(format!("get_unique_type_id_of_type() - unexpected type: {}, {:?}",
@@ -538,66 +581,6 @@ 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.
@@ -2920,11 +2903,6 @@ 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,43 +382,26 @@ 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, true))
+        Some(&def::DefVariant(found_enum_id, variant_id, _))
                 if found_enum_id == enum_id => {
             // Get the struct fields from this struct-like enum variant.
-            let struct_fields = ty::lookup_struct_fields(tcx, variant_id);
-            check_struct_pat_fields(pcx, span, fields, struct_fields,
+            let class_fields = ty::lookup_struct_fields(tcx, variant_id);
+
+            check_struct_pat_fields(pcx, span, fields, class_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,
-                "`{}` does not name a variant", name);
-            fcx.write_error(pat_id);
+                "mismatched types: expected `{}`, found `{}`",
+                fcx.infcx().ty_to_string(expected), name);
         }
         _ => {
             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, true)) => {
+            Some(def::DefVariant(enum_id, variant_id, _)) => {
                 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::USER_RWX).unwrap();
+        mkdir(&dir, io::UserRWX).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::USER_RWX).unwrap();
-        mkdir_recursive(&d, io::USER_RWX).unwrap();
+        mkdir_recursive(&b, io::UserRWX).unwrap();
+        mkdir_recursive(&d, io::UserRWX).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::USER_RWX)
+        fs::mkdir(path, io::UserRWX)
     } else {
         Ok(())
     }