kumi 0.0.3 → 0.0.5

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

@@ -13,7 +13,7 @@ module Kumi
           definitions = get_state(:definitions, required: false) || {}
 
           order = compute_topological_order(dependency_graph, definitions, errors)
-          set_state(:topo_order, order)
+          state.with(:topo_order, order)
         end
 
         private
@@ -47,7 +47,7 @@ module Kumi
           # (i.e., declarations with no dependencies)
           definitions.each_key { |node| visit_node.call(node) }
 
-          order
+          order.freeze
         end
 
         def report_unexpected_cycle(temp_marks, current_node, errors)
@@ -57,7 +57,7 @@ module Kumi
           first_decl = find_declaration_by_name(temp_marks.first || current_node)
           location = first_decl&.loc
 
-          add_error(errors, location, "cycle detected: #{cycle_path}")
+          report_error(errors, "cycle detected: #{cycle_path}", location: location)
         end
 
         def find_declaration_by_name(name)

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: None (can run independently)
+      # DEPENDENCIES: :decl_types from TypeInferencer
       # PRODUCES: None (validation only)
       # INTERFACE: new(schema, state).run(errors)
       class TypeChecker < VisitorPass
@@ -12,6 +12,7 @@ module Kumi
           visit_nodes_of_type(Expressions::CallExpression, errors: errors) do |node, _decl, errs|
             validate_function_call(node, errs)
           end
+          state
         end
 
         private

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

@@ -16,6 +16,7 @@ module Kumi
 
           # Then check basic consistency (placeholder for now)
           # In a full implementation, this would do sophisticated usage analysis
+          state
         end
 
         private
@@ -30,7 +31,7 @@ module Kumi
             field_decl = find_input_field_declaration(field_name)
             location = field_decl&.loc
 
-            add_error(errors, location, "Invalid type declaration for field :#{field_name}: #{declared_type.inspect}")
+            report_type_error(errors, "Invalid type declaration for field :#{field_name}: #{declared_type.inspect}", location: location)
           end
         end
 

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

@@ -9,8 +9,6 @@ module Kumi
       # INTERFACE: new(schema, state).run(errors)
       class TypeInferencer < PassBase
         def run(errors)
-          return if state[:decl_types] # Already run
-
           types = {}
           topo_order = get_state(:topo_order)
           definitions = get_state(:definitions)
@@ -24,11 +22,11 @@ module Kumi
               inferred_type = infer_expression_type(decl.expression, types)
               types[name] = inferred_type
             rescue StandardError => e
-              add_error(errors, decl&.loc, "Type inference failed: #{e.message}")
+              report_type_error(errors, "Type inference failed: #{e.message}", location: decl&.loc)
             end
           end
 
-          set_state(:decl_types, types)
+          state.with(:decl_types, types)
         end
 
         private

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

@@ -11,6 +11,8 @@ module Kumi
 
         def run(errors)
           definitions = get_state(:definitions)
+          @input_meta = get_state(:input_meta) || {}
+          @definitions = definitions
           @evaluator = ConstantEvaluator.new(definitions)
 
           each_decl do |decl|
@@ -18,17 +20,64 @@ module Kumi
               # Special handling for cascade expressions
               check_cascade_expression(decl, definitions, errors)
             else
-              # Normal handling for non-cascade expressions
-              atoms = gather_atoms(decl.expression, definitions, Set.new)
-              next if atoms.empty?
+              # 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?
 
-              add_error(errors, decl.loc, "conjunction `#{decl.name}` is impossible") if Kumi::AtomUnsatSolver.unsat?(atoms)
+                # 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
           end
+          state
         end
 
         private
 
+        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
+                              false
+                            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
+                               false
+                             end
+
+          # OR is impossible only if BOTH sides are impossible
+          left_impossible && right_impossible
+        end
+
         def gather_atoms(node, defs, visited, list = [])
           return list unless node
 
@@ -41,7 +90,25 @@ module Kumi
 
             if current.is_a?(CallExpression) && COMPARATORS.include?(current.fn_name)
               lhs, rhs = current.args
-              list << Atom.new(current.fn_name, term(lhs, defs), term(rhs, defs))
+
+              # Check for domain constraint violations before creating atom
+              list << if impossible_constraint?(lhs, rhs, current.fn_name)
+                        # Create a special impossible atom that will always trigger unsat
+                        Atom.new(:==, :__impossible__, true)
+                      else
+                        Atom.new(current.fn_name, term(lhs, defs), term(rhs, defs))
+                      end
+            elsif current.is_a?(CallExpression) && current.fn_name == :or
+              # Special handling for OR expressions - they are disjunctive, not conjunctive
+              # We should NOT add OR children to the stack as they would be treated as AND
+              # OR expressions need separate analysis in the main run() method
+              next
+            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
+              current.elements.each { |elem| stack << elem }
             elsif current.is_a?(Binding)
               name = current.name
               unless visited.include?(name)
@@ -51,7 +118,10 @@ module Kumi
             end
 
             # Add children to stack for processing
-            current.children.each { |child| stack << child } if current.respond_to?(:children)
+            # IMPORTANT: Skip CascadeExpression children to avoid false positives
+            # Cascades are handled separately by check_cascade_expression() and are disjunctive,
+            # but gather_atoms() treats all collected atoms as conjunctive
+            current.children.each { |child| stack << child } if current.respond_to?(:children) && !current.is_a?(CascadeExpression)
           end
 
           list
@@ -66,27 +136,58 @@ module Kumi
             # Skip the base case (it's typically a literal true condition)
             next if when_case.condition.is_a?(Literal) && when_case.condition.value == true
 
+            # Skip non-conjunctive conditions (any?, none?) as they are disjunctive
+            next if when_case.condition.is_a?(CallExpression) && %i[any? none?].include?(when_case.condition.fn_name)
+
             # Skip single-trait 'on' branches: trait-level unsat detection covers these
             if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :all?
-              list = when_case.condition.args.first
-              next if list.is_a?(ListExpression) && list.elements.size < 2
+              # 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)
+                list = when_case.condition.args.first
+                next if list.elements.size == 1
+              elsif when_case.condition.args.size == 1
+                # Multiple args format
+                next
+              end
             end
             # Gather atoms from this individual condition only
             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
 
             # Only flag if this individual condition is impossible
-            next unless !condition_atoms.empty? && Kumi::AtomUnsatSolver.unsat?(condition_atoms)
+            # if !condition_atoms.empty?
+            #   is_unsat = Kumi::AtomUnsatSolver.unsat?(condition_atoms)
+            #   puts "  Is unsat? #{is_unsat}"
+            # end
+            # Use enhanced solver for cascade conditions too
+            impossible = if definitions && !definitions.empty?
+                           Kumi::ConstraintRelationshipSolver.unsat?(condition_atoms, definitions, input_meta: @input_meta)
+                         else
+                           Kumi::AtomUnsatSolver.unsat?(condition_atoms)
+                         end
+            next unless !condition_atoms.empty? && impossible
 
             # 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?
-              list = when_case.condition.args.first
-              if list.is_a?(ListExpression) && list.elements.all?(Binding)
-                traits = list.elements.map(&:name).join(" AND ")
-                add_error(errors, decl.loc, "conjunction `#{traits}` is impossible")
+              # 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)
+                                 when_case.condition.args.first.elements
+                               else
+                                 when_case.condition.args
+                               end
+
+              if trait_bindings.all?(Binding)
+                traits = trait_bindings.map(&:name).join(" AND ")
+                report_error(errors, "conjunction `#{traits}` is impossible", location: decl.loc)
                 next
               end
             end
-            add_error(errors, decl.loc, "conjunction `#{decl.name}` is impossible")
+            report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc)
           end
         end
 
@@ -101,6 +202,124 @@ module Kumi
             :unknown
           end
         end
+
+        def check_domain_constraints(node, definitions, errors)
+          case node
+          when FieldRef
+            # Check if FieldRef 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
+            # Check if this binding evaluates to a value that violates domain constraints
+            definition = definitions[node.name]
+            return unless definition
+
+            if definition.expression.is_a?(Literal)
+              literal_value = definition.expression.value
+              check_value_against_domains(node.name, literal_value, errors, definition.loc)
+            end
+          end
+        end
+
+        def check_value_against_domains(_var_name, value, _errors, _location)
+          # Check if this value violates any input domain constraints
+          @input_meta.each_value do |field_meta|
+            domain = field_meta[:domain]
+            next unless domain
+
+            if violates_domain?(value, domain)
+              # This indicates a constraint that can never be satisfied
+              # Rather than flagging the cascade, flag the impossible condition
+              return true
+            end
+          end
+          false
+        end
+
+        def violates_domain?(value, domain)
+          case domain
+          when Range
+            !domain.include?(value)
+          when Array
+            !domain.include?(value)
+          when Proc
+            # For Proc domains, we can't statically analyze
+            false
+          else
+            false
+          end
+        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)
+            return field_literal_impossible?(lhs, rhs, operator)
+          elsif rhs.is_a?(FieldRef) && 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)
+            return binding_literal_impossible?(lhs, rhs, operator)
+          elsif rhs.is_a?(Binding) && lhs.is_a?(Literal)
+            return binding_literal_impossible?(rhs, lhs, flip_operator(operator))
+          end
+
+          false
+        end
+
+        def field_literal_impossible?(field_ref, literal, operator)
+          field_meta = @input_meta[field_ref.name]
+          return false unless field_meta&.dig(:domain)
+
+          domain = field_meta[:domain]
+          literal_value = literal.value
+
+          case operator
+          when :==
+            # field == value where value is not in domain
+            violates_domain?(literal_value, domain)
+          when :!=
+            # field != value where value is not in domain is always true (not impossible)
+            false
+          else
+            # For other operators, we'd need more sophisticated analysis
+            false
+          end
+        end
+
+        def binding_literal_impossible?(binding, literal, operator)
+          # Check if binding evaluates to a literal that conflicts with the comparison
+          evaluated_value = @evaluator.evaluate(binding)
+          return false if evaluated_value == :unknown
+
+          literal_value = literal.value
+
+          case operator
+          when :==
+            # binding == value where binding evaluates to different value
+            evaluated_value != literal_value
+          else
+            # For other operators, we could add more sophisticated checking
+            false
+          end
+        end
+
+        def flip_operator(operator)
+          case operator
+          when :> then :<
+          when :>= then :<=
+          when :< then :>
+          when :<= then :>=
+          when :== then :==
+          when :!= then :!=
+          else operator
+          end
+        end
       end
     end
   end

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

@@ -3,7 +3,8 @@
 module Kumi
   module Analyzer
     module Passes
-      # Base class for analyzer passes that need to traverse the AST using the visitor pattern
+      # Base class for analyzer passes that need to traverse the AST using the visitor pattern.
+      # Inherits the new immutable state interface from PassBase.
       class VisitorPass < PassBase
         # Visit a node and all its children using depth-first traversal
         # @param node [Syntax::Node] The node to visit

data/lib/kumi/analyzer.rb

@@ -1,5 +1,7 @@
 # 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)
@@ -7,40 +9,56 @@ 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::DependencyResolver,     # 4. Builds the dependency graph.
-      Passes::UnsatDetector,          # 5. Detects unsatisfiable constraints in rules.
-      Passes::Toposorter,             # 6. Creates the final evaluation order.
-      Passes::TypeInferencer,         # 7. Infers types for all declarations (pure annotation).
-      Passes::TypeConsistencyChecker, # 8. Validates declared vs inferred type consistency.
-      Passes::TypeChecker             # 9. 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::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.
     ].freeze
 
     def analyze!(schema, passes: DEFAULT_PASSES, **opts)
-      analysis_state = { opts: opts }
+      state = AnalysisState.new(opts)
       errors = []
 
-      passes.each { |klass| klass.new(schema, analysis_state).run(errors) }
+      state = run_analysis_passes(schema, passes, state, errors)
+      handle_analysis_errors(errors) unless errors.empty?
+      create_analysis_result(state)
+    end
 
-      unless errors.empty?
-        # Check if we have type-specific errors to raise more specific exception
-        type_errors = errors.select { |e| e.type == :type }
-        first_error_location = errors.first.location
+    def self.run_analysis_passes(schema, passes, state, errors)
+      passes.each do |pass_class|
+        pass_instance = pass_class.new(schema, state)
+        begin
+          state = pass_instance.run(errors)
+        rescue StandardError => e
+          errors << ErrorReporter.create_error(e.message, location: nil, type: :semantic)
+        end
+      end
+      state
+    end
 
-        raise Errors::TypeError.new(format_errors(errors), first_error_location) if type_errors.any?
+    def self.handle_analysis_errors(errors)
+      type_errors = errors.select { |e| e.type == :type }
+      first_error_location = errors.first.location
 
-        raise Errors::SemanticError.new(format_errors(errors), first_error_location)
-      end
+      raise Errors::TypeError.new(format_errors(errors), first_error_location) if type_errors.any?
+
+      raise Errors::SemanticError.new(format_errors(errors), first_error_location)
+    end
 
+    def self.create_analysis_result(state)
       Result.new(
-        definitions: analysis_state[:definitions].freeze,
-        dependency_graph: analysis_state[:dependency_graph].freeze,
-        leaf_map: analysis_state[:leaf_map].freeze,
-        topo_order: analysis_state[:topo_order].freeze,
-        decl_types: analysis_state[:decl_types].freeze,
-        state: analysis_state.freeze
+        definitions: state[:definitions],
+        dependency_graph: state[:dependency_graph],
+        leaf_map: state[:leaf_map],
+        topo_order: state[:topo_order],
+        decl_types: state[:decl_types],
+        state: state.to_h
       )
     end
 

data/lib/kumi/atom_unsat_solver.rb

@@ -38,6 +38,9 @@ module Kumi
     # @param debug [Boolean] enable debug output
     # @return [Boolean] true if constraints are unsatisfiable
     def unsat?(atoms, debug: false)
+      # Pass 0: Check for special impossible atoms (domain violations, etc.)
+      return true if impossible_atoms_exist?(atoms, debug: debug)
+
       # Pass 1: Check numerical bound contradictions (symbol vs numeric)
       return true if numerical_contradiction?(atoms, debug: debug)
 
@@ -51,6 +54,21 @@ module Kumi
       StrictInequalitySolver.cycle?(edges, debug: debug)
     end
 
+    # Pass 0: Detects special impossible atoms (domain violations, etc.)
+    # These atoms are created by UnsatDetector when it finds statically impossible constraints
+    #
+    # @param atoms [Array<Atom>] constraint atoms
+    # @param debug [Boolean] enable debug output
+    # @return [Boolean] true if impossible atoms exist
+    def impossible_atoms_exist?(atoms, debug: false)
+      impossible_found = atoms.any? do |atom|
+        atom.lhs == :__impossible__ || atom.rhs == :__impossible__
+      end
+
+      puts "impossible atom detected (domain violation or static impossibility)" if impossible_found && debug
+      impossible_found
+    end
+
     # Pass 1: Detects numerical bound contradictions using interval analysis
     # Handles cases like x > 5 AND x < 3 (contradictory bounds)
     # Also detects always-false comparisons like 100 < 100 or 5 > 5
@@ -99,6 +117,7 @@ module Kumi
       equal_pairs, strict_pairs = collect_equality_pairs(atoms)
 
       return true if direct_equality_contradiction?(equal_pairs, strict_pairs, debug)
+      return true if conflicting_equalities?(atoms, debug: debug)
 
       transitive_equality_contradiction?(equal_pairs, strict_pairs, debug)
     end
@@ -210,6 +229,32 @@ module Kumi
       true
     end
 
+    # Checks for conflicting equalities (x == a AND x == b where a != b)
+    # @param atoms [Array<Atom>] constraint atoms
+    # @param debug [Boolean] enable debug output
+    # @return [Boolean] true if conflicting equalities exist
+    def conflicting_equalities?(atoms, debug: false)
+      equalities = atoms.select { |atom| atom.op == :== }
+
+      # Group equalities by their left-hand side
+      by_lhs = equalities.group_by(&:lhs)
+
+      # Check each variable for conflicting equality constraints
+      by_lhs.each do |lhs, atoms_for_lhs|
+        next if atoms_for_lhs.size < 2
+
+        # Get all values this variable is constrained to equal
+        values = atoms_for_lhs.map(&:rhs).uniq
+
+        if values.size > 1
+          puts "conflicting equalities detected: #{lhs} == #{values.join(" AND #{lhs} == ")}" if debug
+          return true
+        end
+      end
+
+      false
+    end
+
     # Checks for transitive equality contradictions using union-find
     # @param equal_pairs [Set] equality constraint pairs
     # @param strict_pairs [Set] strict inequality pairs