feat(cst): create CstType

- used in function signatures

- may represent a named type (`i8`) or a tuple type (`(i8, bool)`)

- `ast_gen` updated to enforce `CstType::Named` variant when lowering

Author: andogq

src/ir/cst.rs

@@ -4,6 +4,7 @@ pub use self::{
     expression::{BinaryOperation, UnaryOperation, *},
     function::*,
     statement::*,
+    ty::*,
     util::*,
 };
 
@@ -70,7 +71,7 @@ mod function {
         #[expect(dead_code, reason = "token field")]
         pub tok_colon: tok::Colon,
         /// Type of the parameter.
-        pub ty: tok::Ident,
+        pub ty: CstType,
     }
 
     /// Return type for a function declaration.
@@ -83,7 +84,7 @@ mod function {
         #[expect(dead_code, reason = "token field")]
         pub tok_thin_arrow: tok::ThinArrow,
         /// Return type.
-        pub ty: tok::Ident,
+        pub ty: CstType,
     }
 }
 
@@ -98,9 +99,45 @@ pub struct Block {
     pub tok_r_brace: tok::RBrace,
 }
 
-mod statement {
-    use crate::enum_conversion;
+/// Tuple of items. Used for both a tuple of [`Expression`], and a tuple of [`CstType`].
+#[derive(Clone, Debug)]
+pub struct Tuple<T> {
+    #[expect(dead_code, reason = "token field")]
+    pub tok_l_parenthesis: tok::LParenthesis,
+    pub items: PunctuatedList<T, tok::Comma>,
+    #[expect(dead_code, reason = "token field")]
+    pub tok_r_parenthesis: tok::RParenthesis,
+}
+
+mod ty {
+    use super::*;
+
+    /// A type, such as for parameters or variable declarations.
+    #[derive(Clone, Debug)]
+    pub enum CstType {
+        /// A named type represented with a single [`tok::Ident`], such as `i8`.
+        Named(tok::Ident),
+        /// A tuple type, composed of many inner [`CstType`]s.
+        Tuple(Tuple<CstType>),
+    }
+
+    impl CstType {
+        pub fn as_named(&self) -> &tok::Ident {
+            match self {
+                Self::Named(ident) => ident,
+                _ => panic!(),
+            }
+        }
+    }
 
+    enum_conversion! {
+        [CstType]
+        Named: tok::Ident,
+        Tuple: Tuple<CstType>,
+    }
+}
+
+mod statement {
     use super::*;
 
     /// A statement present within a [`Block`].
@@ -166,8 +203,6 @@ mod statement {
 }
 
 mod expression {
-    use crate::enum_conversion;
-
     use super::*;
 
     /// All possible expressions.
@@ -184,7 +219,7 @@ mod expression {
         Call(Call),
         Block(Block),
         Variable(Variable),
-        Tuple(Tuple),
+        Tuple(Tuple<Expression>),
     }
 
     /// Assignment.
@@ -392,16 +427,6 @@ mod expression {
         pub variable: tok::Ident,
     }
 
-    /// Tuple expression.
-    #[derive(Clone, Debug)]
-    pub struct Tuple {
-        #[expect(dead_code, reason = "token field")]
-        pub tok_l_parenthesis: tok::LParenthesis,
-        pub values: PunctuatedList<Expression, tok::Comma>,
-        #[expect(dead_code, reason = "token field")]
-        pub tok_r_parenthesis: tok::RParenthesis,
-    }
-
     enum_conversion! {
         [Expression]
         Assign: Assign,
@@ -414,7 +439,7 @@ mod expression {
         Call: Call,
         Block: Block,
         Variable: Variable,
-        Tuple: Tuple,
+        Tuple: Tuple<Expression>,
     }
 }
 

src/passes/ast_gen.rs

@@ -44,13 +44,13 @@ impl<'ctx> AstGen<'ctx> {
                 .iter_items()
                 .map(|parameter| FunctionParameter {
                     name: self.ctx.strings.intern(&parameter.name.0),
-                    ty: self.ctx.strings.intern(&parameter.ty.0),
+                    ty: self.ctx.strings.intern(&parameter.ty.as_named().0),
                 })
                 .collect(),
             return_ty: function
                 .return_ty
                 .as_ref()
-                .map(|ty| self.ctx.strings.intern(&ty.ty.0)),
+                .map(|ty| self.ctx.strings.intern(&ty.ty.as_named().0)),
             body: self.lower_block(&function.body),
         };
         self.ast.function_declarations.insert(function_declaration);

src/passes/cst_gen.rs

@@ -55,7 +55,7 @@ mod function {
                     .next_if()
                     .map(|tok_thin_arrow| cst::FunctionReturnType {
                         tok_thin_arrow,
-                        ty: lexer.expect().unwrap(),
+                        ty: cst::CstType::parse(lexer),
                     }),
                 body: cst::Block::parse(lexer),
             }
@@ -67,7 +67,7 @@ mod function {
             Self {
                 name: lexer.expect().unwrap(),
                 tok_colon: lexer.expect().unwrap(),
-                ty: lexer.expect().unwrap(),
+                ty: cst::CstType::parse(lexer),
             }
         }
     }
@@ -95,6 +95,68 @@ impl Parse for cst::Block {
     }
 }
 
+impl<T> cst::Tuple<T>
+where
+    T: Parse,
+{
+    /// Parse a tuple from an existing [`tok::LParenthesis`] and an optional first item with
+    /// it's [`tok::Comma`]. If an item isn't provided, it will still attempt to be parsed.
+    ///
+    /// The [`tok::Comma`] must be provided with an item to ensure that single-item tuples are
+    /// only accepted if they were terminated with a [`tok::Comma`].
+    fn parse_with_parts(
+        tok_l_parenthesis: tok::LParenthesis,
+        first_item: Option<(T, tok::Comma)>,
+        lexer: &mut Lexer,
+    ) -> Self {
+        Self {
+            tok_l_parenthesis,
+            items: {
+                // Parse out remaining values.
+                let mut values = cst::PunctuatedList::parse_while(lexer, |tok| {
+                    !matches!(tok, Tok::RParenthesis)
+                });
+
+                // Prepend the provided first expression.
+                if let Some((item, comma)) = first_item {
+                    values.items.insert(0, item);
+                    values.punctuation.insert(0, comma);
+                }
+
+                assert!(
+                    values.items.len() != 1 || values.has_trailing(),
+                    "if tuple is of length 1, it must end in a trailing comma"
+                );
+
+                values
+            },
+            tok_r_parenthesis: lexer.expect().unwrap(),
+        }
+    }
+}
+impl<T> Parse for cst::Tuple<T>
+where
+    T: Parse,
+{
+    fn parse(lexer: &mut Lexer<'_>) -> Self {
+        Self::parse_with_parts(lexer.expect().unwrap(), None, lexer)
+    }
+}
+
+mod ty {
+    use super::*;
+
+    impl Parse for cst::CstType {
+        fn parse(lexer: &mut Lexer<'_>) -> Self {
+            match lexer.peek() {
+                Tok::Ident(_) => lexer.expect::<tok::Ident>().unwrap().into(),
+                Tok::LParenthesis => cst::Tuple::parse(lexer).into(),
+                tok => panic!("unexpected tok when parsing type: {tok}"),
+            }
+        }
+    }
+}
+
 mod statement {
     use super::*;
 
@@ -461,50 +523,6 @@ mod expression {
             }
         }
     }
-
-    impl cst::Tuple {
-        /// Parse a tuple from an existing [`tok::LParenthesis`] and an optional first
-        /// [`cst::Expression`] with it's [`tok::Comma`]. If the expression isn't provided, it will
-        /// still attempt to be parsed.
-        ///
-        /// The [`tok::Comma`] must be provided with the [`cst::Expression`] to ensure that
-        /// single-expression tuples are only accepted if they were terminated with a
-        /// [`tok::Comma`].
-        fn parse_with_parts(
-            tok_l_parenthesis: tok::LParenthesis,
-            first_expression: Option<(cst::Expression, tok::Comma)>,
-            lexer: &mut Lexer,
-        ) -> Self {
-            Self {
-                tok_l_parenthesis,
-                values: {
-                    // Parse out remaining values.
-                    let mut values = cst::PunctuatedList::parse_while(lexer, |tok| {
-                        !matches!(tok, Tok::RParenthesis)
-                    });
-
-                    // Prepend the provided first expression.
-                    if let Some((expression, comma)) = first_expression {
-                        values.items.insert(0, expression);
-                        values.punctuation.insert(0, comma);
-                    }
-
-                    assert!(
-                        values.items.len() != 1 || values.has_trailing(),
-                        "if tuple is of length 1, it must end in a trailing comma"
-                    );
-
-                    values
-                },
-                tok_r_parenthesis: lexer.expect().unwrap(),
-            }
-        }
-    }
-    impl Parse for cst::Tuple {
-        fn parse(lexer: &mut Lexer<'_>) -> Self {
-            Self::parse_with_parts(lexer.expect().unwrap(), None, lexer)
-        }
-    }
 }
 
 mod util {
@@ -551,6 +569,56 @@ mod test {
         assert_eq!(lexer.next(), Tok::Eof)
     }
 
+    mod tuple {
+        use super::*;
+
+        #[rstest]
+        #[case("tuple_empty", "()")]
+        #[case("tuple_single_item_trailing_comma", "(1,)")]
+        #[case("tuple_many_items", "(1, 2, 3)")]
+        #[case("tuple_many_items_trailing_comma", "(1, 2, 3,)")]
+        fn tuple(#[case] name: &str, #[case] source: &str) {
+            test_with_lexer(source, |lexer| {
+                let tuple = cst::Tuple::<cst::Literal>::parse(lexer);
+                assert_debug_snapshot!(name, tuple, source);
+            });
+        }
+
+        #[rstest]
+        #[should_panic]
+        #[case::single_item_no_comma("(1)")]
+        fn tuple_failure(#[case] source: &str) {
+            test_with_lexer(source, |lexer| {
+                cst::Tuple::<cst::Literal>::parse(lexer);
+            });
+        }
+    }
+
+    mod ty {
+        use super::*;
+
+        #[rstest]
+        #[case("named_ident", "i8")]
+        #[case("tuple_empty", "()")]
+        #[case("tuple_single", "(i8,)")]
+        #[case("tuple_many", "(i8, bool, u8)")]
+        fn ty(#[case] name: &str, #[case] source: &str) {
+            test_with_lexer(source, |lexer| {
+                let ty = cst::CstType::parse(lexer);
+                assert_debug_snapshot!(name, ty, source);
+            });
+        }
+
+        #[rstest]
+        #[should_panic]
+        #[case::tuple_no_trailing_comma("(i8)")]
+        fn ty_failure(#[case] source: &str) {
+            test_with_lexer(source, |lexer| {
+                cst::CstType::parse(lexer);
+            });
+        }
+    }
+
     mod expression {
         use super::*;
 
@@ -688,27 +756,6 @@ mod test {
                 assert_debug_snapshot!(name, variable, source);
             });
         }
-
-        #[rstest]
-        #[case("tuple_empty", "()")]
-        #[case("tuple_single_item_trailing_comma", "(1,)")]
-        #[case("tuple_many_items", "(1, 2, 3)")]
-        #[case("tuple_many_items_trailing_comma", "(1, 2, 3,)")]
-        fn tuple(#[case] name: &str, #[case] source: &str) {
-            test_with_lexer(source, |lexer| {
-                let tuple = cst::Tuple::parse(lexer);
-                assert_debug_snapshot!(name, tuple, source);
-            });
-        }
-
-        #[rstest]
-        #[should_panic]
-        #[case::single_item_no_comma("(1)")]
-        fn tuple_failure(#[case] source: &str) {
-            test_with_lexer(source, |lexer| {
-                cst::Tuple::parse(lexer);
-            });
-        }
     }
 
     #[rstest]

src/passes/snapshots/lumina2__passes__cst_gen__test__expression__expression_tuple_empty.snap

@@ -5,7 +5,7 @@ expression: ()
 Tuple(
     Tuple {
         tok_l_parenthesis: LParenthesis,
-        values: PunctuatedList {
+        items: PunctuatedList {
             items: [],
             punctuation: [],
         },

src/passes/snapshots/lumina2__passes__cst_gen__test__expression__expression_tuple_many_values.snap

@@ -5,7 +5,7 @@ expression: "(1,2,3)"
 Tuple(
     Tuple {
         tok_l_parenthesis: LParenthesis,
-        values: PunctuatedList {
+        items: PunctuatedList {
             items: [
                 Literal(
                     Integer(

src/passes/snapshots/lumina2__passes__cst_gen__test__expression__expression_tuple_many_values_trailing.snap

@@ -5,7 +5,7 @@ expression: "(1,2,3,)"
 Tuple(
     Tuple {
         tok_l_parenthesis: LParenthesis,
-        values: PunctuatedList {
+        items: PunctuatedList {
             items: [
                 Literal(
                     Integer(

src/passes/snapshots/lumina2__passes__cst_gen__test__expression__expression_tuple_single_value.snap

@@ -5,7 +5,7 @@ expression: "(1,)"
 Tuple(
     Tuple {
         tok_l_parenthesis: LParenthesis,
-        values: PunctuatedList {
+        items: PunctuatedList {
             items: [
                 Literal(
                     Integer(