kumi 0.0.7 → 0.0.8

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

@@ -1,404 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-        COMPARATORS = %i[> < >= <= == !=].freeze
-        Atom        = Kumi::AtomUnsatSolver::Atom
-
-        def run(errors)
-          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)
-            elsif decl.expression.is_a?(CallExpression) && decl.expression.fn_name == :or
-              # Check for OR expressions which need special disjunctive handling
-              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
-
-        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
-
-          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
-
-        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
-
-          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?
-                              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?
-                               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
-          left_impossible && right_impossible
-        end
-
-        def gather_atoms(node, defs, visited, list = [])
-          return list unless node
-
-          # Use iterative approach with stack to avoid SystemStackError on deep graphs
-          stack = [node]
-
-          until stack.empty?
-            current = stack.pop
-            next unless current
-
-            if current.is_a?(CallExpression) && COMPARATORS.include?(current.fn_name)
-              lhs, rhs = current.args
-
-              # 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?(ArrayExpression)
-              # For ArrayExpression, add all elements to the stack
-              current.elements.each { |elem| stack << elem }
-            elsif current.is_a?(DeclarationReference)
-              name = current.name
-              unless visited.include?(name)
-                visited << name
-                stack << defs[name].expression if defs.key?(name)
-              end
-            end
-
-            # Add children to stack for processing
-            # 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
-        end
-
-        def check_cascade_expression(decl, definitions, errors)
-          # Analyze each cascade branch condition independently
-          # This is the correct behavior: each 'on' condition should be checked separately
-          # since only ONE will be evaluated at runtime (they're mutually exclusive by design)
-
-          decl.expression.cases.each_with_index do |when_case, _index|
-            # 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?
-              # 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
-                # 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 "  Args: #{when_case.condition.args.inspect}"
-            #   puts "  Atoms found: #{condition_atoms.inspect}"
-            # end
-
-            # Only flag if this individual condition is impossible
-            # 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?
-              # 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?(DeclarationReference)
-                traits = trait_bindings.map(&:name).join(" AND ")
-                report_error(errors, "conjunction `#{traits}` is impossible", location: decl.loc)
-                next
-              end
-            end
-            report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc)
-          end
-        end
-
-        def term(node, _defs)
-          case node
-          when InputReference, DeclarationReference
-            val = @evaluator.evaluate(node)
-            val == :unknown ? node.name : val
-          when Literal
-            node.value
-          else
-            :unknown
-          end
-        end
-
-        def check_domain_constraints(node, definitions, errors)
-          case node
-          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 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
-
-            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: 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?(InputReference) && lhs.is_a?(Literal)
-            # Reverse case: literal compared to field
-            return field_literal_impossible?(rhs, lhs, flip_operator(operator))
-          end
-
-          # 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?(DeclarationReference) && 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
-end

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

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Analyzer
-    module Passes
-      # 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
-        # @yield [Syntax::Node] Each node in the traversal
-        def visit(node, &block)
-          return unless node
-
-          yield(node)
-          node.children.each { |child| visit(child, &block) }
-        end
-
-        protected
-
-        # Helper to visit each declaration's expression tree
-        # @param errors [Array] Error accumulator
-        # @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) }
-          end
-        end
-
-        # 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::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) }
-          end
-        end
-      end
-    end
-  end
-end