feat: 大規模リファクタリング - SRP原則に基づくモジュール分割

## MIR builder_calls.rs リファクタリング
- 879行 → 629行 (28%削減) + 7専門モジュール
- calls/ ディレクトリに機能別分割:
  - call_target.rs: CallTarget型定義
  - method_resolution.rs: メソッド解決ロジック
  - extern_calls.rs: 外部呼び出し処理
  - special_handlers.rs: 特殊ハンドラー
  - function_lowering.rs: 関数変換ユーティリティ
  - call_unified.rs: 統一Call実装
  - mod.rs: モジュール統合

## Parser statements.rs リファクタリング
- 723行 → 8専門モジュール
- statements/ ディレクトリに機能別分割:
  - control_flow.rs: if/loop/break/continue/return
  - declarations.rs: 宣言系ディスパッチャー
  - exceptions.rs: try/throw/catch/cleanup
  - helpers.rs: ヘルパー関数
  - io_async.rs: print/nowait
  - modules.rs: import/using/from
  - variables.rs: local/outbox/assignments
  - mod.rs: 統合モジュール

## 効果
✅ 単一責任原則(SRP)の達成
✅ 保守性・再利用性の向上
✅ ChatGPT5 Pro設計の型安全Call解決システム実装
✅ スモークテスト通過確認済み

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

src/mir/builder/calls/call_target.rs

@@ -0,0 +1,58 @@
+/*!
+ * Call Target Types
+ *
+ * Type-safe call target specification for unified call system
+ * Part of Phase 15.5 MIR Call unification
+ */
+
+use crate::mir::ValueId;
+
+/// Call target specification for emit_unified_call
+/// Provides type-safe target resolution at the builder level
+#[derive(Debug, Clone)]
+pub enum CallTarget {
+    /// Global function (print, panic, etc.)
+    Global(String),
+
+    /// Method call (box.method)
+    Method {
+        box_type: Option<String>,  // None = infer from value
+        method: String,
+        receiver: ValueId,
+    },
+
+    /// Constructor (new BoxType)
+    Constructor(String),
+
+    /// External function (nyash.*)
+    Extern(String),
+
+    /// Dynamic function value
+    Value(ValueId),
+
+    /// Closure creation
+    Closure {
+        params: Vec<String>,
+        captures: Vec<(String, ValueId)>,
+        me_capture: Option<ValueId>,
+    },
+}
+
+impl CallTarget {
+    /// Check if this target is a constructor
+    pub fn is_constructor(&self) -> bool {
+        matches!(self, CallTarget::Constructor(_))
+    }
+
+    /// Get the name of the target for debugging
+    pub fn name(&self) -> String {
+        match self {
+            CallTarget::Global(name) => name.clone(),
+            CallTarget::Method { method, .. } => method.clone(),
+            CallTarget::Constructor(box_type) => format!("new {}", box_type),
+            CallTarget::Extern(name) => name.clone(),
+            CallTarget::Value(_) => "<dynamic>".to_string(),
+            CallTarget::Closure { .. } => "<closure>".to_string(),
+        }
+    }
+}

src/mir/builder/calls/call_unified.rs

@@ -0,0 +1,198 @@
+/*!
+ * Unified Call System
+ *
+ * ChatGPT5 Pro A++ design for complete call unification
+ * Replaces 6 different call instructions with a single unified system
+ */
+
+use crate::mir::{Callee, Effect, EffectMask, ValueId};
+use crate::mir::definitions::call_unified::{CallFlags, MirCall};
+use super::call_target::CallTarget;
+use super::method_resolution;
+use super::extern_calls;
+
+/// Check if unified call system is enabled
+pub fn is_unified_call_enabled() -> bool {
+    std::env::var("NYASH_MIR_UNIFIED_CALL").unwrap_or_default() == "1"
+}
+
+/// Convert CallTarget to Callee
+/// Main translation layer between builder and MIR representations
+pub fn convert_target_to_callee(
+    target: CallTarget,
+    value_origin_newbox: &std::collections::HashMap<ValueId, String>,
+    value_types: &std::collections::HashMap<ValueId, crate::mir::MirType>,
+) -> Result<Callee, String> {
+    match target {
+        CallTarget::Global(name) => {
+            // Check if it's a built-in function
+            if method_resolution::is_builtin_function(&name) {
+                Ok(Callee::Global(name))
+            } else if method_resolution::is_extern_function(&name) {
+                Ok(Callee::Extern(name))
+            } else {
+                Err(format!("Unknown global function: {}", name))
+            }
+        },
+
+        CallTarget::Method { box_type, method, receiver } => {
+            let inferred_box_type = box_type.unwrap_or_else(|| {
+                // Try to infer box type from value origin or type annotation
+                value_origin_newbox.get(&receiver)
+                    .cloned()
+                    .or_else(|| {
+                        value_types.get(&receiver)
+                            .and_then(|t| match t {
+                                crate::mir::MirType::Box(box_name) => Some(box_name.clone()),
+                                _ => None,
+                            })
+                    })
+                    .unwrap_or_else(|| "UnknownBox".to_string())
+            });
+
+            Ok(Callee::Method {
+                box_name: inferred_box_type,
+                method,
+                receiver: Some(receiver),
+            })
+        },
+
+        CallTarget::Constructor(box_type) => {
+            Ok(Callee::Constructor { box_type })
+        },
+
+        CallTarget::Extern(name) => {
+            Ok(Callee::Extern(name))
+        },
+
+        CallTarget::Value(func_val) => {
+            Ok(Callee::Value(func_val))
+        },
+
+        CallTarget::Closure { params, captures, me_capture } => {
+            Ok(Callee::Closure { params, captures, me_capture })
+        },
+    }
+}
+
+/// Compute effects for a call based on its callee
+pub fn compute_call_effects(callee: &Callee) -> EffectMask {
+    match callee {
+        Callee::Global(name) => {
+            match name.as_str() {
+                "print" | "error" => EffectMask::IO,
+                "panic" | "exit" => EffectMask::IO.add(Effect::Control),
+                "gc_collect" => EffectMask::IO.add(Effect::Alloc),
+                _ => EffectMask::IO,
+            }
+        },
+
+        Callee::Method { method, box_name, .. } => {
+            match method.as_str() {
+                "birth" => EffectMask::PURE.add(Effect::Alloc),
+                "get" | "length" | "size" => EffectMask::READ,
+                "set" | "push" | "pop" => EffectMask::READ.add(Effect::WriteHeap),
+                _ => {
+                    // Check if it's a known pure method
+                    if is_pure_method(box_name, method) {
+                        EffectMask::PURE
+                    } else {
+                        EffectMask::READ
+                    }
+                }
+            }
+        },
+
+        Callee::Constructor { .. } => EffectMask::PURE.add(Effect::Alloc),
+
+        Callee::Closure { .. } => EffectMask::PURE.add(Effect::Alloc),
+
+        Callee::Extern(name) => {
+            let (iface, method) = extern_calls::parse_extern_name(name);
+            extern_calls::compute_extern_effects(&iface, &method)
+        },
+
+        Callee::Value(_) => EffectMask::IO, // Conservative for dynamic calls
+    }
+}
+
+/// Check if a method is known to be pure (no side effects)
+fn is_pure_method(box_name: &str, method: &str) -> bool {
+    match (box_name, method) {
+        ("StringBox", m) => matches!(m, "upper" | "lower" | "trim" | "length"),
+        ("IntegerBox", m) => matches!(m, "abs" | "toString"),
+        ("FloatBox", m) => matches!(m, "round" | "floor" | "ceil"),
+        ("BoolBox", "not") => true,
+        _ => false,
+    }
+}
+
+/// Create CallFlags based on callee type
+pub fn create_call_flags(callee: &Callee) -> CallFlags {
+    if callee.is_constructor() {
+        CallFlags::constructor()
+    } else if matches!(callee, Callee::Closure { .. }) {
+        CallFlags::constructor() // Closures are also constructors
+    } else {
+        CallFlags::new()
+    }
+}
+
+/// Create a MirCall instruction from components
+pub fn create_mir_call(
+    dst: Option<ValueId>,
+    callee: Callee,
+    args: Vec<ValueId>,
+) -> MirCall {
+    let effects = compute_call_effects(&callee);
+    let flags = create_call_flags(&callee);
+
+    MirCall {
+        dst,
+        callee,
+        args,
+        flags,
+        effects,
+    }
+}
+
+/// Validate call arguments match expected signature
+pub fn validate_call_args(
+    callee: &Callee,
+    args: &[ValueId],
+) -> Result<(), String> {
+    match callee {
+        Callee::Global(name) => {
+            // Check known global functions
+            match name.as_str() {
+                "print" | "error" | "panic" => {
+                    if args.is_empty() {
+                        return Err(format!("{} requires at least one argument", name));
+                    }
+                }
+                "exit" => {
+                    if args.len() != 1 {
+                        return Err("exit requires exactly one argument (exit code)".to_string());
+                    }
+                }
+                _ => {} // Unknown functions pass through
+            }
+        },
+
+        Callee::Method { box_name, method, .. } => {
+            // Validate known methods
+            match (box_name.as_str(), method.as_str()) {
+                ("ArrayBox", "get") | ("ArrayBox", "set") => {
+                    if args.is_empty() {
+                        return Err(format!("ArrayBox.{} requires an index", method));
+                    }
+                }
+                _ => {} // Unknown methods pass through
+            }
+        },
+
+        _ => {} // Other callee types don't have validation yet
+    }
+
+    Ok(())
+}

src/mir/builder/calls/extern_calls.rs

@@ -0,0 +1,169 @@
+/*!
+ * External Call Handling
+ *
+ * Manages env.* methods and external interface calls
+ * Provides bridge to host environment functionality
+ */
+
+use crate::mir::{Effect, EffectMask};
+
+/// Table-like spec for env.* methods
+/// Returns (iface_name, method_name, effects, returns_value)
+pub fn get_env_method_spec(
+    iface: &str,
+    method: &str,
+) -> Option<(String, String, EffectMask, bool)> {
+    match (iface, method) {
+        // Future/async operations
+        ("future", "delay") => Some((
+            "env.future".to_string(),
+            "delay".to_string(),
+            EffectMask::READ.add(Effect::Io),
+            true,
+        )),
+        ("future", "spawn") => Some((
+            "env.future".to_string(),
+            "spawn".to_string(),
+            EffectMask::IO,
+            true,
+        )),
+
+        // Task management
+        ("task", "currentToken") => Some((
+            "env.task".to_string(),
+            "currentToken".to_string(),
+            EffectMask::READ,
+            true,
+        )),
+        ("task", "cancelCurrent") => Some((
+            "env.task".to_string(),
+            "cancelCurrent".to_string(),
+            EffectMask::IO,
+            false,
+        )),
+
+        // Console I/O
+        ("console", "log") => Some((
+            "env.console".to_string(),
+            "log".to_string(),
+            EffectMask::IO,
+            false,
+        )),
+        ("console", "readLine") => Some((
+            "env.console".to_string(),
+            "readLine".to_string(),
+            EffectMask::IO,
+            true,
+        )),
+        ("console", "error") => Some((
+            "env.console".to_string(),
+            "error".to_string(),
+            EffectMask::IO,
+            false,
+        )),
+
+        // Canvas operations
+        ("canvas", m) if matches!(m, "fillRect" | "fillText" | "clear") => Some((
+            "env.canvas".to_string(),
+            method.to_string(),
+            EffectMask::IO,
+            false,
+        )),
+
+        // File system
+        ("fs", "readFile") => Some((
+            "env.fs".to_string(),
+            "readFile".to_string(),
+            EffectMask::IO,
+            true,
+        )),
+        ("fs", "writeFile") => Some((
+            "env.fs".to_string(),
+            "writeFile".to_string(),
+            EffectMask::IO,
+            false,
+        )),
+        ("fs", "exists") => Some((
+            "env.fs".to_string(),
+            "exists".to_string(),
+            EffectMask::READ,
+            true,
+        )),
+
+        // Network
+        ("net", "fetch") => Some((
+            "env.net".to_string(),
+            "fetch".to_string(),
+            EffectMask::IO,
+            true,
+        )),
+        ("net", "listen") => Some((
+            "env.net".to_string(),
+            "listen".to_string(),
+            EffectMask::IO,
+            true,
+        )),
+
+        // Process/system
+        ("process", "exit") => Some((
+            "env.process".to_string(),
+            "exit".to_string(),
+            EffectMask::IO.add(Effect::Control),
+            false,
+        )),
+        ("process", "argv") => Some((
+            "env.process".to_string(),
+            "argv".to_string(),
+            EffectMask::READ,
+            true,
+        )),
+        ("process", "env") => Some((
+            "env.process".to_string(),
+            "env".to_string(),
+            EffectMask::READ,
+            true,
+        )),
+
+        // Unknown
+        _ => None,
+    }
+}
+
+/// Parse external call name into interface and method
+/// E.g., "nyash.builtin.print" -> ("nyash.builtin", "print")
+pub fn parse_extern_name(name: &str) -> (String, String) {
+    let parts: Vec<&str> = name.rsplitn(2, '.').collect();
+    if parts.len() == 2 {
+        (parts[1].to_string(), parts[0].to_string())
+    } else {
+        ("nyash".to_string(), name.to_string())
+    }
+}
+
+/// Check if a name refers to an environment interface
+pub fn is_env_interface(name: &str) -> bool {
+    matches!(name,
+        "env" | "env.console" | "env.fs" | "env.net" |
+        "env.canvas" | "env.task" | "env.future" | "env.process"
+    )
+}
+
+/// Determine effects for an external call
+pub fn compute_extern_effects(iface: &str, method: &str) -> EffectMask {
+    match (iface, method) {
+        // Pure reads
+        (_, m) if m.starts_with("get") || m == "argv" || m == "env" => {
+            EffectMask::READ
+        }
+        // Control flow changes
+        (_, "exit") | (_, "panic") | (_, "throw") => {
+            EffectMask::IO.add(Effect::Control)
+        }
+        // Memory allocation
+        (_, m) if m.starts_with("new") || m.starts_with("create") => {
+            EffectMask::IO.add(Effect::Alloc)
+        }
+        // Default to I/O
+        _ => EffectMask::IO,
+    }
+}

src/mir/builder/calls/function_lowering.rs

@@ -0,0 +1,150 @@
+/*!
+ * Function Lowering Utilities
+ *
+ * Helpers for lowering box methods and static methods to MIR functions
+ * Manages the complex state transitions during function lowering
+ */
+
+use crate::ast::ASTNode;
+use crate::mir::{Effect, EffectMask, FunctionSignature, MirType};
+use super::special_handlers::contains_value_return;
+
+/// Prepare function signature for a box method
+/// Includes 'me' parameter as first parameter
+pub fn prepare_method_signature(
+    func_name: String,
+    box_name: &str,
+    params: &[String],
+    body: &[ASTNode],
+) -> FunctionSignature {
+    let mut param_types = Vec::new();
+
+    // First parameter is always 'me' (the box instance)
+    param_types.push(MirType::Box(box_name.to_string()));
+
+    // Additional parameters (type unknown initially)
+    for _ in params {
+        param_types.push(MirType::Unknown);
+    }
+
+    // Determine return type based on body analysis
+    let returns_value = contains_value_return(body);
+    let ret_ty = if returns_value {
+        MirType::Unknown  // Will be inferred later
+    } else {
+        MirType::Void
+    };
+
+    FunctionSignature {
+        name: func_name,
+        params: param_types,
+        return_type: ret_ty,
+        effects: EffectMask::READ.add(Effect::ReadHeap),
+    }
+}
+
+/// Prepare function signature for a static method
+/// No 'me' parameter needed
+pub fn prepare_static_method_signature(
+    func_name: String,
+    params: &[String],
+    body: &[ASTNode],
+) -> FunctionSignature {
+    let mut param_types = Vec::new();
+
+    // Parameters (type unknown initially)
+    for _ in params {
+        param_types.push(MirType::Unknown);
+    }
+
+    // Determine return type based on body analysis
+    let returns_value = contains_value_return(body);
+    let ret_ty = if returns_value {
+        MirType::Unknown  // Will be inferred later
+    } else {
+        MirType::Void
+    };
+
+    FunctionSignature {
+        name: func_name,
+        params: param_types,
+        return_type: ret_ty,
+        effects: EffectMask::READ.add(Effect::ReadHeap),
+    }
+}
+
+/// Generate canonical method name for MIR function
+/// E.g., "StringBox.upper/0" for StringBox's upper method with 0 args
+pub fn generate_method_function_name(
+    box_name: &str,
+    method_name: &str,
+    arity: usize,
+) -> String {
+    format!("{}.{}/{}", box_name, method_name, arity)
+}
+
+/// Generate canonical static method name for MIR function
+/// E.g., "Main.main/0" for static box Main's main method
+pub fn generate_static_method_function_name(
+    static_box_name: &str,
+    method_name: &str,
+    arity: usize,
+) -> String {
+    format!("{}.{}/{}", static_box_name, method_name, arity)
+}
+
+/// Check if a function needs termination with void return
+pub fn needs_void_termination(returns_value: bool, is_terminated: bool) -> bool {
+    !returns_value && !is_terminated
+}
+
+/// Create parameter mapping for method lowering
+/// Returns (parameter_names, includes_me)
+pub fn create_method_parameter_mapping(
+    box_name: &str,
+    params: &[String],
+) -> (Vec<(String, MirType)>, bool) {
+    let mut param_mapping = Vec::new();
+
+    // Add 'me' parameter
+    param_mapping.push(("me".to_string(), MirType::Box(box_name.to_string())));
+
+    // Add regular parameters
+    for p in params {
+        param_mapping.push((p.clone(), MirType::Unknown));
+    }
+
+    (param_mapping, true)
+}
+
+/// Create parameter mapping for static method lowering
+pub fn create_static_parameter_mapping(
+    params: &[String],
+) -> Vec<(String, MirType)> {
+    params.iter()
+        .map(|p| (p.clone(), MirType::Unknown))
+        .collect()
+}
+
+/// Wrap statements in a Program node for consistent processing
+pub fn wrap_in_program(statements: Vec<ASTNode>) -> ASTNode {
+    ASTNode::Program {
+        statements,
+        span: crate::ast::Span::unknown(),
+    }
+}
+
+/// Check if method name suggests it returns a value
+pub fn method_likely_returns_value(method_name: &str) -> bool {
+    // Heuristic: methods that likely return values
+    method_name.starts_with("get") ||
+    method_name.starts_with("is") ||
+    method_name.starts_with("has") ||
+    method_name.starts_with("to") ||
+    matches!(method_name,
+        "length" | "size" | "count" |
+        "upper" | "lower" | "trim" |
+        "add" | "sub" | "mul" | "div" |
+        "min" | "max" | "abs"
+    )
+}

src/mir/builder/calls/method_resolution.rs

@@ -0,0 +1,114 @@
+/*!
+ * Method Resolution System
+ *
+ * Type-safe function and method resolution at compile-time
+ * ChatGPT5 Pro design for preventing runtime string-based resolution
+ */
+
+use crate::mir::{Callee, ValueId};
+use std::collections::HashMap;
+
+/// Resolve function call target to type-safe Callee
+/// Implements the core logic of compile-time function resolution
+pub fn resolve_call_target(
+    name: &str,
+    current_static_box: &Option<String>,
+    variable_map: &HashMap<String, ValueId>,
+) -> Result<Callee, String> {
+    // 1. Check for built-in/global functions first
+    if is_builtin_function(name) {
+        return Ok(Callee::Global(name.to_string()));
+    }
+
+    // 2. Check for static box method in current context
+    if let Some(box_name) = current_static_box {
+        if has_method(box_name, name) {
+            // Warn about potential self-recursion
+            if is_commonly_shadowed_method(name) {
+                eprintln!("{}", generate_self_recursion_warning(box_name, name));
+            }
+
+            return Ok(Callee::Method {
+                box_name: box_name.clone(),
+                method: name.to_string(),
+                receiver: None, // Static method call
+            });
+        }
+    }
+
+    // 3. Check for local variable containing function value
+    if let Some(&value_id) = variable_map.get(name) {
+        return Ok(Callee::Value(value_id));
+    }
+
+    // 4. Check for external/host functions
+    if is_extern_function(name) {
+        return Ok(Callee::Extern(name.to_string()));
+    }
+
+    // 5. Resolution failed - this prevents runtime string-based resolution
+    Err(format!("Unresolved function: '{}'. {}", name, suggest_resolution(name)))
+}
+
+/// Check if function name is a built-in global function
+pub fn is_builtin_function(name: &str) -> bool {
+    matches!(name,
+        "print" | "error" | "panic" | "exit" | "now" |
+        "gc_collect" | "gc_stats" |
+        // Math functions (handled specially)
+        "sin" | "cos" | "abs" | "min" | "max"
+    )
+}
+
+/// Check if function name is an external/host function
+pub fn is_extern_function(name: &str) -> bool {
+    name.starts_with("nyash.") ||
+    name.starts_with("env.") ||
+    name.starts_with("system.")
+}
+
+/// Check if method is commonly shadowed (for warning generation)
+pub fn is_commonly_shadowed_method(name: &str) -> bool {
+    matches!(name, "print" | "log" | "error" | "toString")
+}
+
+/// Generate warning about potential self-recursion
+pub fn generate_self_recursion_warning(box_name: &str, method: &str) -> String {
+    format!(
+        "[Warning] Calling '{}' in static box '{}' context. \
+         This resolves to '{}.{}' which may cause self-recursion if called from within the same method.",
+        method, box_name, box_name, method
+    )
+}
+
+/// Suggest resolution for unresolved function
+pub fn suggest_resolution(name: &str) -> String {
+    match name {
+        n if n.starts_with("console") => {
+            "Did you mean 'env.console.log' or 'print'?".to_string()
+        }
+        "log" | "println" => {
+            "Did you mean 'print' or 'env.console.log'?".to_string()
+        }
+        n if n.contains('.') => {
+            "Qualified names should use 'env.' prefix for external calls.".to_string()
+        }
+        _ => {
+            "Check function name or ensure it's in scope.".to_string()
+        }
+    }
+}
+
+/// Check if current static box has the specified method
+/// TODO: Replace with proper method registry lookup
+pub fn has_method(box_name: &str, method: &str) -> bool {
+    match box_name {
+        "ConsoleStd" => matches!(method, "print" | "println" | "log"),
+        "StringBox" => matches!(method, "upper" | "lower" | "length" | "concat" | "slice"),
+        "IntegerBox" => matches!(method, "add" | "sub" | "mul" | "div"),
+        "ArrayBox" => matches!(method, "push" | "pop" | "get" | "set" | "length"),
+        "MapBox" => matches!(method, "get" | "set" | "has" | "delete"),
+        "MathBox" => matches!(method, "sin" | "cos" | "abs" | "min" | "max"),
+        _ => false, // Conservative: assume no method unless explicitly known
+    }
+}

src/mir/builder/calls/mod.rs

@@ -0,0 +1,66 @@
+/*!
+ * Call System Module Organization
+ *
+ * Refactored from monolithic builder_calls.rs (879 lines)
+ * Split into focused modules following Single Responsibility Principle
+ */
+
+// Core types
+pub mod call_target;
+pub use call_target::CallTarget;
+
+// Resolution system
+pub mod method_resolution;
+
+// External calls
+pub mod extern_calls;
+
+// Special handlers
+pub mod special_handlers;
+
+// Function lowering
+pub mod function_lowering;
+
+// Unified call system
+pub mod call_unified;
+
+// Re-export commonly used items
+pub use method_resolution::{
+    resolve_call_target,
+    is_builtin_function,
+    is_extern_function,
+    has_method,
+};
+
+pub use extern_calls::{
+    get_env_method_spec,
+    parse_extern_name,
+    is_env_interface,
+    compute_extern_effects,
+};
+
+pub use special_handlers::{
+    is_math_function,
+    is_typeop_method,
+    extract_string_literal,
+    parse_type_name_to_mir,
+    contains_value_return,
+    make_function_name_with_arity,
+};
+
+pub use function_lowering::{
+    prepare_method_signature,
+    prepare_static_method_signature,
+    generate_method_function_name,
+    generate_static_method_function_name,
+    wrap_in_program,
+};
+
+pub use call_unified::{
+    is_unified_call_enabled,
+    convert_target_to_callee,
+    compute_call_effects,
+    create_call_flags,
+    create_mir_call,
+    validate_call_args,
+};

src/mir/builder/calls/special_handlers.rs

@@ -0,0 +1,140 @@
+/*!
+ * Special Call Handlers
+ *
+ * Handles math functions, type operations, and other special cases
+ * These require custom processing beyond standard method calls
+ */
+
+use crate::ast::{ASTNode, LiteralValue};
+use crate::mir::MirType;
+
+/// Check if a function is a math function
+pub fn is_math_function(name: &str) -> bool {
+    matches!(name, "sin" | "cos" | "abs" | "min" | "max" | "sqrt" | "pow" | "floor" | "ceil")
+}
+
+/// Check if a method is a type operation (.is() or .as())
+pub fn is_typeop_method(method: &str, arguments: &[ASTNode]) -> Option<String> {
+    if (method == "is" || method == "as") && arguments.len() == 1 {
+        extract_string_literal(&arguments[0])
+    } else {
+        None
+    }
+}
+
+/// Extract string literal from AST node if possible
+/// Handles both direct literals and StringBox constructors
+pub fn extract_string_literal(node: &ASTNode) -> Option<String> {
+    let mut cur = node;
+    loop {
+        match cur {
+            ASTNode::Literal {
+                value: LiteralValue::String(s),
+                ..
+            } => return Some(s.clone()),
+            ASTNode::New {
+                class, arguments, ..
+            } if class == "StringBox" && arguments.len() == 1 => {
+                cur = &arguments[0];
+                continue;
+            }
+            _ => return None,
+        }
+    }
+}
+
+/// Map a user-facing type name to MIR type
+pub fn parse_type_name_to_mir(name: &str) -> MirType {
+    match name {
+        // Core primitive types only (no Box suffixes)
+        "Integer" | "Int" | "I64" => MirType::Integer,
+        "Float" | "F64" => MirType::Float,
+        "Bool" | "Boolean" => MirType::Bool,
+        "String" => MirType::String,
+        "Void" | "Unit" => MirType::Void,
+        // Phase 15.5: All Box types (including former core IntegerBox, StringBox, etc.) treated uniformly
+        other => MirType::Box(other.to_string()),
+    }
+}
+
+/// Check if a value is a numeric literal or numeric Box constructor
+pub fn is_numeric_value(node: &ASTNode) -> bool {
+    match node {
+        ASTNode::Literal { value: LiteralValue::Integer(_), .. } => true,
+        ASTNode::Literal { value: LiteralValue::Float(_), .. } => true,
+        ASTNode::New { class, arguments, .. } => {
+            (class == "IntegerBox" || class == "FloatBox") && arguments.len() == 1
+        }
+        _ => false,
+    }
+}
+
+/// Extract numeric type from AST node
+pub fn extract_numeric_type(node: &ASTNode) -> Option<MirType> {
+    match node {
+        ASTNode::Literal { value: LiteralValue::Integer(_), .. } => Some(MirType::Integer),
+        ASTNode::Literal { value: LiteralValue::Float(_), .. } => Some(MirType::Float),
+        ASTNode::New { class, .. } if class == "IntegerBox" => Some(MirType::Integer),
+        ASTNode::New { class, .. } if class == "FloatBox" => Some(MirType::Float),
+        _ => None,
+    }
+}
+
+/// Check if an AST node contains a return statement with value
+pub fn contains_value_return(nodes: &[ASTNode]) -> bool {
+    fn node_has_value_return(node: &ASTNode) -> bool {
+        match node {
+            ASTNode::Return { value: Some(_), .. } => true,
+            ASTNode::If { then_body, else_body, .. } => {
+                contains_value_return(then_body)
+                    || else_body
+                        .as_ref()
+                        .map_or(false, |body| contains_value_return(body))
+            }
+            ASTNode::Loop { body, .. } => contains_value_return(body),
+            ASTNode::TryCatch {
+                try_body,
+                catch_clauses,
+                finally_body,
+                ..
+            } => {
+                contains_value_return(try_body)
+                    || catch_clauses
+                        .iter()
+                        .any(|clause| contains_value_return(&clause.body))
+                    || finally_body
+                        .as_ref()
+                        .map_or(false, |body| contains_value_return(body))
+            }
+            ASTNode::Program { statements, .. } => contains_value_return(statements),
+            ASTNode::ScopeBox { body, .. } => contains_value_return(body),
+            ASTNode::FunctionDeclaration { body, .. } => contains_value_return(body),
+            _ => false,
+        }
+    }
+
+    nodes.iter().any(node_has_value_return)
+}
+
+/// Generate canonical function name with arity
+pub fn make_function_name_with_arity(base_name: &str, arity: usize) -> String {
+    format!("{}/{}", base_name, arity)
+}
+
+/// Check if a name is a reserved/special function
+pub fn is_reserved_function(name: &str) -> bool {
+    matches!(name,
+        "birth" | "me" | "this" | "super" | "from" |
+        "new" | "delete" | "typeof" | "instanceof"
+    )
+}
+
+/// Suggest alternative for reserved function names
+pub fn suggest_alternative_for_reserved(name: &str) -> String {
+    match name {
+        "birth" => "Use 'new BoxType()' to create instances".to_string(),
+        "me" | "this" => "Use 'me' to reference current instance in methods".to_string(),
+        "from" => "Use 'from Parent.method()' syntax for delegation".to_string(),
+        _ => format!("'{}' is a reserved keyword", name),
+    }
+}