kumi 0.0.7 → 0.0.8

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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        # RESPONSIBILITY: Validate function call arity and argument types against FunctionRegistry
+        # DEPENDENCIES: :inferred_types from TypeInferencer
+        # PRODUCES: None (validation only)
+        # INTERFACE: new(schema, state).run(errors)
+        class TypeChecker < VisitorPass
+          def run(errors)
+            visit_nodes_of_type(Kumi::Syntax::CallExpression, errors: errors) do |node, _decl, errs|
+              validate_function_call(node, errs)
+            end
+            state
+          end
+
+          private
+
+          def validate_function_call(node, errors)
+            signature = get_function_signature(node, errors)
+            return unless signature
+
+            validate_arity(node, signature, errors)
+            validate_argument_types(node, signature, errors)
+          end
+
+          def get_function_signature(node, errors)
+            Kumi::Registry.signature(node.fn_name)
+          rescue Kumi::Errors::UnknownFunction
+            # Use old format for backward compatibility, but node.loc provides better location
+            report_error(errors, "unsupported operator `#{node.fn_name}`", location: node.loc, type: :type)
+            nil
+          end
+
+          def validate_arity(node, signature, errors)
+            expected_arity = signature[:arity]
+            actual_arity = node.args.size
+
+            return if expected_arity.negative? || expected_arity == actual_arity
+
+            report_error(errors, "operator `#{node.fn_name}` expects #{expected_arity} args, got #{actual_arity}", location: node.loc,
+                                                                                                                   type: :type)
+          end
+
+          def validate_argument_types(node, signature, errors)
+            types = signature[:param_types]
+            return if types.nil? || (signature[:arity].negative? && node.args.empty?)
+
+            # Skip type checking for vectorized operations
+            broadcast_meta = get_state(:broadcasts, required: false)
+            return if broadcast_meta && is_part_of_vectorized_operation?(node, broadcast_meta)
+
+            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::Core::Types::ANY
+
+            # Get the inferred type for this argument
+            actual_type = get_expression_type(arg)
+            return if Kumi::Core::Types.compatible?(actual_type, expected_type)
+
+            # Generate descriptive error message
+            source_desc = describe_expression_type(arg, actual_type)
+            report_error(errors, "argument #{index + 1} of `fn(:#{fn_name})` expects #{expected_type}, " \
+                                 "got #{source_desc}", location: arg.loc, type: :type)
+          end
+
+          def get_expression_type(expr)
+            case expr
+            when Kumi::Syntax::Literal
+              # Inferred type from literal value
+              Kumi::Core::Types.infer_from_value(expr.value)
+
+            when Kumi::Syntax::InputReference
+              # Declared type from input block (user-specified)
+              get_declared_field_type(expr.name)
+
+            when Kumi::Syntax::DeclarationReference
+              # Inferred type from type inference results
+              get_inferred_declaration_type(expr.name)
+
+            else
+              # For complex expressions, we should have type inference results
+              # This is a simplified approach - in reality we'd need to track types for all expressions
+              Kumi::Core::Types::ANY
+            end
+          end
+
+          def get_declared_field_type(field_name)
+            # Get explicitly declared type from input metadata
+            input_meta = get_state(:inputs, required: false) || {}
+            field_meta = input_meta[field_name]
+            field_meta&.dig(:type) || Kumi::Core::Types::ANY
+          end
+
+          def get_inferred_declaration_type(decl_name)
+            # Get inferred type from type inference results
+            decl_types = get_state(:inferred_types, required: true)
+            decl_types[decl_name] || Kumi::Core::Types::ANY
+          end
+
+          def describe_expression_type(expr, type)
+            case expr
+            when Kumi::Syntax::Literal
+              "`#{expr.value}` of type #{type} (literal value)"
+
+            when Kumi::Syntax::InputReference
+              input_meta = get_state(:inputs, required: false) || {}
+              field_meta = input_meta[expr.name]
+
+              if field_meta&.dig(:type)
+                # Explicitly declared type
+                domain_desc = field_meta[:domain] ? " (domain: #{field_meta[:domain]})" : ""
+                "input field `#{expr.name}` of declared type #{type}#{domain_desc}"
+              else
+                # Undeclared field
+                "undeclared input field `#{expr.name}` (inferred as #{type})"
+              end
+
+            when Kumi::Syntax::DeclarationReference
+              # This type was inferred from the declaration's expression
+              "reference to declaration `#{expr.name}` of inferred type #{type}"
+
+            when Kumi::Syntax::CallExpression
+              "result of function `#{expr.fn_name}` returning #{type}"
+
+            when Kumi::Syntax::ArrayExpression
+              "list expression of type #{type}"
+
+            when Kumi::Syntax::CascadeExpression
+              "cascade expression of type #{type}"
+
+            else
+              "expression of type #{type}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        # RESPONSIBILITY: Validate consistency between declared and inferred types
+        # DEPENDENCIES: :inputs from InputCollector, :inferred_types from TypeInferencer
+        # PRODUCES: None (validation only)
+        # INTERFACE: new(schema, state).run(errors)
+        class TypeConsistencyChecker < PassBase
+          def run(errors)
+            input_meta = get_state(:inputs, required: false) || {}
+
+            # First, validate that all declared types are valid
+            validate_declared_types(input_meta, errors)
+
+            # Then check basic consistency (placeholder for now)
+            # In a full implementation, this would do sophisticated usage analysis
+            state
+          end
+
+          private
+
+          def validate_declared_types(input_meta, errors)
+            input_meta.each do |field_name, meta|
+              declared_type = meta[:type]
+              next unless declared_type # Skip fields without declared types
+              next if Kumi::Core::Types.valid_type?(declared_type)
+
+              # Find the input field declaration for proper location information
+              field_decl = find_input_field_declaration(field_name)
+              location = field_decl&.loc
+
+              report_type_error(errors, "Invalid type declaration for field :#{field_name}: #{declared_type.inspect}", location: location)
+            end
+          end
+
+          def find_input_field_declaration(field_name)
+            return nil unless schema
+
+            schema.inputs.find { |input_decl| input_decl.name == field_name }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        # RESPONSIBILITY: Infer types for all declarations based on expression analysis
+        # 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
+          def run(errors)
+            types = {}
+            topo_order = get_state(:evaluation_order)
+            definitions = get_state(:declarations)
+
+            # Get broadcast metadata from broadcast detector
+            broadcast_meta = get_state(:broadcasts, required: false) || {}
+
+            # Process declarations in topological order to ensure dependencies are resolved
+            topo_order.each do |name|
+              decl = definitions[name]
+              next unless decl
+
+              begin
+                # 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
+                report_type_error(errors, "Type inference failed: #{e.message}", location: decl&.loc)
+              end
+            end
+
+            state.with(:inferred_types, types)
+          end
+
+          private
+
+          def infer_expression_type(expr, type_context = {}, broadcast_metadata = {}, current_decl_name = nil)
+            case expr
+            when Literal
+              Types.infer_from_value(expr.value)
+            when InputReference
+              # Look up type from field metadata
+              input_meta = get_state(:inputs, required: false) || {}
+              meta = input_meta[expr.name]
+              meta&.dig(:type) || :any
+            when DeclarationReference
+              type_context[expr.name] || :any
+            when CallExpression
+              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, 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, 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 Kumi::Registry.supported?(fn_name)
+              # Don't push error here - let existing TypeChecker handle it
+              return :any
+            end
+
+            signature = Kumi::Registry.signature(fn_name)
+
+            # Validate arity if not variable
+            if signature[:arity] >= 0 && args.size != signature[:arity]
+              # Don't push error here - let existing TypeChecker handle it
+              return :any
+            end
+
+            # Infer argument types
+            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] || []
+            if signature[:arity] >= 0 && param_types.size.positive?
+              arg_types.each_with_index do |arg_type, i|
+                expected_type = param_types[i] || param_types.last
+                next if expected_type.nil?
+
+                unless Types.compatible?(arg_type, expected_type)
+                  # Could add warning here in future, but for now just infer best type
+                end
+              end
+            end
+
+            signature[:return_type] || :any
+          end
+
+          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 Kumi::Registry.supported?(fn_name)
+
+            signature = Kumi::Registry.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 do |elem|
+              infer_expression_type(elem, type_context, broadcast_metadata, current_decl_name)
+            end
+
+            # Try to unify all element types
+            unified_type = element_types.reduce { |acc, type| Types.unify(acc, type) }
+            Types.array(unified_type)
+          rescue StandardError
+            # If unification fails, fall back to generic array
+            Types.array(:any)
+          end
+
+          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(:inputs, 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(:inputs, 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, broadcast_metadata, current_decl_name)
+            end
+
+            # Reduce all possible types into a single unified type
+            result_types.reduce { |unified, type| Types.unify(unified, type) } || :any
+          rescue StandardError
+            # Check if unification fails, fall back to base type
+            # TODO: understand if this right to fallback or we should raise
+            :any
+          end
+        end
+      end
+    end
+  end
+end