cl-ast: Let Ty handle the complexities of VariantKind::Tuple's type list

cl-ast/src/ast_impl.rs

@@ -251,7 +251,7 @@ mod display {
             match self {
                 VariantKind::Plain => Ok(()),
                 VariantKind::CLike(n) => write!(f, " = {n}"),
-                VariantKind::Tuple(v) => delimit(separate(v, ", "), INLINE_PARENS)(f),
+                VariantKind::Tuple(v) => v.fmt(f),
                 VariantKind::Struct(v) => delimit(separate(v, ", "), INLINE_BRACES)(f),
             }
         }

cl-ast/src/lib.rs

@@ -197,7 +197,7 @@ pub struct Variant {
 pub enum VariantKind {
     Plain,
     CLike(u128),
-    Tuple(Vec<Ty>),
+    Tuple(Ty),
     Struct(Vec<StructMember>),
 }
 

cl-parser/src/parser.rs

@@ -565,11 +565,15 @@ impl<'t> Parser<'t> {
     /// Parses a [tuple-like](VariantKind::Tuple) [`enum`](Enum) [Variant]
     pub fn variantkind_tuple(&mut self) -> PResult<VariantKind> {
         const PARSING: Parsing = Parsing::VariantKind;
-        Ok(VariantKind::Tuple(delim(
-            sep(Self::ty, Punct::Comma, Punct::RParen, PARSING),
-            PARENS,
-            PARSING,
-        )(self)?))
+        let tup = self.ty()?;
+        if !matches!(tup.kind, TyKind::Tuple(_) | TyKind::Empty) {
+            Err(self.error(
+                ErrorKind::ExpectedParsing { want: Parsing::TyTuple },
+                PARSING,
+            ))?
+        }
+
+        Ok(VariantKind::Tuple(tup))
     }
 
     pub fn parse_impl(&mut self) -> PResult<Impl> {