(feat) Analyzer HIR Metadata Setup (#52)

## Problem

Setup code for the analyzer. The `HIR` gets wrapped with a metadata
field.

Illustration:

```rust
/// Metadata that can be attached to expression nodes
///
/// This trait allows for different types of metadata to be attached to
/// expression nodes while maintaining a common interface for access.
pub trait ExprMetadata: Debug + Clone {}

/// Empty metadata implementation for cases where no additional data is needed
pub struct NoMetadata;

/// Combined span and type information for an expression
pub struct TypedSpan {
    /// Source code location.
    pub span: Span,
    /// Inferred type.
    pub ty: Type,
}

/// Expression nodes in the HIR with optional metadata
///
/// The M type parameter allows attaching different kinds of metadata to expressions,
/// such as type information, source spans, or both.
pub struct Expr<M: ExprMetadata = NoMetadata> {
    /// The actual expression node
    pub kind: ExprKind<M>,
    /// Optional metadata for the expression
    pub metadata: M,
}
```

## Summary of changes

Adapted the engine to take EmptyMetadata (no functional changes), all
relevant code to review is in HIR.
The critical pass is that the metadata is all we should need to perform
type checking and inference.

This PR is dependent on #51

Author: AlSchlo

optd-dsl/src/analyzer/hir.rs

@@ -15,9 +15,11 @@
 //! unified representation that can be transformed into optimizer-specific
 //! intermediate representations through the bridge modules.
 
-use std::{collections::HashMap, sync::Arc};
-
 use super::context::Context;
+use super::r#type::Type;
+use crate::utils::span::Span;
+use std::fmt::Debug;
+use std::{collections::HashMap, sync::Arc};
 
 /// Unique identifier for variables, functions, types, etc.
 pub type Identifier = String;
@@ -190,25 +192,68 @@ pub enum CoreData<T> {
     None,
 }
 
-/// Expression nodes in the HIR
+/// Metadata that can be attached to expression nodes
+///
+/// This trait allows for different types of metadata to be attached to
+/// expression nodes while maintaining a common interface for access.
+pub trait ExprMetadata: Debug + Clone {}
+
+/// Empty metadata implementation for cases where no additional data is needed
+#[derive(Debug, Clone, Default)]
+pub struct NoMetadata;
+impl ExprMetadata for NoMetadata {}
+
+/// Combined span and type information for an expression
+#[derive(Debug, Clone)]
+pub struct TypedSpan {
+    /// Source code location.
+    pub span: Span,
+    /// Inferred type.
+    pub ty: Type,
+}
+impl ExprMetadata for TypedSpan {}
+
+/// Expression nodes in the HIR with optional metadata
+///
+/// The M type parameter allows attaching different kinds of metadata to expressions,
+/// such as type information, source spans, or both.
 #[derive(Debug, Clone)]
-pub enum Expr {
+pub struct Expr<M: ExprMetadata = NoMetadata> {
+    /// The actual expression node
+    pub kind: ExprKind<M>,
+    /// Optional metadata for the expression
+    pub metadata: M,
+}
+
+impl Expr<NoMetadata> {
+    /// Creates a new expression without metadata
+    pub fn new(kind: ExprKind<NoMetadata>) -> Self {
+        Self {
+            kind,
+            metadata: NoMetadata,
+        }
+    }
+}
+
+/// Expression node kinds without metadata
+#[derive(Debug, Clone)]
+pub enum ExprKind<M: ExprMetadata = NoMetadata> {
     /// Pattern matching expression
-    PatternMatch(Arc<Expr>, Vec<MatchArm>),
+    PatternMatch(Arc<Expr<M>>, Vec<MatchArm<M>>),
     /// Conditional expression
-    IfThenElse(Arc<Expr>, Arc<Expr>, Arc<Expr>),
+    IfThenElse(Arc<Expr<M>>, Arc<Expr<M>>, Arc<Expr<M>>),
     /// Variable binding
-    Let(Identifier, Arc<Expr>, Arc<Expr>),
+    Let(Identifier, Arc<Expr<M>>, Arc<Expr<M>>),
     /// Binary operation
-    Binary(Arc<Expr>, BinOp, Arc<Expr>),
+    Binary(Arc<Expr<M>>, BinOp, Arc<Expr<M>>),
     /// Unary operation
-    Unary(UnaryOp, Arc<Expr>),
+    Unary(UnaryOp, Arc<Expr<M>>),
     /// Function call
-    Call(Arc<Expr>, Vec<Arc<Expr>>),
+    Call(Arc<Expr<M>>, Vec<Arc<Expr<M>>>),
     /// Variable reference
     Ref(Identifier),
     /// Core expression
-    CoreExpr(CoreData<Arc<Expr>>),
+    CoreExpr(CoreData<Arc<Expr<M>>>),
     /// Core value
     CoreVal(Value),
 }
@@ -238,11 +283,11 @@ pub enum Pattern {
 
 /// Match arm combining pattern and expression
 #[derive(Debug, Clone)]
-pub struct MatchArm {
+pub struct MatchArm<M: ExprMetadata = NoMetadata> {
     /// Pattern to match against
     pub pattern: Pattern,
     /// Expression to evaluate if pattern matches
-    pub expr: Arc<Expr>,
+    pub expr: Arc<Expr<M>>,
 }
 
 /// Standard binary operators
@@ -269,7 +314,11 @@ pub enum UnaryOp {
 
 /// Program representation after the analysis phase
 #[derive(Debug)]
-pub struct HIR {
+pub struct HIR<M: ExprMetadata = NoMetadata> {
     pub context: Context,
     pub annotations: HashMap<Identifier, Vec<Annotation>>,
+    pub expressions: Vec<Expr<M>>,
 }
+
+/// Type alias for HIR with both type and source location information
+pub type TypedSpannedHIR = HIR<TypedSpan>;

optd-dsl/src/analyzer/mod.rs

@@ -1,4 +1,5 @@
 pub mod context;
 pub mod hir;
 pub mod semantic_checker;
+pub mod r#type;
 pub mod type_checker;

optd-dsl/src/analyzer/type_checker/type.rs renamed to optd-dsl/src/analyzer/type.rs

@@ -3,6 +3,7 @@ use std::{
     collections::{HashMap, HashSet},
     ops::{Deref, DerefMut},
 };
+
 pub type Identifier = String;
 
 /// Represents types in the language.

optd-dsl/src/analyzer/type_checker/mod.rs

@@ -1,2 +1 @@
 pub mod error;
-pub mod r#type;

optd-dsl/src/engine/eval/core.rs

@@ -161,10 +161,11 @@ mod tests {
     use crate::{
         analyzer::{
             context::Context,
-            hir::{CoreData, Expr, FunKind, Literal, Value},
+            hir::{CoreData, Expr, ExprKind, FunKind, Literal, Value},
         },
         engine::Engine,
     };
+    use ExprKind::*;
     use std::sync::Arc;
 
     /// Test evaluation of literal values
@@ -175,7 +176,7 @@ mod tests {
         let harness = TestHarness::new();
 
         // Create a literal expression
-        let literal_expr = Arc::new(Expr::CoreExpr(CoreData::Literal(int(42))));
+        let literal_expr = Arc::new(Expr::new(CoreExpr(CoreData::Literal(int(42)))));
         let results = evaluate_and_collect(literal_expr, engine, harness).await;
 
         // Check result
@@ -196,11 +197,11 @@ mod tests {
         let engine = Engine::new(ctx);
 
         // Create an array expression with values to evaluate
-        let array_expr = Arc::new(Expr::CoreExpr(CoreData::Array(vec![
+        let array_expr = Arc::new(Expr::new(CoreExpr(CoreData::Array(vec![
             lit_expr(int(1)),
             lit_expr(int(2)),
             lit_expr(int(3)),
-        ])));
+        ]))));
 
         let results = evaluate_and_collect(array_expr, engine, harness).await;
 
@@ -234,11 +235,11 @@ mod tests {
         let engine = Engine::new(ctx);
 
         // Create a tuple expression with mixed types
-        let tuple_expr = Arc::new(Expr::CoreExpr(CoreData::Tuple(vec![
+        let tuple_expr = Arc::new(Expr::new(CoreExpr(CoreData::Tuple(vec![
             lit_expr(int(42)),
             lit_expr(string("hello")),
             lit_expr(Literal::Bool(true)),
-        ])));
+        ]))));
 
         let results = evaluate_and_collect(tuple_expr, engine, harness).await;
 
@@ -272,10 +273,10 @@ mod tests {
         let engine = Engine::new(ctx);
 
         // Create a struct expression
-        let struct_expr = Arc::new(Expr::CoreExpr(CoreData::Struct(
+        let struct_expr = Arc::new(Expr::new(CoreExpr(CoreData::Struct(
             "Point".to_string(),
             vec![lit_expr(int(10)), lit_expr(int(20))],
-        )));
+        ))));
 
         let results = evaluate_and_collect(struct_expr, engine, harness).await;
 
@@ -306,11 +307,11 @@ mod tests {
         let engine = Engine::new(ctx);
 
         // Create a map expression
-        let map_expr = Arc::new(Expr::CoreExpr(CoreData::Map(vec![
+        let map_expr = Arc::new(Expr::new(CoreExpr(CoreData::Map(vec![
             (lit_expr(string("a")), lit_expr(int(1))),
             (lit_expr(string("b")), lit_expr(int(2))),
             (lit_expr(string("c")), lit_expr(int(3))),
-        ])));
+        ]))));
 
         let results = evaluate_and_collect(map_expr, engine, harness).await;
 
@@ -371,10 +372,10 @@ mod tests {
         let engine = Engine::new(ctx);
 
         // Create a function expression (just a simple closure)
-        let fn_expr = Arc::new(Expr::CoreExpr(CoreData::Function(FunKind::Closure(
+        let fn_expr = Arc::new(Expr::new(CoreExpr(CoreData::Function(FunKind::Closure(
             vec!["x".to_string()],
             lit_expr(int(42)), // Just returns 42 regardless of argument
-        ))));
+        )))));
 
         let results = evaluate_and_collect(fn_expr, engine, harness).await;
 
@@ -396,7 +397,7 @@ mod tests {
         let engine = Engine::new(ctx);
 
         // Create a null expression
-        let null_expr = Arc::new(Expr::CoreExpr(CoreData::None));
+        let null_expr = Arc::new(Expr::new(CoreExpr(CoreData::None)));
 
         let results = evaluate_and_collect(null_expr, engine, harness).await;
 
@@ -430,9 +431,9 @@ mod tests {
         let engine = Engine::new(ctx);
 
         // Create a fail expression with a message
-        let fail_expr = Arc::new(Expr::CoreExpr(CoreData::Fail(Box::new(Arc::new(
-            Expr::CoreVal(Value(CoreData::Literal(string("error message")))),
-        )))));
+        let fail_expr = Arc::new(Expr::new(CoreExpr(CoreData::Fail(Box::new(Arc::new(
+            Expr::new(CoreVal(Value(CoreData::Literal(string("error message"))))),
+        ))))));
 
         let results =
             evaluate_and_collect_with_custom_k(fail_expr, engine, harness, return_k).await;