Generalize interpreter traversal over CFG, Block, DiGraph, and UnGraph bodies

Cargo.toml

@@ -115,10 +115,14 @@ kirin-bitwise = { workspace = true }
 kirin-cf = { workspace = true }
 kirin-cmp = { workspace = true }
 kirin-constant = { workspace = true }
+kirin-constprop = { workspace = true }
 kirin-function = { workspace = true }
 kirin-scf = { workspace = true }
+kirin-interpreter = { workspace = true, features = ["derive"] }
 kirin-test-languages = { workspace = true, features = [
   "arith-function-language",
+  "graph-function-language",
+  "interpreter",
   "bitwise-function-language",
   "callable-language",
   "namespaced-language",

crates/kirin-chumsky/src/function_text/error.rs

@@ -9,7 +9,7 @@ pub enum FunctionParseErrorKind {
     UnknownStage,
     InconsistentFunctionName,
     MissingStageDeclaration,
-    BodyParseFailed,
+    DefinitionParseFailed,
     EmitFailed,
 }
 
@@ -24,7 +24,9 @@ impl Display for FunctionParseErrorKind {
             FunctionParseErrorKind::MissingStageDeclaration => {
                 write!(f, "missing stage declaration")
             }
-            FunctionParseErrorKind::BodyParseFailed => write!(f, "function body parse failed"),
+            FunctionParseErrorKind::DefinitionParseFailed => {
+                write!(f, "function definition parse failed")
+            }
             FunctionParseErrorKind::EmitFailed => write!(f, "IR emission failed"),
         }
     }

crates/kirin-chumsky/src/function_text/parse_text.rs

@@ -15,10 +15,10 @@
 //!    - collect `(stage, function) -> staged_function` mappings;
 //!    - record offsets of `specialize` declarations for pass 2.
 //!
-//! 2. **Pass 2 (specialize bodies)**
+//! 2. **Pass 2 (specialization definitions)**
 //!    - re-parse only the previously recorded `specialize` declarations;
 //!    - resolve the target staged function from the pass-1 lookup;
-//!    - emit specialization bodies into the resolved stage dialect.
+//!    - emit specialization definitions into the resolved stage dialect.
 //!
 //! This separation guarantees that specialization emission sees a complete
 //! staged-function header set, which keeps behavior deterministic even when
@@ -27,7 +27,7 @@
 //! ## Why stage dispatch is central
 //!
 //! A pipeline can contain different dialects per stage (for example stage `A`
-//! with `FunctionBody`, stage `B` with `LowerBody`). The parser does not guess
+//! with `FunctionDefinition`, stage `B` with `LowerDefinition`). The parser does not guess
 //! which dialect to use from text alone. Instead it:
 //!
 //! - resolves/creates the stage symbol first (`@A`, `@B`, ...);
@@ -39,7 +39,7 @@
 //!
 //! ## Illustrative examples
 //!
-//! Same-stage header + body:
+//! Same-stage header + definition:
 //!
 //! ```text
 //! stage @A fn @foo(()) -> ();
@@ -275,7 +275,7 @@ where
 
     let Declaration::Specialize {
         stage: _stage_sym,
-        body_span,
+        definition_span,
         span,
     } = declaration
     else {
@@ -286,7 +286,7 @@ where
         ));
     };
 
-    let body_text = &ctx.src[body_span.start..body_span.end];
+    let definition_text = &ctx.src[definition_span.start..definition_span.end];
 
     // Use the function name from parse_declaration_head (always available),
     // not from the chumsky Declaration (empty for dialect-controlled format).
@@ -300,7 +300,7 @@ where
         stage_id,
         &function_name,
         ctx.function_symbol,
-        body_text,
+        definition_text,
         span,
         &mut *ctx.function_lookup,
         &mut *ctx.staged_lookup,
@@ -607,7 +607,7 @@ fn apply_specialize_declaration<L>(
     stage_id: CompileStage,
     function_name: &SymbolName<'_>,
     function_symbol: GlobalSymbol,
-    body_text: &str,
+    definition_text: &str,
     span: SimpleSpan,
     function_lookup: &mut FxHashMap<String, Function>,
     staged_lookup: &mut FxHashMap<StagedKey, StagedFunction>,
@@ -617,14 +617,14 @@ where
     L: Dialect + ParseEmit<L> + kirin_ir::HasSignature<L>,
     L::Type: kirin_ir::Placeholder,
 {
-    // Parse and emit the body first — we need it to extract signature if needed
-    let body_statement = stage
+    // Parse and emit the definition first — we need it to extract the signature.
+    let definition = stage
         .with_builder(|builder| {
             let mut emit_ctx = EmitContext::new(builder);
-            L::parse_and_emit(body_text, &mut emit_ctx).map_err(|err| {
+            L::parse_and_emit(definition_text, &mut emit_ctx).map_err(|err| {
                 let (kind, message) = match &err {
                     crate::ChumskyError::Parse(errs) => (
-                        FunctionParseErrorKind::BodyParseFailed,
+                        FunctionParseErrorKind::DefinitionParseFailed,
                         errs.iter()
                             .map(|e| e.to_string())
                             .collect::<Vec<_>>()
@@ -645,11 +645,11 @@ where
             )
         })?;
 
-    // Get signature from HasSignature on the body statement.
+    // Get the signature from HasSignature on the definition statement.
     // The Signature field is populated by the statement parser from format string elements.
-    let def = body_statement.expect_info(stage).definition();
-    let signature = def.signature().unwrap_or_else(|| {
-        // Fallback: create a placeholder signature if the body type
+    let definition_value = definition.expect_info(stage).definition();
+    let signature = definition_value.signature().unwrap_or_else(|| {
+        // Fallback: create a placeholder signature if the definition type
         // doesn't carry one (e.g., no Signature field).
         kirin_ir::Signature::placeholder()
     });
@@ -673,7 +673,7 @@ where
                 .specialize()
                 .staged_func(staged_function)
                 .signature(signature.clone())
-                .body(body_statement)
+                .definition(definition)
                 .new()
                 .map_err(|err| {
                     FunctionParseError::new(

crates/kirin-chumsky/src/function_text/syntax.rs

@@ -24,8 +24,8 @@ pub(super) enum Declaration<'src, T> {
     Stage(Header<'src, T>),
     Specialize {
         stage: SymbolName<'src>,
-        /// Span of the body portion (from keyword through closing `}`).
-        body_span: SimpleSpan,
+        /// Span of the definition (from keyword through closing `}`).
+        definition_span: SimpleSpan,
         /// Span of the entire specialize declaration.
         span: SimpleSpan,
     },
@@ -69,11 +69,11 @@ where
         .labelled("function signature")
 }
 
-/// Body span scanner. Matches an optional keyword prefix (e.g. `digraph`,
+/// Definition span scanner. Matches an optional keyword prefix (e.g. `digraph`,
 /// `ungraph`) followed by a brace-balanced `{ ... }` CFG. Returns the
 /// span covering everything from the first non-brace token (or the opening
-/// brace) through the matching closing brace. Does not parse body contents.
-fn body_span<'src, I>() -> impl Parser<'src, I, SimpleSpan, ParserError<'src>>
+/// brace) through the matching closing brace. Does not parse the definition.
+fn definition_span<'src, I>() -> impl Parser<'src, I, SimpleSpan, ParserError<'src>>
 where
     I: TokenInput<'src>,
 {
@@ -88,7 +88,7 @@ where
                 None => {
                     return Err(Rich::custom(
                         input.span_since(&start),
-                        "expected '{' in body",
+                        "expected '{' in function definition",
                     ));
                 }
             }
@@ -132,10 +132,10 @@ where
     // The function name is extracted post-parse from EmitContext::function_name().
     let specialize_decl = identifier("specialize")
         .ignore_then(symbol())
-        .then(body_span::<I>()) // captures from keyword (e.g. `fn`) through closing `}`
-        .map_with(|(stage, body_span), extra| Declaration::Specialize {
+        .then(definition_span::<I>()) // captures from keyword (e.g. `fn`) through closing `}`
+        .map_with(|(stage, definition_span), extra| Declaration::Specialize {
             stage,
-            body_span,
+            definition_span,
             span: extra.span(),
         });