kumi 0.0.4 → 0.0.6

data/examples/static_analysis_errors.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+# Static Analysis Error Examples
+# This file demonstrates various errors that Kumi catches during schema definition
+
+require_relative "../lib/kumi"
+
+puts "=== Kumi Static Analysis Examples ===\n"
+puts "All errors caught during schema definition, before any data processing!\n\n"
+
+# Example 1: Circular Dependency Detection
+puts "1. Circular Dependency Detection:"
+puts "   Code with circular references between values..."
+begin
+  module CircularDependency
+    extend Kumi::Schema
+    
+    schema do
+      input { float :base }
+      
+      value :monthly_rate, yearly_rate / 12
+      value :yearly_rate, monthly_rate * 12
+    end
+  end
+rescue Kumi::Errors::SemanticError => e
+  puts "   → #{e.message}"
+end
+
+puts "\n" + "="*60 + "\n"
+
+# Example 2: Impossible Logic Detection (UnsatDetector)
+puts "2. Impossible Logic Detection:"
+puts "   Code with contradictory conditions..."
+begin
+  module ImpossibleLogic
+    extend Kumi::Schema
+    
+    schema do
+      input { integer :age }
+      
+      trait :child, input.age < 13
+      trait :adult, input.age >= 18
+      
+      # This combination can never be true
+      value :status do
+        on child & adult, "Impossible!"
+        base "Normal"
+      end
+    end
+  end
+rescue Kumi::Errors::SemanticError => e
+  puts "   → #{e.message}"
+end
+
+puts "\n" + "="*60 + "\n"
+
+# Example 3: Type System Validation
+puts "3. Type Mismatch Detection:"
+puts "   Code trying to add incompatible types..."
+begin
+  module TypeMismatch
+    extend Kumi::Schema
+    
+    schema do
+      input do
+        string :name
+        integer :age
+      end
+      
+      # String + Integer type mismatch
+      value :invalid_sum, input.name + input.age
+    end
+  end
+rescue Kumi::Errors::TypeError => e
+  puts "   → #{e.message}"
+end
+
+puts "\n" + "="*60 + "\n"
+
+# Example 4: Domain Constraint Analysis
+puts "4. Domain Constraint Violations:"
+puts "   Code using values outside declared domains..."
+begin
+  module DomainViolation
+    extend Kumi::Schema
+    
+    schema do
+      input do
+        integer :score, domain: 0..100
+        string :grade, domain: %w[A B C D F]
+      end
+      
+      # 150 is outside the domain 0..100
+      trait :impossible_score, input.score == 150
+    end
+  end
+rescue Kumi::Errors::SemanticError => e
+  puts "   → #{e.message}"
+end
+
+puts "\n" + "="*60 + "\n"
+
+# Example 5: Undefined Reference Detection
+puts "5. Undefined Reference Detection:"
+puts "   Code referencing non-existent declarations..."
+begin
+  module UndefinedReference
+    extend Kumi::Schema
+    
+    schema do
+      input { integer :amount }
+      
+      # References a trait that doesn't exist
+      value :result, ref(:nonexistent_trait) ? 100 : 0
+    end
+  end
+rescue Kumi::Errors::SemanticError => e
+  puts "   → #{e.message}"
+end
+
+puts "\n" + "="*60 + "\n"
+
+# Example 6: Invalid Function Usage
+puts "6. Invalid Function Detection:"
+puts "   Code using non-existent functions..."
+begin
+  module InvalidFunction
+    extend Kumi::Schema
+    
+    schema do
+      input { string :text }
+      
+      # Function doesn't exist in registry
+      value :result, fn(:nonexistent_function, input.text)
+    end
+  end
+rescue Kumi::Errors::TypeError => e
+  puts "   → #{e.message}"
+end
+
+puts "\n" + "="*60 + "\n"
+
+# Example 7: Complex Schema with Multiple Issues
+puts "7. Multiple Issues Detected:"
+puts "   Complex schema with several problems..."
+begin
+  module MultipleIssues
+    extend Kumi::Schema
+    
+    schema do
+      input { integer :value, domain: 1..10 }
+      
+      # Issue 1: Circular dependency
+      value :a, b + 1
+      value :b, c + 1  
+      value :c, a + 1
+      
+      # Issue 2: Impossible domain condition
+      trait :impossible, (input.value > 10) & (input.value < 5)
+      
+      # Issue 3: Undefined reference
+      value :result, ref(:undefined_declaration)
+    end
+  end
+rescue Kumi::Errors::SemanticError => e
+  puts "   → " + e.message.split("\n").join("\n   → ")
+end
+
+puts "\n" + "="*60 + "\n"
+puts "Summary:"
+puts "• Circular dependencies caught before infinite loops"
+puts "• Impossible logic detected through constraint analysis"  
+puts "• Type mismatches found during type inference"
+puts "• Domain violations identified through static analysis"
+puts "• Undefined references caught during name resolution"
+puts "• Invalid functions detected during compilation"
+puts "• Multiple issues reported together with precise locations"
+puts "\nAll validation happens during schema definition - no runtime surprises!"

data/examples/wide_schema_compilation_and_evaluation_benchmark.rb

@@ -41,7 +41,7 @@ def build_wide_schema(width)
             ref(:sum_all), :>, (width * (width + 1) / 2)
 
       value :final_total do
-        on :large_total, fn(:add, ref(:sum_all), ref(:avg_all))
+        on large_total, fn(:add, ref(:sum_all), ref(:avg_all))
         base ref(:sum_all)
       end
     end

data/lib/kumi/analyzer/analysis_state.rb

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

data/lib/kumi/analyzer/constant_evaluator.rb

@@ -22,29 +22,35 @@ module Kumi
         return @memo[node] if @memo.key?(node)
         return node.value if node.is_a?(Literal)
 
-        if node.is_a?(Binding)
-          return :unknown if visited.include?(node.name)
+        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
 
-          visited << node.name
+      private
 
-          definition = @definitions[node.name]
-          return :unknown unless definition
+      def evaluate_binding(node, visited)
+        return :unknown if visited.include?(node.name)
 
-          @memo[node] = evaluate(definition.expression, visited)
-          return @memo[node]
-        end
+        visited << node.name
+        definition = @definitions[node.name]
+        return :unknown unless definition
 
-        if node.is_a?(CallExpression)
-          return :unknown unless OPERATORS.key?(node.fn_name)
+        evaluate(definition.expression, visited)
+      end
 
-          args = node.args.map { |arg| evaluate(arg, visited) }
-          return :unknown if args.any?(:unknown)
+      def evaluate_call_expression(node, visited)
+        return :unknown unless OPERATORS.key?(node.fn_name)
 
-          @memo[node] = args.reduce(OPERATORS[node.fn_name])
-          return @memo[node]
-        end
+        args = node.args.map { |arg| evaluate(arg, visited) }
+        return :unknown if args.any?(:unknown)
 
-        :unknown
+        args.reduce(OPERATORS[node.fn_name])
       end
     end
   end

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}

@@ -4,23 +4,24 @@ module Kumi
   module Analyzer
     module Passes
       # RESPONSIBILITY: Perform local structural validation on each declaration
-      # DEPENDENCIES: None (can run independently)
+      # 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) }
           end
+          state
         end
 
         private
 
         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
@@ -28,13 +29,13 @@ module Kumi
         def validate_attribute(node, errors)
           return unless node.expression.nil?
 
-          add_error(errors, node.loc, "attribute `#{node.name}` requires an expression")
+          report_error(errors, "attribute `#{node.name}` requires an expression", location: node.loc)
         end
 
         def validate_trait(node, errors)
-          return if node.expression.is_a?(Expressions::CallExpression)
+          return if node.expression.is_a?(Kumi::Syntax::CallExpression)
 
-          add_error(errors, node.loc, "trait `#{node.name}` must wrap a CallExpression")
+          report_error(errors, "trait `#{node.name}` must wrap a CallExpression", location: node.loc)
         end
       end
     end