kumi 0.0.5 → 0.0.7

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

@@ -4,14 +4,17 @@ module Kumi
   module Analyzer
     module Passes
       # RESPONSIBILITY: Infer types for all declarations based on expression analysis
-      # DEPENDENCIES: Toposorter (needs topo_order), DefinitionValidator (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(:broadcasts, required: false) || {}
 
           # Process declarations in topological order to ensure dependencies are resolved
           topo_order.each do |name|
@@ -19,44 +22,67 @@ module Kumi
             next unless decl
 
             begin
-              inferred_type = infer_expression_type(decl.expression, types)
-              types[name] = inferred_type
+              # Check if this declaration is marked as vectorized
+              if broadcast_meta[:vectorized_operations]&.key?(name)
+                # Infer the element type and wrap in array
+                element_type = infer_vectorized_element_type(decl.expression, types, broadcast_meta)
+                types[name] = decl.is_a?(Kumi::Syntax::TraitDeclaration) ? { array: :boolean } : { array: element_type }
+              else
+                # Normal type inference
+                inferred_type = infer_expression_type(decl.expression, types, broadcast_meta, name)
+                types[name] = inferred_type
+              end
             rescue StandardError => e
               report_type_error(errors, "Type inference failed: #{e.message}", location: decl&.loc)
             end
           end
 
-          state.with(:decl_types, types)
+          state.with(:inferred_types, types)
         end
 
         private
 
-        def infer_expression_type(expr, type_context = {})
+        def infer_expression_type(expr, type_context = {}, broadcast_metadata = {}, current_decl_name = nil)
           case expr
           when Literal
             Types.infer_from_value(expr.value)
-          when FieldRef
+          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 Binding
+          when DeclarationReference
             type_context[expr.name] || :any
           when CallExpression
-            infer_call_type(expr, type_context)
-          when ListExpression
-            infer_list_type(expr, type_context)
+            infer_call_type(expr, type_context, broadcast_metadata, current_decl_name)
+          when ArrayExpression
+            infer_list_type(expr, type_context, broadcast_metadata, current_decl_name)
           when CascadeExpression
-            infer_cascade_type(expr, type_context)
+            infer_cascade_type(expr, type_context, broadcast_metadata, current_decl_name)
+          when InputElementReference
+            # Element reference returns the field type
+            infer_element_reference_type(expr)
           else
             :any
           end
         end
 
-        def infer_call_type(call_expr, type_context)
+        def infer_call_type(call_expr, type_context, broadcast_metadata = {}, current_decl_name = nil)
           fn_name = call_expr.fn_name
           args = call_expr.args
 
+          # Check broadcast metadata first
+          if current_decl_name && broadcast_metadata[:vectorized_values]&.key?(current_decl_name)
+            # This declaration is marked as vectorized, so it produces an array
+            element_type = infer_vectorized_element_type(call_expr, type_context, broadcast_metadata)
+            return { array: element_type }
+          end
+
+          if current_decl_name && broadcast_metadata[:reducer_values]&.key?(current_decl_name)
+            # This declaration is marked as a reducer, get the result from the function
+            return infer_function_return_type(fn_name, args, type_context, broadcast_metadata)
+          end
+
           # Check if function exists in registry
           unless FunctionRegistry.supported?(fn_name)
             # Don't push error here - let existing TypeChecker handle it
@@ -72,7 +98,7 @@ module Kumi
           end
 
           # Infer argument types
-          arg_types = args.map { |arg| infer_expression_type(arg, type_context) }
+          arg_types = args.map { |arg| infer_expression_type(arg, type_context, broadcast_metadata, current_decl_name) }
 
           # Validate parameter types (warn but don't fail)
           param_types = signature[:param_types] || []
@@ -90,10 +116,29 @@ module Kumi
           signature[:return_type] || :any
         end
 
-        def infer_list_type(list_expr, type_context)
+        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
+          when :multiply, :add, :subtract, :divide
+            :float
+          else
+            :any
+          end
+        end
+
+        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
+
+        def infer_list_type(list_expr, type_context, broadcast_metadata = {}, current_decl_name = nil)
           return Types.array(:any) if list_expr.elements.empty?
 
-          element_types = list_expr.elements.map { |elem| infer_expression_type(elem, type_context) }
+          element_types = list_expr.elements.map { |elem| infer_expression_type(elem, type_context, broadcast_metadata, current_decl_name) }
 
           # Try to unify all element types
           unified_type = element_types.reduce { |acc, type| Types.unify(acc, type) }
@@ -103,11 +148,75 @@ module Kumi
           Types.array(:any)
         end
 
-        def infer_cascade_type(cascade_expr, type_context)
+        def infer_vectorized_element_type(expr, type_context, vectorization_meta)
+          # For vectorized operations, we need to infer the element type
+          case expr
+          when InputElementReference
+            # Get the field type from metadata
+            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)
+              # Get types of operands
+              arg_types = expr.args.map do |arg|
+                if arg.is_a?(InputElementReference)
+                  infer_vectorized_element_type(arg, type_context, vectorization_meta)
+                elsif arg.is_a?(DeclarationReference)
+                  # Get the element type if it's vectorized
+                  ref_type = type_context[arg.name]
+                  if ref_type.is_a?(Hash) && ref_type.key?(:array)
+                    ref_type[:array]
+                  else
+                    ref_type || :any
+                  end
+                else
+                  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
+        end
+
+        def infer_element_reference_type(expr)
+          # Get array field metadata
+          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
+
+        def infer_cascade_type(cascade_expr, type_context, broadcast_metadata = {}, current_decl_name = nil)
           return :any if cascade_expr.cases.empty?
 
           result_types = cascade_expr.cases.map do |case_stmt|
-            infer_expression_type(case_stmt.result, type_context)
+            infer_expression_type(case_stmt.result, type_context, broadcast_metadata, current_decl_name)
           end
 
           # Reduce all possible types into a single unified type

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

@@ -3,6 +3,10 @@
 module Kumi
   module Analyzer
     module Passes
+      # RESPONSIBILITY: Detect unsatisfiable constraints and analyze cascade mutual exclusion
+      # 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
 
@@ -10,68 +14,143 @@ 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
+          cascades = {}
           each_decl do |decl|
+            cascades[decl.name] = analyze_cascade_mutual_exclusion(decl, definitions) if decl.expression.is_a?(CascadeExpression)
+
+            # Store cascade metadata for later passes
+
+            # Second pass: check for unsatisfiable constraints
             if decl.expression.is_a?(CascadeExpression)
               # Special handling for cascade expressions
               check_cascade_expression(decl, definitions, errors)
-            else
+            elsif decl.expression.is_a?(CallExpression) && decl.expression.fn_name == :or
               # Check for OR expressions which need special disjunctive handling
-              if decl.expression.is_a?(CallExpression) && decl.expression.fn_name == :or
-                impossible = check_or_expression(decl.expression, definitions, errors)
-                report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
-              else
-                # Normal handling for non-cascade expressions
-                atoms = gather_atoms(decl.expression, definitions, Set.new)
-                next if atoms.empty?
-
-                # Use enhanced solver that can detect cross-variable mathematical constraints
-                impossible = if definitions && !definitions.empty?
-                               Kumi::ConstraintRelationshipSolver.unsat?(atoms, definitions, input_meta: @input_meta)
-                             else
-                               Kumi::AtomUnsatSolver.unsat?(atoms)
-                             end
+              impossible = check_or_expression(decl.expression, definitions, errors)
+              report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
+            else
+              # Normal handling for non-cascade expressions
+              atoms = gather_atoms(decl.expression, definitions, Set.new)
+              next if atoms.empty?
+
+              # Use enhanced solver that can detect cross-variable mathematical constraints
+              impossible = if definitions && !definitions.empty?
+                             Kumi::ConstraintRelationshipSolver.unsat?(atoms, definitions, input_meta: @input_meta)
+                           else
+                             Kumi::AtomUnsatSolver.unsat?(atoms)
+                           end
+
+              report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
+            end
+          end
+          state.with(:cascades, cascades)
+        end
+
+        private
 
-                report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
+        def analyze_cascade_mutual_exclusion(decl, definitions)
+          conditions = []
+          condition_traits = []
+
+          # Extract all cascade conditions (except base case)
+          decl.expression.cases[0...-1].each do |when_case|
+            next unless when_case.condition
+
+            next unless when_case.condition.fn_name == :all?
+
+            when_case.condition.args.each do |arg|
+              next unless arg.is_a?(ArrayExpression)
+
+              arg.elements.each do |element|
+                next unless element.is_a?(DeclarationReference)
+
+                trait_name = element.name
+                trait = definitions[trait_name]
+                if trait
+                  conditions << trait.expression
+                  condition_traits << trait_name
+                end
               end
             end
+            # end
+          end
+
+          # Check mutual exclusion for all pairs
+          total_pairs = conditions.size * (conditions.size - 1) / 2
+          exclusive_pairs = 0
+
+          if conditions.size >= 2
+            conditions.combination(2).each do |cond1, cond2|
+              exclusive_pairs += 1 if conditions_mutually_exclusive?(cond1, cond2)
+            end
           end
-          state
+
+          all_mutually_exclusive = total_pairs.positive? && (exclusive_pairs == total_pairs)
+
+          {
+            condition_traits: condition_traits,
+            condition_count: conditions.size,
+            all_mutually_exclusive: all_mutually_exclusive,
+            exclusive_pairs: exclusive_pairs,
+            total_pairs: total_pairs
+          }
         end
 
-        private
+        def conditions_mutually_exclusive?(cond1, cond2)
+          if cond1.is_a?(CallExpression) && cond1.fn_name == :== &&
+             cond2.is_a?(CallExpression) && cond2.fn_name == :==
+
+            c1_field, c1_value = cond1.args
+            c2_field, c2_value = cond2.args
+
+            # Same field, different values = mutually exclusive
+            return true if same_field?(c1_field, c2_field) && different_values?(c1_value, c2_value)
+          end
 
-        def check_or_expression(or_expr, definitions, errors)
+          false
+        end
+
+        def same_field?(field1, field2)
+          return false unless field1.is_a?(InputReference) && field2.is_a?(InputReference)
+
+          field1.name == field2.name
+        end
+
+        def different_values?(val1, val2)
+          return false unless val1.is_a?(Literal) && val2.is_a?(Literal)
+
+          val1.value != val2.value
+        end
+
+        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
 
           # Check if left side is impossible
           left_atoms = gather_atoms(left_side, definitions, Set.new)
-          left_impossible = if !left_atoms.empty?
-                              if definitions && !definitions.empty?
-                                Kumi::ConstraintRelationshipSolver.unsat?(left_atoms, definitions, input_meta: @input_meta)
-                              else
-                                Kumi::AtomUnsatSolver.unsat?(left_atoms)
-                              end
-                            else
+          left_impossible = if left_atoms.empty?
                               false
+                            elsif definitions && !definitions.empty?
+                              Kumi::ConstraintRelationshipSolver.unsat?(left_atoms, definitions, input_meta: @input_meta)
+                            else
+                              Kumi::AtomUnsatSolver.unsat?(left_atoms)
                             end
 
           # Check if right side is impossible
           right_atoms = gather_atoms(right_side, definitions, Set.new)
-          right_impossible = if !right_atoms.empty?
-                               if definitions && !definitions.empty?
-                                 Kumi::ConstraintRelationshipSolver.unsat?(right_atoms, definitions, input_meta: @input_meta)
-                               else
-                                 Kumi::AtomUnsatSolver.unsat?(right_atoms)
-                               end
-                             else
+          right_impossible = if right_atoms.empty?
                                false
+                             elsif definitions && !definitions.empty?
+                               Kumi::ConstraintRelationshipSolver.unsat?(right_atoms, definitions, input_meta: @input_meta)
+                             else
+                               Kumi::AtomUnsatSolver.unsat?(right_atoms)
                              end
 
           # OR is impossible only if BOTH sides are impossible
@@ -106,10 +185,10 @@ module Kumi
             elsif current.is_a?(CallExpression) && current.fn_name == :all?
               # For all? function, add all trait arguments to the stack
               current.args.each { |arg| stack << arg }
-            elsif current.is_a?(ListExpression)
-              # For ListExpression, add all elements to the stack
+            elsif current.is_a?(ArrayExpression)
+              # For ArrayExpression, add all elements to the stack
               current.elements.each { |elem| stack << elem }
-            elsif current.is_a?(Binding)
+            elsif current.is_a?(DeclarationReference)
               name = current.name
               unless visited.include?(name)
                 visited << name
@@ -141,8 +220,8 @@ module Kumi
 
             # Skip single-trait 'on' branches: trait-level unsat detection covers these
             if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :all?
-              # Handle both ListExpression (old format) and multiple args (new format)
-              if when_case.condition.args.size == 1 && when_case.condition.args.first.is_a?(ListExpression)
+              # Handle both ArrayExpression (old format) and multiple args (new format)
+              if when_case.condition.args.size == 1 && when_case.condition.args.first.is_a?(ArrayExpression)
                 list = when_case.condition.args.first
                 next if list.elements.size == 1
               elsif when_case.condition.args.size == 1
@@ -154,7 +233,6 @@ module Kumi
             condition_atoms = gather_atoms(when_case.condition, definitions, Set.new, [])
             # DEBUG
             # if when_case.condition.is_a?(CallExpression) && [:all?, :any?, :none?].include?(when_case.condition.fn_name)
-            #   puts "DEBUG: Processing #{when_case.condition.fn_name} condition"
             #   puts "  Args: #{when_case.condition.args.inspect}"
             #   puts "  Atoms found: #{condition_atoms.inspect}"
             # end
@@ -174,14 +252,14 @@ module Kumi
 
             # For multi-trait on-clauses, report the trait names rather than the value name
             if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :all?
-              # Handle both ListExpression (old format) and multiple args (new format)
-              trait_bindings = if when_case.condition.args.size == 1 && when_case.condition.args.first.is_a?(ListExpression)
+              # Handle both ArrayExpression (old format) and multiple args (new format)
+              trait_bindings = if when_case.condition.args.size == 1 && when_case.condition.args.first.is_a?(ArrayExpression)
                                  when_case.condition.args.first.elements
                                else
                                  when_case.condition.args
                                end
 
-              if trait_bindings.all?(Binding)
+              if trait_bindings.all?(DeclarationReference)
                 traits = trait_bindings.map(&:name).join(" AND ")
                 report_error(errors, "conjunction `#{traits}` is impossible", location: decl.loc)
                 next
@@ -193,7 +271,7 @@ module Kumi
 
         def term(node, _defs)
           case node
-          when FieldRef, Binding
+          when InputReference, DeclarationReference
             val = @evaluator.evaluate(node)
             val == :unknown ? node.name : val
           when Literal
@@ -205,14 +283,14 @@ module Kumi
 
         def check_domain_constraints(node, definitions, errors)
           case node
-          when FieldRef
-            # Check if FieldRef points to a field with domain constraints
+          when InputReference
+            # Check if InputReference points to a field with domain constraints
             field_meta = @input_meta[node.name]
             nil unless field_meta&.dig(:domain)
 
-            # For FieldRef, the constraint comes from trait conditions
-            # We don't flag here since the FieldRef itself is valid
-          when Binding
+            # For InputReference, the constraint comes from trait conditions
+            # We don't flag here since the InputReference itself is valid
+          when DeclarationReference
             # Check if this binding evaluates to a value that violates domain constraints
             definition = definitions[node.name]
             return unless definition
@@ -254,18 +332,18 @@ module Kumi
         end
 
         def impossible_constraint?(lhs, rhs, operator)
-          # Case 1: FieldRef compared against value outside its domain
-          if lhs.is_a?(FieldRef) && rhs.is_a?(Literal)
+          # Case 1: InputReference compared against value outside its domain
+          if lhs.is_a?(InputReference) && rhs.is_a?(Literal)
             return field_literal_impossible?(lhs, rhs, operator)
-          elsif rhs.is_a?(FieldRef) && lhs.is_a?(Literal)
+          elsif rhs.is_a?(InputReference) && lhs.is_a?(Literal)
             # Reverse case: literal compared to field
             return field_literal_impossible?(rhs, lhs, flip_operator(operator))
           end
 
-          # Case 2: Binding that evaluates to literal compared against impossible value
-          if lhs.is_a?(Binding) && rhs.is_a?(Literal)
+          # Case 2: DeclarationReference that evaluates to literal compared against impossible value
+          if lhs.is_a?(DeclarationReference) && rhs.is_a?(Literal)
             return binding_literal_impossible?(lhs, rhs, operator)
-          elsif rhs.is_a?(Binding) && lhs.is_a?(Literal)
+          elsif rhs.is_a?(DeclarationReference) && lhs.is_a?(Literal)
             return binding_literal_impossible?(rhs, lhs, flip_operator(operator))
           end
 

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

@@ -20,7 +20,7 @@ module Kumi
 
         # Helper to visit each declaration's expression tree
         # @param errors [Array] Error accumulator
-        # @yield [Syntax::Node, Syntax::Declarations::Base] Each node and its containing declaration
+        # @yield [Syntax::Node, Syntax::Base] Each node and its containing declaration
         def visit_all_expressions(errors)
           each_decl do |decl|
             visit(decl.expression) { |node| yield(node, decl, errors) }
@@ -30,7 +30,7 @@ module Kumi
         # Helper to visit only specific node types
         # @param node_types [Array<Class>] Node types to match
         # @param errors [Array] Error accumulator
-        # @yield [Syntax::Node, Syntax::Declarations::Base] Matching nodes and their declarations
+        # @yield [Syntax::Node, Syntax::Base] Matching nodes and their declarations
         def visit_nodes_of_type(*node_types, errors:)
           visit_all_expressions(errors) do |node, decl, errs|
             yield(node, decl, errs) if node_types.any? { |type| node.is_a?(type) }

data/lib/kumi/analyzer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "analyzer/analysis_state"
-
 module Kumi
   module Analyzer
     Result = Struct.new(:definitions, :dependency_graph, :leaf_map, :topo_order, :decl_types, :state, keyword_init: true)
@@ -9,16 +7,17 @@ module Kumi
     module_function
 
     DEFAULT_PASSES = [
-      Passes::NameIndexer,                # 1. Finds all names and checks for duplicates.
-      Passes::InputCollector,             # 2. Collects field metadata from input declarations.
-      Passes::DefinitionValidator,        # 3. Checks the basic structure of each rule.
-      Passes::SemanticConstraintValidator, # 4. Validates DSL semantic constraints at AST level.
-      Passes::DependencyResolver,         # 5. Builds the dependency graph.
-      Passes::UnsatDetector,              # 6. Detects unsatisfiable constraints in rules.
-      Passes::Toposorter,                 # 7. Creates the final evaluation order.
-      Passes::TypeInferencer,             # 8. Infers types for all declarations (pure annotation).
-      Passes::TypeConsistencyChecker,     # 9. Validates declared vs inferred type consistency.
-      Passes::TypeChecker                 # 10. Validates types using inferred information.
+      Passes::NameIndexer,                     # 1. Finds all names and checks for duplicates.
+      Passes::InputCollector,                  # 2. Collects field metadata from input declarations.
+      Passes::DeclarationValidator,            # 3. Checks the basic structure of each rule.
+      Passes::SemanticConstraintValidator,     # 4. Validates DSL semantic constraints at AST level.
+      Passes::DependencyResolver,              # 5. Builds the dependency graph with conditional dependencies.
+      Passes::UnsatDetector,                   # 6. Detects unsatisfiable constraints and analyzes cascade mutual exclusion.
+      Passes::Toposorter,                      # 7. Creates the final evaluation order, allowing safe cycles.
+      Passes::BroadcastDetector, # 8. Detects which operations should be broadcast over arrays (must run before type inference).
+      Passes::TypeInferencer,                  # 9. Infers types for all declarations (uses vectorization metadata).
+      Passes::TypeConsistencyChecker,          # 10. Validates declared vs inferred type consistency.
+      Passes::TypeChecker                      # 11. Validates types using inferred information.
     ].freeze
 
     def analyze!(schema, passes: DEFAULT_PASSES, **opts)
@@ -53,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