refactor: rename arguments to modifiers

sqlparser-rs · Oct 20, 2022 · 46ff407 · 46ff407
1 parent 5aa13eb
commit 46ff407
Show file tree

Hide file tree

Showing 2 changed files with 12 additions and 12 deletions.
diff --git a/src/ast/data_type.rs b/src/ast/data_type.rs
@@ -217,11 +217,11 @@ impl fmt::Display for DataType {
             DataType::String => write!(f, "STRING"),
             DataType::Bytea => write!(f, "BYTEA"),
             DataType::Array(ty) => write!(f, "{}[]", ty),
-            DataType::Custom(ty, args) => {
-                if args.is_empty() {
+            DataType::Custom(ty, modifiers) => {
+                if modifiers.is_empty() {
                     write!(f, "{}", ty)
                 } else {
-                    write!(f, "{}({})", ty, args.join(", "))
+                    write!(f, "{}({})", ty, modifiers.join(", "))
                 }
             }
             DataType::Enum(vals) => {

diff --git a/src/parser.rs b/src/parser.rs
@@ -3624,8 +3624,8 @@ impl<'a> Parser<'a> {
                 _ => {
                     self.prev_token();
                     let type_name = self.parse_object_name()?;
-                    if let Some(arguments) = self.parse_optional_type_arguments()? {
-                        Ok(DataType::Custom(type_name, arguments))
+                    if let Some(modifiers) = self.parse_optional_type_modifiers()? {
+                        Ok(DataType::Custom(type_name, modifiers))
                     } else {
                         Ok(DataType::Custom(type_name, vec![]))
                     }
@@ -3874,26 +3874,26 @@ impl<'a> Parser<'a> {
         }
     }
 
-    pub fn parse_optional_type_arguments(&mut self) -> Result<Option<Vec<String>>, ParserError> {
+    pub fn parse_optional_type_modifiers(&mut self) -> Result<Option<Vec<String>>, ParserError> {
         if self.consume_token(&Token::LParen) {
-            let mut args = Vec::new();
+            let mut modifiers = Vec::new();
             loop {
                 match self.next_token() {
-                    Token::Word(w) => args.push(w.to_string()),
-                    Token::Number(n, _) => args.push(n),
-                    Token::SingleQuotedString(s) => args.push(s),
+                    Token::Word(w) => modifiers.push(w.to_string()),
+                    Token::Number(n, _) => modifiers.push(n),
+                    Token::SingleQuotedString(s) => modifiers.push(s),
 
                     Token::Comma => {
                         continue;
                     }
                     Token::RParen => {
                         break;
                     }
-                    unexpected => self.expected("type argument", unexpected)?,
+                    unexpected => self.expected("type modifiers", unexpected)?,
                 }
             }
 
-            Ok(Some(args))
+            Ok(Some(modifiers))
         } else {
             Ok(None)
         }