Remove Option from the return type of Attribute::name()

topecongiro · topecongiro · commit f2b4234e0e34 · 2018-02-12T13:34:45.000+09:00
diff --git a/src/librustc/hir/check_attr.rs b/src/librustc/hir/check_attr.rs
@@ -50,10 +50,8 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
         self.tcx.target_features_enabled(self.tcx.hir.local_def_id(item.id));
 
         for attr in &item.attrs {
-            if let Some(name) = attr.name() {
-                if name == "inline" {
-                    self.check_inline(attr, item, target)
-                }
+            if attr.name() == "inline" {
+                self.check_inline(attr, item, target)
             }
         }
 
@@ -81,10 +79,7 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
         // ```
         let hints: Vec<_> = item.attrs
             .iter()
-            .filter(|attr| match attr.name() {
-                Some(name) => name == "repr",
-                None => false,
-            })
+            .filter(|attr| attr.name() == "repr")
             .filter_map(|attr| attr.meta_item_list())
             .flat_map(|hints| hints)
             .collect();
diff --git a/src/librustc/ich/impls_syntax.rs b/src/librustc/ich/impls_syntax.rs
@@ -178,8 +178,7 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for [ast::Attribute] {
         let filtered: AccumulateVec<[&ast::Attribute; 8]> = self
             .iter()
             .filter(|attr| {
-                !attr.is_sugared_doc &&
-                attr.name().map(|name| !hcx.is_ignored_attr(name)).unwrap_or(true)
+                !attr.is_sugared_doc && !hcx.is_ignored_attr(attr.name())
             })
             .collect();
 
@@ -206,7 +205,7 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for ast::Attribute {
                                           hcx: &mut StableHashingContext<'gcx>,
                                           hasher: &mut StableHasher<W>) {
         // Make sure that these have been filtered out.
-        debug_assert!(self.name().map(|name| !hcx.is_ignored_attr(name)).unwrap_or(true));
+        debug_assert!(!hcx.is_ignored_attr(self.name()));
         debug_assert!(!self.is_sugared_doc);
 
         let ast::Attribute {
diff --git a/src/librustc/lint/levels.rs b/src/librustc/lint/levels.rs
@@ -197,7 +197,7 @@ impl<'a> LintLevelsBuilder<'a> {
                       "malformed lint attribute");
         };
         for attr in attrs {
-            let level = match attr.name().and_then(|name| Level::from_str(&name.as_str())) {
+            let level = match Level::from_str(&attr.name().as_str()) {
                 None => continue,
                 Some(lvl) => lvl,
             };
diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs
@@ -205,7 +205,7 @@ impl<'a, 'tcx: 'a> Annotator<'a, 'tcx> {
         } else {
             // Emit errors for non-staged-api crates.
             for attr in attrs {
-                let tag = unwrap_or!(attr.name(), continue);
+                let tag = attr.name();
                 if tag == "unstable" || tag == "stable" || tag == "rustc_deprecated" {
                     attr::mark_used(attr);
                     self.tcx.sess.span_err(attr.span(), "stability attributes may not be used \
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
@@ -663,9 +663,8 @@ impl LintPass for DeprecatedAttr {
 
 impl EarlyLintPass for DeprecatedAttr {
     fn check_attribute(&mut self, cx: &EarlyContext, attr: &ast::Attribute) {
-        let name = unwrap_or!(attr.name(), return);
         for &&(n, _, ref g) in &self.depr_attrs {
-            if name == n {
+            if attr.name() == n {
                 if let &AttributeGate::Gated(Stability::Deprecated(link),
                                              ref name,
                                              ref reason,
diff --git a/src/librustc_lint/lib.rs b/src/librustc_lint/lib.rs
@@ -33,7 +33,6 @@
 #![feature(rustc_diagnostic_macros)]
 #![feature(slice_patterns)]
 
-#[macro_use]
 extern crate syntax;
 #[macro_use]
 extern crate rustc;
diff --git a/src/librustc_lint/unused.rs b/src/librustc_lint/unused.rs
@@ -174,8 +174,6 @@ impl LintPass for UnusedAttributes {
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedAttributes {
     fn check_attribute(&mut self, cx: &LateContext, attr: &ast::Attribute) {
         debug!("checking attribute: {:?}", attr);
-        let name = unwrap_or!(attr.name(), return);
-
         // Note that check_name() marks the attribute as used if it matches.
         for &(ref name, ty, _) in BUILTIN_ATTRIBUTES {
             match ty {
@@ -195,6 +193,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedAttributes {
             }
         }
 
+        let name = attr.name();
         if !attr::is_used(attr) {
             debug!("Emitting warning for: {:?}", attr);
             cx.span_lint(UNUSED_ATTRIBUTES, attr.span, "unused attribute");
diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs
@@ -210,7 +210,7 @@ impl<'a> base::Resolver for Resolver<'a> {
     fn find_legacy_attr_invoc(&mut self, attrs: &mut Vec<ast::Attribute>)
                               -> Option<ast::Attribute> {
         for i in 0..attrs.len() {
-            let name = unwrap_or!(attrs[i].name(), continue);
+            let name = attrs[i].name();
 
             if self.session.plugin_attributes.borrow().iter()
                     .any(|&(ref attr_nm, _)| name == &**attr_nm) {
@@ -230,11 +230,11 @@ impl<'a> base::Resolver for Resolver<'a> {
 
         // Check for legacy derives
         for i in 0..attrs.len() {
-            let name = unwrap_or!(attrs[i].name(), continue);
+            let name = attrs[i].name();
 
             if name == "derive" {
                 let result = attrs[i].parse_list(&self.session.parse_sess, |parser| {
-                    parser.parse_path(PathStyle::Mod)
+                    parser.parse_path_allowing_meta(PathStyle::Mod)
                 });
 
                 let mut traits = match result {
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -3359,7 +3359,7 @@ impl Clean<Vec<Item>> for doctree::Import {
         // #[doc(no_inline)] attribute is present.
         // Don't inline doc(hidden) imports so they can be stripped at a later stage.
         let denied = self.vis != hir::Public || self.attrs.iter().any(|a| {
-            a.name().unwrap() == "doc" && match a.meta_item_list() {
+            a.name() == "doc" && match a.meta_item_list() {
                 Some(l) => attr::list_contains_name(&l, "no_inline") ||
                            attr::list_contains_name(&l, "hidden"),
                 None => false,
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
@@ -3077,7 +3077,7 @@ fn render_attributes(w: &mut fmt::Formatter, it: &clean::Item) -> fmt::Result {
     let mut attrs = String::new();
 
     for attr in &it.attrs.other_attrs {
-        let name = attr.name().unwrap();
+        let name = attr.name();
         if !ATTRIBUTE_WHITELIST.contains(&&*name.as_str()) {
             continue;
         }
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
@@ -218,11 +218,10 @@ impl Attribute {
         matches
     }
 
-    pub fn name(&self) -> Option<Name> {
-        match self.path.segments.len() {
-            1 => Some(self.path.segments[0].identifier.name),
-            _ => None,
-        }
+    /// Returns the first segment of the name of this attribute.
+    /// E.g. `foo` for `#[foo]`, `rustfmt` for `#[rustfmt::skip]`.
+    pub fn name(&self) -> Name {
+        name_from_path(&self.path)
     }
 
     pub fn value_str(&self) -> Option<Symbol> {
diff --git a/src/libsyntax/ext/derive.rs b/src/libsyntax/ext/derive.rs
@@ -26,7 +26,8 @@ pub fn collect_derives(cx: &mut ExtCtxt, attrs: &mut Vec<ast::Attribute>) -> Vec
             return true;
         }
 
-        match attr.parse_list(cx.parse_sess, |parser| parser.parse_path(PathStyle::Mod)) {
+        match attr.parse_list(cx.parse_sess,
+                              |parser| parser.parse_path_allowing_meta(PathStyle::Mod)) {
             Ok(ref traits) if traits.is_empty() => {
                 cx.span_warn(attr.span, "empty trait list in `derive`");
                 false
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
@@ -1074,7 +1074,7 @@ macro_rules! gate_feature {
 impl<'a> Context<'a> {
     fn check_attribute(&self, attr: &ast::Attribute, is_macro: bool) {
         debug!("check_attribute(attr = {:?})", attr);
-        let name = unwrap_or!(attr.name(), return).as_str();
+        let name = attr.name().as_str();
         for &(n, ty, ref gateage) in BUILTIN_ATTRIBUTES {
             if name == n {
                 if let Gated(_, name, desc, ref has_feature) = *gateage {
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -1988,6 +1988,26 @@ impl<'a> Parser<'a> {
         Ok(ast::Path { segments, span: lo.to(self.prev_span) })
     }
 
+    /// Like `parse_path`, but also supports parsing `Word` meta items into paths for back-compat.
+    /// This is used when parsing derive macro paths in `#[derive]` attributes.
+    pub fn parse_path_allowing_meta(&mut self, style: PathStyle) -> PResult<'a, ast::Path> {
+        let meta_name = match self.token {
+            token::Interpolated(ref nt) => match nt.0 {
+                token::NtMeta(ref meta) => match meta.node {
+                    ast::MetaItemKind::Word => Some(meta.name.clone()),
+                    _ => None,
+                },
+                _ => None,
+            },
+            _ => None,
+        };
+        if let Some(path) = meta_name {
+            self.bump();
+            return Ok(path);
+        }
+        self.parse_path(style)
+    }
+
     fn parse_path_segments(&mut self,
                            segments: &mut Vec<PathSegment>,
                            style: PathStyle,
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
@@ -770,6 +770,7 @@ pub trait PrintState<'a> {
             ast::MetaItemKind::Word => self.print_attribute_path(&item.name)?,
             ast::MetaItemKind::NameValue(ref value) => {
                 self.print_attribute_path(&item.name)?;
+                self.writer().space()?;
                 self.word_space("=")?;
                 self.print_literal(value)?;
             }
diff --git a/src/libsyntax_ext/deriving/custom.rs b/src/libsyntax_ext/deriving/custom.rs
@@ -22,11 +22,9 @@ struct MarkAttrs<'a>(&'a [ast::Name]);
 
 impl<'a> Visitor<'a> for MarkAttrs<'a> {
     fn visit_attribute(&mut self, attr: &Attribute) {
-        if let Some(name) = attr.name() {
-            if self.0.contains(&name) {
-                mark_used(attr);
-                mark_known(attr);
-            }
+        if self.0.contains(&attr.name()) {
+            mark_used(attr);
+            mark_known(attr);
         }
     }
 
diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs
@@ -467,7 +467,7 @@ impl<'a> TraitDef<'a> {
                 attrs.extend(item.attrs
                     .iter()
                     .filter(|a| {
-                        a.name().is_some() && match &*a.name().unwrap().as_str() {
+                        match &*a.name().as_str() {
                             "allow" | "warn" | "deny" | "forbid" | "stable" | "unstable" => true,
                             _ => false,
                         }

Original file line number	Diff line number	Diff line change
`@@ -3077,7 +3077,7 @@ fn render_attributes(w: &mut fmt::Formatter, it: &clean::Item) -> fmt::Result {`
`3077`	`3077`	`let mut attrs = String::new();`
`3078`	`3078`
`3079`	`3079`	`for attr in &it.attrs.other_attrs {`
`3080`		`- let name = attr.name().unwrap();`
	`3080`	`+ let name = attr.name();`
`3081`	`3081`	`if !ATTRIBUTE_WHITELIST.contains(&&*name.as_str()) {`
`3082`	`3082`	`continue;`
`3083`	`3083`	`}`
Original file line number	Diff line number	Diff line change
`@@ -218,11 +218,10 @@ impl Attribute {`
`218`	`218`	`matches`
`219`	`219`	`}`
`220`	`220`
`221`		`- pub fn name(&self) -> Option<Name> {`
`222`		`- match self.path.segments.len() {`
`223`		`- 1 => Some(self.path.segments[0].identifier.name),`
`224`		`- _ => None,`
`225`		`- }`
	`221`	`+ /// Returns the first segment of the name of this attribute.`
	`222`	+ /// E.g. `foo` for `#[foo]`, `rustfmt` for `#[rustfmt::skip]`.
	`223`	`+ pub fn name(&self) -> Name {`
	`224`	`+ name_from_path(&self.path)`
`226`	`225`	`}`
`227`	`226`
`228`	`227`	`pub fn value_str(&self) -> Option<Symbol> {`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,8 @@ pub fn collect_derives(cx: &mut ExtCtxt, attrs: &mut Vec<ast::Attribute>) -> Vec`
`26`	`26`	`return true;`
`27`	`27`	`}`
`28`	`28`
`29`		`- match attr.parse_list(cx.parse_sess, \|parser\| parser.parse_path(PathStyle::Mod)) {`
	`29`	`+ match attr.parse_list(cx.parse_sess,`
	`30`	`+ \|parser\| parser.parse_path_allowing_meta(PathStyle::Mod)) {`
`30`	`31`	`Ok(ref traits) if traits.is_empty() => {`
`31`	`32`	cx.span_warn(attr.span, "empty trait list in `derive`");
`32`	`33`	`false`
Original file line number	Diff line number	Diff line change
`@@ -770,6 +770,7 @@ pub trait PrintState<'a> {`
`770`	`770`	`ast::MetaItemKind::Word => self.print_attribute_path(&item.name)?,`
`771`	`771`	`ast::MetaItemKind::NameValue(ref value) => {`
`772`	`772`	`self.print_attribute_path(&item.name)?;`
	`773`	`+ self.writer().space()?;`
`773`	`774`	`self.word_space("=")?;`
`774`	`775`	`self.print_literal(value)?;`
`775`	`776`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,11 +22,9 @@ struct MarkAttrs<'a>(&'a [ast::Name]);`
`22`	`22`
`23`	`23`	`impl<'a> Visitor<'a> for MarkAttrs<'a> {`
`24`	`24`	`fn visit_attribute(&mut self, attr: &Attribute) {`
`25`		`- if let Some(name) = attr.name() {`
`26`		`- if self.0.contains(&name) {`
`27`		`- mark_used(attr);`
`28`		`- mark_known(attr);`
`29`		`- }`
	`25`	`+ if self.0.contains(&attr.name()) {`
	`26`	`+ mark_used(attr);`
	`27`	`+ mark_known(attr);`
`30`	`28`	`}`
`31`	`29`	`}`
`32`	`30`
Original file line number	Diff line number	Diff line change
`@@ -467,7 +467,7 @@ impl<'a> TraitDef<'a> {`
`467`	`467`	`attrs.extend(item.attrs`
`468`	`468`	`.iter()`
`469`	`469`	`.filter(\|a\| {`
`470`		`- a.name().is_some() && match &*a.name().unwrap().as_str() {`
	`470`	`+ match &*a.name().as_str() {`
`471`	`471`	`"allow" \| "warn" \| "deny" \| "forbid" \| "stable" \| "unstable" => true,`
`472`	`472`	`_ => false,`
`473`	`473`	`}`