kumi 0.0.0 → 0.0.4

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Analyzer
+    module Passes
+      # RESPONSIBILITY: Validate function call arity and argument types against FunctionRegistry
+      # DEPENDENCIES: None (can run independently)
+      # PRODUCES: None (validation only)
+      # INTERFACE: new(schema, state).run(errors)
+      class TypeChecker < VisitorPass
+        def run(errors)
+          visit_nodes_of_type(Expressions::CallExpression, errors: errors) do |node, _decl, errs|
+            validate_function_call(node, errs)
+          end
+        end
+
+        private
+
+        def validate_function_call(node, errors)
+          signature = get_function_signature(node, errors)
+          return unless signature
+
+          validate_arity(node, signature, errors)
+          validate_argument_types(node, signature, errors)
+        end
+
+        def get_function_signature(node, errors)
+          FunctionRegistry.signature(node.fn_name)
+        rescue FunctionRegistry::UnknownFunction
+          # Use old format for backward compatibility, but node.loc provides better location
+          report_error(errors, "unsupported operator `#{node.fn_name}`", location: node.loc, type: :type)
+          nil
+        end
+
+        def validate_arity(node, signature, errors)
+          expected_arity = signature[:arity]
+          actual_arity = node.args.size
+
+          return if expected_arity.negative? || expected_arity == actual_arity
+
+          report_error(errors, "operator `#{node.fn_name}` expects #{expected_arity} args, got #{actual_arity}", location: node.loc,
+                                                                                                                 type: :type)
+        end
+
+        def validate_argument_types(node, signature, errors)
+          types = signature[:param_types]
+          return if types.nil? || (signature[:arity].negative? && node.args.empty?)
+
+          node.args.each_with_index do |arg, i|
+            validate_argument_type(arg, i, types[i], node.fn_name, errors)
+          end
+        end
+
+        def validate_argument_type(arg, index, expected_type, fn_name, errors)
+          return if expected_type.nil? || expected_type == Kumi::Types::ANY
+
+          # Get the inferred type for this argument
+          actual_type = get_expression_type(arg)
+          return if Kumi::Types.compatible?(actual_type, expected_type)
+
+          # Generate descriptive error message
+          source_desc = describe_expression_type(arg, actual_type)
+          report_error(errors, "argument #{index + 1} of `fn(:#{fn_name})` expects #{expected_type}, " \
+                               "got #{source_desc}", location: arg.loc, type: :type)
+        end
+
+        def get_expression_type(expr)
+          case expr
+          when TerminalExpressions::Literal
+            # Inferred type from literal value
+            Kumi::Types.infer_from_value(expr.value)
+
+          when TerminalExpressions::FieldRef
+            # Declared type from input block (user-specified)
+            get_declared_field_type(expr.name)
+
+          when TerminalExpressions::Binding
+            # Inferred type from type inference results
+            get_inferred_declaration_type(expr.name)
+
+          else
+            # For complex expressions, we should have type inference results
+            # This is a simplified approach - in reality we'd need to track types for all expressions
+            Kumi::Types::ANY
+          end
+        end
+
+        def get_declared_field_type(field_name)
+          # Get explicitly declared type from input metadata
+          input_meta = get_state(:input_meta, 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[decl_name] || Kumi::Types::ANY
+        end
+
+        def describe_expression_type(expr, type)
+          case expr
+          when TerminalExpressions::Literal
+            "`#{expr.value}` of type #{type} (literal value)"
+
+          when TerminalExpressions::FieldRef
+            input_meta = get_state(:input_meta, required: false) || {}
+            field_meta = input_meta[expr.name]
+
+            if field_meta&.dig(:type)
+              # Explicitly declared type
+              domain_desc = field_meta[:domain] ? " (domain: #{field_meta[:domain]})" : ""
+              "input field `#{expr.name}` of declared type #{type}#{domain_desc}"
+            else
+              # Undeclared field
+              "undeclared input field `#{expr.name}` (inferred as #{type})"
+            end
+
+          when TerminalExpressions::Binding
+            # This type was inferred from the declaration's expression
+            "reference to declaration `#{expr.name}` of inferred type #{type}"
+
+          when Expressions::CallExpression
+            "result of function `#{expr.fn_name}` returning #{type}"
+
+          when Expressions::ListExpression
+            "list expression of type #{type}"
+
+          when Expressions::CascadeExpression
+            "cascade expression of type #{type}"
+
+          else
+            "expression of type #{type}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Analyzer
+    module Passes
+      # RESPONSIBILITY: Validate consistency between declared and inferred types
+      # DEPENDENCIES: :input_meta from InputCollector, :decl_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) || {}
+
+          # First, validate that all declared types are valid
+          validate_declared_types(input_meta, errors)
+
+          # Then check basic consistency (placeholder for now)
+          # In a full implementation, this would do sophisticated usage analysis
+        end
+
+        private
+
+        def validate_declared_types(input_meta, errors)
+          input_meta.each do |field_name, meta|
+            declared_type = meta[:type]
+            next unless declared_type # Skip fields without declared types
+            next if Kumi::Types.valid_type?(declared_type)
+
+            # Find the input field declaration for proper location information
+            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}")
+          end
+        end
+
+        def find_input_field_declaration(field_name)
+          return nil unless schema
+
+          schema.inputs.find { |input_decl| input_decl.name == field_name }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+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
+      # 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)
+
+          # Process declarations in topological order to ensure dependencies are resolved
+          topo_order.each do |name|
+            decl = definitions[name]
+            next unless decl
+
+            begin
+              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}")
+            end
+          end
+
+          set_state(:decl_types, types)
+        end
+
+        private
+
+        def infer_expression_type(expr, type_context = {})
+          case expr
+          when Literal
+            Types.infer_from_value(expr.value)
+          when FieldRef
+            # Look up type from field metadata
+            input_meta = get_state(:input_meta, required: false) || {}
+            meta = input_meta[expr.name]
+            meta&.dig(:type) || :any
+          when Binding
+            type_context[expr.name] || :any
+          when CallExpression
+            infer_call_type(expr, type_context)
+          when ListExpression
+            infer_list_type(expr, type_context)
+          when CascadeExpression
+            infer_cascade_type(expr, type_context)
+          else
+            :any
+          end
+        end
+
+        def infer_call_type(call_expr, type_context)
+          fn_name = call_expr.fn_name
+          args = call_expr.args
+
+          # Check if function exists in registry
+          unless FunctionRegistry.supported?(fn_name)
+            # Don't push error here - let existing TypeChecker handle it
+            return :any
+          end
+
+          signature = FunctionRegistry.signature(fn_name)
+
+          # Validate arity if not variable
+          if signature[:arity] >= 0 && args.size != signature[:arity]
+            # Don't push error here - let existing TypeChecker handle it
+            return :any
+          end
+
+          # Infer argument types
+          arg_types = args.map { |arg| infer_expression_type(arg, type_context) }
+
+          # Validate parameter types (warn but don't fail)
+          param_types = signature[:param_types] || []
+          if signature[:arity] >= 0 && param_types.size.positive?
+            arg_types.each_with_index do |arg_type, i|
+              expected_type = param_types[i] || param_types.last
+              next if expected_type.nil?
+
+              unless Types.compatible?(arg_type, expected_type)
+                # Could add warning here in future, but for now just infer best type
+              end
+            end
+          end
+
+          signature[:return_type] || :any
+        end
+
+        def infer_list_type(list_expr, type_context)
+          return Types.array(:any) if list_expr.elements.empty?
+
+          element_types = list_expr.elements.map { |elem| infer_expression_type(elem, type_context) }
+
+          # Try to unify all element types
+          unified_type = element_types.reduce { |acc, type| Types.unify(acc, type) }
+          Types.array(unified_type)
+        rescue StandardError
+          # If unification fails, fall back to generic array
+          Types.array(:any)
+        end
+
+        def infer_cascade_type(cascade_expr, type_context)
+          return :any if cascade_expr.cases.empty?
+
+          result_types = cascade_expr.cases.map do |case_stmt|
+            infer_expression_type(case_stmt.result, type_context)
+          end
+
+          # Reduce all possible types into a single unified type
+          result_types.reduce { |unified, type| Types.unify(unified, type) } || :any
+        rescue StandardError
+          # Check if unification fails, fall back to base type
+          # TODO: understand if this right to fallback or we should raise
+          :any
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Analyzer
+    module Passes
+      class UnsatDetector < VisitorPass
+        include Syntax
+
+        COMPARATORS = %i[> < >= <= == !=].freeze
+        Atom        = Kumi::AtomUnsatSolver::Atom
+
+        def run(errors)
+          definitions = get_state(:definitions)
+          @evaluator = ConstantEvaluator.new(definitions)
+
+          each_decl do |decl|
+            if decl.expression.is_a?(CascadeExpression)
+              # 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?
+
+              add_error(errors, decl.loc, "conjunction `#{decl.name}` is impossible") if Kumi::AtomUnsatSolver.unsat?(atoms)
+            end
+          end
+        end
+
+        private
+
+        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
+              list << Atom.new(current.fn_name, term(lhs, defs), term(rhs, defs))
+            elsif current.is_a?(Binding)
+              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
+            current.children.each { |child| stack << child } if current.respond_to?(:children)
+          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 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
+            end
+            # Gather atoms from this individual condition only
+            condition_atoms = gather_atoms(when_case.condition, definitions, Set.new, [])
+
+            # Only flag if this individual condition is impossible
+            next unless !condition_atoms.empty? && Kumi::AtomUnsatSolver.unsat?(condition_atoms)
+
+            # 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")
+                next
+              end
+            end
+            add_error(errors, decl.loc, "conjunction `#{decl.name}` is impossible")
+          end
+        end
+
+        def term(node, _defs)
+          case node
+          when FieldRef, Binding
+            val = @evaluator.evaluate(node)
+            val == :unknown ? node.name : val
+          when Literal
+            node.value
+          else
+            :unknown
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# 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
+      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::Declarations::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::Declarations::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

data/lib/kumi/analyzer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Analyzer
+    Result = Struct.new(:definitions, :dependency_graph, :leaf_map, :topo_order, :decl_types, :state, keyword_init: true)
+
+    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.
+    ].freeze
+
+    def analyze!(schema, passes: DEFAULT_PASSES, **opts)
+      analysis_state = { opts: opts }
+      errors = []
+
+      passes.each { |klass| klass.new(schema, analysis_state).run(errors) }
+
+      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
+
+        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
+
+      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
+      )
+    end
+
+    # Handle both old and new error formats for backward compatibility
+    def format_errors(errors)
+      return "" if errors.empty?
+
+      errors.map(&:to_s).join("\n")
+    end
+  end
+end