kumi 0.0.7 → 0.0.9

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

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        # Detects which operations should be broadcast over arrays
+        # DEPENDENCIES: :inputs, :declarations
+        # PRODUCES: :broadcasts
+        class BroadcastDetector < PassBase
+          def run(errors)
+            input_meta = get_state(:inputs) || {}
+            definitions = get_state(:declarations) || {}
+
+            # 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(:broadcasts, compiler_metadata.freeze)
+          end
+
+          private
+
+          def find_array_fields(input_meta)
+            result = {}
+            input_meta.each do |name, meta|
+              next unless meta[:type] == :array && meta[:children]
+
+              result[name] = {
+                element_fields: meta[:children].keys,
+                element_types: meta[:children].transform_values { |v| v[:type] || :any }
+              }
+            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 Kumi::Registry.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 %i[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] }.filter_map { |info| info[:array_source] }.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
+            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
+end

data/lib/kumi/core/analyzer/passes/declaration_validator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        # RESPONSIBILITY: Perform local structural validation on each declaration
+        # DEPENDENCIES: :definitions
+        # PRODUCES: None (validation only)
+        # INTERFACE: new(schema, state).run(errors)
+        class DeclarationValidator < VisitorPass
+          def run(errors)
+            each_decl do |decl|
+              visit(decl) { |node| validate_node(node, errors) }
+            end
+            state
+          end
+
+          private
+
+          def validate_node(node, errors)
+            case node
+            when Kumi::Syntax::ValueDeclaration
+              validate_attribute(node, errors)
+            when Kumi::Syntax::TraitDeclaration
+              validate_trait(node, errors)
+            end
+          end
+
+          def validate_attribute(node, errors)
+            return unless node.expression.nil?
+
+            report_error(errors, "attribute `#{node.name}` requires an expression", location: node.loc)
+          end
+
+          def validate_trait(node, errors)
+            return if node.expression.is_a?(Kumi::Syntax::CallExpression)
+
+            report_error(errors, "trait `#{node.name}` must wrap a CallExpression", location: node.loc)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    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
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    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
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    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
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        # Base class for analyzer passes with simple immutable state
+        class PassBase
+          include Kumi::Syntax
+          include Kumi::Core::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
+end