kumi 0.0.7 → 0.0.8

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

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Analyzer
-    module Passes
-      # RESPONSIBILITY: Build dependency graph and detect conditional dependencies in cascades
-      # DEPENDENCIES: :declarations from NameIndexer, :inputs from InputCollector
-      # PRODUCES: :dependencies, :dependents, :leaves - Dependency analysis results
-      # INTERFACE: new(schema, state).run(errors)
-      class DependencyResolver < PassBase
-        # Enhanced edge with conditional flag and cascade metadata
-        class DependencyEdge
-          attr_reader :to, :type, :via, :conditional, :cascade_owner
-
-          def initialize(to:, type:, via:, conditional: false, cascade_owner: nil)
-            @to = to
-            @type = type
-            @via = via
-            @conditional = conditional
-            @cascade_owner = cascade_owner
-          end
-        end
-
-        include Syntax
-
-        def run(errors)
-          definitions = get_state(:declarations)
-          input_meta = get_state(:inputs)
-
-          dependency_graph = Hash.new { |h, k| h[k] = [] }
-          reverse_dependencies = Hash.new { |h, k| h[k] = [] }
-          leaf_map = Hash.new { |h, k| h[k] = Set.new }
-
-          each_decl do |decl|
-            # Traverse the expression for each declaration, passing context down
-            visit_with_context(decl.expression, { decl_name: decl.name }) do |node, context|
-              process_node(node, decl, dependency_graph, reverse_dependencies, leaf_map, definitions, input_meta, errors, context)
-            end
-          end
-
-          # Compute transitive closure of reverse dependencies
-          transitive_dependents = compute_transitive_closure(reverse_dependencies)
-
-          state.with(:dependencies, dependency_graph.transform_values(&:freeze).freeze)
-               .with(:dependents, transitive_dependents.freeze)
-               .with(:leaves, leaf_map.transform_values(&:freeze).freeze)
-        end
-
-        private
-
-        def process_node(node, decl, graph, reverse_deps, leaves, definitions, _input_meta, errors, context)
-          case node
-          when DeclarationReference
-            report_error(errors, "undefined reference to `#{node.name}`", location: node.loc) unless definitions.key?(node.name)
-
-            # Determine if this is a conditional dependency
-            conditional = context[:in_cascade_branch] || context[:in_cascade_base] || false
-            cascade_owner = conditional ? (context[:cascade_owner] || context[:decl_name]) : nil
-
-            add_dependency_edge(graph, reverse_deps, decl.name, node.name, :ref, context[:via],
-                                conditional: conditional,
-                                cascade_owner: cascade_owner)
-          when InputReference
-            add_dependency_edge(graph, reverse_deps, decl.name, node.name, :key, context[:via])
-            leaves[decl.name] << node
-          when InputElementReference
-            # adds the root input declaration as a dependency
-            root_input_declr_name = node.path.first
-            add_dependency_edge(graph, reverse_deps, decl.name, root_input_declr_name, :key, context[:via])
-          when Literal
-            leaves[decl.name] << node
-          end
-        end
-
-        def add_dependency_edge(graph, reverse_deps, from, to, type, via, conditional: false, cascade_owner: nil)
-          edge = DependencyEdge.new(
-            to: to,
-            type: type,
-            via: via,
-            conditional: conditional,
-            cascade_owner: cascade_owner
-          )
-          graph[from] << edge
-          reverse_deps[to] << from
-        end
-
-        # Custom visitor that understands cascade structure
-        def visit_with_context(node, context = {}, &block)
-          return unless node
-
-          yield(node, context)
-
-          case node
-          when CascadeExpression
-            # Visit condition nodes and result expressions (non-base cases)
-            node.cases[0...-1].each do |when_case|
-              if when_case.condition
-                # Visit condition normally
-                visit_with_context(when_case.condition, context, &block)
-              end
-              # Visit result expressions as conditional dependencies
-              conditional_context = context.merge(in_cascade_branch: true, cascade_owner: context[:decl_name])
-              visit_with_context(when_case.result, conditional_context, &block)
-            end
-
-            # Visit base case with conditional flag
-            if node.cases.last
-              base_context = context.merge(in_cascade_base: true)
-              visit_with_context(node.cases.last.result, base_context, &block)
-            end
-          when CallExpression
-            new_context = context.merge(via: node.fn_name)
-            node.children.each { |child| visit_with_context(child, new_context, &block) }
-          else
-            node.children.each { |child| visit_with_context(child, context, &block) } if node.respond_to?(:children)
-          end
-        end
-
-        def compute_transitive_closure(reverse_dependencies)
-          transitive = {}
-          all_keys = reverse_dependencies.keys
-
-          all_keys.each do |key|
-            visited = Set.new
-            to_visit = [key]
-            dependents = Set.new
-
-            while to_visit.any?
-              current = to_visit.shift
-              next if visited.include?(current)
-
-              visited.add(current)
-
-              direct_dependents = reverse_dependencies[current] || []
-              direct_dependents.each do |dependent|
-                next if visited.include?(dependent)
-
-                dependents << dependent
-                to_visit << dependent
-              end
-            end
-
-            transitive[key] = dependents.to_a
-          end
-
-          transitive
-        end
-      end
-    end
-  end
-end

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

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Analyzer
-    module Passes
-      # RESPONSIBILITY: Collect field metadata from input declarations and validate consistency
-      # DEPENDENCIES: :definitions
-      # PRODUCES: :inputs - Hash mapping field names to {type:, domain:} metadata
-      # INTERFACE: new(schema, state).run(errors)
-      class InputCollector < PassBase
-        def run(errors)
-          input_meta = {}
-
-          schema.inputs.each do |field_decl|
-            unless field_decl.is_a?(Kumi::Syntax::InputDeclaration)
-              report_error(errors, "Expected InputDeclaration node, got #{field_decl.class}", location: field_decl.loc)
-              next
-            end
-
-            name = field_decl.name
-            existing = input_meta[name]
-
-            if existing
-              # Check for compatibility and merge
-              merged_meta = merge_field_metadata(existing, field_decl, errors)
-              input_meta[name] = merged_meta if merged_meta
-            else
-              # New field - collect its metadata
-              input_meta[name] = collect_field_metadata(field_decl, errors)
-            end
-          end
-
-          state.with(:inputs, freeze_nested_hash(input_meta))
-        end
-
-        private
-
-        def collect_field_metadata(field_decl, errors)
-          validate_domain_type(field_decl, errors) if field_decl.domain
-
-          metadata = {
-            type: field_decl.type,
-            domain: field_decl.domain
-          }
-
-          # Process children if present
-          if field_decl.children && !field_decl.children.empty?
-            children_meta = {}
-            field_decl.children.each do |child_decl|
-              unless child_decl.is_a?(Kumi::Syntax::InputDeclaration)
-                report_error(errors, "Expected InputDeclaration node in children, got #{child_decl.class}", location: child_decl.loc)
-                next
-              end
-              children_meta[child_decl.name] = collect_field_metadata(child_decl, errors)
-            end
-            metadata[:children] = children_meta
-          end
-
-          metadata
-        end
-
-        def merge_field_metadata(existing, field_decl, errors)
-          name = field_decl.name
-
-          # Check for type compatibility
-          if existing[:type] != field_decl.type && field_decl.type && existing[:type]
-            report_error(errors,
-                         "Field :#{name} declared with conflicting types: #{existing[:type]} vs #{field_decl.type}",
-                         location: field_decl.loc)
-          end
-
-          # Check for domain compatibility
-          if existing[:domain] != field_decl.domain && field_decl.domain && existing[:domain]
-            report_error(errors,
-                         "Field :#{name} declared with conflicting domains: #{existing[:domain].inspect} vs #{field_decl.domain.inspect}",
-                         location: field_decl.loc)
-          end
-
-          # Validate domain type if provided
-          validate_domain_type(field_decl, errors) if field_decl.domain
-
-          # Merge metadata (later declarations override nil values)
-          merged = {
-            type: field_decl.type || existing[:type],
-            domain: field_decl.domain || existing[:domain]
-          }
-
-          # Merge children if present
-          if field_decl.children && !field_decl.children.empty?
-            existing_children = existing[:children] || {}
-            new_children = {}
-
-            field_decl.children.each do |child_decl|
-              unless child_decl.is_a?(Kumi::Syntax::InputDeclaration)
-                report_error(errors, "Expected InputDeclaration node in children, got #{child_decl.class}", location: child_decl.loc)
-                next
-              end
-
-              child_name = child_decl.name
-              new_children[child_name] = if existing_children[child_name]
-                                           merge_field_metadata(existing_children[child_name], child_decl, errors)
-                                         else
-                                           collect_field_metadata(child_decl, errors)
-                                         end
-            end
-
-            merged[:children] = new_children
-          elsif existing[:children]
-            merged[:children] = existing[:children]
-          end
-
-          merged
-        end
-
-        def freeze_nested_hash(hash)
-          hash.each_value do |value|
-            freeze_nested_hash(value) if value.is_a?(Hash)
-          end
-          hash.freeze
-        end
-
-        def validate_domain_type(field_decl, errors)
-          domain = field_decl.domain
-          return if valid_domain_type?(domain)
-
-          report_error(errors,
-                       "Field :#{field_decl.name} has invalid domain constraint: #{domain.inspect}. Domain must be a Range, Array, or Proc",
-                       location: field_decl.loc)
-        end
-
-        def valid_domain_type?(domain)
-          domain.is_a?(Range) || domain.is_a?(Array) || domain.is_a?(Proc)
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Analyzer
-    module Passes
-      # RESPONSIBILITY: Build definitions index and detect duplicate names
-      # DEPENDENCIES: None (first pass in pipeline)
-      # PRODUCES: :declarations - Hash mapping names to declaration nodes
-      # INTERFACE: new(schema, state).run(errors)
-      class NameIndexer < PassBase
-        def run(errors)
-          definitions = {}
-
-          each_decl do |decl|
-            report_error(errors, "duplicated definition `#{decl.name}`", location: decl.loc) if definitions.key?(decl.name)
-            definitions[decl.name] = decl
-          end
-
-          state.with(:declarations, definitions.freeze)
-        end
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Analyzer
-    module Passes
-      # Base class for analyzer passes with simple immutable state
-      class PassBase
-        include Kumi::Syntax
-        include Kumi::ErrorReporting
-
-        # @param schema [Syntax::Root] The schema to analyze
-        # @param state [AnalysisState] Current analysis state
-        def initialize(schema, state)
-          @schema = schema
-          @state = state
-        end
-
-        # Main pass execution - subclasses implement this
-        # @param errors [Array] Error accumulator array
-        # @return [AnalysisState] New state after pass execution
-        def run(errors)
-          raise NotImplementedError, "#{self.class.name} must implement #run"
-        end
-
-        protected
-
-        attr_reader :schema, :state
-
-        # Iterate over all declarations (attributes and traits) in the schema
-        # @yield [Syntax::Attribute|Syntax::Trait] Each declaration
-        def each_decl(&block)
-          schema.attributes.each(&block)
-          schema.traits.each(&block)
-        end
-
-        # Get state value - compatible with old interface
-        def get_state(key, required: true)
-          raise StandardError, "Required state key '#{key}' not found" if required && !state.key?(key)
-
-          state[key]
-        end
-
-        # Add error to the error list
-        def add_error(errors, location, message)
-          errors << ErrorReporter.create_error(message, location: location, type: :semantic)
-        end
-      end
-    end
-  end
-end

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

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Analyzer
-    module Passes
-      # RESPONSIBILITY: Validate DSL semantic constraints at the AST level
-      # DEPENDENCIES: :definitions
-      # PRODUCES: None (validation only)
-      # INTERFACE: new(schema, state).run(errors)
-      #
-      # This pass enforces semantic constraints that must hold regardless of which parser
-      # was used to construct the AST. It validates:
-      # 1. Cascade conditions are only trait references (DeclarationReference nodes)
-      # 2. Trait expressions evaluate to boolean values (CallExpression nodes)
-      # 3. Function names exist in the function registry
-      # 4. Expression types are valid for their context
-      class SemanticConstraintValidator < VisitorPass
-        def run(errors)
-          each_decl do |decl|
-            visit(decl) { |node| validate_semantic_constraints(node, decl, errors) }
-          end
-          state
-        end
-
-        private
-
-        def validate_semantic_constraints(node, _decl, errors)
-          case node
-          when Kumi::Syntax::TraitDeclaration
-            validate_trait_expression(node, errors)
-          when Kumi::Syntax::CaseExpression
-            validate_cascade_condition(node, errors)
-          when Kumi::Syntax::CallExpression
-            validate_function_call(node, errors)
-          end
-        end
-
-        def validate_trait_expression(trait, errors)
-          return if trait.expression.is_a?(Kumi::Syntax::CallExpression)
-
-          report_error(
-            errors,
-            "trait `#{trait.name}` must have a boolean expression",
-            location: trait.loc,
-            type: :semantic
-          )
-        end
-
-        def validate_cascade_condition(when_case, errors)
-          condition = when_case.condition
-
-          case condition
-          when Kumi::Syntax::DeclarationReference
-            # Valid: trait reference
-            nil
-          when Kumi::Syntax::CallExpression
-            # Valid if it's a boolean composition of traits (all?, any?, none?)
-            return if boolean_trait_composition?(condition)
-
-            # For now, allow other CallExpressions - they'll be validated by other passes
-            nil
-          when Kumi::Syntax::Literal
-            # Allow literal conditions (like true/false) - they might be valid
-            nil
-          else
-            # Only reject truly invalid conditions like InputReference or complex expressions
-            report_error(
-              errors,
-              "cascade condition must be trait reference",
-              location: when_case.loc,
-              type: :semantic
-            )
-          end
-        end
-
-        def validate_function_call(call_expr, errors)
-          fn_name = call_expr.fn_name
-
-          # Skip validation if FunctionRegistry is being mocked for testing
-          return if function_registry_mocked?
-
-          return if FunctionRegistry.supported?(fn_name)
-
-          report_error(
-            errors,
-            "unknown function `#{fn_name}`",
-            location: call_expr.loc,
-            type: :semantic
-          )
-        end
-
-        def boolean_trait_composition?(call_expr)
-          # Allow boolean composition functions that operate on trait collections
-          %i[all? any? none?].include?(call_expr.fn_name)
-        end
-
-        def function_registry_mocked?
-          # Check if FunctionRegistry is being mocked (for tests)
-
-          # Try to access a method that doesn't exist in the real registry
-          # If it's mocked, this won't raise an error
-          FunctionRegistry.respond_to?(:confirm_support!)
-        rescue StandardError
-          false
-        end
-      end
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Analyzer
-    module Passes
-      # RESPONSIBILITY: Compute topological ordering of declarations, allowing safe conditional cycles
-      # DEPENDENCIES: :dependencies from DependencyResolver, :declarations from NameIndexer, :cascades from UnsatDetector
-      # PRODUCES: :evaluation_order - Array of declaration names in evaluation order
-      # INTERFACE: new(schema, state).run(errors)
-      class Toposorter < PassBase
-        def run(errors)
-          dependency_graph = get_state(:dependencies, required: false) || {}
-          definitions = get_state(:declarations, required: false) || {}
-
-          order = compute_topological_order(dependency_graph, definitions, errors)
-          state.with(:evaluation_order, order)
-        end
-
-        private
-
-        def compute_topological_order(graph, definitions, errors)
-          temp_marks = Set.new
-          perm_marks = Set.new
-          order = []
-          cascades = get_state(:cascades) || {}
-
-          visit_node = lambda do |node, path = []|
-            return if perm_marks.include?(node)
-
-            if temp_marks.include?(node)
-              # Check if this is a safe conditional cycle
-              cycle_path = path + [node]
-              return if safe_conditional_cycle?(cycle_path, graph, cascades)
-
-              # Allow this cycle - it's safe due to cascade mutual exclusion
-
-              report_unexpected_cycle(temp_marks, node, errors)
-
-              return
-            end
-
-            temp_marks << node
-            current_path = path + [node]
-            Array(graph[node]).each { |edge| visit_node.call(edge.to, current_path) }
-            temp_marks.delete(node)
-            perm_marks << node
-
-            # Only include declaration nodes in the final order
-            order << node if definitions.key?(node)
-          end
-
-          # Visit all nodes in the graph
-          graph.each_key { |node| visit_node.call(node) }
-
-          # Also visit any definitions that aren't in the dependency graph
-          # (i.e., declarations with no dependencies)
-          definitions.each_key { |node| visit_node.call(node) }
-
-          order.freeze
-        end
-
-        def safe_conditional_cycle?(cycle_path, graph, cascades)
-          return false if cycle_path.nil? || cycle_path.size < 2
-
-          # Find where the cycle starts - look for the first occurrence of the repeated node
-          last_node = cycle_path.last
-          return false if last_node.nil?
-
-          cycle_start = cycle_path.index(last_node)
-          return false unless cycle_start && cycle_start < cycle_path.size - 1
-
-          cycle_nodes = cycle_path[cycle_start..]
-
-          # Check if all edges in the cycle are conditional
-          cycle_nodes.each_cons(2) do |from, to|
-            edges = graph[from] || []
-            edge = edges.find { |e| e.to == to }
-
-            return false unless edge&.conditional
-
-            # Check if the cascade has mutually exclusive conditions
-            cascade_meta = cascades[edge.cascade_owner]
-            return false unless cascade_meta&.dig(:all_mutually_exclusive)
-          end
-
-          true
-        end
-
-        def report_unexpected_cycle(temp_marks, current_node, errors)
-          cycle_path = temp_marks.to_a.join(" → ") + " → #{current_node}"
-
-          # Try to find the first declaration in the cycle for location info
-          first_decl = find_declaration_by_name(temp_marks.first || current_node)
-          location = first_decl&.loc
-
-          report_error(errors, "cycle detected: #{cycle_path}", location: location)
-        end
-
-        def find_declaration_by_name(name)
-          return nil unless schema
-
-          schema.attributes.find { |attr| attr.name == name } ||
-            schema.traits.find { |trait| trait.name == name }
-        end
-      end
-    end
-  end
-end