---

yaml
---
r: 128715
b: refs/heads/try
c: 81241dc
h: refs/heads/master
i:
  128713: c747b8d
  128711: 9473c59
v: v3

Author: nrc

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: 5e720f0e5453e7b113f313df7827f3ad0a6dbe46
+refs/heads/try: 81241dce8036c6e84e5640c179f53bf8cfc038a6
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/macros.rs

@@ -31,17 +31,12 @@ macro_rules! fail(
         // because it's just a tiny wrapper. Small wins (156K to 149K in size)
         // were seen when forcing this to be inlined, and that number just goes
         // up with the number of calls to fail!()
-        //
-        // The leading _'s are to avoid dead code warnings if this is
-        // used inside a dead function. Just `#[allow(dead_code)]` is
-        // insufficient, since the user may have
-        // `#[forbid(dead_code)]` and which cannot be overridden.
         #[inline(always)]
-        fn _run_fmt(fmt: &::std::fmt::Arguments) -> ! {
-            static _FILE_LINE: (&'static str, uint) = (file!(), line!());
-            ::core::failure::begin_unwind(fmt, &_FILE_LINE)
+        fn run_fmt(fmt: &::std::fmt::Arguments) -> ! {
+            static FILE_LINE: (&'static str, uint) = (file!(), line!());
+            ::core::failure::begin_unwind(fmt, &FILE_LINE)
         }
-        format_args!(_run_fmt, $fmt, $($arg)*)
+        format_args!(run_fmt, $fmt, $($arg)*)
     });
 )
 

branches/try/src/liblog/directive.rs

@@ -38,7 +38,7 @@ pub fn parse_logging_spec(spec: &str) -> Vec<LogDirective> {
     for s in spec.split(',') {
         if s.len() == 0 { continue }
         let mut parts = s.split('=');
-        let (log_level, name) = match (parts.next(), parts.next(), parts.next()) {
+        let (log_level, name) = match (parts.next(), parts.next().map(|s| s.trim()), parts.next()) {
             (Some(part0), None, None) => {
                 // if the single argument is a log-level string or number,
                 // treat that as a global fallback
@@ -47,6 +47,7 @@ pub fn parse_logging_spec(spec: &str) -> Vec<LogDirective> {
                     None => (::MAX_LOG_LEVEL, Some(part0)),
                 }
             }
+            (Some(part0), Some(""), None) => (::MAX_LOG_LEVEL, Some(part0)),
             (Some(part0), Some(part1), None) => {
                 match parse_log_level(part1) {
                     Some(num) => (num, Some(part0)),
@@ -120,6 +121,16 @@ mod tests {
         assert_eq!(dirs[0].level, ::WARN);
     }
 
+    #[test]
+    fn parse_logging_spec_empty_log_level() {
+        // test parse_logging_spec with '' as log level
+        let dirs = parse_logging_spec("crate1::mod1=wrong,crate2=");
+        let dirs = dirs.as_slice();
+        assert_eq!(dirs.len(), 1);
+        assert_eq!(dirs[0].name, Some("crate2".to_string()));
+        assert_eq!(dirs[0].level, ::MAX_LOG_LEVEL);
+    }
+
     #[test]
     fn parse_logging_spec_global() {
         // test parse_logging_spec with no crate

branches/try/src/librustc/middle/dead.rs

@@ -26,6 +26,7 @@ use syntax::ast_util::{local_def, is_local, PostExpansionMethod};
 use syntax::attr::AttrMetaMethods;
 use syntax::attr;
 use syntax::codemap;
+use syntax::parse::token;
 use syntax::visit::Visitor;
 use syntax::visit;
 
@@ -411,14 +412,18 @@ struct DeadVisitor<'a> {
 
 impl<'a> DeadVisitor<'a> {
     fn should_warn_about_field(&mut self, node: &ast::StructField_) -> bool {
-        let is_named = node.ident().is_some();
+        let (is_named, has_leading_underscore) = match node.ident() {
+            Some(ref ident) => (true, token::get_ident(*ident).get().as_bytes()[0] == ('_' as u8)),
+            _ => (false, false)
+        };
         let field_type = ty::node_id_to_type(self.tcx, node.id);
         let is_marker_field = match ty::ty_to_def_id(field_type) {
             Some(def_id) => self.tcx.lang_items.items().any(|(_, item)| *item == Some(def_id)),
             _ => false
         };
         is_named
             && !self.symbol_is_live(node.id, None)
+            && !has_leading_underscore
             && !is_marker_field
             && !has_allow_dead_code_or_lang_attr(node.attrs.as_slice())
     }
@@ -463,15 +468,13 @@ impl<'a> DeadVisitor<'a> {
                       id: ast::NodeId,
                       span: codemap::Span,
                       ident: ast::Ident) {
-        let name = ident.as_str();
-        if !name.starts_with("_") {
-            self.tcx
-                .sess
-                .add_lint(lint::builtin::DEAD_CODE,
-                          id,
-                          span,
-                          format!("code is never used: `{}`", name));
-        }
+        self.tcx
+            .sess
+            .add_lint(lint::builtin::DEAD_CODE,
+                      id,
+                      span,
+                      format!("code is never used: `{}`",
+                              token::get_ident(ident)));
     }
 }
 

branches/try/src/libstd/macros.rs

@@ -43,8 +43,8 @@ macro_rules! fail(
     });
     ($msg:expr) => ({
         // static requires less code at runtime, more constant data
-        static _FILE_LINE: (&'static str, uint) = (file!(), line!());
-        ::std::rt::begin_unwind($msg, &_FILE_LINE)
+        static FILE_LINE: (&'static str, uint) = (file!(), line!());
+        ::std::rt::begin_unwind($msg, &FILE_LINE)
     });
     ($fmt:expr, $($arg:tt)*) => ({
         // a closure can't have return type !, so we need a full
@@ -58,17 +58,12 @@ macro_rules! fail(
         // because it's just a tiny wrapper. Small wins (156K to 149K in size)
         // were seen when forcing this to be inlined, and that number just goes
         // up with the number of calls to fail!()
-        //
-        // The leading _'s are to avoid dead code warnings if this is
-        // used inside a dead function. Just `#[allow(dead_code)]` is
-        // insufficient, since the user may have
-        // `#[forbid(dead_code)]` and which cannot be overridden.
         #[inline(always)]
-        fn _run_fmt(fmt: &::std::fmt::Arguments) -> ! {
-            static _FILE_LINE: (&'static str, uint) = (file!(), line!());
-            ::std::rt::begin_unwind_fmt(fmt, &_FILE_LINE)
+        fn run_fmt(fmt: &::std::fmt::Arguments) -> ! {
+            static FILE_LINE: (&'static str, uint) = (file!(), line!());
+            ::std::rt::begin_unwind_fmt(fmt, &FILE_LINE)
         }
-        format_args!(_run_fmt, $fmt, $($arg)*)
+        format_args!(run_fmt, $fmt, $($arg)*)
     });
 )