---

yaml
---
r: 161702
b: refs/heads/master
c: 2018510
h: refs/heads/master
v: v3

Author: nodakai

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 21ba1d5e58144c83093a8cbb467a6c9cb12fc4a1
+refs/heads/master: 2018510dd9578b9c3ca25d574130056f9c36aaf9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cafe2966770ff377aad6dd9fd808e68055587c58
 refs/heads/try: 0f0d21c1eb5c7be04d323e0b06faf252ad790af6

trunk/src/liblibc/lib.rs

@@ -192,7 +192,7 @@ pub use funcs::bsd43::{shutdown};
 #[cfg(unix)] pub use types::os::arch::posix01::{stat, utimbuf};
 #[cfg(unix)] pub use types::os::common::bsd44::{ifaddrs};
 #[cfg(unix)] pub use funcs::posix88::unistd::{sysconf, setgid, setsid, setuid, pread, pwrite};
-#[cfg(unix)] pub use funcs::posix88::unistd::{getgid, getuid};
+#[cfg(unix)] pub use funcs::posix88::unistd::{getgid, getuid, getsid};
 #[cfg(unix)] pub use funcs::posix88::unistd::{_PC_NAME_MAX, utime, nanosleep, pathconf, link};
 #[cfg(unix)] pub use funcs::posix88::unistd::{chown};
 #[cfg(unix)] pub use funcs::posix88::mman::{mmap, munmap, mprotect};
@@ -4402,6 +4402,7 @@ pub mod funcs {
                 pub fn getpid() -> pid_t;
                 pub fn getppid() -> pid_t;
                 pub fn getuid() -> uid_t;
+                pub fn getsid(pid: pid_t) -> pid_t;
                 pub fn isatty(fd: c_int) -> c_int;
                 pub fn link(src: *const c_char, dst: *const c_char) -> c_int;
                 pub fn lseek(fd: c_int, offset: off_t, whence: c_int)

trunk/src/librustc/lint/builtin.rs

@@ -514,27 +514,41 @@ fn each_child_of_item_or_crate(intr: Rc<IdentInterner>,
         let inherent_impl_def_id = item_def_id(inherent_impl_def_id_doc,
                                                cdata);
         let items = reader::get_doc(rbml::Doc::new(cdata.data()), tag_items);
-        if let Some(inherent_impl_doc) = maybe_find_item(inherent_impl_def_id.node, items) {
-            let _ = reader::tagged_docs(inherent_impl_doc,
-                                        tag_item_impl_item,
-                                        |impl_item_def_id_doc| {
-                let impl_item_def_id = item_def_id(impl_item_def_id_doc,
-                                                   cdata);
-                if let Some(impl_method_doc) = maybe_find_item(impl_item_def_id.node, items) {
-                    if let StaticMethod = item_family(impl_method_doc) {
-                        // Hand off the static method to the callback.
-                        let static_method_name = item_name(&*intr, impl_method_doc);
-                        let static_method_def_like = item_to_def_like(impl_method_doc,
-                                                                      impl_item_def_id,
-                                                                      cdata.cnum);
-                        callback(static_method_def_like,
-                                 static_method_name,
-                                 item_visibility(impl_method_doc));
+        match maybe_find_item(inherent_impl_def_id.node, items) {
+            None => {}
+            Some(inherent_impl_doc) => {
+                let _ = reader::tagged_docs(inherent_impl_doc,
+                                            tag_item_impl_item,
+                                            |impl_item_def_id_doc| {
+                    let impl_item_def_id = item_def_id(impl_item_def_id_doc,
+                                                       cdata);
+                    match maybe_find_item(impl_item_def_id.node, items) {
+                        None => {}
+                        Some(impl_method_doc) => {
+                            match item_family(impl_method_doc) {
+                                StaticMethod => {
+                                    // Hand off the static method
+                                    // to the callback.
+                                    let static_method_name =
+                                        item_name(&*intr, impl_method_doc);
+                                    let static_method_def_like =
+                                        item_to_def_like(impl_method_doc,
+                                                         impl_item_def_id,
+                                                         cdata.cnum);
+                                    callback(static_method_def_like,
+                                             static_method_name,
+                                             item_visibility(impl_method_doc));
+                                }
+                                _ => {}
+                            }
+                        }
                     }
-                }
-                true
-            });
+
+                    true
+                });
+            }
         }
+
         true
     });
 
@@ -564,14 +578,17 @@ fn each_child_of_item_or_crate(intr: Rc<IdentInterner>,
         let other_crates_items = reader::get_doc(rbml::Doc::new(crate_data.data()), tag_items);
 
         // Get the item.
-        if let Some(child_item_doc) = maybe_find_item(child_def_id.node, other_crates_items) {
-            // Hand off the item to the callback.
-            let def_like = item_to_def_like(child_item_doc,
-                                            child_def_id,
-                                            child_def_id.krate);
-            // These items have a public visibility because they're part of
-            // a public re-export.
-            callback(def_like, token::intern(name), ast::Public);
+        match maybe_find_item(child_def_id.node, other_crates_items) {
+            None => {}
+            Some(child_item_doc) => {
+                // Hand off the item to the callback.
+                let def_like = item_to_def_like(child_item_doc,
+                                                child_def_id,
+                                                child_def_id.krate);
+                // These items have a public visibility because they're part of
+                // a public re-export.
+                callback(def_like, token::intern(name), ast::Public);
+            }
         }
 
         true

trunk/src/librustc/metadata/decoder.rs

@@ -433,13 +433,17 @@ fn encode_reexported_static_trait_methods(ecx: &EncodeContext,
     match ecx.tcx.trait_items_cache.borrow().get(&exp.def_id) {
         Some(trait_items) => {
             for trait_item in trait_items.iter() {
-                if let ty::MethodTraitItem(ref m) = *trait_item {
-                    encode_reexported_static_method(rbml_w,
-                                                    exp,
-                                                    m.def_id,
-                                                    m.name);
+                match *trait_item {
+                    ty::MethodTraitItem(ref m) => {
+                        encode_reexported_static_method(rbml_w,
+                                                        exp,
+                                                        m.def_id,
+                                                        m.name);
+                    }
+                    _ => {}
                 }
             }
+
             true
         }
         None => { false }
@@ -450,42 +454,46 @@ fn encode_reexported_static_methods(ecx: &EncodeContext,
                                     rbml_w: &mut Encoder,
                                     mod_path: PathElems,
                                     exp: &middle::resolve::Export2) {
-    if let Some(ast_map::NodeItem(item)) = ecx.tcx.map.find(exp.def_id.node) {
-        let original_name = token::get_ident(item.ident);
-
-        let path_differs = ecx.tcx.map.with_path(exp.def_id.node, |path| {
-            let (mut a, mut b) = (path, mod_path.clone());
-            loop {
-                match (a.next(), b.next()) {
-                    (None, None) => return true,
-                    (None, _) | (_, None) => return false,
-                    (Some(x), Some(y)) => if x != y { return false },
+    match ecx.tcx.map.find(exp.def_id.node) {
+        Some(ast_map::NodeItem(item)) => {
+            let original_name = token::get_ident(item.ident);
+
+            let path_differs = ecx.tcx.map.with_path(exp.def_id.node, |path| {
+                let (mut a, mut b) = (path, mod_path.clone());
+                loop {
+                    match (a.next(), b.next()) {
+                        (None, None) => return true,
+                        (None, _) | (_, None) => return false,
+                        (Some(x), Some(y)) => if x != y { return false },
+                    }
                 }
-            }
-        });
+            });
 
-        //
-        // We don't need to reexport static methods on items
-        // declared in the same module as our `pub use ...` since
-        // that's done when we encode the item itself.
-        //
-        // The only exception is when the reexport *changes* the
-        // name e.g. `pub use Foo = self::Bar` -- we have
-        // encoded metadata for static methods relative to Bar,
-        // but not yet for Foo.
-        //
-        if path_differs || original_name.get() != exp.name.as_slice() {
-            if !encode_reexported_static_base_methods(ecx, rbml_w, exp) {
-                if encode_reexported_static_trait_methods(ecx, rbml_w, exp) {
-                    debug!("(encode reexported static methods) {} [trait]",
-                           original_name);
+            //
+            // We don't need to reexport static methods on items
+            // declared in the same module as our `pub use ...` since
+            // that's done when we encode the item itself.
+            //
+            // The only exception is when the reexport *changes* the
+            // name e.g. `pub use Foo = self::Bar` -- we have
+            // encoded metadata for static methods relative to Bar,
+            // but not yet for Foo.
+            //
+            if path_differs || original_name.get() != exp.name.as_slice() {
+                if !encode_reexported_static_base_methods(ecx, rbml_w, exp) {
+                    if encode_reexported_static_trait_methods(ecx, rbml_w, exp) {
+                        debug!("(encode reexported static methods) {} \
+                                 [trait]",
+                                original_name);
+                    }
+                }
+                else {
+                    debug!("(encode reexported static methods) {} [base]",
+                            original_name);
                 }
-            }
-            else {
-                debug!("(encode reexported static methods) {} [base]",
-                       original_name);
             }
         }
+        _ => {}
     }
 }
 
@@ -573,15 +581,19 @@ fn encode_info_for_mod(ecx: &EncodeContext,
             true
         });
 
-        if let ast::ItemImpl(..) = item.node {
-            let (ident, did) = (item.ident, item.id);
-            debug!("(encoding info for module) ... encoding impl {} ({}/{})",
-                   token::get_ident(ident),
-                   did, ecx.tcx.map.node_to_string(did));
+        match item.node {
+            ast::ItemImpl(..) => {
+                let (ident, did) = (item.ident, item.id);
+                debug!("(encoding info for module) ... encoding impl {} \
+                        ({}/{})",
+                        token::get_ident(ident),
+                        did, ecx.tcx.map.node_to_string(did));
 
-            rbml_w.start_tag(tag_mod_impl);
-            rbml_w.wr_str(def_to_string(local_def(did)).as_slice());
-            rbml_w.end_tag();
+                rbml_w.start_tag(tag_mod_impl);
+                rbml_w.wr_str(def_to_string(local_def(did)).as_slice());
+                rbml_w.end_tag();
+            }
+            _ => {}
         }
     }
 
@@ -911,9 +923,12 @@ fn encode_method_argument_names(rbml_w: &mut Encoder,
     rbml_w.start_tag(tag_method_argument_names);
     for arg in decl.inputs.iter() {
         rbml_w.start_tag(tag_method_argument_name);
-        if let ast::PatIdent(_, ref path1, _) = arg.pat.node {
-            let name = token::get_ident(path1.node);
-            rbml_w.writer.write(name.get().as_bytes());
+        match arg.pat.node {
+            ast::PatIdent(_, ref path1, _) => {
+                let name = token::get_ident(path1.node);
+                rbml_w.writer.write(name.get().as_bytes());
+            }
+            _ => {}
         }
         rbml_w.end_tag();
     }
@@ -1839,19 +1854,22 @@ struct ImplVisitor<'a, 'b:'a, 'c:'a, 'tcx:'b> {
 
 impl<'a, 'b, 'c, 'tcx, 'v> Visitor<'v> for ImplVisitor<'a, 'b, 'c, 'tcx> {
     fn visit_item(&mut self, item: &ast::Item) {
-        if let ast::ItemImpl(_, Some(ref trait_ref), _, _) = item.node {
-            let def_map = &self.ecx.tcx.def_map;
-            let trait_def = def_map.borrow()[trait_ref.ref_id].clone();
-            let def_id = trait_def.def_id();
-
-            // Load eagerly if this is an implementation of the Drop trait
-            // or if the trait is not defined in this crate.
-            if Some(def_id) == self.ecx.tcx.lang_items.drop_trait() ||
-                    def_id.krate != ast::LOCAL_CRATE {
-                self.rbml_w.start_tag(tag_impls_impl);
-                encode_def_id(self.rbml_w, local_def(item.id));
-                self.rbml_w.end_tag();
+        match item.node {
+            ast::ItemImpl(_, Some(ref trait_ref), _, _) => {
+                let def_map = &self.ecx.tcx.def_map;
+                let trait_def = def_map.borrow()[trait_ref.ref_id].clone();
+                let def_id = trait_def.def_id();
+
+                // Load eagerly if this is an implementation of the Drop trait
+                // or if the trait is not defined in this crate.
+                if Some(def_id) == self.ecx.tcx.lang_items.drop_trait() ||
+                        def_id.krate != ast::LOCAL_CRATE {
+                    self.rbml_w.start_tag(tag_impls_impl);
+                    encode_def_id(self.rbml_w, local_def(item.id));
+                    self.rbml_w.end_tag();
+                }
             }
+            _ => {}
         }
         visit::walk_item(self, item);
     }
@@ -1913,12 +1931,17 @@ fn encode_reachable_extern_fns(ecx: &EncodeContext, rbml_w: &mut Encoder) {
     rbml_w.start_tag(tag_reachable_extern_fns);
 
     for id in ecx.reachable.iter() {
-        if let Some(ast_map::NodeItem(i)) = ecx.tcx.map.find(*id) {
-            if let ast::ItemFn(_, _, abi, ref generics, _) = i.node {
-                if abi != abi::Rust && !generics.is_type_parameterized() {
-                    rbml_w.wr_tagged_u32(tag_reachable_extern_fn_id, *id);
+        match ecx.tcx.map.find(*id) {
+            Some(ast_map::NodeItem(i)) => {
+                match i.node {
+                    ast::ItemFn(_, _, abi, ref generics, _)
+                                if abi != abi::Rust && !generics.is_type_parameterized() => {
+                        rbml_w.wr_tagged_u32(tag_reachable_extern_fn_id, *id);
+                    }
+                    _ => {}
                 }
             }
+            _ => {}
         }
     }
 

trunk/src/librustc/metadata/encoder.rs

@@ -892,9 +892,14 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
             let guarantor = cmt.guarantor();
             debug!("check_for_aliasable_mutable_writes(cmt={}, guarantor={})",
                    cmt.repr(this.tcx()), guarantor.repr(this.tcx()));
-            if let mc::cat_deref(ref b, _, mc::BorrowedPtr(ty::MutBorrow, _)) = guarantor.cat {
-                // Statically prohibit writes to `&mut` when aliasable
-                check_for_aliasability_violation(this, span, b.clone());
+            match guarantor.cat {
+                mc::cat_deref(ref b, _, mc::BorrowedPtr(ty::MutBorrow, _)) => {
+                    // Statically prohibit writes to `&mut` when aliasable
+
+                    check_for_aliasability_violation(this, span, b.clone());
+                }
+
+                _ => {}
             }
 
             return true; // no errors reported
@@ -957,3 +962,4 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
                     self.bccx.loan_path_to_string(loan_path)).as_slice());
     }
 }
+

trunk/src/librustc/middle/borrowck/check_loans.rs

@@ -97,10 +97,12 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for GatherLoanCtxt<'a, 'tcx> {
                cmt.repr(self.tcx()),
                mode);
 
-        if let mc::cat_downcast(..) = cmt.cat {
-            gather_moves::gather_match_variant(
-                self.bccx, &self.move_data, &self.move_error_collector,
-                matched_pat, cmt, mode);
+        match cmt.cat {
+            mc::cat_downcast(..) =>
+                gather_moves::gather_match_variant(
+                    self.bccx, &self.move_data, &self.move_error_collector,
+                    matched_pat, cmt, mode),
+            _ => {}
         }
     }
 
@@ -487,14 +489,17 @@ struct StaticInitializerCtxt<'a, 'tcx: 'a> {
 
 impl<'a, 'tcx, 'v> Visitor<'v> for StaticInitializerCtxt<'a, 'tcx> {
     fn visit_expr(&mut self, ex: &Expr) {
-        if let ast::ExprAddrOf(mutbl, ref base) = ex.node {
-            let base_cmt = self.bccx.cat_expr(&**base);
-            let borrow_kind = ty::BorrowKind::from_mutbl(mutbl);
-            // Check that we don't allow borrows of unsafe static items.
-            if check_aliasability(self.bccx, ex.span, euv::AddrOf,
-                                  base_cmt, borrow_kind).is_err() {
-                return; // reported an error, no sense in reporting more.
+        match ex.node {
+            ast::ExprAddrOf(mutbl, ref base) => {
+                let base_cmt = self.bccx.cat_expr(&**base);
+                let borrow_kind = ty::BorrowKind::from_mutbl(mutbl);
+                // Check that we don't allow borrows of unsafe static items.
+                if check_aliasability(self.bccx, ex.span, euv::AddrOf,
+                                      base_cmt, borrow_kind).is_err() {
+                    return; // reported an error, no sense in reporting more.
+                }
             }
+            _ => {}
         }
 
         visit::walk_expr(self, ex);