feat: simple traits (#6)

Author: andogq

.cspell.json

@@ -2,7 +2,7 @@
     "version": "0.2",
     "language": "en-GB",
     "useGitignore": true,
-    "ignorePaths": [".cspell.json"],
+    "ignorePaths": [".cspell.json", "*.snap"],
     "words": [
         "color",
 

src/ir/ast.rs

@@ -1,3 +1,5 @@
+use std::collections::BTreeMap;
+
 use crate::prelude::*;
 
 pub use self::{block::*, expression::*, function::*, statement::*};
@@ -7,6 +9,7 @@ create_id!(ExpressionId);
 create_id!(FunctionId);
 create_id!(StatementId);
 create_id!(AstTypeId);
+create_id!(TraitId);
 
 #[derive(Clone, Debug)]
 pub struct Ast {
@@ -17,6 +20,12 @@ pub struct Ast {
     pub expressions: IndexedVec<ExpressionId, Expression>,
 
     pub types: IndexedVec<AstTypeId, AstType>,
+
+    /// Top-level function declarations.
+    pub item_functions: Vec<FunctionId>,
+
+    pub traits: IndexedVec<TraitId, Trait>,
+    pub trait_implementations: Vec<TraitImplementation>,
 }
 
 impl Ast {
@@ -27,6 +36,9 @@ impl Ast {
             statements: IndexedVec::new(),
             expressions: IndexedVec::new(),
             types: IndexedVec::new(),
+            item_functions: Vec::new(),
+            traits: IndexedVec::new(),
+            trait_implementations: Vec::new(),
         }
     }
 }
@@ -71,9 +83,19 @@ impl Index<AstTypeId> for Ast {
     }
 }
 
+impl Index<TraitId> for Ast {
+    type Output = Trait;
+
+    fn index(&self, index: TraitId) -> &Self::Output {
+        &self.traits[index]
+    }
+}
+
 /// Type representation used within the [`Ast`].
 #[derive(Clone, Debug)]
 pub enum AstType {
+    /// Built-in alias for the type where this type representation is used.
+    SelfType,
     /// A type referenced by a single interned name (eg. `i8`, `bool`).
     Named(StringId),
     /// A tuple type (`(i8, bool, u8)`).
@@ -84,10 +106,15 @@ mod function {
     use super::*;
 
     #[derive(Clone, Debug)]
-    pub struct FunctionDeclaration {
+    pub struct FunctionSignature {
         pub name: StringId,
         pub parameters: Vec<FunctionParameter>,
         pub return_ty: Option<AstTypeId>,
+    }
+
+    #[derive(Clone, Debug)]
+    pub struct FunctionDeclaration {
+        pub signature: FunctionSignature,
         pub body: BlockId,
     }
 
@@ -167,6 +194,7 @@ mod expression {
         Variable(Variable),
         Tuple(Tuple),
         Field(Field),
+        QualifiedPath(QualifiedPath),
     }
 
     #[derive(Clone, Debug)]
@@ -235,6 +263,13 @@ mod expression {
         Unnamed(usize),
     }
 
+    #[derive(Clone, Debug)]
+    pub struct QualifiedPath {
+        pub ty: AstTypeId,
+        pub name: StringId,
+        pub item: StringId,
+    }
+
     enum_conversion! {
         [Expression]
         Assign: Assign,
@@ -248,5 +283,21 @@ mod expression {
         Variable: Variable,
         Tuple: Tuple,
         Field: Field,
+        QualifiedPath: QualifiedPath,
     }
 }
+
+#[derive(Clone, Debug)]
+pub struct Trait {
+    /// Original name of the trait.
+    pub name: StringId,
+    /// Methods defined within the trait.
+    pub methods: BTreeMap<StringId, FunctionSignature>,
+}
+
+#[derive(Clone, Debug)]
+pub struct TraitImplementation {
+    pub trait_name: StringId,
+    pub target_ty: AstTypeId,
+    pub methods: BTreeMap<StringId, FunctionId>,
+}

src/ir/cst.rs

@@ -22,28 +22,83 @@ impl Program {
 
     pub fn add_function_declaration(&mut self, function_declaration: FunctionDeclaration) {
         self.items
-            .push(Item::FunctionDeclaration(function_declaration))
+            .push(Item::FunctionDeclaration(function_declaration));
+    }
+
+    pub fn add_trait_declaration(&mut self, trait_declaration: TraitDeclaration) {
+        self.items.push(Item::TraitDeclaration(trait_declaration));
+    }
+
+    pub fn add_trait_implementation(&mut self, trait_implementation: TraitImplementation) {
+        self.items
+            .push(Item::TraitImplementation(trait_implementation));
     }
 }
 
 /// A node which may appear at the top-level of a program.
 #[derive(Clone, Debug)]
 pub enum Item {
+    TraitDeclaration(TraitDeclaration),
+    TraitImplementation(TraitImplementation),
     FunctionDeclaration(FunctionDeclaration),
 }
 
+/// Trait declaration.
+///
+/// ```
+/// trait MyTrait {
+///     fn a() -> bool;
+///     fn b(n: i32);
+/// }
+/// ```
+#[derive(Clone, Debug)]
+pub struct TraitDeclaration {
+    #[expect(dead_code, reason = "token field")]
+    pub tok_trait: tok::Trait,
+    pub name: tok::Ident,
+    #[expect(dead_code, reason = "token field")]
+    pub tok_l_brace: tok::LBrace,
+    pub methods: Vec<(FunctionSignature, tok::SemiColon)>,
+    #[expect(dead_code, reason = "token field")]
+    pub tok_r_brace: tok::RBrace,
+}
+
+/// Trait implementation.
+///
+/// ```
+/// impl MyTrait for SomeType {
+///     fn a() -> bool {
+///         true
+///     }
+///
+///     fn b(n: 123) { }
+/// }
+/// ```
+#[derive(Clone, Debug)]
+pub struct TraitImplementation {
+    #[expect(dead_code, reason = "token field")]
+    pub tok_impl: tok::Impl,
+    pub name: tok::Ident,
+    #[expect(dead_code, reason = "named fields will be implemented with struct")]
+    pub tok_for: tok::For,
+    pub ty: CstType,
+    #[expect(dead_code, reason = "token field")]
+    pub tok_l_brace: tok::LBrace,
+    pub methods: Vec<FunctionDeclaration>,
+    #[expect(dead_code, reason = "token field")]
+    pub tok_r_brace: tok::RBrace,
+}
+
 mod function {
     use super::*;
 
-    /// Function declaration.
+    /// Function signature.
     ///
     /// ```
-    /// fn some_function(parameter_a: usize, parameter_b: bool) -> f64 {
-    ///     // Statements...
-    /// }
+    /// fn some_function(parameter_a: usize, parameter_b: bool) -> f64
     /// ```
     #[derive(Clone, Debug)]
-    pub struct FunctionDeclaration {
+    pub struct FunctionSignature {
         #[expect(dead_code, reason = "token field")]
         pub tok_fn: tok::Fn,
         /// Name of the function.
@@ -56,6 +111,20 @@ mod function {
         pub tok_r_parenthesis: tok::RParenthesis,
         /// Optional return type for the function.
         pub return_ty: Option<FunctionReturnType>,
+    }
+
+    /// Function declaration.
+    ///
+    /// ```
+    /// fn some_function(parameter_a: usize, parameter_b: bool) -> f64 {
+    ///     // Statements...
+    /// }
+    /// ```
+    #[derive(Clone, Debug)]
+    pub struct FunctionDeclaration {
+        /// Signature of the function.
+        pub signature: FunctionSignature,
+        /// Implementation of the function.
         pub body: Block,
     }
 
@@ -212,6 +281,7 @@ mod expression {
         Variable(Variable),
         Tuple(Tuple<Expression>),
         Field(Field),
+        QualifiedPath(QualifiedPath),
     }
 
     /// Assignment.
@@ -425,6 +495,29 @@ mod expression {
         Named(tok::Ident),
     }
 
+    /// Qualified path.
+    ///
+    /// ```
+    /// <Ty as Trait>::item
+    /// ```
+    #[derive(Clone, Debug)]
+    pub struct QualifiedPath {
+        #[expect(dead_code, reason = "named fields will be implemented with struct")]
+        pub tok_l_angle: tok::LAngle,
+        /// Self qualifier.
+        pub ty: CstType,
+        #[expect(dead_code, reason = "named fields will be implemented with struct")]
+        pub tok_as: tok::As,
+        /// Qualification.
+        pub name: tok::Ident,
+        #[expect(dead_code, reason = "named fields will be implemented with struct")]
+        pub tok_r_angle: tok::RAngle,
+        #[expect(dead_code, reason = "named fields will be implemented with struct")]
+        pub tok_colon_colon: tok::ColonColon,
+        /// Path item.
+        pub item: tok::Ident,
+    }
+
     enum_conversion! {
         [Expression]
         Assign: Assign,
@@ -439,6 +532,7 @@ mod expression {
         Variable: Variable,
         Tuple: Tuple<Expression>,
         Field: Field,
+        QualifiedPath: QualifiedPath,
     }
 }