Unify macro name detection for cfg_{if|matach}!

Specifically, both cfg_if! and cfg_match! visitors now gate using the
same is_macro_name predicate, which checks the last path segment ident.

cfg_if! previously tested the *first* path segment, meaning that the
visitor would walk `cfg_if!` and `cfg_if::cfg_if!`, but would also
walk `cfg_if::other!` and wouldn't walk `::cfg_if::cfg_if!`. cfg_match!
instead chose to check the *last* path segment, so its visitor would
walk any macro invoked as `cfg_match!` independent of the leading path.

Author: CAD97

src/modules.rs

@@ -590,30 +590,23 @@ fn find_path_value(attrs: &[ast::Attribute]) -> Option<Symbol> {
     attrs.iter().flat_map(path_value).next()
 }
 
+fn is_macro_name(mac: &ast::MacCall, name: &str) -> bool {
+    mac.path
+        .segments
+        .last()
+        .map_or(false, |segment| segment.ident.name == Symbol::intern(name))
+}
+
 fn is_cfg_if(item: &ast::Item) -> bool {
     match item.kind {
-        ast::ItemKind::MacCall(ref mac) => {
-            if let Some(first_segment) = mac.path.segments.first() {
-                if first_segment.ident.name == Symbol::intern("cfg_if") {
-                    return true;
-                }
-            }
-            false
-        }
+        ast::ItemKind::MacCall(ref mac) => is_macro_name(mac, "cfg_if"),
         _ => false,
     }
 }
 
 fn is_cfg_match(item: &ast::Item) -> bool {
     match item.kind {
-        ast::ItemKind::MacCall(ref mac) => {
-            if let Some(last_segment) = mac.path.segments.last() {
-                if last_segment.ident.name == Symbol::intern("cfg_match") {
-                    return true;
-                }
-            }
-            false
-        }
+        ast::ItemKind::MacCall(ref mac) => is_macro_name(mac, "cfg_match"),
         _ => false,
     }
 }

src/modules/visitor.rs

@@ -1,8 +1,9 @@
 use rustc_ast::ast;
 use rustc_ast::visit::Visitor;
-use rustc_span::{Symbol, sym};
+use rustc_span::sym;
 use tracing::debug;
 
+use super::is_macro_name;
 use crate::attr::MetaVisitor;
 use crate::parse::macros::cfg_if::parse_cfg_if;
 use crate::parse::macros::cfg_match::parse_cfg_match;
@@ -42,27 +43,9 @@ impl<'a, 'ast: 'a> Visitor<'ast> for CfgIfVisitor<'a> {
 
 impl<'a, 'ast: 'a> CfgIfVisitor<'a> {
     fn visit_mac_inner(&mut self, mac: &'ast ast::MacCall) -> Result<(), &'static str> {
-        // Support both:
-        // ```
-        // extern crate cfg_if;
-        // cfg_if::cfg_if! {..}
-        // ```
-        // And:
-        // ```
-        // #[macro_use]
-        // extern crate cfg_if;
-        // cfg_if! {..}
-        // ```
-        match mac.path.segments.first() {
-            Some(first_segment) => {
-                if first_segment.ident.name != Symbol::intern("cfg_if") {
-                    return Err("Expected cfg_if");
-                }
-            }
-            None => {
-                return Err("Expected cfg_if");
-            }
-        };
+        if !is_macro_name(mac, "cfg_if") {
+            return Err("Expected cfg_if");
+        }
 
         let items = parse_cfg_if(self.psess, mac)?;
         self.mods
@@ -102,26 +85,9 @@ impl<'a, 'ast: 'a> Visitor<'ast> for CfgMatchVisitor<'a> {
 
 impl<'a, 'ast: 'a> CfgMatchVisitor<'a> {
     fn visit_mac_inner(&mut self, mac: &'ast ast::MacCall) -> Result<(), &'static str> {
-        // Support both:
-        // ```
-        // std::cfg_match! {..}
-        // core::cfg_match! {..}
-        // ```
-        // And:
-        // ```
-        // use std::cfg_match;
-        // cfg_match! {..}
-        // ```
-        match mac.path.segments.last() {
-            Some(last_segment) => {
-                if last_segment.ident.name != Symbol::intern("cfg_match") {
-                    return Err("Expected cfg_match");
-                }
-            }
-            None => {
-                return Err("Expected cfg_match");
-            }
-        };
+        if !is_macro_name(mac, "cfg_match") {
+            return Err("Expected cfg_match");
+        }
 
         let items = parse_cfg_match(self.psess, mac)?;
         self.mods