kumi 0.0.4 → 0.0.6

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

@@ -4,14 +4,15 @@ module Kumi
   module Analyzer
     module Passes
       # RESPONSIBILITY: Validate function call arity and argument types against FunctionRegistry
-      # DEPENDENCIES: None (can run independently)
+      # DEPENDENCIES: :decl_types from TypeInferencer
       # PRODUCES: None (validation only)
       # INTERFACE: new(schema, state).run(errors)
       class TypeChecker < VisitorPass
         def run(errors)
-          visit_nodes_of_type(Expressions::CallExpression, errors: errors) do |node, _decl, errs|
+          visit_nodes_of_type(Kumi::Syntax::CallExpression, errors: errors) do |node, _decl, errs|
             validate_function_call(node, errs)
           end
+          state
         end
 
         private
@@ -46,11 +47,33 @@ module Kumi
           types = signature[:param_types]
           return if types.nil? || (signature[:arity].negative? && node.args.empty?)
 
+          # Skip type checking for vectorized operations
+          broadcast_meta = get_state(:broadcast_metadata, required: false)
+          if broadcast_meta && is_part_of_vectorized_operation?(node, broadcast_meta)
+            return
+          end
+
           node.args.each_with_index do |arg, i|
             validate_argument_type(arg, i, types[i], node.fn_name, errors)
           end
         end
 
+        def is_part_of_vectorized_operation?(node, broadcast_meta)
+          # Check if this node is part of a vectorized or reduction operation
+          # This is a simplified check - in a real implementation we'd need to track context
+          node.args.any? do |arg|
+            case arg
+            when Kumi::Syntax::DeclarationReference
+              broadcast_meta[:vectorized_operations]&.key?(arg.name) ||
+              broadcast_meta[:reduction_operations]&.key?(arg.name)
+            when Kumi::Syntax::InputElementReference
+              broadcast_meta[:array_fields]&.key?(arg.path.first)
+            else
+              false
+            end
+          end
+        end
+
         def validate_argument_type(arg, index, expected_type, fn_name, errors)
           return if expected_type.nil? || expected_type == Kumi::Types::ANY
 
@@ -66,15 +89,15 @@ module Kumi
 
         def get_expression_type(expr)
           case expr
-          when TerminalExpressions::Literal
+          when Kumi::Syntax::Literal
             # Inferred type from literal value
             Kumi::Types.infer_from_value(expr.value)
 
-          when TerminalExpressions::FieldRef
+          when Kumi::Syntax::InputReference
             # Declared type from input block (user-specified)
             get_declared_field_type(expr.name)
 
-          when TerminalExpressions::Binding
+          when Kumi::Syntax::DeclarationReference
             # Inferred type from type inference results
             get_inferred_declaration_type(expr.name)
 
@@ -100,10 +123,10 @@ module Kumi
 
         def describe_expression_type(expr, type)
           case expr
-          when TerminalExpressions::Literal
+          when Kumi::Syntax::Literal
             "`#{expr.value}` of type #{type} (literal value)"
 
-          when TerminalExpressions::FieldRef
+          when Kumi::Syntax::InputReference
             input_meta = get_state(:input_meta, required: false) || {}
             field_meta = input_meta[expr.name]
 
@@ -116,17 +139,17 @@ module Kumi
               "undeclared input field `#{expr.name}` (inferred as #{type})"
             end
 
-          when TerminalExpressions::Binding
+          when Kumi::Syntax::DeclarationReference
             # This type was inferred from the declaration's expression
             "reference to declaration `#{expr.name}` of inferred type #{type}"
 
-          when Expressions::CallExpression
+          when Kumi::Syntax::CallExpression
             "result of function `#{expr.fn_name}` returning #{type}"
 
-          when Expressions::ListExpression
+          when Kumi::Syntax::ArrayExpression
             "list expression of type #{type}"
 
-          when Expressions::CascadeExpression
+          when Kumi::Syntax::CascadeExpression
             "cascade expression of type #{type}"
 
           else

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

@@ -16,6 +16,7 @@ module Kumi
 
           # Then check basic consistency (placeholder for now)
           # In a full implementation, this would do sophisticated usage analysis
+          state
         end
 
         private
@@ -30,7 +31,7 @@ module Kumi
             field_decl = find_input_field_declaration(field_name)
             location = field_decl&.loc
 
-            add_error(errors, location, "Invalid type declaration for field :#{field_name}: #{declared_type.inspect}")
+            report_type_error(errors, "Invalid type declaration for field :#{field_name}: #{declared_type.inspect}", location: location)
           end
         end
 

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

@@ -4,16 +4,17 @@ module Kumi
   module Analyzer
     module Passes
       # RESPONSIBILITY: Infer types for all declarations based on expression analysis
-      # DEPENDENCIES: Toposorter (needs topo_order), DefinitionValidator (needs definitions)
+      # DEPENDENCIES: Toposorter (needs topo_order), DeclarationValidator (needs definitions)
       # PRODUCES: decl_types hash mapping declaration names to inferred types
       # INTERFACE: new(schema, state).run(errors)
       class TypeInferencer < PassBase
         def run(errors)
-          return if state[:decl_types] # Already run
-
           types = {}
           topo_order = get_state(:topo_order)
           definitions = get_state(:definitions)
+          
+          # Get broadcast metadata from broadcast detector
+          broadcast_meta = get_state(:broadcast_metadata, required: false) || {}
 
           # Process declarations in topological order to ensure dependencies are resolved
           topo_order.each do |name|
@@ -21,44 +22,67 @@ module Kumi
             next unless decl
 
             begin
-              inferred_type = infer_expression_type(decl.expression, types)
-              types[name] = inferred_type
+              # Check if this declaration is marked as vectorized
+              if broadcast_meta[:vectorized_operations]&.key?(name)
+                # Infer the element type and wrap in array
+                element_type = infer_vectorized_element_type(decl.expression, types, broadcast_meta)
+                types[name] = decl.is_a?(Kumi::Syntax::TraitDeclaration) ? { array: :boolean } : { array: element_type }
+              else
+                # Normal type inference
+                inferred_type = infer_expression_type(decl.expression, types, broadcast_meta, name)
+                types[name] = inferred_type
+              end
             rescue StandardError => e
-              add_error(errors, decl&.loc, "Type inference failed: #{e.message}")
+              report_type_error(errors, "Type inference failed: #{e.message}", location: decl&.loc)
             end
           end
 
-          set_state(:decl_types, types)
+          state.with(:decl_types, types)
         end
 
         private
 
-        def infer_expression_type(expr, type_context = {})
+        def infer_expression_type(expr, type_context = {}, broadcast_metadata = {}, current_decl_name = nil)
           case expr
           when Literal
             Types.infer_from_value(expr.value)
-          when FieldRef
+          when InputReference
             # Look up type from field metadata
             input_meta = get_state(:input_meta, required: false) || {}
             meta = input_meta[expr.name]
             meta&.dig(:type) || :any
-          when Binding
+          when DeclarationReference
             type_context[expr.name] || :any
           when CallExpression
-            infer_call_type(expr, type_context)
-          when ListExpression
-            infer_list_type(expr, type_context)
+            infer_call_type(expr, type_context, broadcast_metadata, current_decl_name)
+          when ArrayExpression
+            infer_list_type(expr, type_context, broadcast_metadata, current_decl_name)
           when CascadeExpression
-            infer_cascade_type(expr, type_context)
+            infer_cascade_type(expr, type_context, broadcast_metadata, current_decl_name)
+          when InputElementReference
+            # Element reference returns the field type
+            infer_element_reference_type(expr)
           else
             :any
           end
         end
 
-        def infer_call_type(call_expr, type_context)
-          fn_name = call_expr.fn_name
+        def infer_call_type(call_expr, type_context, broadcast_metadata = {}, current_decl_name = nil)
+          fn_name = call_expr.fn_name  
           args = call_expr.args
 
+          # Check broadcast metadata first
+          if current_decl_name && broadcast_metadata[:vectorized_values]&.key?(current_decl_name)
+            # This declaration is marked as vectorized, so it produces an array
+            element_type = infer_vectorized_element_type(call_expr, type_context, broadcast_metadata)
+            return { array: element_type }
+          end
+
+          if current_decl_name && broadcast_metadata[:reducer_values]&.key?(current_decl_name)
+            # This declaration is marked as a reducer, get the result from the function
+            return infer_function_return_type(fn_name, args, type_context, broadcast_metadata)
+          end
+
           # Check if function exists in registry
           unless FunctionRegistry.supported?(fn_name)
             # Don't push error here - let existing TypeChecker handle it
@@ -74,7 +98,7 @@ module Kumi
           end
 
           # Infer argument types
-          arg_types = args.map { |arg| infer_expression_type(arg, type_context) }
+          arg_types = args.map { |arg| infer_expression_type(arg, type_context, broadcast_metadata, current_decl_name) }
 
           # Validate parameter types (warn but don't fail)
           param_types = signature[:param_types] || []
@@ -92,10 +116,29 @@ module Kumi
           signature[:return_type] || :any
         end
 
-        def infer_list_type(list_expr, type_context)
+        def infer_vectorized_element_type(call_expr, type_context, broadcast_metadata)
+          # For vectorized arithmetic operations, infer the element type
+          # For now, assume arithmetic operations on floats produce floats
+          case call_expr.fn_name
+          when :multiply, :add, :subtract, :divide
+            :float
+          else
+            :any
+          end
+        end
+
+        def infer_function_return_type(fn_name, args, type_context, broadcast_metadata)
+          # Get the function signature
+          return :any unless FunctionRegistry.supported?(fn_name)
+          
+          signature = FunctionRegistry.signature(fn_name)
+          signature[:return_type] || :any
+        end
+
+        def infer_list_type(list_expr, type_context, broadcast_metadata = {}, current_decl_name = nil)
           return Types.array(:any) if list_expr.elements.empty?
 
-          element_types = list_expr.elements.map { |elem| infer_expression_type(elem, type_context) }
+          element_types = list_expr.elements.map { |elem| infer_expression_type(elem, type_context, broadcast_metadata, current_decl_name) }
 
           # Try to unify all element types
           unified_type = element_types.reduce { |acc, type| Types.unify(acc, type) }
@@ -105,11 +148,75 @@ module Kumi
           Types.array(:any)
         end
 
-        def infer_cascade_type(cascade_expr, type_context)
+        def infer_vectorized_element_type(expr, type_context, vectorization_meta)
+          # For vectorized operations, we need to infer the element type
+          case expr
+          when InputElementReference
+            # Get the field type from metadata
+            input_meta = get_state(:input_meta, required: false) || {}
+            array_name = expr.path.first
+            field_name = expr.path[1]
+            
+            array_meta = input_meta[array_name]
+            return :any unless array_meta&.dig(:type) == :array
+            
+            array_meta.dig(:children, field_name, :type) || :any
+            
+          when CallExpression
+            # For arithmetic operations, infer from operands
+            if %i[add subtract multiply divide].include?(expr.fn_name)
+              # Get types of operands
+              arg_types = expr.args.map do |arg|
+                if arg.is_a?(InputElementReference)
+                  infer_vectorized_element_type(arg, type_context, vectorization_meta)
+                elsif arg.is_a?(DeclarationReference)
+                  # Get the element type if it's vectorized
+                  ref_type = type_context[arg.name]
+                  if ref_type.is_a?(Hash) && ref_type.key?(:array)
+                    ref_type[:array]
+                  else
+                    ref_type || :any
+                  end
+                else
+                  infer_expression_type(arg, type_context, vectorization_meta)
+                end
+              end
+              
+              # Unify types for arithmetic
+              Types.unify(*arg_types) || :float
+            else
+              :any
+            end
+            
+          else
+            :any
+          end
+        end
+
+        def infer_element_reference_type(expr)
+          # Get array field metadata
+          input_meta = get_state(:input_meta, required: false) || {}
+          
+          return :any unless expr.path.size >= 2
+          
+          array_name = expr.path.first
+          field_name = expr.path[1]
+          
+          array_meta = input_meta[array_name]
+          return :any unless array_meta&.dig(:type) == :array
+          
+          # Get the field type from children metadata
+          field_type = array_meta.dig(:children, field_name, :type) || :any
+          
+          # Return array of field type (vectorized)
+          { array: field_type }
+        end
+
+        def infer_cascade_type(cascade_expr, type_context, broadcast_metadata = {}, current_decl_name = nil)
           return :any if cascade_expr.cases.empty?
 
           result_types = cascade_expr.cases.map do |case_stmt|
-            infer_expression_type(case_stmt.result, type_context)
+            infer_expression_type(case_stmt.result, type_context, broadcast_metadata, current_decl_name)
           end
 
           # Reduce all possible types into a single unified type