kumi 0.0.6 → 0.0.8

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

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Analyzer
-    module Passes
-      # RESPONSIBILITY: Validate function call arity and argument types against FunctionRegistry
-      # 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(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)
-          FunctionRegistry.signature(node.fn_name)
-        rescue FunctionRegistry::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(: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
-
-          # Get the inferred type for this argument
-          actual_type = get_expression_type(arg)
-          return if Kumi::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::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::Types::ANY
-          end
-        end
-
-        def get_declared_field_type(field_name)
-          # Get explicitly declared type from input metadata
-          input_meta = get_state(:input_meta, required: false) || {}
-          field_meta = input_meta[field_name]
-          field_meta&.dig(:type) || Kumi::Types::ANY
-        end
-
-        def get_inferred_declaration_type(decl_name)
-          # Get inferred type from type inference results
-          decl_types = get_state(:decl_types, required: true)
-          decl_types[decl_name] || Kumi::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(:input_meta, 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

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

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Analyzer
-    module Passes
-      # RESPONSIBILITY: Validate consistency between declared and inferred types
-      # DEPENDENCIES: :input_meta from InputCollector, :decl_types from TypeInferencer
-      # PRODUCES: None (validation only)
-      # INTERFACE: new(schema, state).run(errors)
-      class TypeConsistencyChecker < PassBase
-        def run(errors)
-          input_meta = get_state(:input_meta, 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::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

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

@@ -1,232 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Analyzer
-    module Passes
-      # RESPONSIBILITY: Infer types for all declarations based on expression analysis
-      # 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)
-          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|
-            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(:decl_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(:input_meta, 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 FunctionRegistry.supported?(fn_name)
-            # Don't push error here - let existing TypeChecker handle it
-            return :any
-          end
-
-          signature = FunctionRegistry.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 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, broadcast_metadata, current_decl_name) }
-
-          # 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(: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, 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