kumi 0.0.6 → 0.0.8

data/lib/kumi/compiler.rb

@@ -27,7 +27,6 @@ module Kumi
         end
       end
 
-
       def compile_binding_node(expr)
         name = expr.name
         # Handle forward references in cycles by deferring binding lookup to runtime
@@ -45,7 +44,7 @@ module Kumi
       def compile_call(expr)
         fn_name = expr.fn_name
         arg_fns = expr.args.map { |a| compile_expr(a) }
-        
+
         # Check if this is a vectorized operation
         if vectorized_operation?(expr)
           ->(ctx) { invoke_vectorized_function(fn_name, arg_fns, ctx, expr.loc) }
@@ -56,40 +55,39 @@ module Kumi
 
       def compile_cascade(expr)
         # Check if current declaration is vectorized
-        broadcast_meta = @analysis.state[:broadcast_metadata]
+        broadcast_meta = @analysis.state[:broadcasts]
         is_vectorized = @current_declaration && broadcast_meta&.dig(:vectorized_operations, @current_declaration)
-        
-        
+
         # For vectorized cascades, we need to transform conditions that use all?
-        if is_vectorized
-          pairs = expr.cases.map do |c|
-            condition_fn = transform_vectorized_condition(c.condition)
-            result_fn = compile_expr(c.result)
-            [condition_fn, result_fn]
-          end
-        else
-          pairs = expr.cases.map { |c| [compile_expr(c.condition), compile_expr(c.result)] }
-        end
-        
+        pairs = if is_vectorized
+                  expr.cases.map do |c|
+                    condition_fn = transform_vectorized_condition(c.condition)
+                    result_fn = compile_expr(c.result)
+                    [condition_fn, result_fn]
+                  end
+                else
+                  expr.cases.map { |c| [compile_expr(c.condition), compile_expr(c.result)] }
+                end
+
         if is_vectorized
           lambda do |ctx|
             # This cascade can be vectorized - check if we actually need to at runtime
             # Evaluate all conditions and results to check for arrays
             cond_results = pairs.map { |cond, _res| cond.call(ctx) }
             res_results = pairs.map { |_cond, res| res.call(ctx) }
-            
+
             # Check if any conditions or results are arrays (vectorized)
-            has_vectorized_data = (cond_results + res_results).any? { |v| v.is_a?(Array) }
-            
+            has_vectorized_data = (cond_results + res_results).any?(Array)
+
             if has_vectorized_data
               # Apply element-wise cascade evaluation
-              array_length = cond_results.find { |v| v.is_a?(Array) }&.length || 
-                           res_results.find { |v| v.is_a?(Array) }&.length || 1
-              
+              array_length = cond_results.find { |v| v.is_a?(Array) }&.length ||
+                             res_results.find { |v| v.is_a?(Array) }&.length || 1
+
               (0...array_length).map do |i|
-                pairs.each_with_index do |(cond, res), pair_idx|
+                pairs.each_with_index do |(_cond, _res), pair_idx|
                   cond_val = cond_results[pair_idx].is_a?(Array) ? cond_results[pair_idx][i] : cond_results[pair_idx]
-                  
+
                   if cond_val
                     res_val = res_results[pair_idx].is_a?(Array) ? res_results[pair_idx][i] : res_results[pair_idx]
                     break res_val
@@ -98,7 +96,7 @@ module Kumi
               end
             else
               # All data is scalar - use regular cascade evaluation
-              pairs.each_with_index do |(cond, res), pair_idx|
+              pairs.each_with_index do |(_cond, _res), pair_idx|
                 return res_results[pair_idx] if cond_results[pair_idx]
               end
               nil
@@ -114,17 +112,17 @@ module Kumi
 
       def transform_vectorized_condition(condition_expr)
         # If this is fn(:all?, [trait_ref]), extract the trait_ref for vectorized cascades
-        if condition_expr.is_a?(Kumi::Syntax::CallExpression) && 
-           condition_expr.fn_name == :all? && 
+        if condition_expr.is_a?(Kumi::Syntax::CallExpression) &&
+           condition_expr.fn_name == :all? &&
            condition_expr.args.length == 1
-          
+
           arg = condition_expr.args.first
           if arg.is_a?(Kumi::Syntax::ArrayExpression) && arg.elements.length == 1
             trait_ref = arg.elements.first
             return compile_expr(trait_ref)
           end
         end
-        
+
         # Otherwise compile normally
         compile_expr(condition_expr)
       end
@@ -160,7 +158,7 @@ module Kumi
         compile_declaration(decl)
       end
 
-      CompiledSchema.new(@bindings.freeze)
+      Core::CompiledSchema.new(@bindings.freeze)
     end
 
     private
@@ -216,14 +214,12 @@ module Kumi
 
     def vectorized_operation?(expr)
       # Check if this operation uses vectorized inputs
-      broadcast_meta = @analysis.state[:broadcast_metadata]
+      broadcast_meta = @analysis.state[:broadcasts]
       return false unless broadcast_meta
-      
+
       # Reduction functions are NOT vectorized operations - they consume arrays
-      if FunctionRegistry.reducer?(expr.fn_name)
-        return false
-      end
-      
+      return false if Kumi::Registry.reducer?(expr.fn_name)
+
       expr.args.any? do |arg|
         case arg
         when Kumi::Syntax::InputElementReference
@@ -235,21 +231,20 @@ module Kumi
         end
       end
     end
-    
-    
+
     def invoke_vectorized_function(name, arg_fns, ctx, loc)
       # Evaluate arguments
       values = arg_fns.map { |fn| fn.call(ctx) }
-      
+
       # Check if any argument is vectorized (array)
-      has_vectorized_args = values.any? { |v| v.is_a?(Array) }
-      
+      has_vectorized_args = values.any?(Array)
+
       if has_vectorized_args
         # Apply function with broadcasting to all vectorized arguments
         vectorized_function_call(name, values)
       else
         # All arguments are scalars - regular function call
-        fn = FunctionRegistry.fetch(name)
+        fn = Kumi::Registry.fetch(name)
         fn.call(*values)
       end
     rescue StandardError => e
@@ -259,37 +254,36 @@ module Kumi
       runtime_error.define_singleton_method(:cause) { e }
       raise runtime_error
     end
-    
+
     def vectorized_function_call(fn_name, values)
       # Get the function from registry
-      fn = FunctionRegistry.fetch(fn_name)
-      
+      fn = Kumi::Registry.fetch(fn_name)
+
       # Find array dimensions for broadcasting
       array_values = values.select { |v| v.is_a?(Array) }
       return fn.call(*values) if array_values.empty?
-      
+
       # All arrays should have the same length (validation could be added)
       array_length = array_values.first.size
-      
+
       # Broadcast and apply function element-wise
       (0...array_length).map do |i|
         element_args = values.map do |v|
-          v.is_a?(Array) ? v[i] : v  # Broadcast scalars
+          v.is_a?(Array) ? v[i] : v # Broadcast scalars
         end
         fn.call(*element_args)
       end
     end
-    
 
     def invoke_function(name, arg_fns, ctx, loc)
-      fn = FunctionRegistry.fetch(name)
+      fn = Kumi::Registry.fetch(name)
       values = arg_fns.map { |fn| fn.call(ctx) }
       fn.call(*values)
     rescue StandardError => e
       # Preserve original error class and backtrace while adding context
       enhanced_message = "Error calling fn(:#{name}) at #{loc}: #{e.message}"
 
-      if e.is_a?(Kumi::Errors::Error)
+      if e.is_a?(Kumi::Core::Errors::Error)
         # Re-raise Kumi errors with enhanced message but preserve type
         e.define_singleton_method(:message) { enhanced_message }
         raise e

data/lib/kumi/core/analyzer/analysis_state.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      # Simple immutable state wrapper to prevent accidental mutations between passes
+      class AnalysisState
+        def initialize(data = {})
+          @data = data.dup.freeze
+        end
+
+        # Get a value (same as hash access)
+        def [](key)
+          @data[key]
+        end
+
+        # Check if key exists (same as hash)
+        def key?(key)
+          @data.key?(key)
+        end
+
+        # Get all keys (same as hash)
+        def keys
+          @data.keys
+        end
+
+        # Create new state with additional data (simple and clean)
+        def with(key, value)
+          AnalysisState.new(@data.merge(key => value))
+        end
+
+        # Convert back to hash for final result
+        def to_h
+          @data.dup
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/analyzer/constant_evaluator.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      class ConstantEvaluator
+        include Syntax
+
+        def initialize(definitions)
+          @definitions = definitions
+          @memo = {}
+        end
+
+        OPERATORS = {
+          add: :+,
+          subtract: :-,
+          multiply: :*,
+          divide: :/
+        }.freeze
+
+        def evaluate(node, visited = Set.new)
+          return :unknown unless node
+          return @memo[node] if @memo.key?(node)
+          return node.value if node.is_a?(Literal)
+
+          result = case node
+                   when DeclarationReference then evaluate_binding(node, visited)
+                   when CallExpression then evaluate_call_expression(node, visited)
+                   else :unknown
+                   end
+
+          @memo[node] = result unless result == :unknown
+          result
+        end
+
+        private
+
+        def evaluate_binding(node, visited)
+          return :unknown if visited.include?(node.name)
+
+          visited << node.name
+          definition = @definitions[node.name]
+          return :unknown unless definition
+
+          evaluate(definition.expression, visited)
+        end
+
+        def evaluate_call_expression(node, visited)
+          return :unknown unless OPERATORS.key?(node.fn_name)
+
+          args = node.args.map { |arg| evaluate(arg, visited) }
+          return :unknown if args.any?(:unknown)
+
+          args.reduce(OPERATORS[node.fn_name])
+        end
+      end
+    end
+  end
+end

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