PostgreSQL: Support the VARIADIC function call argument marker

`pg_get_viewdef` writes the marker into stock system views, so
introspecting `pg_catalog` failed on `pg_publication_tables`:

    SELECT concat(VARIADIC a)
    -- Expected: ), found: a at Line: 1, Column: 24

The marker is represented additively as `FunctionArg::Variadic`, which
wraps any argument so the named form `f(VARIADIC a => ARRAY[1])` that
PostgreSQL's grammar accepts is preserved too. Parsing is gated on the
new `Dialect::supports_variadic_function_argument`, enabled for
PostgreSQL and the generic dialect.

PostgreSQL reserves the keyword, so there the marker is unambiguous.
Where it is unreserved, the ordinary reading is parsed first and kept
whenever the argument stands on its own, leaving `f(variadic)` and
`f(variadic + 1)` untouched. A clause keyword only ends that reading
when its own syntax follows, so `f(VARIADIC separator)` still marks the
operand while `array_agg(variadic ORDER BY x)` does not.

As in PostgreSQL, the marker is rejected on a wildcard operand, in
combination with `DISTINCT` or `ALL`, and on any but the final argument.
The last check runs in the enclosing argument-list parsers, so the comma
before a table function's `SETTINGS` clause is not read as an argument.

Author: LucaCappelletti94

src/ast/mod.rs

@@ -8088,6 +8088,14 @@ pub enum FunctionArg {
     },
     /// An unnamed argument (positional), given by expression or wildcard.
     Unnamed(FunctionArgExpr),
+    /// An argument carrying PostgreSQL's `VARIADIC` marker, e.g.
+    /// `concat(VARIADIC ARRAY['a', 'b'])`. Only the final argument of a call
+    /// may carry it.
+    ///
+    /// Enabled when `Dialect::supports_variadic_function_argument` returns `true`.
+    ///
+    /// [PostgreSQL](https://www.postgresql.org/docs/current/xfunc-sql.html#XFUNC-SQL-VARIADIC-FUNCTIONS)
+    Variadic(Box<FunctionArg>),
 }
 
 impl fmt::Display for FunctionArg {
@@ -8104,6 +8112,7 @@ impl fmt::Display for FunctionArg {
                 operator,
             } => fmt_named_function_arg(f, name, operator, arg),
             FunctionArg::Unnamed(unnamed_arg) => write!(f, "{unnamed_arg}"),
+            FunctionArg::Variadic(arg) => write!(f, "VARIADIC {arg}"),
         }
     }
 }

src/ast/spans.rs

@@ -2194,6 +2194,7 @@ impl Spanned for FunctionArg {
                 arg,
                 operator: _,
             } => name.span().union(&arg.span()),
+            FunctionArg::Variadic(arg) => arg.span(),
         }
     }
 }

src/dialect/generic.rs

@@ -320,4 +320,8 @@ impl Dialect for GenericDialect {
     fn supports_aliased_function_args(&self) -> bool {
         true
     }
+
+    fn supports_variadic_function_argument(&self) -> bool {
+        true
+    }
 }

src/dialect/mod.rs

@@ -1852,6 +1852,16 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if the dialect supports the `VARIADIC` marker on the final
+    /// argument of a function call, e.g. `concat(VARIADIC ARRAY['a', 'b'])`.
+    ///
+    /// When this returns false, `VARIADIC` is treated as a regular identifier.
+    ///
+    /// [PostgreSQL](https://www.postgresql.org/docs/current/xfunc-sql.html#XFUNC-SQL-VARIADIC-FUNCTIONS)
+    fn supports_variadic_function_argument(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialect supports `USING <format>` in `CREATE TABLE`.
     ///
     /// Example:

src/dialect/postgresql.rs

@@ -98,10 +98,12 @@ impl Dialect for PostgreSqlDialect {
     }
 
     fn is_reserved_for_identifier(&self, kw: Keyword) -> bool {
-        if matches!(kw, Keyword::INTERVAL) {
-            false
-        } else {
-            RESERVED_FOR_IDENTIFIER.contains(&kw)
+        match kw {
+            Keyword::INTERVAL => false,
+            // PostgreSQL reserves `VARIADIC`, so inside a call it always
+            // introduces the argument marker rather than a column of that name.
+            Keyword::VARIADIC => true,
+            _ => RESERVED_FOR_IDENTIFIER.contains(&kw),
         }
     }
 
@@ -361,6 +363,10 @@ impl Dialect for PostgreSqlDialect {
         true
     }
 
+    fn supports_variadic_function_argument(&self) -> bool {
+        true
+    }
+
     /// Postgres supports query optimizer hints via the `pg_hint_plan` extension,
     /// using the same comment-prefixed-with-`+` syntax as MySQL and Oracle.
     ///

src/parser/mod.rs

@@ -18828,8 +18828,100 @@ impl<'a> Parser<'a> {
         }
     }
 
-    /// Parse a single function argument, handling named and unnamed variants.
+    /// Parse a single function argument, handling the `VARIADIC` marker as well
+    /// as named and unnamed variants.
+    ///
+    /// Dialects that reserve `VARIADIC`, such as PostgreSQL, always mean the
+    /// marker. Where the keyword is unreserved, `f(variadic)` passes a column
+    /// of that name instead, so the ordinary reading is parsed first and kept
+    /// whenever it stands as an argument on its own; `f(VARIADIC a)` is left as
+    /// the only reading that takes the marker.
     pub fn parse_function_args(&mut self) -> Result<FunctionArg, ParserError> {
+        if self.dialect.supports_variadic_function_argument()
+            && self.peek_keyword(Keyword::VARIADIC)
+        {
+            if !self.dialect.is_reserved_for_identifier(Keyword::VARIADIC) {
+                let plain = self.maybe_parse(|p| {
+                    let arg = p.parse_plain_function_args()?;
+                    if p.peek_ends_function_arg() {
+                        Ok(arg)
+                    } else {
+                        p.expected_ref("end of the function argument", p.peek_token_ref())
+                    }
+                })?;
+                if let Some(arg) = plain {
+                    return Ok(arg);
+                }
+            }
+
+            let loc = self.peek_token_ref().span.start;
+            self.expect_keyword(Keyword::VARIADIC)?;
+            let arg = self.parse_plain_function_args()?;
+            // PostgreSQL's VARIADIC productions require expression operands,
+            // so no wildcard argument form is valid.
+            let carries_wildcard = match &arg {
+                FunctionArg::Unnamed(arg)
+                | FunctionArg::Named { arg, .. }
+                | FunctionArg::ExprNamed { arg, .. } => !matches!(arg, FunctionArgExpr::Expr(_)),
+                FunctionArg::Variadic(_) => false,
+            };
+            if carries_wildcard {
+                return parser_err!("A VARIADIC argument cannot be a wildcard", loc);
+            }
+            return Ok(FunctionArg::Variadic(Box::new(arg)));
+        }
+        self.parse_plain_function_args()
+    }
+
+    /// Returns true when the next token can follow a complete function
+    /// argument: the argument separator, the end of the list, or a complete
+    /// clause that [`Parser::parse_function_argument_list`] accepts after the
+    /// arguments. A clause keyword whose own syntax does not follow is an
+    /// operand instead, as in `f(VARIADIC separator)`.
+    fn peek_ends_function_arg(&self) -> bool {
+        let word = match &self.peek_token_ref().token {
+            Token::Comma | Token::RParen => return true,
+            Token::Word(word) => word,
+            _ => return false,
+        };
+        let next = &self.peek_nth_token_ref(1).token;
+        let next_is = |keyword| matches!(next, Token::Word(next) if next.keyword == keyword);
+        match word.keyword {
+            Keyword::ORDER => next_is(Keyword::BY),
+            Keyword::IGNORE | Keyword::RESPECT => next_is(Keyword::NULLS),
+            // `ON OVERFLOW`, and the `ABSENT ON NULL` / `NULL ON NULL` clauses.
+            Keyword::ON => next_is(Keyword::OVERFLOW),
+            Keyword::ABSENT | Keyword::NULL => next_is(Keyword::ON),
+            Keyword::HAVING => next_is(Keyword::MIN) || next_is(Keyword::MAX),
+            // These take an expression, a value or a type of their own.
+            Keyword::LIMIT | Keyword::RETURNING | Keyword::SEPARATOR | Keyword::WHERE => {
+                !matches!(next, Token::Comma | Token::RParen)
+            }
+            _ => false,
+        }
+    }
+
+    /// Rejects a `VARIADIC` marker on any but the final argument, as
+    /// PostgreSQL's grammar carries it on the last one only.
+    fn verify_variadic_argument_is_last(args: &[FunctionArg]) -> Result<(), ParserError> {
+        let Some((_, preceding)) = args.split_last() else {
+            return Ok(());
+        };
+        match preceding
+            .iter()
+            .find(|arg| matches!(arg, FunctionArg::Variadic(_)))
+        {
+            Some(arg) => parser_err!(
+                "A VARIADIC argument must be the last function argument",
+                arg.span().start
+            ),
+            None => Ok(()),
+        }
+    }
+
+    /// Parse a single function argument carrying no `VARIADIC` marker,
+    /// handling named and unnamed variants.
+    fn parse_plain_function_args(&mut self) -> Result<FunctionArg, ParserError> {
         // Parse the argument expression once, then check for a named-arg
         // operator. Parsing it speculatively and re-parsing on the unnamed
         // path is O(2^depth) on nested calls like `CAST(CASE (CAST(CASE (…`.
@@ -18954,6 +19046,7 @@ impl<'a> Parser<'a> {
             Ok(vec![])
         } else {
             let args = self.parse_comma_separated(Parser::parse_function_args)?;
+            Self::verify_variadic_argument_is_last(&args)?;
             self.expect_token(&Token::RParen)?;
             Ok(args)
         }
@@ -18976,6 +19069,7 @@ impl<'a> Parser<'a> {
                 break None;
             }
         };
+        Self::verify_variadic_argument_is_last(&args)?;
         self.expect_token(&Token::RParen)?;
         Ok(TableFunctionArgs { args, settings })
     }
@@ -19011,8 +19105,18 @@ impl<'a> Parser<'a> {
             });
         }
 
+        let loc = self.peek_token_ref().span.start;
         let duplicate_treatment = self.parse_duplicate_treatment()?;
         let args = self.parse_comma_separated(Parser::parse_function_args)?;
+        Self::verify_variadic_argument_is_last(&args)?;
+
+        // PostgreSQL pairs the marker with neither `DISTINCT` nor `ALL`.
+        if duplicate_treatment.is_some() && matches!(args.last(), Some(FunctionArg::Variadic(_))) {
+            return parser_err!(
+                "A VARIADIC argument cannot be combined with DISTINCT or ALL",
+                loc
+            );
+        }
 
         if self.parse_keyword(Keyword::WHERE) {
             clauses.push(FunctionArgumentClause::Where(self.parse_expr()?));