kumi 0.0.4 → 0.0.6

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

@@ -3,13 +3,24 @@
 module Kumi
   module Analyzer
     module Passes
-      # RESPONSIBILITY: Build dependency graph and leaf map, validate references
-      # DEPENDENCIES: :definitions from NameIndexer
-      # PRODUCES: :dependency_graph - Hash of name → [DependencyEdge], :leaf_map - Hash of name → Set[nodes]
+      # RESPONSIBILITY: Build dependency graph and detect conditional dependencies in cascades
+      # DEPENDENCIES: :definitions from NameIndexer, :input_meta from InputCollector
+      # PRODUCES: :dependency_graph, :transitive_dependents, :leaf_map - Dependency analysis results
       # INTERFACE: new(schema, state).run(errors)
       class DependencyResolver < PassBase
-        # A Struct to hold rich dependency information
-        DependencyEdge = Struct.new(:to, :type, :via, keyword_init: true)
+        # 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)
@@ -17,53 +28,122 @@ module Kumi
           input_meta = get_state(:input_meta)
 
           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) do |node, context|
-              process_node(node, decl, dependency_graph, leaf_map, definitions, input_meta, errors, context)
+            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
 
-          set_state(:dependency_graph, dependency_graph.transform_values(&:freeze).freeze)
-          set_state(:leaf_map, leaf_map.transform_values(&:freeze).freeze)
+          # Compute transitive closure of reverse dependencies
+          transitive_dependents = compute_transitive_closure(reverse_dependencies)
+
+          state.with(:dependency_graph, dependency_graph.transform_values(&:freeze).freeze)
+               .with(:transitive_dependents, transitive_dependents.freeze)
+               .with(:leaf_map, leaf_map.transform_values(&:freeze).freeze)
         end
 
         private
 
-        def process_node(node, decl, graph, leaves, definitions, input_meta, errors, context)
+        def process_node(node, decl, graph, reverse_deps, leaves, definitions, input_meta, errors, context)
           case node
-          when Binding
-            add_error(errors, node.loc, "undefined reference to `#{node.name}`") unless definitions.key?(node.name)
-            add_dependency_edge(graph, decl.name, node.name, :ref, context[:via])
-          when FieldRef
-            add_error(errors, node.loc, "undeclared input `#{node.name}`") unless input_meta.key?(node.name)
-            add_dependency_edge(graph, decl.name, node.name, :key, context[:via])
-            leaves[decl.name] << node # put it back
+          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, from, to, type, via)
-          edge = DependencyEdge.new(to: to, type: type, via: via)
+        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 passes context (like function name) down the tree
+        # Custom visitor that understands cascade structure
         def visit_with_context(node, context = {}, &block)
           return unless node
 
           yield(node, context)
 
-          new_context = if node.is_a?(Expressions::CallExpression)
-                          { via: node.fn_name }
-                        else
-                          context
-                        end
+          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
 
-          node.children.each { |child| visit_with_context(child, new_context, &block) }
+          transitive
         end
       end
     end

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

@@ -4,18 +4,16 @@ module Kumi
   module Analyzer
     module Passes
       # RESPONSIBILITY: Collect field metadata from input declarations and validate consistency
-      # DEPENDENCIES: None
+      # DEPENDENCIES: :definitions
       # PRODUCES: :input_meta - Hash mapping field names to {type:, domain:} metadata
       # INTERFACE: new(schema, state).run(errors)
       class InputCollector < PassBase
-        include Syntax::TerminalExpressions
-
         def run(errors)
           input_meta = {}
 
           schema.inputs.each do |field_decl|
-            unless field_decl.is_a?(FieldDecl)
-              add_error(errors, field_decl.loc, "Expected FieldDecl node, got #{field_decl.class}")
+            unless field_decl.is_a?(Kumi::Syntax::InputDeclaration)
+              report_error(errors, "Expected InputDeclaration node, got #{field_decl.class}", location: field_decl.loc)
               next
             end
 
@@ -23,31 +21,115 @@ module Kumi
             existing = input_meta[name]
 
             if existing
-              # Check for compatibility
-              if existing[:type] != field_decl.type && field_decl.type && existing[:type]
-                add_error(errors, field_decl.loc,
-                          "Field :#{name} declared with conflicting types: #{existing[:type]} vs #{field_decl.type}")
+              # 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(:input_meta, 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
 
-              if existing[:domain] != field_decl.domain && field_decl.domain && existing[:domain]
-                add_error(errors, field_decl.loc,
-                          "Field :#{name} declared with conflicting domains: #{existing[:domain].inspect} vs #{field_decl.domain.inspect}")
+          # 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
 
-              # Merge metadata (later declarations override nil values)
-              input_meta[name] = {
-                type: field_decl.type || existing[:type],
-                domain: field_decl.domain || existing[:domain]
-              }
-            else
-              input_meta[name] = {
-                type: field_decl.type,
-                domain: field_decl.domain
-              }
+              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
 
-          set_state(:input_meta, input_meta.freeze)
+          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

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

@@ -12,11 +12,11 @@ module Kumi
           definitions = {}
 
           each_decl do |decl|
-            add_error(errors, decl.loc, "duplicated definition `#{decl.name}`") if definitions.key?(decl.name)
+            report_error(errors, "duplicated definition `#{decl.name}`", location: decl.loc) if definitions.key?(decl.name)
             definitions[decl.name] = decl
           end
 
-          set_state(:definitions, definitions.freeze)
+          state.with(:definitions, definitions.freeze)
         end
       end
     end

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

@@ -3,22 +3,21 @@
 module Kumi
   module Analyzer
     module Passes
-      # Base class for all analyzer passes providing common functionality
-      # and enforcing consistent interface patterns.
+      # 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 [Hash] Shared analysis state accumulator
+        # @param state [AnalysisState] Current analysis state
         def initialize(schema, state)
           @schema = schema
           @state = state
         end
 
-        # Main entry point for pass execution
+        # Main pass execution - subclasses implement this
         # @param errors [Array] Error accumulator array
-        # @abstract Subclasses must implement this method
+        # @return [AnalysisState] New state after pass execution
         def run(errors)
           raise NotImplementedError, "#{self.class.name} must implement #run"
         end
@@ -28,38 +27,22 @@ module Kumi
         attr_reader :schema, :state
 
         # Iterate over all declarations (attributes and traits) in the schema
-        # @yield [Syntax::Declarations::Attribute|Syntax::Declarations::Trait] Each declaration
+        # @yield [Syntax::Attribute|Syntax::Trait] Each declaration
         def each_decl(&block)
           schema.attributes.each(&block)
           schema.traits.each(&block)
         end
 
-        # DEPRECATED: Use report_error instead for consistent error handling
-        # Helper to add standardized error messages
-        # @param errors [Array] Error accumulator
-        # @param location [Syntax::Location] Error location
-        # @param message [String] Error message
-        def add_error(errors, location, message)
-          errors << ErrorReporter.create_error(message, location: location, type: :semantic)
-        end
-
-        # Helper to get required state from previous passes
-        # @param key [Symbol] State key to retrieve
-        # @param required [Boolean] Whether this state is required
-        # @return [Object] The state value
-        # @raise [StandardError] If required state is missing
+        # Get state value - compatible with old interface
         def get_state(key, required: true)
-          value = state[key]
-          raise "Pass #{self.class.name} requires #{key} from previous passes, but it was not found" if required && value.nil?
+          raise StandardError, "Required state key '#{key}' not found" if required && !state.key?(key)
 
-          value
+          state[key]
         end
 
-        # Helper to set state for subsequent passes
-        # @param key [Symbol] State key to set
-        # @param value [Object] Value to store
-        def set_state(key, value)
-          state[key] = value
+        # Add error to the error list
+        def add_error(errors, location, message)
+          errors << ErrorReporter.create_error(message, location: location, type: :semantic)
         end
       end
     end

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

@@ -0,0 +1,110 @@
+# 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
+            return
+          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
+            return
+          when Kumi::Syntax::Literal
+            # Allow literal conditions (like true/false) - they might be valid
+            return
+          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)
+          begin
+            # 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
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,8 +3,8 @@
 module Kumi
   module Analyzer
     module Passes
-      # RESPONSIBILITY: Compute topological ordering of declarations from dependency graph
-      # DEPENDENCIES: :dependency_graph from DependencyResolver, :definitions from NameIndexer
+      # RESPONSIBILITY: Compute topological ordering of declarations, allowing safe conditional cycles
+      # DEPENDENCIES: :dependency_graph from DependencyResolver, :definitions from NameIndexer, :cascade_metadata from UnsatDetector
       # PRODUCES: :topo_order - Array of declaration names in evaluation order
       # INTERFACE: new(schema, state).run(errors)
       class Toposorter < PassBase
@@ -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
@@ -22,17 +22,26 @@ module Kumi
           temp_marks = Set.new
           perm_marks = Set.new
           order = []
+          cascade_metadata = get_state(:cascade_metadata) || {}
 
-          visit_node = lambda do |node|
+          visit_node = lambda do |node, path = []|
             return if perm_marks.include?(node)
 
             if temp_marks.include?(node)
-              report_unexpected_cycle(temp_marks, node, errors)
-              return
+              # Check if this is a safe conditional cycle
+              cycle_path = path + [node]
+              if safe_conditional_cycle?(cycle_path, graph, cascade_metadata)
+                # Allow this cycle - it's safe due to cascade mutual exclusion
+                return
+              else
+                report_unexpected_cycle(temp_marks, node, errors)
+                return
+              end
             end
 
             temp_marks << node
-            Array(graph[node]).each { |edge| visit_node.call(edge.to) }
+            current_path = path + [node]
+            Array(graph[node]).each { |edge| visit_node.call(edge.to, current_path) }
             temp_marks.delete(node)
             perm_marks << node
 
@@ -47,7 +56,34 @@ module Kumi
           # (i.e., declarations with no dependencies)
           definitions.each_key { |node| visit_node.call(node) }
 
-          order
+          order.freeze
+        end
+
+        def safe_conditional_cycle?(cycle_path, graph, cascade_metadata)
+          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..-1]
+          
+          # 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 = cascade_metadata[edge.cascade_owner]
+            return false unless cascade_meta&.dig(:all_mutually_exclusive)
+          end
+          
+          true
         end
 
         def report_unexpected_cycle(temp_marks, current_node, errors)
@@ -57,7 +93,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)