Adressed PR comments.

cgswords · cgswords · commit 5553901146fa · 2016-07-25T14:27:10.000-07:00
diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs
@@ -367,18 +367,18 @@ pub fn gather_attr(attr: &ast::Attribute)
 
     let meta = &attr.node.value;
     let metas = if let Some(metas) = meta.meta_item_list() {
-                    metas
-                } else {
-                    out.push(Err(meta.span));
-                    return out;
-                };
+        metas
+    } else {
+        out.push(Err(meta.span));
+        return out;
+    };
 
     for meta in metas {
         out.push(if meta.is_word() {
-                     Ok((meta.name().clone(), level, meta.span))
-                 } else {
-                     Err(meta.span)
-                 });
+            Ok((meta.name().clone(), level, meta.span))
+        } else {
+            Err(meta.span)
+        });
     }
 
     out
diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs
@@ -394,11 +394,10 @@ fn check_cfg(sopts: &config::Options,
     let mut saw_invalid_predicate = false;
     for item in sopts.cfg.iter() {
         if item.is_meta_item_list() {
-            saw_invalid_predicate = true;
             saw_invalid_predicate = true;
             handler.emit(&MultiSpan::new(),
                          &format!("invalid predicate in --cfg command line argument: `{}`",
-                                  pred),
+                                  item.name()),
                             errors::Level::Fatal);
         }
     }
@@ -651,10 +650,8 @@ impl RustcDefaultCalls {
                         if cfg.is_word() {
                             println!("{}", cfg.name());
                         } else if cfg.is_value_str() {
-                            let rhs = cfg.value_str();
-                            match rhs {
-                                Some(s) => println!("{}=\"{}\"", cfg.name(), s),
-                                None => continue,
+                            if let Some(s) = cfg.value_str() {
+                                println!("{}=\"{}\"", cfg.name(), s);
                             }
                         } else if cfg.is_meta_item_list() {
                             // Right now there are not and should not be any
diff --git a/src/librustc_incremental/assert_dep_graph.rs b/src/librustc_incremental/assert_dep_graph.rs
@@ -114,9 +114,7 @@ impl<'a, 'tcx> IfThisChanged<'a, 'tcx> {
                         id = Some(meta_item.name().clone());
                     } else {
                         // FIXME better-encapsulate meta_item (don't directly access `node`)
-                        self.tcx.sess.span_err(
-                            meta_item.span(),
-                            &format!("unexpected meta-item {:?}", meta_item.node));
+                        span_bug!(meta_item.span(), "unexpected meta-item {:?}", meta_item.node)
                     }
                 }
                 let id = id.unwrap_or(InternedString::new(ID));
@@ -133,9 +131,7 @@ impl<'a, 'tcx> IfThisChanged<'a, 'tcx> {
                         id = Some(meta_item.name().clone());
                     } else {
                         // FIXME better-encapsulate meta_item (don't directly access `node`)
-                        self.tcx.sess.span_err(
-                            meta_item.span(),
-                            &format!("unexpected meta-item {:?}", meta_item.node));
+                        span_bug!(meta_item.span(), "unexpected meta-item {:?}", meta_item.node)
                     }
                 }
                 let dep_node = match dep_node_interned {
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
@@ -298,13 +298,7 @@ impl MissingDoc {
             }
         }
 
-        let has_doc = attrs.iter().any(|a| {
-            if a.is_value_str() && a.name() == "doc" {
-                true
-            } else {
-                false
-            }
-        });
+        let has_doc = attrs.iter().any(|a| a.is_value_str() && a.name() == "doc");
         if !has_doc {
             cx.span_lint(MISSING_DOCS, sp,
                          &format!("missing documentation for {}", desc));
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -504,7 +504,7 @@ impl Clean<Attribute> for ast::MetaItem {
             NameValue(self.name().to_string(), v.to_string())
         } else { // must be a list
             let l = self.meta_item_list().unwrap();
-              List(self.name().to_string(), l.clean(cx))
+            List(self.name().to_string(), l.clean(cx))
        }
     }
 }
@@ -2589,26 +2589,6 @@ impl ToSource for syntax_pos::Span {
     }
 }
 
-// fn lit_to_string(lit: &ast::Lit) -> String {
-//     match lit.node {
-//         ast::LitKind::Str(ref st, _) => st.to_string(),
-//         ast::LitKind::ByteStr(ref data) => format!("{:?}", data),
-//         ast::LitKind::Byte(b) => {
-//             let mut res = String::from("b'");
-//             for c in (b as char).escape_default() {
-//                 res.push(c);
-//             }
-//             res.push('\'');
-//             res
-//         },
-//         ast::LitKind::Char(c) => format!("'{}'", c),
-//         ast::LitKind::Int(i, _t) => i.to_string(),
-//         ast::LitKind::Float(ref f, _t) => f.to_string(),
-//         ast::LitKind::FloatUnsuffixed(ref f) => f.to_string(),
-//         ast::LitKind::Bool(b) => b.to_string(),
-//     }
-// }
-
 fn name_from_pat(p: &hir::Pat) -> String {
     use rustc::hir::*;
     debug!("Trying to get a name from pattern: {:?}", p);
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
@@ -94,10 +94,16 @@ pub trait AttrMetaMethods {
 
     /// Indicates if the attribute is a Word.
     fn is_word(&self) -> bool;
+
     /// Indicates if the attribute is a Value String.
-    fn is_value_str(&self) -> bool;
+    fn is_value_str(&self) -> bool {
+        self.value_str().is_some()
+    }
+
     /// Indicates if the attribute is a Meta-Item List.
-    fn is_meta_item_list(&self) -> bool;
+    fn is_meta_item_list(&self) -> bool {
+        self.meta_item_list().is_some()
+    }
 
     fn span(&self) -> Span;
 }
@@ -119,9 +125,6 @@ impl AttrMetaMethods for Attribute {
     }
 
     fn is_word(&self) -> bool { self.meta().is_word() }
-    fn is_value_str(&self) -> bool { self.meta().is_value_str() }
-
-    fn is_meta_item_list(&self) -> bool { self.meta().is_meta_item_list() }
 
     fn span(&self) -> Span { self.meta().span }
 }
@@ -161,10 +164,6 @@ impl AttrMetaMethods for MetaItem {
         }
     }
 
-    fn is_value_str(&self) -> bool { self.value_str().is_some() }
-
-    fn is_meta_item_list(&self) -> bool { self.meta_item_list().is_some() }
-
     fn span(&self) -> Span { self.span }
 }
 
@@ -240,7 +239,7 @@ pub fn mk_word_item(name: InternedString) -> P<MetaItem> {
 
 pub fn mk_spanned_name_value_item(sp: Span, name: InternedString, value: ast::Lit)
                           -> P<MetaItem> {
-    P(respan(sp,MetaItemKind::NameValue(name, value)))
+    P(respan(sp, MetaItemKind::NameValue(name, value)))
 }
 
 pub fn mk_spanned_list_item(sp: Span, name: InternedString, items: Vec<P<MetaItem>>)
@@ -249,7 +248,7 @@ pub fn mk_spanned_list_item(sp: Span, name: InternedString, items: Vec<P<MetaIte
 }
 
 pub fn mk_spanned_word_item(sp: Span, name: InternedString) -> P<MetaItem> {
-    P(respan(sp,MetaItemKind::Word(name)))
+    P(respan(sp, MetaItemKind::Word(name)))
 }
 
 
diff --git a/src/libsyntax_pos/lib.rs b/src/libsyntax_pos/lib.rs
@@ -254,6 +254,10 @@ pub const NO_EXPANSION: ExpnId = ExpnId(!0);
 // For code appearing from the command line
 pub const COMMAND_LINE_EXPN: ExpnId = ExpnId(!1);
 
+// For code generated by a procedural macro, without knowing which
+// Used in `qquote!`
+pub const PROC_EXPN: ExpnId = ExpnId(!2);
+
 impl ExpnId {
     pub fn from_u32(id: u32) -> ExpnId {
         ExpnId(id)

Original file line number	Diff line number	Diff line change
`@@ -114,9 +114,7 @@ impl<'a, 'tcx> IfThisChanged<'a, 'tcx> {`
`114`	`114`	`id = Some(meta_item.name().clone());`
`115`	`115`	`} else {`
`116`	`116`	// FIXME better-encapsulate meta_item (don't directly access `node`)
`117`		`- self.tcx.sess.span_err(`
`118`		`- meta_item.span(),`
`119`		`- &format!("unexpected meta-item {:?}", meta_item.node));`
	`117`	`+ span_bug!(meta_item.span(), "unexpected meta-item {:?}", meta_item.node)`
`120`	`118`	`}`
`121`	`119`	`}`
`122`	`120`	`let id = id.unwrap_or(InternedString::new(ID));`
`@@ -133,9 +131,7 @@ impl<'a, 'tcx> IfThisChanged<'a, 'tcx> {`
`133`	`131`	`id = Some(meta_item.name().clone());`
`134`	`132`	`} else {`
`135`	`133`	// FIXME better-encapsulate meta_item (don't directly access `node`)
`136`		`- self.tcx.sess.span_err(`
`137`		`- meta_item.span(),`
`138`		`- &format!("unexpected meta-item {:?}", meta_item.node));`
	`134`	`+ span_bug!(meta_item.span(), "unexpected meta-item {:?}", meta_item.node)`
`139`	`135`	`}`
`140`	`136`	`}`
`141`	`137`	`let dep_node = match dep_node_interned {`
Original file line number	Diff line number	Diff line change
`@@ -298,13 +298,7 @@ impl MissingDoc {`
`298`	`298`	`}`
`299`	`299`	`}`
`300`	`300`
`301`		`- let has_doc = attrs.iter().any(\|a\| {`
`302`		`- if a.is_value_str() && a.name() == "doc" {`
`303`		`- true`
`304`		`- } else {`
`305`		`- false`
`306`		`- }`
`307`		`- });`
	`301`	`+ let has_doc = attrs.iter().any(\|a\| a.is_value_str() && a.name() == "doc");`
`308`	`302`	`if !has_doc {`
`309`	`303`	`cx.span_lint(MISSING_DOCS, sp,`
`310`	`304`	`&format!("missing documentation for {}", desc));`
Original file line number	Diff line number	Diff line change
`@@ -94,10 +94,16 @@ pub trait AttrMetaMethods {`
`94`	`94`
`95`	`95`	`/// Indicates if the attribute is a Word.`
`96`	`96`	`fn is_word(&self) -> bool;`
	`97`	`+`
`97`	`98`	`/// Indicates if the attribute is a Value String.`
`98`		`- fn is_value_str(&self) -> bool;`
	`99`	`+ fn is_value_str(&self) -> bool {`
	`100`	`+ self.value_str().is_some()`
	`101`	`+ }`
	`102`	`+`
`99`	`103`	`/// Indicates if the attribute is a Meta-Item List.`
`100`		`- fn is_meta_item_list(&self) -> bool;`
	`104`	`+ fn is_meta_item_list(&self) -> bool {`
	`105`	`+ self.meta_item_list().is_some()`
	`106`	`+ }`
`101`	`107`
`102`	`108`	`fn span(&self) -> Span;`
`103`	`109`	`}`
`@@ -119,9 +125,6 @@ impl AttrMetaMethods for Attribute {`
`119`	`125`	`}`
`120`	`126`
`121`	`127`	`fn is_word(&self) -> bool { self.meta().is_word() }`
`122`		`- fn is_value_str(&self) -> bool { self.meta().is_value_str() }`
`123`		`-`
`124`		`- fn is_meta_item_list(&self) -> bool { self.meta().is_meta_item_list() }`
`125`	`128`
`126`	`129`	`fn span(&self) -> Span { self.meta().span }`
`127`	`130`	`}`
`@@ -161,10 +164,6 @@ impl AttrMetaMethods for MetaItem {`
`161`	`164`	`}`
`162`	`165`	`}`
`163`	`166`
`164`		`- fn is_value_str(&self) -> bool { self.value_str().is_some() }`
`165`		`-`
`166`		`- fn is_meta_item_list(&self) -> bool { self.meta_item_list().is_some() }`
`167`		`-`
`168`	`167`	`fn span(&self) -> Span { self.span }`
`169`	`168`	`}`
`170`	`169`
`@@ -240,7 +239,7 @@ pub fn mk_word_item(name: InternedString) -> P<MetaItem> {`
`240`	`239`
`241`	`240`	`pub fn mk_spanned_name_value_item(sp: Span, name: InternedString, value: ast::Lit)`
`242`	`241`	`-> P<MetaItem> {`
`243`		`- P(respan(sp,MetaItemKind::NameValue(name, value)))`
	`242`	`+ P(respan(sp, MetaItemKind::NameValue(name, value)))`
`244`	`243`	`}`
`245`	`244`
`246`	`245`	`pub fn mk_spanned_list_item(sp: Span, name: InternedString, items: Vec<P<MetaItem>>)`
`@@ -249,7 +248,7 @@ pub fn mk_spanned_list_item(sp: Span, name: InternedString, items: Vec<P<MetaIte`
`249`	`248`	`}`
`250`	`249`
`251`	`250`	`pub fn mk_spanned_word_item(sp: Span, name: InternedString) -> P<MetaItem> {`
`252`		`- P(respan(sp,MetaItemKind::Word(name)))`
	`251`	`+ P(respan(sp, MetaItemKind::Word(name)))`
`253`	`252`	`}`
`254`	`253`
`255`	`254`