kumi 0.0.5 → 0.0.6

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

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Analyzer
+    module Passes
+      # Detects which operations should be broadcast over arrays
+      # DEPENDENCIES: :input_meta, :definitions
+      # PRODUCES: :broadcast_metadata
+      class BroadcastDetector < PassBase
+        def run(errors)
+          input_meta = get_state(:input_meta) || {}
+          definitions = get_state(:definitions) || {}
+          
+          # Find array fields with their element types
+          array_fields = find_array_fields(input_meta)
+          
+          # Build compiler metadata
+          compiler_metadata = {
+            array_fields: array_fields,
+            vectorized_operations: {},
+            reduction_operations: {}
+          }
+          
+          # Track which values are vectorized for type inference
+          vectorized_values = {}
+          
+          # Analyze traits first, then values (to handle dependencies)
+          traits = definitions.select { |name, decl| decl.is_a?(Kumi::Syntax::TraitDeclaration) }
+          values = definitions.select { |name, decl| decl.is_a?(Kumi::Syntax::ValueDeclaration) }
+          
+          (traits.to_a + values.to_a).each do |name, decl|
+            result = analyze_value_vectorization(name, decl.expression, array_fields, vectorized_values, errors)
+            
+            
+            case result[:type]
+            when :vectorized
+              compiler_metadata[:vectorized_operations][name] = result[:info]
+              # Store array source information for dimension checking
+              array_source = extract_array_source(result[:info], array_fields)
+              vectorized_values[name] = { vectorized: true, array_source: array_source }
+            when :reduction
+              compiler_metadata[:reduction_operations][name] = result[:info]
+              # Reduction produces scalar, not vectorized
+              vectorized_values[name] = { vectorized: false }
+            end
+          end
+          
+          state.with(:broadcast_metadata, compiler_metadata.freeze)
+        end
+
+        private
+
+        def find_array_fields(input_meta)
+          result = {}
+          input_meta.each do |name, meta|
+            if meta[:type] == :array && meta[:children]
+              result[name] = {
+                element_fields: meta[:children].keys,
+                element_types: meta[:children].transform_values { |v| v[:type] || :any }
+              }
+            end
+          end
+          result
+        end
+
+        def analyze_value_vectorization(name, expr, array_fields, vectorized_values, errors)
+          case expr
+          when Kumi::Syntax::InputElementReference
+            if array_fields.key?(expr.path.first)
+              { type: :vectorized, info: { source: :array_field_access, path: expr.path } }
+            else
+              { type: :scalar }
+            end
+            
+          when Kumi::Syntax::DeclarationReference
+            # Check if this references a vectorized value
+            vector_info = vectorized_values[expr.name]
+            if vector_info && vector_info[:vectorized]
+              { type: :vectorized, info: { source: :vectorized_declaration, name: expr.name } }
+            else
+              { type: :scalar }
+            end
+            
+          when Kumi::Syntax::CallExpression
+            analyze_call_vectorization(name, expr, array_fields, vectorized_values, errors)
+            
+          when Kumi::Syntax::CascadeExpression
+            analyze_cascade_vectorization(name, expr, array_fields, vectorized_values, errors)
+            
+          else
+            { type: :scalar }
+          end
+        end
+
+        def analyze_call_vectorization(name, expr, array_fields, vectorized_values, errors)
+          # Check if this is a reduction function using function registry metadata
+          if FunctionRegistry.reducer?(expr.fn_name)
+            # Only treat as reduction if the argument is actually vectorized
+            arg_info = analyze_argument_vectorization(expr.args.first, array_fields, vectorized_values)
+            if arg_info[:vectorized]
+              { type: :reduction, info: { function: expr.fn_name, source: arg_info[:source] } }
+            else
+              # Not a vectorized reduction - just a regular function call
+              { type: :scalar }
+            end
+            
+          else
+            # Special case: all?, any?, none? functions with vectorized trait arguments should be treated as vectorized
+            # for cascade condition purposes (they get transformed during compilation)
+            if [:all?, :any?, :none?].include?(expr.fn_name) && expr.args.length == 1
+              arg = expr.args.first
+              if arg.is_a?(Kumi::Syntax::ArrayExpression) && arg.elements.length == 1
+                trait_ref = arg.elements.first
+                if trait_ref.is_a?(Kumi::Syntax::DeclarationReference) && vectorized_values[trait_ref.name]&.[](:vectorized)
+                  return { type: :vectorized, info: { source: :cascade_condition_with_vectorized_trait, trait: trait_ref.name } }
+                end
+              end
+            end
+            
+            # ANY function with vectorized arguments becomes vectorized (with broadcasting)
+            arg_infos = expr.args.map { |arg| analyze_argument_vectorization(arg, array_fields, vectorized_values) }
+            
+            if arg_infos.any? { |info| info[:vectorized] }
+              # Check for dimension mismatches when multiple arguments are vectorized
+              vectorized_sources = arg_infos.select { |info| info[:vectorized] }.map { |info| info[:array_source] }.compact.uniq
+              
+              if vectorized_sources.length > 1
+                # Multiple different array sources - this is a dimension mismatch
+                # Generate enhanced error message with type information
+                enhanced_message = build_dimension_mismatch_error(expr, arg_infos, array_fields, vectorized_sources)
+                
+                report_error(errors, enhanced_message, location: expr.loc, type: :semantic)
+                return { type: :scalar }  # Treat as scalar to prevent further errors
+              end
+              
+              # This is a vectorized operation - ANY function supports broadcasting
+              { type: :vectorized, info: { 
+                operation: expr.fn_name, 
+                vectorized_args: arg_infos.map.with_index { |info, i| [i, info[:vectorized]] }.to_h 
+              }}
+            else
+              { type: :scalar }
+            end
+          end
+        end
+
+        def analyze_argument_vectorization(arg, array_fields, vectorized_values)
+          case arg
+          when Kumi::Syntax::InputElementReference
+            if array_fields.key?(arg.path.first)
+              { vectorized: true, source: :array_field, array_source: arg.path.first }
+            else
+              { vectorized: false }
+            end
+            
+          when Kumi::Syntax::DeclarationReference
+            # Check if this references a vectorized value
+            vector_info = vectorized_values[arg.name]
+            if vector_info && vector_info[:vectorized]
+              array_source = vector_info[:array_source]
+              { vectorized: true, source: :vectorized_value, array_source: array_source }
+            else
+              { vectorized: false }
+            end
+            
+          when Kumi::Syntax::CallExpression
+            # Recursively check
+            result = analyze_value_vectorization(nil, arg, array_fields, vectorized_values, [])
+            { vectorized: result[:type] == :vectorized, source: :expression }
+            
+          else
+            { vectorized: false }
+          end
+        end
+
+        def extract_array_source(info, array_fields)
+          case info[:source]
+          when :array_field_access
+            info[:path]&.first
+          when :cascade_condition_with_vectorized_trait
+            # For cascades, we'd need to trace back to the original source
+            nil  # TODO: Could be enhanced to trace through trait dependencies
+          else
+            nil
+          end
+        end
+
+        def analyze_cascade_vectorization(name, expr, array_fields, vectorized_values, errors)
+          # A cascade is vectorized if:
+          # 1. Any of its result expressions are vectorized, OR
+          # 2. Any of its conditions reference vectorized values (traits or arrays)
+          vectorized_results = []
+          vectorized_conditions = []
+          
+          expr.cases.each do |case_expr|
+            # Check if result is vectorized
+            result_info = analyze_value_vectorization(nil, case_expr.result, array_fields, vectorized_values, errors)
+            vectorized_results << (result_info[:type] == :vectorized)
+            
+            # Check if condition is vectorized
+            condition_info = analyze_value_vectorization(nil, case_expr.condition, array_fields, vectorized_values, errors)
+            vectorized_conditions << (condition_info[:type] == :vectorized)
+            
+          end
+          
+          if vectorized_results.any? || vectorized_conditions.any?
+            { type: :vectorized, info: { source: :cascade_with_vectorized_conditions_or_results } }
+          else
+            { type: :scalar }
+          end
+        end
+
+        def build_dimension_mismatch_error(_expr, arg_infos, array_fields, vectorized_sources)
+          # Build detailed error message with type information
+          summary = "Cannot broadcast operation across arrays from different sources: #{vectorized_sources.join(', ')}. "
+          
+          problem_desc = "Problem: Multiple operands are arrays from different sources:\n"
+          
+          vectorized_args = arg_infos.select { |info| info[:vectorized] }
+          vectorized_args.each_with_index do |arg_info, index|
+            array_source = arg_info[:array_source]
+            next unless array_source && array_fields[array_source]
+
+            # Determine the type based on array field metadata
+            type_desc = determine_array_type(array_source, array_fields)
+            problem_desc += "  - Operand #{index + 1} resolves to #{type_desc} from array '#{array_source}'\n"
+          end
+          
+          explanation = "Direct operations on arrays from different sources is ambiguous and not supported. " \
+                        "Vectorized operations can only work on fields from the same array input."
+          
+          "#{summary}#{problem_desc}#{explanation}"
+        end
+
+        def determine_array_type(array_source, array_fields)
+          field_info = array_fields[array_source]
+          return "array(any)" unless field_info[:element_types]
+
+          # For nested arrays (like items.name where items is an array), this represents array(element_type)
+          element_types = field_info[:element_types].values.uniq
+          if element_types.length == 1
+            "array(#{element_types.first})"
+          else
+            "array(mixed)"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/kumi/analyzer/passes/{definition_validator.rb → declaration_validator.rb}

@@ -7,7 +7,7 @@ module Kumi
       # DEPENDENCIES: :definitions
       # PRODUCES: None (validation only)
       # INTERFACE: new(schema, state).run(errors)
-      class DefinitionValidator < VisitorPass
+      class DeclarationValidator < VisitorPass
         def run(errors)
           each_decl do |decl|
             visit(decl) { |node| validate_node(node, errors) }
@@ -19,9 +19,9 @@ module Kumi
 
         def validate_node(node, errors)
           case node
-          when Declarations::Attribute
+          when Kumi::Syntax::ValueDeclaration
             validate_attribute(node, errors)
-          when Declarations::Trait
+          when Kumi::Syntax::TraitDeclaration
             validate_trait(node, errors)
           end
         end
@@ -33,7 +33,7 @@ module Kumi
         end
 
         def validate_trait(node, errors)
-          return if node.expression.is_a?(Expressions::CallExpression)
+          return if node.expression.is_a?(Kumi::Syntax::CallExpression)
 
           report_error(errors, "trait `#{node.name}` must wrap a CallExpression", location: node.loc)
         end

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, :input_meta
-      # 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)
@@ -22,7 +33,7 @@ module Kumi
 
           each_decl do |decl|
             # Traverse the expression for each declaration, passing context down
-            visit_with_context(decl.expression) do |node, 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
@@ -39,29 +50,74 @@ module Kumi
 
         def process_node(node, decl, graph, reverse_deps, leaves, definitions, input_meta, errors, context)
           case node
-          when Binding
+          when DeclarationReference
             report_error(errors, "undefined reference to `#{node.name}`", location: node.loc) unless definitions.key?(node.name)
-            add_dependency_edge(graph, reverse_deps, decl.name, node.name, :ref, context[:via])
-          when FieldRef
-            report_error(errors, "undeclared input `#{node.name}`", location: node.loc) unless input_meta.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 # put it back
+            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)
-          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
 
-        # Compute transitive closure: for each key, find ALL declarations that depend on it
+        # 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 = {}
-
-          # Collect all keys first to avoid iteration issues
           all_keys = reverse_dependencies.keys
 
           all_keys.each do |key|
@@ -75,7 +131,6 @@ module Kumi
 
               visited.add(current)
 
-              # Get direct dependents
               direct_dependents = reverse_dependencies[current] || []
               direct_dependents.each do |dependent|
                 next if visited.include?(dependent)
@@ -90,21 +145,6 @@ module Kumi
 
           transitive
         end
-
-        # Custom visitor that passes context (like function name) down the tree
-        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
-
-          node.children.each { |child| visit_with_context(child, new_context, &block) }
-        end
       end
     end
   end

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

@@ -8,14 +8,12 @@ module Kumi
       # 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)
-              report_error(errors, "Expected FieldDecl node, got #{field_decl.class}", location: field_decl.loc)
+            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,40 +21,103 @@ module Kumi
             existing = input_meta[name]
 
             if existing
-              # Check for 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 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
 
-              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)
+        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
 
-              # Validate domain type if provided
-              validate_domain_type(field_decl, errors) if field_decl.domain
+          metadata
+        end
 
-              # Merge metadata (later declarations override nil values)
-              input_meta[name] = {
-                type: field_decl.type || existing[:type],
-                domain: field_decl.domain || existing[:domain]
-              }
-            else
-              validate_domain_type(field_decl, errors) if field_decl.domain
-              input_meta[name] = {
-                type: field_decl.type,
-                domain: field_decl.domain
-              }
+        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
 
-          state.with(:input_meta, input_meta.freeze)
+          merged
         end
 
-        private
+        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

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

@@ -27,7 +27,7 @@ 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)

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

@@ -10,7 +10,7 @@ module Kumi
       #
       # 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 (Binding nodes)
+      # 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
@@ -26,17 +26,17 @@ module Kumi
 
         def validate_semantic_constraints(node, decl, errors)
           case node
-          when Declarations::Trait
+          when Kumi::Syntax::TraitDeclaration
             validate_trait_expression(node, errors)
-          when Expressions::WhenCaseExpression
+          when Kumi::Syntax::CaseExpression
             validate_cascade_condition(node, errors)
-          when Expressions::CallExpression
+          when Kumi::Syntax::CallExpression
             validate_function_call(node, errors)
           end
         end
 
         def validate_trait_expression(trait, errors)
-          return if trait.expression.is_a?(Expressions::CallExpression)
+          return if trait.expression.is_a?(Kumi::Syntax::CallExpression)
 
           report_error(
             errors,
@@ -50,20 +50,20 @@ module Kumi
           condition = when_case.condition
           
           case condition
-          when TerminalExpressions::Binding
+          when Kumi::Syntax::DeclarationReference
             # Valid: trait reference
             return
-          when Expressions::CallExpression
+          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 TerminalExpressions::Literal
+          when Kumi::Syntax::Literal
             # Allow literal conditions (like true/false) - they might be valid
             return
           else
-            # Only reject truly invalid conditions like FieldRef or complex expressions
+            # Only reject truly invalid conditions like InputReference or complex expressions
             report_error(
               errors,
               "cascade condition must be trait reference",