kumi 0.0.25 → 0.0.27

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

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        # RESPONSIBILITY: Propagate constraints forward and backward through operations
+        # DEPENDENCIES: :registry (function registry), constraint metadata from function specs
+        # INTERFACE: propagate_forward(constraint), propagate_reverse_through_operation(...)
+        #
+        # Implements formal constraint propagation rules based on function semantics.
+        # Forward: x == 5, y = x + 10 => y == 15
+        # Reverse: y == 15, y = x + 10 => x == 5
+        class FormalConstraintPropagator
+          def initialize(schema, state)
+            @schema = schema
+            @state = state
+            @registry = state[:registry]
+          end
+
+          # Forward propagate a constraint through a single operation
+          def propagate_forward_through_operation(constraint, operation_spec, operand_map)
+            case constraint[:op]
+            when :==
+              propagate_equality_forward(constraint, operation_spec, operand_map)
+            when :range
+              propagate_range_forward(constraint, operation_spec, operand_map)
+            else
+              nil
+            end
+          end
+
+          # Reverse propagate: derive input constraints from output constraints
+          def propagate_reverse_through_operation(constraint, operation_spec, operand_map)
+            case constraint[:op]
+            when :==
+              propagate_equality_reverse(constraint, operation_spec, operand_map)
+            when :range
+              propagate_range_reverse(constraint, operation_spec, operand_map)
+            else
+              nil
+            end
+          end
+
+          private
+
+          # FORWARD PROPAGATION: Compute output value from input constraints
+          def propagate_equality_forward(constraint, operation_spec, operand_map)
+            result_var = operand_map[:result]
+            input_var = constraint[:variable]
+            input_value = constraint[:value]
+
+            case operation_spec.id
+            when "core.add"
+              # x == V, result = x + C => result == V + C
+              other_operand = get_other_operand_value(constraint, operand_map, "add")
+              return nil unless other_operand.is_a?(Numeric)
+
+              output_value = input_value + other_operand
+              { variable: result_var, op: :==, value: output_value }
+
+            when "core.mul"
+              # x == V, result = x * C => result == V * C
+              other_operand = get_other_operand_value(constraint, operand_map, "mul")
+              return nil unless other_operand.is_a?(Numeric)
+
+              output_value = input_value * other_operand
+              { variable: result_var, op: :==, value: output_value }
+
+            when "core.sub"
+              # x == V, result = x - C => result == V - C
+              other_operand = get_other_operand_value(constraint, operand_map, "sub")
+              return nil unless other_operand.is_a?(Numeric)
+
+              output_value = input_value - other_operand
+              { variable: result_var, op: :==, value: output_value }
+
+            else
+              nil
+            end
+          end
+
+          # FORWARD PROPAGATION: Compute output range from input range
+          def propagate_range_forward(constraint, operation_spec, operand_map)
+            result_var = operand_map[:result]
+            input_min = constraint[:min]
+            input_max = constraint[:max]
+
+            case operation_spec.id
+            when "core.add"
+              # x in [min, max], result = x + C => result in [min + C, max + C]
+              other = get_other_operand_value(constraint, operand_map, "add")
+              return nil unless other.is_a?(Numeric)
+
+              output_min = input_min + other
+              output_max = input_max + other
+              { variable: result_var, op: :range, min: output_min, max: output_max }
+
+            when "core.mul"
+              # x in [min, max], result = x * C => depends on sign of C
+              other = get_other_operand_value(constraint, operand_map, "mul")
+              return nil unless other.is_a?(Numeric)
+
+              if other > 0
+                output_min = input_min * other
+                output_max = input_max * other
+              elsif other < 0
+                output_min = input_max * other
+                output_max = input_min * other
+              else
+                output_min = 0
+                output_max = 0
+              end
+              { variable: result_var, op: :range, min: output_min, max: output_max }
+
+            when "core.sub"
+              # x in [min, max], result = x - C => result in [min - C, max - C]
+              other = get_other_operand_value(constraint, operand_map, "sub")
+              return nil unless other.is_a?(Numeric)
+
+              output_min = input_min - other
+              output_max = input_max - other
+              { variable: result_var, op: :range, min: output_min, max: output_max }
+
+            else
+              nil
+            end
+          end
+
+          # REVERSE PROPAGATION: Derive input equality from output equality
+          def propagate_equality_reverse(constraint, operation_spec, operand_map)
+            result_var = constraint[:variable]
+            result_value = constraint[:value]
+            left_var = operand_map[:left_operand]
+            right_var = operand_map[:right_operand]
+
+            case operation_spec.id
+            when "core.add"
+              # result == V, result = x + C => x == V - C
+              if left_var.is_a?(Symbol) && right_var.is_a?(Numeric)
+                { variable: left_var, op: :==, value: result_value - right_var }
+              elsif right_var.is_a?(Symbol) && left_var.is_a?(Numeric)
+                { variable: right_var, op: :==, value: result_value - left_var }
+              else
+                nil
+              end
+
+            when "core.mul"
+              # result == V, result = x * C => x == V / C (if C != 0)
+              if left_var.is_a?(Symbol) && right_var.is_a?(Numeric) && right_var != 0
+                return nil unless (result_value % right_var).zero?
+                { variable: left_var, op: :==, value: result_value / right_var }
+              elsif right_var.is_a?(Symbol) && left_var.is_a?(Numeric) && left_var != 0
+                return nil unless (result_value % left_var).zero?
+                { variable: right_var, op: :==, value: result_value / left_var }
+              else
+                nil
+              end
+
+            when "core.sub"
+              # result == V, result = x - C => x == V + C
+              if left_var.is_a?(Symbol) && right_var.is_a?(Numeric)
+                { variable: left_var, op: :==, value: result_value + right_var }
+              elsif right_var.is_a?(Symbol) && left_var.is_a?(Numeric)
+                { variable: right_var, op: :==, value: left_var - result_value }
+              else
+                nil
+              end
+
+            else
+              nil
+            end
+          end
+
+          # REVERSE PROPAGATION: Derive input range from output range
+          def propagate_range_reverse(constraint, operation_spec, operand_map)
+            result_min = constraint[:min]
+            result_max = constraint[:max]
+            left_var = operand_map[:left_operand]
+            right_var = operand_map[:right_operand]
+
+            case operation_spec.id
+            when "core.add"
+              # result in [min, max], result = x + C => x in [min - C, max - C]
+              if left_var.is_a?(Symbol) && right_var.is_a?(Numeric)
+                return { variable: left_var, op: :range, min: result_min - right_var, max: result_max - right_var }
+              elsif right_var.is_a?(Symbol) && left_var.is_a?(Numeric)
+                return { variable: right_var, op: :range, min: result_min - left_var, max: result_max - left_var }
+              end
+
+            when "core.mul"
+              # result in [min, max], result = x * C => x in [min/C, max/C] (depends on sign)
+              if left_var.is_a?(Symbol) && right_var.is_a?(Numeric) && right_var != 0
+                if right_var > 0
+                  return { variable: left_var, op: :range, min: result_min / right_var, max: result_max / right_var }
+                else
+                  return { variable: left_var, op: :range, min: result_max / right_var, max: result_min / right_var }
+                end
+              elsif right_var.is_a?(Symbol) && left_var.is_a?(Numeric) && left_var != 0
+                if left_var > 0
+                  return { variable: right_var, op: :range, min: result_min / left_var, max: result_max / left_var }
+                else
+                  return { variable: right_var, op: :range, min: result_max / left_var, max: result_min / left_var }
+                end
+              end
+
+            when "core.sub"
+              # result in [min, max], result = x - C => x in [min + C, max + C]
+              if left_var.is_a?(Symbol) && right_var.is_a?(Numeric)
+                return { variable: left_var, op: :range, min: result_min + right_var, max: result_max + right_var }
+              elsif right_var.is_a?(Symbol) && left_var.is_a?(Numeric)
+                return { variable: right_var, op: :range, min: left_var - result_max, max: left_var - result_min }
+              end
+            end
+
+            nil
+          end
+
+          def get_other_operand_value(constraint, operand_map, operation)
+            input_var = constraint[:variable]
+            left_var = operand_map[:left_operand] || operand_map.values[0]
+            right_var = operand_map[:right_operand] || operand_map.values[1]
+
+            if input_var == left_var && right_var.is_a?(Numeric)
+              right_var
+            elsif input_var == right_var && left_var.is_a?(Numeric)
+              left_var
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -103,10 +103,28 @@ module Kumi
           end
 
           def kind_from_type(t)
-            return :array if t == :array
-            return :hash  if t == :hash
-
-            :scalar
+            # Handle both symbols (legacy) and Type objects (new)
+            case t
+            when Kumi::Core::Types::ArrayType
+              :array
+            when Kumi::Core::Types::TupleType
+              :array  # Tuples behave like arrays for input access
+            when :array, Kumi::Core::Types::ScalarType
+              # Check if it's a hash scalar or :hash symbol
+              if t.is_a?(Kumi::Core::Types::ScalarType) && t.kind == :hash
+                :hash
+              elsif t == :hash
+                :hash
+              elsif t == :array
+                :array
+              else
+                :scalar
+              end
+            when :hash
+              :hash
+            else
+              :scalar
+            end
           end
         end
       end

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

@@ -68,18 +68,61 @@ module Kumi
           end
 
           def analyze_call_expression(call, errors)
-            function_spec = @registry.function(call.fn.to_s)
-
+            # Step 1: Analyze arguments to get their types and scopes
             arg_metadata = call.args.map { |arg| analyze_expression(arg, errors) }
             arg_types    = arg_metadata.map { |m| m[:type] }
             arg_scopes   = arg_metadata.map { |m| m[:scope] }
 
-            debug "    Call #{call.fn}: arg_scopes=#{arg_scopes.inspect}"
+            # Ensure all arg_types are Type objects (defensive programming)
+            arg_types = arg_types.map do |t|
+              case t
+              when Types::Type
+                t
+              when :array
+                # :array is actually an ArrayType marker, not a scalar kind
+                Types.array(Types.scalar(:any))
+              when :hash
+                Types.scalar(:hash)
+              when Symbol
+                # Try to normalize as scalar kind
+                Types.normalize(t)
+              else
+                # Already a Type object or unknown format
+                t
+              end
+            end
 
-            if ENV["DEBUG_NAST_DIMENSIONAL_ANALYZER"] == "1" && function_spec.param_names.size != arg_types.size
-              puts "[NASTDimensionalAnalyzer] WARNING: #{call.fn} expects #{function_spec.param_names.size} args, got #{arg_types.size}"
+            debug "    Call #{call.fn}: arg_scopes=#{arg_scopes.inspect}, arg_types=#{arg_types.inspect}"
+
+            # Step 2: Resolve function using type-aware overload resolution
+            begin
+              resolved_fn_id = @registry.resolve_function_with_types(call.fn.to_s, arg_types)
+              function_spec = @registry.function(resolved_fn_id)
+              debug "    Resolved '#{call.fn}' with types #{arg_types.inspect} to #{resolved_fn_id}"
+            rescue Core::Functions::OverloadResolver::ResolutionError => e
+              # Type-aware overload resolution failed - report with location
+              report_type_error(
+                errors,
+                e.message,
+                location: call.loc,
+                context: {
+                  function: call.fn.to_s,
+                  arg_types: arg_types
+                }
+              )
+              raise Kumi::Core::Errors::TypeError, e.message
+            rescue StandardError => e
+              # Other function resolution errors
+              report_semantic_error(
+                errors,
+                "Function resolution error for '#{call.fn}': #{e.message}",
+                location: call.loc,
+                context: { function: call.fn.to_s }
+              )
+              raise Kumi::Core::Errors::SemanticError, e.message
             end
 
+            # Step 3: Compute result type
             named_types =
               if function_spec.params.size == arg_types.size
                 Hash[function_spec.param_names.zip(arg_types)]
@@ -89,11 +132,17 @@ module Kumi
 
             begin
               result_type = function_spec.dtype_rule.call(named_types)
-            rescue StandardError
-              # Maybe we have the wrong function, lets try to see if another function with same name works
-              # TODO: Fix this hack
-
-              raise
+            rescue StandardError => e
+              report_type_error(
+                errors,
+                "Type rule evaluation failed for #{function_spec.id}: #{e.message}",
+                location: call.loc,
+                context: {
+                  function: function_spec.id,
+                  arg_types: arg_types
+                }
+              )
+              raise Kumi::Core::Errors::TypeError, "Type rule failed for #{function_spec.id}: #{e.message}"
             end
 
             over_collection = arg_types.size == 1 && Types.collection?(arg_types[0])
@@ -120,11 +169,8 @@ module Kumi
             element_scopes  = elems.map { |m| m[:scope] }
             result_scope    = lub_by_prefix(element_scopes)
 
-            result_type = if element_types.uniq.size == 1
-                            "tuple<#{element_types.uniq[0]}>"
-                          else
-                            "tuple<#{element_types.join(', ')}>"
-                          end
+            # Create TupleType from element Types
+            result_type = Types.tuple(element_types)
 
             @metadata_table[node_id(node)] = {
               parameter_names: [],
@@ -143,7 +189,7 @@ module Kumi
             fields = node.pairs.map { |e| analyze_expression(e, errors) }
             fields_scopes = fields.map { |m| m[:scope] }
             scope = lub_by_prefix(fields_scopes)
-            dtype = :hash
+            dtype = Types.scalar(:hash)
 
             @metadata_table[node_id(node)] = {
               type: dtype,
@@ -153,7 +199,7 @@ module Kumi
 
           def analyze_pair(node, errors)
             value_node = analyze_expression(node.value, errors)
-            dtype = :pair
+            dtype = Types.scalar(:pair)
 
             @metadata_table[node_id(node)] = {
               type: dtype,
@@ -182,7 +228,7 @@ module Kumi
           def analyze_index_ref(node, _errors)
             meta = @input_table.find { _1.path_fqn == node.input_fqn } or raise "Index plan found: #{n.name.inspect}"
             axes = Array(meta[:axes])
-            type = :integer
+            type = Types.scalar(:integer)
 
             debug "    IndexRef #{node.name}: input_fqn=#{node.input_fqn}, axes=#{axes.inspect}"
 

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

@@ -75,14 +75,18 @@ module Kumi
 
           def normalize_call_expression(node, errors)
             begin
-              fn_name = FnAliases::MAP[node.fn_name] || node.fn_name
-              func = @registry.function(fn_name)
+              fn_alias = FnAliases::MAP[node.fn_name] || node.fn_name
+
+              # Try to get the function to check if it's expandable
+              # For expandable functions, we need to resolve now
+              # For regular functions, we defer resolution to NASTDimensionalAnalyzerPass
+              func = @registry.function(fn_alias) rescue nil
             rescue StandardError
               # puts "MISSING_FUNCTION: #{node.fn_name.inspect}"
               raise
             end
 
-            if func.expand
+            if func && func.expand
               # 1. Normalize the arguments FIRST.
               normalized_args = node.args.map { |arg| normalize_expr(arg, errors) }
 
@@ -91,8 +95,9 @@ module Kumi
               MacroExpander.expand(func, normalized_args, node.loc, errors)
             else
               # Regular, non-expandable function call.
+              # Keep the alias, don't resolve yet - let NASTDimensionalAnalyzerPass handle overload resolution
               args = node.args.map { |a| normalize_expr(a, errors) }
-              NAST::Call.new(fn: func.id.to_sym, args: args, opts: node.opts, loc: node.loc)
+              NAST::Call.new(fn: fn_alias.to_sym, args: args, opts: node.opts, loc: node.loc)
             end
           end
 

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

@@ -174,7 +174,9 @@ module Kumi
             # regular elementwise
             args = n.args.map { _1.accept(self) }
             m    = meta_for(n)
-            out  = n.class.new(id: n.id, fn: @registry.resolve_function(n.fn), args:, opts: n.opts, loc: n.loc)
+            # Use the function ID from metadata (already resolved with type awareness in NASTDimensionalAnalyzerPass)
+            fn_id = m[:function] || @registry.resolve_function(n.fn)
+            out  = n.class.new(id: n.id, fn: fn_id.to_sym, args:, opts: n.opts, loc: n.loc)
             stamp!(out, m[:result_scope], m[:result_type])
           end