kumi 0.0.6 → 0.0.7

data/lib/kumi/analyzer/passes/semantic_constraint_validator.rb

@@ -24,7 +24,7 @@ module Kumi
 
         private
 
-        def validate_semantic_constraints(node, decl, errors)
+        def validate_semantic_constraints(node, _decl, errors)
           case node
           when Kumi::Syntax::TraitDeclaration
             validate_trait_expression(node, errors)
@@ -48,20 +48,20 @@ module Kumi
 
         def validate_cascade_condition(when_case, errors)
           condition = when_case.condition
-          
+
           case condition
           when Kumi::Syntax::DeclarationReference
             # Valid: trait reference
-            return
+            nil
           when Kumi::Syntax::CallExpression
             # Valid if it's a boolean composition of traits (all?, any?, none?)
             return if boolean_trait_composition?(condition)
-            
+
             # For now, allow other CallExpressions - they'll be validated by other passes
-            return
+            nil
           when Kumi::Syntax::Literal
             # Allow literal conditions (like true/false) - they might be valid
-            return
+            nil
           else
             # Only reject truly invalid conditions like InputReference or complex expressions
             report_error(
@@ -75,10 +75,10 @@ module Kumi
 
         def validate_function_call(call_expr, errors)
           fn_name = call_expr.fn_name
-          
+
           # Skip validation if FunctionRegistry is being mocked for testing
           return if function_registry_mocked?
-          
+
           return if FunctionRegistry.supported?(fn_name)
 
           report_error(
@@ -96,15 +96,14 @@ module Kumi
 
         def function_registry_mocked?
           # Check if FunctionRegistry is being mocked (for tests)
-          begin
-            # Try to access a method that doesn't exist in the real registry
-            # If it's mocked, this won't raise an error
-            FunctionRegistry.respond_to?(:confirm_support!)
-          rescue
-            false
-          end
+
+          # Try to access a method that doesn't exist in the real registry
+          # If it's mocked, this won't raise an error
+          FunctionRegistry.respond_to?(:confirm_support!)
+        rescue StandardError
+          false
         end
       end
     end
   end
-end
+end

data/lib/kumi/analyzer/passes/toposorter.rb

@@ -4,16 +4,16 @@ module Kumi
   module Analyzer
     module Passes
       # RESPONSIBILITY: Compute topological ordering of declarations, allowing safe conditional cycles
-      # DEPENDENCIES: :dependency_graph from DependencyResolver, :definitions from NameIndexer, :cascade_metadata from UnsatDetector
-      # PRODUCES: :topo_order - Array of declaration names in evaluation order
+      # DEPENDENCIES: :dependencies from DependencyResolver, :declarations from NameIndexer, :cascades from UnsatDetector
+      # PRODUCES: :evaluation_order - Array of declaration names in evaluation order
       # INTERFACE: new(schema, state).run(errors)
       class Toposorter < PassBase
         def run(errors)
-          dependency_graph = get_state(:dependency_graph, required: false) || {}
-          definitions = get_state(:definitions, required: false) || {}
+          dependency_graph = get_state(:dependencies, required: false) || {}
+          definitions = get_state(:declarations, required: false) || {}
 
           order = compute_topological_order(dependency_graph, definitions, errors)
-          state.with(:topo_order, order)
+          state.with(:evaluation_order, order)
         end
 
         private
@@ -22,7 +22,7 @@ module Kumi
           temp_marks = Set.new
           perm_marks = Set.new
           order = []
-          cascade_metadata = get_state(:cascade_metadata) || {}
+          cascades = get_state(:cascades) || {}
 
           visit_node = lambda do |node, path = []|
             return if perm_marks.include?(node)
@@ -30,13 +30,13 @@ module Kumi
             if temp_marks.include?(node)
               # Check if this is a safe conditional cycle
               cycle_path = path + [node]
-              if safe_conditional_cycle?(cycle_path, graph, cascade_metadata)
-                # Allow this cycle - it's safe due to cascade mutual exclusion
-                return
-              else
-                report_unexpected_cycle(temp_marks, node, errors)
-                return
-              end
+              return if safe_conditional_cycle?(cycle_path, graph, cascades)
+
+              # Allow this cycle - it's safe due to cascade mutual exclusion
+
+              report_unexpected_cycle(temp_marks, node, errors)
+
+              return
             end
 
             temp_marks << node
@@ -59,30 +59,30 @@ module Kumi
           order.freeze
         end
 
-        def safe_conditional_cycle?(cycle_path, graph, cascade_metadata)
+        def safe_conditional_cycle?(cycle_path, graph, cascades)
           return false if cycle_path.nil? || cycle_path.size < 2
-          
+
           # Find where the cycle starts - look for the first occurrence of the repeated node
           last_node = cycle_path.last
           return false if last_node.nil?
-          
+
           cycle_start = cycle_path.index(last_node)
           return false unless cycle_start && cycle_start < cycle_path.size - 1
-          
-          cycle_nodes = cycle_path[cycle_start..-1]
-          
+
+          cycle_nodes = cycle_path[cycle_start..]
+
           # Check if all edges in the cycle are conditional
           cycle_nodes.each_cons(2) do |from, to|
             edges = graph[from] || []
             edge = edges.find { |e| e.to == to }
-            
+
             return false unless edge&.conditional
-            
+
             # Check if the cascade has mutually exclusive conditions
-            cascade_meta = cascade_metadata[edge.cascade_owner]
+            cascade_meta = cascades[edge.cascade_owner]
             return false unless cascade_meta&.dig(:all_mutually_exclusive)
           end
-          
+
           true
         end
 

data/lib/kumi/analyzer/passes/type_checker.rb

@@ -4,7 +4,7 @@ module Kumi
   module Analyzer
     module Passes
       # RESPONSIBILITY: Validate function call arity and argument types against FunctionRegistry
-      # DEPENDENCIES: :decl_types from TypeInferencer
+      # DEPENDENCIES: :inferred_types from TypeInferencer
       # PRODUCES: None (validation only)
       # INTERFACE: new(schema, state).run(errors)
       class TypeChecker < VisitorPass
@@ -48,10 +48,8 @@ module Kumi
           return if types.nil? || (signature[:arity].negative? && node.args.empty?)
 
           # Skip type checking for vectorized operations
-          broadcast_meta = get_state(:broadcast_metadata, required: false)
-          if broadcast_meta && is_part_of_vectorized_operation?(node, broadcast_meta)
-            return
-          end
+          broadcast_meta = get_state(:broadcasts, required: false)
+          return if broadcast_meta && is_part_of_vectorized_operation?(node, broadcast_meta)
 
           node.args.each_with_index do |arg, i|
             validate_argument_type(arg, i, types[i], node.fn_name, errors)
@@ -65,7 +63,7 @@ module Kumi
             case arg
             when Kumi::Syntax::DeclarationReference
               broadcast_meta[:vectorized_operations]&.key?(arg.name) ||
-              broadcast_meta[:reduction_operations]&.key?(arg.name)
+                broadcast_meta[:reduction_operations]&.key?(arg.name)
             when Kumi::Syntax::InputElementReference
               broadcast_meta[:array_fields]&.key?(arg.path.first)
             else
@@ -110,14 +108,14 @@ module Kumi
 
         def get_declared_field_type(field_name)
           # Get explicitly declared type from input metadata
-          input_meta = get_state(:input_meta, required: false) || {}
+          input_meta = get_state(:inputs, required: false) || {}
           field_meta = input_meta[field_name]
           field_meta&.dig(:type) || Kumi::Types::ANY
         end
 
         def get_inferred_declaration_type(decl_name)
           # Get inferred type from type inference results
-          decl_types = get_state(:decl_types, required: true)
+          decl_types = get_state(:inferred_types, required: true)
           decl_types[decl_name] || Kumi::Types::ANY
         end
 
@@ -127,7 +125,7 @@ module Kumi
             "`#{expr.value}` of type #{type} (literal value)"
 
           when Kumi::Syntax::InputReference
-            input_meta = get_state(:input_meta, required: false) || {}
+            input_meta = get_state(:inputs, required: false) || {}
             field_meta = input_meta[expr.name]
 
             if field_meta&.dig(:type)

data/lib/kumi/analyzer/passes/type_consistency_checker.rb

@@ -4,12 +4,12 @@ module Kumi
   module Analyzer
     module Passes
       # RESPONSIBILITY: Validate consistency between declared and inferred types
-      # DEPENDENCIES: :input_meta from InputCollector, :decl_types from TypeInferencer
+      # DEPENDENCIES: :inputs from InputCollector, :inferred_types from TypeInferencer
       # PRODUCES: None (validation only)
       # INTERFACE: new(schema, state).run(errors)
       class TypeConsistencyChecker < PassBase
         def run(errors)
-          input_meta = get_state(:input_meta, required: false) || {}
+          input_meta = get_state(:inputs, required: false) || {}
 
           # First, validate that all declared types are valid
           validate_declared_types(input_meta, errors)

data/lib/kumi/analyzer/passes/type_inferencer.rb

@@ -4,17 +4,17 @@ module Kumi
   module Analyzer
     module Passes
       # RESPONSIBILITY: Infer types for all declarations based on expression analysis
-      # DEPENDENCIES: Toposorter (needs topo_order), DeclarationValidator (needs definitions)
-      # PRODUCES: decl_types hash mapping declaration names to inferred types
+      # DEPENDENCIES: Toposorter (needs evaluation_order), DeclarationValidator (needs declarations)
+      # PRODUCES: inferred_types hash mapping declaration names to inferred types
       # INTERFACE: new(schema, state).run(errors)
       class TypeInferencer < PassBase
         def run(errors)
           types = {}
-          topo_order = get_state(:topo_order)
-          definitions = get_state(:definitions)
-          
+          topo_order = get_state(:evaluation_order)
+          definitions = get_state(:declarations)
+
           # Get broadcast metadata from broadcast detector
-          broadcast_meta = get_state(:broadcast_metadata, required: false) || {}
+          broadcast_meta = get_state(:broadcasts, required: false) || {}
 
           # Process declarations in topological order to ensure dependencies are resolved
           topo_order.each do |name|
@@ -37,7 +37,7 @@ module Kumi
             end
           end
 
-          state.with(:decl_types, types)
+          state.with(:inferred_types, types)
         end
 
         private
@@ -48,7 +48,7 @@ module Kumi
             Types.infer_from_value(expr.value)
           when InputReference
             # Look up type from field metadata
-            input_meta = get_state(:input_meta, required: false) || {}
+            input_meta = get_state(:inputs, required: false) || {}
             meta = input_meta[expr.name]
             meta&.dig(:type) || :any
           when DeclarationReference
@@ -68,7 +68,7 @@ module Kumi
         end
 
         def infer_call_type(call_expr, type_context, broadcast_metadata = {}, current_decl_name = nil)
-          fn_name = call_expr.fn_name  
+          fn_name = call_expr.fn_name
           args = call_expr.args
 
           # Check broadcast metadata first
@@ -116,7 +116,7 @@ module Kumi
           signature[:return_type] || :any
         end
 
-        def infer_vectorized_element_type(call_expr, type_context, broadcast_metadata)
+        def infer_vectorized_element_type(call_expr, _type_context, _broadcast_metadata)
           # For vectorized arithmetic operations, infer the element type
           # For now, assume arithmetic operations on floats produce floats
           case call_expr.fn_name
@@ -127,10 +127,10 @@ module Kumi
           end
         end
 
-        def infer_function_return_type(fn_name, args, type_context, broadcast_metadata)
+        def infer_function_return_type(fn_name, _args, _type_context, _broadcast_metadata)
           # Get the function signature
           return :any unless FunctionRegistry.supported?(fn_name)
-          
+
           signature = FunctionRegistry.signature(fn_name)
           signature[:return_type] || :any
         end
@@ -153,15 +153,15 @@ module Kumi
           case expr
           when InputElementReference
             # Get the field type from metadata
-            input_meta = get_state(:input_meta, required: false) || {}
+            input_meta = get_state(:inputs, required: false) || {}
             array_name = expr.path.first
             field_name = expr.path[1]
-            
+
             array_meta = input_meta[array_name]
             return :any unless array_meta&.dig(:type) == :array
-            
+
             array_meta.dig(:children, field_name, :type) || :any
-            
+
           when CallExpression
             # For arithmetic operations, infer from operands
             if %i[add subtract multiply divide].include?(expr.fn_name)
@@ -181,13 +181,13 @@ module Kumi
                   infer_expression_type(arg, type_context, vectorization_meta)
                 end
               end
-              
+
               # Unify types for arithmetic
               Types.unify(*arg_types) || :float
             else
               :any
             end
-            
+
           else
             :any
           end
@@ -195,19 +195,19 @@ module Kumi
 
         def infer_element_reference_type(expr)
           # Get array field metadata
-          input_meta = get_state(:input_meta, required: false) || {}
-          
+          input_meta = get_state(:inputs, required: false) || {}
+
           return :any unless expr.path.size >= 2
-          
+
           array_name = expr.path.first
           field_name = expr.path[1]
-          
+
           array_meta = input_meta[array_name]
           return :any unless array_meta&.dig(:type) == :array
-          
+
           # Get the field type from children metadata
           field_type = array_meta.dig(:children, field_name, :type) || :any
-          
+
           # Return array of field type (vectorized)
           { array: field_type }
         end

data/lib/kumi/analyzer/passes/unsat_detector.rb

@@ -4,8 +4,8 @@ module Kumi
   module Analyzer
     module Passes
       # RESPONSIBILITY: Detect unsatisfiable constraints and analyze cascade mutual exclusion
-      # DEPENDENCIES: :definitions from NameIndexer, :input_meta from InputCollector
-      # PRODUCES: :cascade_metadata - Hash of cascade mutual exclusion analysis results
+      # DEPENDENCIES: :declarations from NameIndexer, :inputs from InputCollector
+      # PRODUCES: :cascades - Hash of cascade mutual exclusion analysis results
       # INTERFACE: new(schema, state).run(errors)
       class UnsatDetector < VisitorPass
         include Syntax
@@ -14,21 +14,19 @@ module Kumi
         Atom        = Kumi::AtomUnsatSolver::Atom
 
         def run(errors)
-          definitions = get_state(:definitions)
-          @input_meta = get_state(:input_meta) || {}
+          definitions = get_state(:declarations)
+          @input_meta = get_state(:inputs) || {}
           @definitions = definitions
           @evaluator = ConstantEvaluator.new(definitions)
 
           # First pass: analyze cascade conditions for mutual exclusion
-          cascade_metadata = {}
+          cascades = {}
           each_decl do |decl|
-            cascade_metadata[decl.name] = analyze_cascade_mutual_exclusion(decl, definitions) if decl.expression.is_a?(CascadeExpression)
-          end
+            cascades[decl.name] = analyze_cascade_mutual_exclusion(decl, definitions) if decl.expression.is_a?(CascadeExpression)
 
-          # Store cascade metadata for later passes
+            # Store cascade metadata for later passes
 
-          # Second pass: check for unsatisfiable constraints
-          each_decl do |decl|
+            # Second pass: check for unsatisfiable constraints
             if decl.expression.is_a?(CascadeExpression)
               # Special handling for cascade expressions
               check_cascade_expression(decl, definitions, errors)
@@ -51,7 +49,7 @@ module Kumi
               report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
             end
           end
-          state.with(:cascade_metadata, cascade_metadata)
+          state.with(:cascades, cascades)
         end
 
         private
@@ -93,7 +91,7 @@ module Kumi
             end
           end
 
-          all_mutually_exclusive = (total_pairs > 0) && (exclusive_pairs == total_pairs)
+          all_mutually_exclusive = total_pairs.positive? && (exclusive_pairs == total_pairs)
 
           {
             condition_traits: condition_traits,
@@ -130,7 +128,7 @@ module Kumi
           val1.value != val2.value
         end
 
-        def check_or_expression(or_expr, definitions, errors)
+        def check_or_expression(or_expr, definitions, _errors)
           # For OR expressions: A | B is impossible only if BOTH A AND B are impossible
           # If either side is satisfiable, the OR is satisfiable
           left_side, right_side = or_expr.args

data/lib/kumi/analyzer.rb

@@ -52,11 +52,11 @@ module Kumi
 
     def self.create_analysis_result(state)
       Result.new(
-        definitions: state[:definitions],
-        dependency_graph: state[:dependency_graph],
-        leaf_map: state[:leaf_map],
-        topo_order: state[:topo_order],
-        decl_types: state[:decl_types],
+        definitions: state[:declarations],
+        dependency_graph: state[:dependencies],
+        leaf_map: state[:leaves],
+        topo_order: state[:evaluation_order],
+        decl_types: state[:inferred_types],
         state: state.to_h
       )
     end

data/lib/kumi/compiler.rb

@@ -27,7 +27,6 @@ module Kumi
         end
       end
 
-
       def compile_binding_node(expr)
         name = expr.name
         # Handle forward references in cycles by deferring binding lookup to runtime
@@ -45,7 +44,7 @@ module Kumi
       def compile_call(expr)
         fn_name = expr.fn_name
         arg_fns = expr.args.map { |a| compile_expr(a) }
-        
+
         # Check if this is a vectorized operation
         if vectorized_operation?(expr)
           ->(ctx) { invoke_vectorized_function(fn_name, arg_fns, ctx, expr.loc) }
@@ -56,40 +55,39 @@ module Kumi
 
       def compile_cascade(expr)
         # Check if current declaration is vectorized
-        broadcast_meta = @analysis.state[:broadcast_metadata]
+        broadcast_meta = @analysis.state[:broadcasts]
         is_vectorized = @current_declaration && broadcast_meta&.dig(:vectorized_operations, @current_declaration)
-        
-        
+
         # For vectorized cascades, we need to transform conditions that use all?
-        if is_vectorized
-          pairs = expr.cases.map do |c|
-            condition_fn = transform_vectorized_condition(c.condition)
-            result_fn = compile_expr(c.result)
-            [condition_fn, result_fn]
-          end
-        else
-          pairs = expr.cases.map { |c| [compile_expr(c.condition), compile_expr(c.result)] }
-        end
-        
+        pairs = if is_vectorized
+                  expr.cases.map do |c|
+                    condition_fn = transform_vectorized_condition(c.condition)
+                    result_fn = compile_expr(c.result)
+                    [condition_fn, result_fn]
+                  end
+                else
+                  expr.cases.map { |c| [compile_expr(c.condition), compile_expr(c.result)] }
+                end
+
         if is_vectorized
           lambda do |ctx|
             # This cascade can be vectorized - check if we actually need to at runtime
             # Evaluate all conditions and results to check for arrays
             cond_results = pairs.map { |cond, _res| cond.call(ctx) }
             res_results = pairs.map { |_cond, res| res.call(ctx) }
-            
+
             # Check if any conditions or results are arrays (vectorized)
-            has_vectorized_data = (cond_results + res_results).any? { |v| v.is_a?(Array) }
-            
+            has_vectorized_data = (cond_results + res_results).any?(Array)
+
             if has_vectorized_data
               # Apply element-wise cascade evaluation
-              array_length = cond_results.find { |v| v.is_a?(Array) }&.length || 
-                           res_results.find { |v| v.is_a?(Array) }&.length || 1
-              
+              array_length = cond_results.find { |v| v.is_a?(Array) }&.length ||
+                             res_results.find { |v| v.is_a?(Array) }&.length || 1
+
               (0...array_length).map do |i|
-                pairs.each_with_index do |(cond, res), pair_idx|
+                pairs.each_with_index do |(_cond, _res), pair_idx|
                   cond_val = cond_results[pair_idx].is_a?(Array) ? cond_results[pair_idx][i] : cond_results[pair_idx]
-                  
+
                   if cond_val
                     res_val = res_results[pair_idx].is_a?(Array) ? res_results[pair_idx][i] : res_results[pair_idx]
                     break res_val
@@ -98,7 +96,7 @@ module Kumi
               end
             else
               # All data is scalar - use regular cascade evaluation
-              pairs.each_with_index do |(cond, res), pair_idx|
+              pairs.each_with_index do |(_cond, _res), pair_idx|
                 return res_results[pair_idx] if cond_results[pair_idx]
               end
               nil
@@ -114,17 +112,17 @@ module Kumi
 
       def transform_vectorized_condition(condition_expr)
         # If this is fn(:all?, [trait_ref]), extract the trait_ref for vectorized cascades
-        if condition_expr.is_a?(Kumi::Syntax::CallExpression) && 
-           condition_expr.fn_name == :all? && 
+        if condition_expr.is_a?(Kumi::Syntax::CallExpression) &&
+           condition_expr.fn_name == :all? &&
            condition_expr.args.length == 1
-          
+
           arg = condition_expr.args.first
           if arg.is_a?(Kumi::Syntax::ArrayExpression) && arg.elements.length == 1
             trait_ref = arg.elements.first
             return compile_expr(trait_ref)
           end
         end
-        
+
         # Otherwise compile normally
         compile_expr(condition_expr)
       end
@@ -216,14 +214,12 @@ module Kumi
 
     def vectorized_operation?(expr)
       # Check if this operation uses vectorized inputs
-      broadcast_meta = @analysis.state[:broadcast_metadata]
+      broadcast_meta = @analysis.state[:broadcasts]
       return false unless broadcast_meta
-      
+
       # Reduction functions are NOT vectorized operations - they consume arrays
-      if FunctionRegistry.reducer?(expr.fn_name)
-        return false
-      end
-      
+      return false if FunctionRegistry.reducer?(expr.fn_name)
+
       expr.args.any? do |arg|
         case arg
         when Kumi::Syntax::InputElementReference
@@ -235,15 +231,14 @@ module Kumi
         end
       end
     end
-    
-    
+
     def invoke_vectorized_function(name, arg_fns, ctx, loc)
       # Evaluate arguments
       values = arg_fns.map { |fn| fn.call(ctx) }
-      
+
       # Check if any argument is vectorized (array)
-      has_vectorized_args = values.any? { |v| v.is_a?(Array) }
-      
+      has_vectorized_args = values.any?(Array)
+
       if has_vectorized_args
         # Apply function with broadcasting to all vectorized arguments
         vectorized_function_call(name, values)
@@ -259,27 +254,26 @@ module Kumi
       runtime_error.define_singleton_method(:cause) { e }
       raise runtime_error
     end
-    
+
     def vectorized_function_call(fn_name, values)
       # Get the function from registry
       fn = FunctionRegistry.fetch(fn_name)
-      
+
       # Find array dimensions for broadcasting
       array_values = values.select { |v| v.is_a?(Array) }
       return fn.call(*values) if array_values.empty?
-      
+
       # All arrays should have the same length (validation could be added)
       array_length = array_values.first.size
-      
+
       # Broadcast and apply function element-wise
       (0...array_length).map do |i|
         element_args = values.map do |v|
-          v.is_a?(Array) ? v[i] : v  # Broadcast scalars
+          v.is_a?(Array) ? v[i] : v # Broadcast scalars
         end
         fn.call(*element_args)
       end
     end
-    
 
     def invoke_function(name, arg_fns, ctx, loc)
       fn = FunctionRegistry.fetch(name)

data/lib/kumi/error_reporting.rb

@@ -54,7 +54,7 @@ module Kumi
 
     # Immediately raise a syntax error
     def raise_syntax_error(message, location: nil, context: {})
-      raise_localized_error(message, location: location, error_class: Errors::SyntaxError, type: :syntax, context: context)
+      raise_localized_error(message, location: location, error_class: Kumi::Errors::SyntaxError, type: :syntax, context: context)
     end
 
     # Immediately raise a type error

data/lib/kumi/explain.rb

@@ -274,6 +274,18 @@ module Kumi
 
       raise ArgumentError, "Schema not found or not compiled" unless syntax_tree && analyzer_result
 
+      metadata = analyzer_result.state
+
+      # Create a minimal analyzer result structure for compatibility
+      analyzer_result = OpenStruct.new(
+        definitions: metadata[:declarations] || {},
+        dependency_graph: metadata[:dependencies] || {},
+        leaf_map: metadata[:leaves] || {},
+        topo_order: metadata[:evaluation_order] || [],
+        decl_types: metadata[:inferred_types] || {},
+        state: metadata
+      )
+
       generator = ExplanationGenerator.new(syntax_tree, analyzer_result, inputs)
       generator.explain(target_name)
     end