kumi 0.0.9 → 0.0.11

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

@@ -27,10 +27,10 @@ module Kumi
 
           attr_reader :schema, :state
 
-          # Iterate over all declarations (attributes and traits) in the schema
+          # Iterate over all declarations (values and traits) in the schema
           # @yield [Syntax::Attribute|Syntax::Trait] Each declaration
           def each_decl(&block)
-            schema.attributes.each(&block)
+            schema.values.each(&block)
             schema.traits.each(&block)
           end
 

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

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        # Plans per-declaration execution scope and join/lift needs.
+        # Determines the dimensional scope (array nesting level) for each declaration
+        # based on vectorization metadata and input paths.
+        #
+        # DEPENDENCIES: :declarations, :input_metadata, :broadcasts
+        # PRODUCES: :scope_plans, :decl_shapes
+        class ScopeResolutionPass < PassBase
+          include Kumi::Core::Analyzer::Plans
+
+          def run(_errors)
+            declarations = get_state(:declarations, required: true)
+            input_metadata = get_state(:input_metadata, required: true)
+            broadcasts = get_state(:broadcasts) || {}
+            dependencies = get_state(:dependencies) || {}
+            
+            puts "Available dependencies: #{dependencies.keys.inspect}" if ENV["DEBUG_SCOPE_RESOLUTION"]
+
+            scope_plans = {}
+            decl_shapes = {}
+
+            initial_scopes = {}
+            declarations.each do |name, decl|
+              debug_output(name, decl) if ENV["DEBUG_SCOPE_RESOLUTION"]
+              target_scope = infer_target_scope(name, decl, broadcasts, input_metadata)
+              result_kind = determine_result_kind(name, target_scope, broadcasts)
+              initial_scopes[name] = target_scope
+              debug_result(target_scope, result_kind) if ENV["DEBUG_SCOPE_RESOLUTION"]
+            end
+
+            final_scopes = propagate_scope_constraints(initial_scopes, declarations, input_metadata)
+            final_scopes.each do |name, target_scope|
+              result_kind = determine_result_kind(name, target_scope, broadcasts)
+              plan = build_scope_plan(target_scope)
+              scope_plans[name] = plan
+              decl_shapes[name] = { scope: target_scope, result: result_kind }.freeze
+            end
+
+            # Return new state with scope information
+            state.with(:scope_plans, scope_plans.freeze)
+                 .with(:decl_shapes, decl_shapes.freeze)
+          end
+
+          private
+
+          def propagate_scope_constraints(initial_scopes, declarations, input_metadata)
+            scopes = initial_scopes.dup
+            puts "\n=== Propagating scope constraints ===" if ENV["DEBUG_SCOPE_RESOLUTION"]
+
+            declarations.each do |name, decl|
+              case decl.expression
+              when Kumi::Syntax::ArrayExpression
+                propagate_from_array_expression(name, decl.expression, scopes, declarations, input_metadata)
+              when Kumi::Syntax::CascadeExpression
+                propagate_from_cascade_expression(name, decl.expression, scopes, declarations, input_metadata)
+              end
+            end
+
+            puts "Final propagated scopes: #{scopes.inspect}" if ENV["DEBUG_SCOPE_RESOLUTION"]
+            scopes
+          end
+
+          def propagate_from_array_expression(name, array_expr, scopes, declarations, input_metadata)
+            puts "Analyzing array expression in #{name}: #{array_expr.elements.map(&:class)}" if ENV["DEBUG_SCOPE_RESOLUTION"]
+
+            anchor_scope = nil
+            declaration_refs = []
+
+            array_expr.elements.each do |element|
+              case element
+              when Kumi::Syntax::InputElementReference
+                path_scope = dims_from_path(element.path, input_metadata)
+                puts "Found input anchor: #{element.path} -> scope #{path_scope}" if ENV["DEBUG_SCOPE_RESOLUTION"]
+                anchor_scope = path_scope if path_scope.length > (anchor_scope&.length || 0)
+              when Kumi::Syntax::DeclarationReference
+                declaration_refs << element.name
+              end
+            end
+
+            if anchor_scope && !anchor_scope.empty?
+              declaration_refs.each do |ref_name|
+                current_scope = scopes[ref_name] || []
+                if anchor_scope.length > current_scope.length
+                  puts "Propagating scope #{anchor_scope} to #{ref_name} (was #{current_scope})" if ENV["DEBUG_SCOPE_RESOLUTION"]
+                  scopes[ref_name] = anchor_scope
+                  propagate_to_dependencies(ref_name, anchor_scope, scopes, declarations, input_metadata)
+                end
+              end
+            end
+          end
+
+          def propagate_from_cascade_expression(name, cascade_expr, scopes, declarations, input_metadata)
+            puts "Analyzing cascade expression in #{name}" if ENV["DEBUG_SCOPE_RESOLUTION"]
+            
+            # Cascade should propagate its own scope to condition dependencies
+            cascade_scope = scopes[name] || []
+            return if cascade_scope.empty?
+            
+            puts "Propagating cascade scope #{cascade_scope} to condition dependencies" if ENV["DEBUG_SCOPE_RESOLUTION"]
+            
+            cascade_expr.cases.each do |case_expr|
+              find_declaration_references(case_expr.condition).each do |ref_name|
+                current_scope = scopes[ref_name] || []
+                if cascade_scope.length > current_scope.length
+                  puts "Propagating scope #{cascade_scope} to cascade condition #{ref_name} (was #{current_scope})" if ENV["DEBUG_SCOPE_RESOLUTION"]
+                  scopes[ref_name] = cascade_scope
+                  propagate_to_dependencies(ref_name, cascade_scope, scopes, declarations, input_metadata)
+                end
+              end
+            end
+          end
+
+          def propagate_to_dependencies(decl_name, required_scope, scopes, declarations, input_metadata)
+            return unless declarations[decl_name]
+            
+            decl = declarations[decl_name]
+            puts "Propagating #{required_scope} into dependencies of #{decl_name}" if ENV["DEBUG_SCOPE_RESOLUTION"]
+            
+            case decl.expression
+            when Kumi::Syntax::CascadeExpression
+              decl.expression.cases.each do |case_expr|
+                find_declaration_references(case_expr.condition).each do |ref_name|
+                  current_scope = scopes[ref_name] || []
+                  if required_scope.length > current_scope.length
+                    puts "Propagating scope #{required_scope} to trait dependency #{ref_name}" if ENV["DEBUG_SCOPE_RESOLUTION"]
+                    scopes[ref_name] = required_scope
+                    update_reduction_scope_if_needed(ref_name, required_scope, declarations, input_metadata)
+                  end
+                end
+              end
+            end
+          end
+
+          def find_declaration_references(expr)
+            refs = []
+            case expr
+            when Kumi::Syntax::DeclarationReference
+              refs << expr.name
+            when Kumi::Syntax::CallExpression
+              expr.args.each { |arg| refs.concat(find_declaration_references(arg)) }
+            when Kumi::Syntax::ArrayExpression
+              expr.elements.each { |elem| refs.concat(find_declaration_references(elem)) }
+            end
+            refs
+          end
+
+          def update_reduction_scope_if_needed(decl_name, required_scope, declarations, input_metadata)
+            decl = declarations[decl_name]
+            return unless decl
+            puts "Checking if #{decl_name} needs reduction scope update for #{required_scope}" if ENV["DEBUG_SCOPE_RESOLUTION"]
+          end
+
+          def debug_output(name, decl)
+            puts "\n=== Resolving scope for #{name} ==="
+            puts "Declaration: #{decl.inspect}"
+          end
+
+          def debug_result(target_scope, result_kind)
+            puts "Target scope: #{target_scope.inspect}"
+            puts "Result kind: #{result_kind.inspect}"
+          end
+
+          def build_scope_plan(target_scope)
+            Scope.new(
+              scope: target_scope,
+              lifts: [], # Will be computed during IR lowering per call-site
+              join_hint: nil, # Will be set to :zip when multiple vectorized args exist
+              arg_shapes: {} # Optional: filled during lowering
+            )
+          end
+
+          def determine_result_kind(name, target_scope, broadcasts)
+            return :scalar if broadcasts.dig(:reduction_operations, name)
+            return :scalar if target_scope.empty?
+
+            { array: :dense }
+          end
+
+          # Derive scope from vectorization metadata or from deepest input path
+          def infer_target_scope(name, decl, broadcasts, input_metadata)
+            # First check vectorized operations
+            vec = broadcasts.dig(:vectorized_operations, name)
+            if vec
+              puts "Vectorization info: #{vec.inspect}" if ENV["DEBUG_SCOPE_RESOLUTION"]
+
+              case vec[:source]
+              when :nested_array_access, :array_field_access
+                path = vec[:path] || []
+                return dims_from_path(path, input_metadata)
+              when :cascade_with_vectorized_conditions_or_results,
+                   :cascade_condition_with_vectorized_trait
+                # Fallback: derive from first input path seen in expression
+                path = find_first_input_path(decl.expression) || []
+                return dims_from_path(path, input_metadata)
+              else
+                return []
+              end
+            end
+
+            # Check if this is a reduction operation that should preserve some scope
+            red = broadcasts.dig(:reduction_operations, name)
+            if red
+              puts "Reduction info: #{red.inspect}" if ENV["DEBUG_SCOPE_RESOLUTION"]
+              
+              # Infer the natural scope for this reduction
+              # For expressions like fn(:any?, input.players.score_matrices.session.points > 1000)
+              # we want to reduce over session dimension but preserve the players dimension
+              scope = infer_reduction_target_scope(decl.expression, input_metadata)
+              puts "Inferred reduction target scope: #{scope.inspect}" if ENV["DEBUG_SCOPE_RESOLUTION"]
+              return scope
+            end
+
+            return []
+          end
+
+          def infer_reduction_target_scope(expr, input_metadata)
+            # For reduction expressions, we need to analyze the argument to the reducer
+            # and determine which dimensions should be preserved vs reduced
+            case expr
+            when Kumi::Syntax::CallExpression
+              if reducer_function?(expr.fn_name)
+                # Find the argument being reduced
+                arg = expr.args.first
+                if arg
+                  # Get the full scope from the argument
+                  full_scope = infer_scope_from_argument(arg, input_metadata)
+                  
+                  # For array reductions, we typically want to preserve
+                  # the outermost dimension (e.g., keep :players, reduce :score_matrices/:session)
+                  if full_scope.length > 1
+                    return full_scope[0..0]  # Keep only the first dimension
+                  end
+                end
+              else
+                # Recursively check if any argument contains a reducer
+                # This handles cases like (fn(:sum, ...) >= 3500)
+                expr.args.each do |arg|
+                  nested_scope = infer_reduction_target_scope(arg, input_metadata)
+                  return nested_scope if !nested_scope.empty?
+                end
+              end
+            end
+            []
+          end
+
+          def reducer_function?(fn_name)
+            entry = Kumi::Registry.entry(fn_name)
+            entry&.reducer == true
+          end
+
+          def infer_scope_from_argument(arg, input_metadata)
+            case arg
+            when Kumi::Syntax::InputElementReference
+              dims_from_path(arg.path, input_metadata)
+            when Kumi::Syntax::InputReference
+              dims_from_path([arg.name], input_metadata)
+            when Kumi::Syntax::CallExpression
+              # For expressions like (input.players.score_matrices.session.points > 1000),
+              # we need to find the deepest input path
+              deepest_path = find_deepest_input_path(arg)
+              deepest_path ? dims_from_path(deepest_path, input_metadata) : []
+            else
+              []
+            end
+          end
+
+          def find_deepest_input_path(expr)
+            paths = collect_input_paths(expr)
+            paths.max_by(&:length)
+          end
+
+          def collect_input_paths(expr)
+            paths = []
+            case expr
+            when Kumi::Syntax::InputElementReference
+              paths << expr.path
+            when Kumi::Syntax::InputReference
+              paths << [expr.name]
+            when Kumi::Syntax::CallExpression
+              expr.args.each { |arg| paths.concat(collect_input_paths(arg)) }
+            when Kumi::Syntax::ArrayExpression
+              expr.elements.each { |elem| paths.concat(collect_input_paths(elem)) }
+            end
+            paths
+          end
+
+          def find_first_input_path(expr)
+            return nil unless expr
+
+            # Handle InputElementReference directly
+            return expr.path if expr.is_a?(Kumi::Syntax::InputElementReference)
+
+            # Handle InputReference (convert to path array)
+            return [expr.name] if expr.is_a?(Kumi::Syntax::InputReference)
+
+            # Recursively search in CallExpression arguments
+            if expr.is_a?(Kumi::Syntax::CallExpression) && expr.args
+              expr.args.each do |arg|
+                path = find_first_input_path(arg)
+                return path if path
+              end
+            end
+
+            # Search in CascadeExpression cases
+            if expr.is_a?(Kumi::Syntax::CascadeExpression) && expr.cases
+              expr.cases.each do |case_item|
+                path = find_first_input_path(case_item.condition)
+                return path if path
+
+                path = find_first_input_path(case_item.result)
+                return path if path
+              end
+            end
+
+            # Search in expression field if present
+            return find_first_input_path(expr.expression) if expr.respond_to?(:expression)
+
+            nil
+          end
+
+          # Map an input path like [:regions, :offices, :salary] to container dims [:regions, :offices]
+          def dims_from_path(path, input_metadata)
+            dims = []
+            meta = input_metadata
+
+            path.each do |seg|
+              field = meta[seg] || meta[seg.to_sym] || meta[seg.to_s]
+              break unless field
+
+              dims << seg.to_sym if field[:type] == :array
+
+              meta = field[:children] || {}
+            end
+
+            dims
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -17,9 +17,15 @@ module Kumi
         # 4. Expression types are valid for their context
         class SemanticConstraintValidator < VisitorPass
           def run(errors)
+            # Visit value and trait declarations
             each_decl do |decl|
               visit(decl) { |node| validate_semantic_constraints(node, decl, errors) }
             end
+
+            # Visit input declarations
+            schema.inputs.each do |input_decl|
+              visit(input_decl) { |node| validate_semantic_constraints(node, input_decl, errors) }
+            end
             state
           end
 
@@ -33,6 +39,8 @@ module Kumi
               validate_cascade_condition(node, errors)
             when Kumi::Syntax::CallExpression
               validate_function_call(node, errors)
+            when Kumi::Syntax::InputDeclaration
+              validate_input_declaration(node, errors)
             end
           end
 
@@ -90,6 +98,26 @@ module Kumi
             )
           end
 
+          def validate_input_declaration(input_decl, errors)
+            return unless input_decl.type == :array && input_decl.children.any?
+
+            # Validate that access_mode is consistent with children structure
+            if input_decl.access_mode == :element
+
+              # Element mode arrays can only have exactly one direct child
+              if input_decl.children.size > 1
+                error_msg = "array with access_mode :element can only have one direct child element, " \
+                            "but found #{input_decl.children.size} children"
+                report_error(errors, error_msg, location: input_decl.loc, type: :semantic)
+              end
+            elsif input_decl.access_mode == :field
+              # Object mode allows multiple children
+            end
+
+            # Recursively validate children
+            input_decl.children.each { |child| validate_input_declaration(child, errors) }
+          end
+
           def boolean_trait_composition?(call_expr)
             # Allow boolean composition functions that operate on trait collections
             %i[all? any? none?].include?(call_expr.fn_name)

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pry"
 module Kumi
   module Core
     module Analyzer
@@ -34,7 +35,6 @@ module Kumi
                 return if safe_conditional_cycle?(cycle_path, graph, cascades)
 
                 # Allow this cycle - it's safe due to cascade mutual exclusion
-
                 report_unexpected_cycle(temp_marks, node, errors)
 
                 return
@@ -42,7 +42,13 @@ module Kumi
 
               temp_marks << node
               current_path = path + [node]
-              Array(graph[node]).each { |edge| visit_node.call(edge.to, current_path) }
+              # Only follow edges to other declarations, not to input fields
+              # This prevents false cycles when a declaration has the same name as an input
+              Array(graph[node]).each do |edge|
+                next if edge.type == :key # Skip input field dependencies
+
+                visit_node.call(edge.to, current_path)
+              end
               temp_marks.delete(node)
               perm_marks << node
 
@@ -100,7 +106,7 @@ module Kumi
           def find_declaration_by_name(name)
             return nil unless schema
 
-            schema.attributes.find { |attr| attr.name == name } ||
+            schema.values.find { |attr| attr.name == name } ||
               schema.traits.find { |trait| trait.name == name }
           end
         end

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

@@ -5,15 +5,19 @@ module Kumi
     module Analyzer
       module Passes
         # RESPONSIBILITY: Validate function call arity and argument types against FunctionRegistry
-        # DEPENDENCIES: :inferred_types from TypeInferencer
-        # PRODUCES: None (validation only)
+        # DEPENDENCIES: :inferred_types from TypeInferencerPass
+        # PRODUCES: :functions_required - Set of function names used in the schema
         # INTERFACE: new(schema, state).run(errors)
         class TypeChecker < VisitorPass
           def run(errors)
+            functions_required = Set.new
+
             visit_nodes_of_type(Kumi::Syntax::CallExpression, errors: errors) do |node, _decl, errs|
               validate_function_call(node, errs)
+              functions_required.add(node.fn_name)
             end
-            state
+
+            state.with(:functions_required, functions_required)
           end
 
           private
@@ -109,7 +113,7 @@ module Kumi
 
           def get_declared_field_type(field_name)
             # Get explicitly declared type from input metadata
-            input_meta = get_state(:inputs, required: false) || {}
+            input_meta = get_state(:input_metadata, required: false) || {}
             field_meta = input_meta[field_name]
             field_meta&.dig(:type) || Kumi::Core::Types::ANY
           end
@@ -126,7 +130,7 @@ module Kumi
               "`#{expr.value}` of type #{type} (literal value)"
 
             when Kumi::Syntax::InputReference
-              input_meta = get_state(:inputs, required: false) || {}
+              input_meta = get_state(:input_metadata, required: false) || {}
               field_meta = input_meta[expr.name]
 
               if field_meta&.dig(:type)

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

@@ -5,12 +5,12 @@ module Kumi
     module Analyzer
       module Passes
         # RESPONSIBILITY: Validate consistency between declared and inferred types
-        # DEPENDENCIES: :inputs from InputCollector, :inferred_types from TypeInferencer
+        # DEPENDENCIES: :input_metadata from InputCollector, :inferred_types from TypeInferencerPass
         # PRODUCES: None (validation only)
         # INTERFACE: new(schema, state).run(errors)
         class TypeConsistencyChecker < PassBase
           def run(errors)
-            input_meta = get_state(:inputs, required: false) || {}
+            input_meta = get_state(:input_metadata, required: false) || {}
 
             # First, validate that all declared types are valid
             validate_declared_types(input_meta, errors)

data/lib/kumi/core/analyzer/passes/{type_inferencer.rb → type_inferencer_pass.rb}

@@ -8,7 +8,7 @@ module Kumi
         # DEPENDENCIES: Toposorter (needs evaluation_order), DeclarationValidator (needs declarations)
         # PRODUCES: inferred_types hash mapping declaration names to inferred types
         # INTERFACE: new(schema, state).run(errors)
-        class TypeInferencer < PassBase
+        class TypeInferencerPass < PassBase
           def run(errors)
             types = {}
             topo_order = get_state(:evaluation_order)
@@ -49,7 +49,7 @@ module Kumi
               Types.infer_from_value(expr.value)
             when InputReference
               # Look up type from field metadata
-              input_meta = get_state(:inputs, required: false) || {}
+              input_meta = get_state(:input_metadata, required: false) || {}
               meta = input_meta[expr.name]
               meta&.dig(:type) || :any
             when DeclarationReference
@@ -156,7 +156,7 @@ module Kumi
             case expr
             when InputElementReference
               # Get the field type from metadata
-              input_meta = get_state(:inputs, required: false) || {}
+              input_meta = get_state(:input_metadata, required: false) || {}
               array_name = expr.path.first
               field_name = expr.path[1]
 
@@ -198,7 +198,7 @@ module Kumi
 
           def infer_element_reference_type(expr)
             # Get array field metadata
-            input_meta = get_state(:inputs, required: false) || {}
+            input_meta = get_state(:input_metadata, required: false) || {}
 
             return :any unless expr.path.size >= 2