use Symbol comparison in get_skip_names

Author: tesuji

src/skip.rs

@@ -1,6 +1,13 @@
 //! Module that contains skip related stuffs.
 
 use syntax::ast;
+use syntax::symbol::{sym, Symbol};
+
+macro_rules! sym {
+    ($tt:tt) => {
+        Symbol::intern(stringify!($tt))
+    };
+}
 
 /// Take care of skip name stack. You can update it by attributes slice or
 /// by other context. Query this context to know if you need skip a block.
@@ -12,9 +19,9 @@ pub(crate) struct SkipContext {
 
 impl SkipContext {
     pub(crate) fn update_with_attrs(&mut self, attrs: &[ast::Attribute]) {
-        self.macros.append(&mut get_skip_names("macros", attrs));
+        self.macros.append(&mut get_skip_names(attrs, sym!(macros)));
         self.attributes
-            .append(&mut get_skip_names("attributes", attrs));
+            .append(&mut get_skip_names(attrs, sym::attributes));
     }
 
     pub(crate) fn update(&mut self, mut other: SkipContext) {
@@ -31,40 +38,31 @@ impl SkipContext {
     }
 }
 
-static RUSTFMT: &str = "rustfmt";
-static SKIP: &str = "skip";
-
 /// Say if you're playing with `rustfmt`'s skip attribute
 pub(crate) fn is_skip_attr(segments: &[ast::PathSegment]) -> bool {
-    if segments.len() < 2 || segments[0].ident.as_str() != RUSTFMT {
+    is_skip_attr_with(segments, |s| s == sym!(macros) || s == sym::attributes)
+}
+
+fn is_skip_attr_with(segments: &[ast::PathSegment], pred: impl FnOnce(Symbol) -> bool) -> bool {
+    if segments.len() < 2 || segments[0].ident.name != sym::rustfmt {
         return false;
     }
     match segments.len() {
-        2 => segments[1].ident.as_str() == SKIP,
-        3 => {
-            segments[1].ident.as_str() == SKIP
-                && ["macros", "attributes"]
-                    .iter()
-                    .any(|&n| n == segments[2].ident.name.as_str())
-        }
+        2 => segments[1].ident.name == sym!(skip),
+        3 => segments[1].ident.name == sym!(skip) && pred(segments[2].ident.name),
         _ => false,
     }
 }
 
-fn get_skip_names(kind: &str, attrs: &[ast::Attribute]) -> Vec<String> {
+fn get_skip_names(attrs: &[ast::Attribute], kind: Symbol) -> Vec<String> {
     let mut skip_names = vec![];
-    let path = format!("{}::{}::{}", RUSTFMT, SKIP, kind);
     for attr in attrs {
-        // syntax::ast::Path is implemented partialEq
-        // but it is designed for segments.len() == 1
-        if format!("{}", attr.path) != path {
-            continue;
-        }
-
-        if let Some(list) = attr.meta_item_list() {
-            for nested_meta_item in list {
-                if let Some(name) = nested_meta_item.ident() {
-                    skip_names.push(name.to_string());
+        if is_skip_attr_with(&attr.item.path.segments, |s| s == kind) {
+            if let Some(list) = attr.meta_item_list() {
+                for nested_meta_item in list {
+                    if let Some(name) = nested_meta_item.ident() {
+                        skip_names.push(name.to_string());
+                    }
                 }
             }
         }