♻️ Adopt hybrid architecture: NodeId + side table for expression types

Replace `inferred_type: Option<StaticType>` on `ExpressionLocation` with
a `NodeId` identity field and an `AnalysisResult` side table in the
analyser. This follows the hybrid pattern: compilation-critical data
(bindings, captures) stays on the AST; tooling-specific data (expression
types) lives in a side table keyed by NodeId.

- Add `NodeId` with atomic counter to ndc_parser
- Add `AnalysisResult { expr_types: HashMap<NodeId, StaticType> }` to
  ndc_analyser, populated during analysis via `take_result()`
- LSP reads expression types from the side table via NodeId lookup

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Author: timfennis

ndc_analyser/src/analyser.rs

@@ -1,9 +1,19 @@
+use std::collections::HashMap;
+use std::fmt::Debug;
+
 use crate::scope::ScopeTree;
 use itertools::Itertools;
 use ndc_core::{StaticType, TypeSignature};
 use ndc_lexer::Span;
-use ndc_parser::{Binding, Expression, ExpressionLocation, ForBody, ForIteration, Lvalue};
-use std::fmt::Debug;
+use ndc_parser::{Binding, Expression, ExpressionLocation, ForBody, ForIteration, Lvalue, NodeId};
+
+/// Side table holding semantic information keyed by AST node identity.
+/// Keeps tooling-specific data (like per-expression types) out of the AST.
+#[derive(Debug, Default)]
+pub struct AnalysisResult {
+    /// Maps each expression node to its inferred result type.
+    pub expr_types: HashMap<NodeId, StaticType>,
+}
 
 #[derive(Debug)]
 pub struct Analyser {
@@ -12,13 +22,16 @@ pub struct Analyser {
     /// Pushed on function entry, popped on exit. The value accumulates the
     /// lub of all `return <expr>` types seen so far.
     return_type_stack: Vec<Option<StaticType>>,
+    /// Side table populated during analysis.
+    result: AnalysisResult,
 }
 
 impl Analyser {
     pub fn from_scope_tree(scope_tree: ScopeTree) -> Self {
         Self {
             scope_tree,
             return_type_stack: Vec::new(),
+            result: AnalysisResult::default(),
         }
     }
 
@@ -30,13 +43,18 @@ impl Analyser {
         self.scope_tree = checkpoint;
     }
 
+    /// Take the accumulated analysis result, resetting it for the next analysis.
+    pub fn take_result(&mut self) -> AnalysisResult {
+        std::mem::take(&mut self.result)
+    }
+
     pub fn analyse(
         &mut self,
         expr_loc: &mut ExpressionLocation,
     ) -> Result<StaticType, AnalysisError> {
-        let result = self.analyse_inner(expr_loc)?;
-        expr_loc.inferred_type = Some(result.clone());
-        Ok(result)
+        let typ = self.analyse_inner(expr_loc)?;
+        self.result.expr_types.insert(expr_loc.id, typ.clone());
+        Ok(typ)
     }
 
     fn analyse_inner(

ndc_analyser/src/lib.rs

@@ -1,5 +1,5 @@
 mod analyser;
 mod scope;
 
-pub use analyser::{Analyser, AnalysisError};
+pub use analyser::{Analyser, AnalysisError, AnalysisResult};
 pub use scope::ScopeTree;

ndc_interpreter/src/lib.rs

@@ -7,6 +7,7 @@ use ndc_vm::value::CompiledFunction;
 use ndc_vm::{OutputSink, Vm};
 use std::rc::Rc;
 
+pub use ndc_analyser::AnalysisResult;
 #[cfg(feature = "trace")]
 pub use ndc_vm::tracer;
 pub use ndc_vm::{NativeFunction, Value};
@@ -92,9 +93,11 @@ impl Interpreter {
     pub fn analyse_str(
         &mut self,
         input: &str,
-    ) -> Result<Vec<ExpressionLocation>, InterpreterError> {
+    ) -> Result<(Vec<ExpressionLocation>, AnalysisResult), InterpreterError> {
         let source_id = self.source_db.add("<input>", input);
-        self.parse_and_analyse(input, source_id)
+        let expressions = self.parse_and_analyse(input, source_id)?;
+        let result = self.analyser.take_result();
+        Ok((expressions, result))
     }
 
     pub fn compile_str(&mut self, input: &str) -> Result<CompiledFunction, InterpreterError> {

ndc_lsp/src/backend.rs

@@ -75,7 +75,9 @@ impl Backend {
             interpreter
                 .analyse_str(text)
                 .ok()
-                .map(|expressions| inlay_hints::collect(&expressions, text))
+                .map(|(expressions, analysis_result)| {
+                    inlay_hints::collect(&expressions, &analysis_result, text)
+                })
         };
 
         // Only update document state when analysis succeeds. On failure (e.g.

ndc_lsp/src/features/inlay_hints.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 
 use ndc_core::StaticType;
+use ndc_interpreter::AnalysisResult;
 use ndc_lexer::Span;
 use ndc_parser::ExpressionLocation;
 use tower_lsp::lsp_types::{InlayHint, InlayHintKind, InlayHintLabel};
@@ -12,15 +13,20 @@ use crate::visitor::{AstVisitor, walk_ast};
 pub struct AnalysisInfo {
     pub hints: Vec<InlayHint>,
     pub variable_types: HashMap<String, StaticType>,
-    /// Maps expression end offset → inferred type for dot-completion on
+    /// Maps expression end offset -> inferred type for dot-completion on
     /// arbitrary expressions (e.g. `read_file("foo").`).
     pub expression_types: HashMap<usize, StaticType>,
 }
 
 /// Collect inlay hints, variable types, and expression types from an analysed AST.
-pub fn collect(expressions: &[ExpressionLocation], text: &str) -> AnalysisInfo {
+pub fn collect(
+    expressions: &[ExpressionLocation],
+    analysis_result: &AnalysisResult,
+    text: &str,
+) -> AnalysisInfo {
     let mut collector = HintCollector {
         text,
+        analysis_result,
         hints: Vec::new(),
         variable_types: HashMap::new(),
         expression_types: HashMap::new(),
@@ -35,14 +41,15 @@ pub fn collect(expressions: &[ExpressionLocation], text: &str) -> AnalysisInfo {
 
 struct HintCollector<'a> {
     text: &'a str,
+    analysis_result: &'a AnalysisResult,
     hints: Vec<InlayHint>,
     variable_types: HashMap<String, StaticType>,
     expression_types: HashMap<usize, StaticType>,
 }
 
 impl AstVisitor for HintCollector<'_> {
     fn on_expression(&mut self, expr: &ExpressionLocation) {
-        if let Some(typ) = &expr.inferred_type {
+        if let Some(typ) = self.analysis_result.expr_types.get(&expr.id) {
             self.expression_types.insert(expr.span.end(), typ.clone());
         }
     }

ndc_parser/src/expression.rs

@@ -4,6 +4,20 @@ use ndc_core::{StaticType, TypeSignature};
 use ndc_lexer::Span;
 use num::BigInt;
 use num::complex::Complex64;
+use std::sync::atomic::{AtomicU32, Ordering};
+
+/// Unique identity for an AST node. Used as a key in side tables (e.g. the
+/// analyser's expression type map) so that tooling data doesn't bloat the AST.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct NodeId(pub u32);
+
+static NEXT_NODE_ID: AtomicU32 = AtomicU32::new(0);
+
+impl NodeId {
+    pub fn next() -> Self {
+        Self(NEXT_NODE_ID.fetch_add(1, Ordering::Relaxed))
+    }
+}
 
 #[derive(Debug, Eq, PartialEq, Clone)]
 pub enum Binding {
@@ -35,10 +49,9 @@ pub enum CaptureSource {
 
 #[derive(Eq, PartialEq, Clone, Debug)]
 pub struct ExpressionLocation {
+    pub id: NodeId,
     pub expression: Expression,
     pub span: Span,
-    /// Filled by the semantic analyser with the inferred result type of this expression.
-    pub inferred_type: Option<StaticType>,
 }
 
 #[derive(Debug, PartialEq, Clone)]
@@ -183,9 +196,9 @@ impl Expression {
     #[must_use]
     pub fn to_location(self, span: Span) -> ExpressionLocation {
         ExpressionLocation {
+            id: NodeId::next(),
             expression: self,
             span,
-            inferred_type: None,
         }
     }
 }
@@ -194,9 +207,9 @@ impl ExpressionLocation {
     #[must_use]
     pub fn to_statement(self) -> Self {
         Self {
+            id: NodeId::next(),
             span: self.span,
             expression: Expression::Statement(Box::new(self)),
-            inferred_type: None,
         }
     }
 

ndc_parser/src/lib.rs

@@ -3,7 +3,7 @@ mod operator;
 mod parser;
 
 pub use expression::{
-    Binding, CaptureSource, Expression, ExpressionLocation, ForBody, ForIteration, Lvalue,
+    Binding, CaptureSource, Expression, ExpressionLocation, ForBody, ForIteration, Lvalue, NodeId,
     ResolvedVar,
 };
 pub use operator::{BinaryOperator, LogicalOperator, UnaryOperator};

ndc_parser/src/parser.rs

@@ -1,7 +1,7 @@
 use std::fmt::Write;
 
 use crate::expression::Expression;
-use crate::expression::{Binding, ExpressionLocation, ForBody, ForIteration, Lvalue};
+use crate::expression::{Binding, ExpressionLocation, ForBody, ForIteration, Lvalue, NodeId};
 use crate::operator::{BinaryOperator, LogicalOperator, UnaryOperator};
 use ndc_core::{Parameter, StaticType, TypeSignature};
 use ndc_lexer::{Span, Token, TokenLocation};
@@ -421,7 +421,7 @@ impl Parser {
                 values: expressions,
             },
             span: new_span,
-            inferred_type: None,
+            id: NodeId::next(),
         };
 
         if must_be_tuple {
@@ -519,7 +519,7 @@ impl Parser {
             Ok(ExpressionLocation {
                 expression,
                 span,
-                inferred_type: None,
+                id: NodeId::next(),
             })
         } else {
             Ok(left)
@@ -653,7 +653,7 @@ impl Parser {
                             arguments,
                         },
                         span: span.merge(arguments_span),
-                        inferred_type: None,
+                        id: NodeId::next(),
                     };
                 }
                 Token::Dot => {
@@ -698,7 +698,7 @@ impl Parser {
                         span: tuple_span
                             .unwrap_or(identifier_span)
                             .merge(first_argument_span),
-                        inferred_type: None,
+                        id: NodeId::next(),
                     }
 
                     // for now, we require parentheses
@@ -763,7 +763,7 @@ impl Parser {
                             arguments: vec![expr, index_expression],
                         },
                         span,
-                        inferred_type: None,
+                        id: NodeId::next(),
                     };
                 }
                 _ => unreachable!("guaranteed to match"),
@@ -1194,7 +1194,7 @@ impl Parser {
                 pure: is_pure,
             },
             span,
-            inferred_type: None,
+            id: NodeId::next(),
         })
     }