Keep the parentheses of an empty CREATE PROCEDURE parameter list

fuzz/fuzz_seeds/generic_procedure_empty_parameter_list.sql

@@ -0,0 +1 @@
+CREATE PROCEDURE p () AS BEGIN SELECT 1; END

src/ast/mod.rs

@@ -4577,7 +4577,7 @@ pub enum Statement {
         or_alter: bool,
         /// Procedure name.
         name: ObjectName,
-        /// Optional procedure parameters.
+        /// Parenthesized parameter list, `None` when absent.
         params: Option<Vec<ProcedureParam>>,
         /// Optional language identifier.
         language: Option<Ident>,
@@ -5591,9 +5591,7 @@ impl fmt::Display for Statement {
                 )?;
 
                 if let Some(p) = params {
-                    if !p.is_empty() {
-                        write!(f, " ({})", display_comma_separated(p))?;
-                    }
+                    write!(f, " ({})", display_comma_separated(p))?;
                 }
 
                 if let Some(language) = language {

src/parser/mod.rs

@@ -9940,8 +9940,11 @@ impl<'a> Parser<'a> {
     pub fn parse_optional_procedure_parameters(
         &mut self,
     ) -> Result<Option<Vec<ProcedureParam>>, ParserError> {
+        if !self.consume_token(&Token::LParen) {
+            return Ok(None);
+        }
         let mut params = vec![];
-        if !self.consume_token(&Token::LParen) || self.consume_token(&Token::RParen) {
+        if self.consume_token(&Token::RParen) {
             return Ok(Some(params));
         }
         loop {

tests/sqlparser_common.rs

@@ -19326,7 +19326,7 @@ fn parse_create_procedure_with_language() {
         } => {
             assert_eq!(or_alter, false);
             assert_eq!(name.to_string(), "test_proc");
-            assert_eq!(params, Some(vec![]));
+            assert_eq!(params, None);
             assert_eq!(
                 language,
                 Some(Ident {
@@ -22714,3 +22714,33 @@ fn parse_grantee_after_public() {
         ParserError::ParserError("Expected: identifier, found: EOF".to_string())
     );
 }
+
+#[test]
+fn parse_create_procedure_empty_parameter_list() {
+    verified_stmt("CREATE PROCEDURE p () AS BEGIN SELECT 1; END");
+    match verified_stmt("CREATE PROCEDURE p AS BEGIN SELECT 1; END") {
+        Statement::CreateProcedure { params, .. } => assert_eq!(params, None),
+        stmt => panic!("unexpected statement: {stmt:?}"),
+    }
+}
+
+#[test]
+fn display_create_procedure_parameter_list_propagates_write_errors() {
+    use core::fmt::{self, Write};
+
+    struct RejectingWriter(&'static str);
+
+    impl Write for RejectingWriter {
+        fn write_str(&mut self, value: &str) -> fmt::Result {
+            if value == self.0 {
+                Err(fmt::Error)
+            } else {
+                Ok(())
+            }
+        }
+    }
+
+    let statement = verified_stmt("CREATE PROCEDURE p () AS BEGIN SELECT 1; END");
+    let mut writer = RejectingWriter(" (");
+    assert_eq!(write!(writer, "{statement}"), Err(fmt::Error));
+}