From ece96ac4e5e8ac7ea7bd035bd7d79ee4635ae088 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hannes=20K=C3=B6rber?= <hannes@hkoerber.de>
Date: Fri, 8 Nov 2024 22:50:31 +0100
Subject: [PATCH] Simplify ident handling

---
 aws_macros/src/tag.rs  | 30 ++++++------------------------
 aws_macros/src/tags.rs | 27 +++++++--------------------
 2 files changed, 13 insertions(+), 44 deletions(-)

diff --git a/aws_macros/src/tag.rs b/aws_macros/src/tag.rs
index 2b05dc6..1f61d49 100644
--- a/aws_macros/src/tag.rs
+++ b/aws_macros/src/tag.rs
@@ -24,15 +24,8 @@ fn parse_enum_attributes(attrs: &[syn::Attribute]) -> Option<syn::LitStr> {
         .filter(|attr| attr.style == syn::AttrStyle::Outer)
         .find_map(|attr| match attr.meta {
             syn::Meta::List(ref meta_list) => {
-                if let (Some(name), 1) = (
-                    meta_list.path.segments.first(),
-                    meta_list.path.segments.len(),
-                ) {
-                    if name.ident == "tag" {
-                        Some(meta_list.clone())
-                    } else {
-                        None
-                    }
+                if meta_list.path.is_ident("tag") {
+                    Some(meta_list.clone())
                 } else {
                     None
                 }
@@ -49,12 +42,7 @@ fn parse_enum_attributes(attrs: &[syn::Attribute]) -> Option<syn::LitStr> {
                 syn::Expr::Assign(ref assign) => {
                     match *assign.left {
                         syn::Expr::Path(ref exprpath) => {
-                            let segments = &exprpath.path.segments;
-                            let (Some(segment), 1) = (segments.first(), segments.len()) else {
-                                panic!("invalid attribute key")
-                            };
-
-                            assert!(segment.ident == "rename", "invalid attribute key");
+                            assert!(exprpath.path.is_ident("rename"), "invalid attribute key");
                         }
                         _ => panic!("invalid expression in enum variant attribute, left side"),
                     }
@@ -103,24 +91,18 @@ fn parse_tag_attribute(expr: syn::Expr, elem: &syn::Data) -> Translator {
 
     match *assign.left {
         syn::Expr::Path(ref exprpath) => {
-            let segments = &exprpath.path.segments;
-            let (Some(segment), 1) = (segments.first(), segments.len()) else {
-                panic!("invalid attribute key")
-            };
-
-            assert!(segment.ident == "translate", "invalid attribute key");
+            assert!(exprpath.path.is_ident("translate"), "invalid attribute key");
         }
         _ => panic!("invalid expression in tag field attribute, left side"),
     }
 
     match *assign.right {
         syn::Expr::Path(ref exprpath) => {
-            let segments = &exprpath.path.segments;
-            let (Some(segment), 1) = (segments.first(), segments.len()) else {
+            let Some(ident) = exprpath.path.get_ident() else {
                 panic!("invalid attribute key")
             };
 
-            match segment.ident.to_string().as_str() {
+            match ident.to_string().as_str() {
                 "serde" => Translator::Serde,
                 "manual" => Translator::Manual,
                 "transparent" =>
diff --git a/aws_macros/src/tags.rs b/aws_macros/src/tags.rs
index aa31bd8..9b1c7d1 100644
--- a/aws_macros/src/tags.rs
+++ b/aws_macros/src/tags.rs
@@ -26,13 +26,7 @@ struct Element {
 
 fn is_cfg_attribute(attr: &syn::Attribute) -> bool {
     match attr.meta {
-        syn::Meta::List(ref meta_list) => {
-            let segments = &meta_list.path.segments;
-            match (segments.first(), segments.len()) {
-                (Some(segment), 1) => segment.ident == "cfg",
-                _ => false,
-            }
-        }
+        syn::Meta::List(ref meta_list) => meta_list.path.is_ident("cfg"),
         _ => false,
     }
 }
@@ -93,13 +87,8 @@ fn parse_field_attrs(attrs: &mut Vec<syn::Attribute>) -> Option<String> {
         .filter(|&(_i, attr)| attr.style == syn::AttrStyle::Outer)
         .find_map(|(i, attr)| match attr.meta {
             syn::Meta::List(ref meta_list) => {
-                let tag = &meta_list.path;
-                if let (Some(segment), 1) = (tag.segments.first(), tag.segments.len()) {
-                    if segment.ident == "tag" {
-                        Some((i, meta_list.clone()))
-                    } else {
-                        None
-                    }
+                if meta_list.path.is_ident("tag") {
+                    Some((i, meta_list.clone()))
                 } else {
                     None
                 }
@@ -123,12 +112,10 @@ fn parse_field_attrs(attrs: &mut Vec<syn::Attribute>) -> Option<String> {
 
             match *assign.left {
                 syn::Expr::Path(ref exprpath) => {
-                    let segments = &exprpath.path.segments;
-                    let (Some(segment), 1) = (segments.first(), segments.len()) else {
-                        panic!("invalid tag field attribute key")
-                    };
-
-                    assert!(segment.ident == "key", "invalid tag field attribute key");
+                    assert!(
+                        exprpath.path.is_ident("key"),
+                        "invalid tag field attribute key"
+                    );
                 }
                 _ => panic!("invalid expression in tag field attribute, left side"),
             }