kumi 0.0.24 → 0.0.26

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/lir/inline_declarations_pass.rb

@@ -41,22 +41,27 @@ module Kumi
               [fused, changed]
             end
 
+            # ---------------- core ----------------
+
+            Hoist = Struct.new(:ops, :target_depth, keyword_init: true)
+
             def inline_top_level_decl(ops)
               env        = Env.new
               reg_map    = {}
               rename_map = {}
-              processed, hoisted = process_and_hoist_block(ops, env, reg_map, rename_map)
-              raise "Orphaned code was hoisted to top level" unless hoisted.empty?
+              processed, hoist_pkgs = process_and_hoist_block(ops, env, reg_map, rename_map)
 
-              processed
-            end
+              top_emit, bubble = hoist_pkgs.partition { |p| p.target_depth == 0 }
+              raise "Orphaned code hoist with target depth(s): #{bubble.map(&:target_depth).uniq.inspect}" unless bubble.empty?
 
-            # ---------------- core ----------------
+              top_emit.flat_map(&:ops) + processed
+            end
 
-            # returns [processed_ops, hoisted_ops]
+            # returns [processed_ops, hoist_pkgs]
+            # returns [processed_ops, hoist_pkgs]
             def process_and_hoist_block(block_ops, env, reg_map, rename_map)
               out = []
-              hoisted = []
+              hoisted_pkgs = []
               i = 0
               while i < block_ops.length
                 ins = block_ops[i]
@@ -67,110 +72,144 @@ module Kumi
 
                   env.push(ins)
                   child_rename = {}
-                  processed_body, hoisted_from_child =
+                  processed_body, child_hoists =
                     process_and_hoist_block(loop_body, env, reg_map, child_rename)
+
+                  depth_here = env.axes.length
+                  child_el   = ins.attributes[:as_element]
+                  child_ix   = ins.attributes[:as_index]
+
+                  # Partition hoists: those that belong *inside* this loop vs bubble upward
+                  inside_pkgs, bubble_pkgs = child_hoists.partition { |p| p.target_depth == depth_here }
+
+                  # Renames: never let aliases to this loop's el/idx escape upward
+                  safe_pairs = child_rename.reject { |_, v| v == child_el || v == child_ix }
                   env.pop
 
-                  out.concat(hoisted_from_child)            # emit hoists before loop
-                  rename_map.merge!(child_rename)           # make child renames visible
+                  # Merge only safe renames into outer scope
+                  rename_map.merge!(safe_pairs)
+
+                  # Emit loop shell
+                  out << rewrite(ins, reg_map, rename_map)
+
+                  # Local view inside loop: apply both local and outer renames, with local taking precedence
+                  local_map = child_rename.merge(rename_map)
+
+                  # Emit hoists that belong at this depth *inside* the loop, before the body
+                  inside_ops = inside_pkgs.flat_map(&:ops)
+                  out.concat(rewrite_block(inside_ops, local_map))
 
-                  out << rewrite(ins, reg_map, rename_map)  # loop shell
-                  out.concat(processed_body)
+                  # Emit rewritten body
+                  out.concat(rewrite_block(processed_body, local_map))
+
+                  # Close loop
                   out << rewrite(block_ops[end_idx], reg_map, rename_map)
 
+                  # Bubble remaining hoists to outer scopes
+                  hoisted_pkgs.concat(bubble_pkgs)
+
+                  # Extra safety: ensure no aliases to this loop's el/idx remain in outer map
+                  rename_map.delete_if { |_, v| v == child_el || v == child_ix }
+
                   i = end_idx
 
                 when :LoadDeclaration
-                  inline_ops, hoist_ops =
-                    handle_load_declaration(ins, env, reg_map, rename_map)
+                  inline_ops, new_pkgs = handle_load_declaration(ins, env, reg_map, rename_map)
                   out.concat(inline_ops)
-                  hoisted.concat(hoist_ops)
+                  hoisted_pkgs.concat(new_pkgs)
 
                 else
                   out << rewrite(ins, reg_map, rename_map)
                 end
                 i += 1
               end
-              [out, hoisted]
+              [out, hoisted_pkgs]
             end
 
-            # returns [inline_ops, hoisted_ops]
-            def handle_load_declaration(call_ins, env, reg_map, outer_rename_map)
-              raise "LoadDeclaration missing callee" unless call_ins.immediates&.first&.respond_to?(:value)
-
-              callee = call_ins.immediates.first.value.to_sym
-              raise "LoadDeclaration callee #{callee} not found" unless @ops_by_decl.key?(callee)
+            # returns [inline_ops, hoist_pkgs]
+            def handle_load_declaration(ins, env, _reg_map, rename_map)
+              callee = ins.immediates.first.value.to_sym
 
-              decl_axes = fetch_decl_axes(callee, call_ins)
-              site_axes = env.axes
+              # axes presence and agreement with callee gamma
+              decl_axes  = ins.attributes.fetch(:axes) { raise "LoadDeclaration missing :axes for #{callee}" }
+              gamma_axes = @gamma.fetch(callee).axes
+              raise "axes mismatch for #{callee}: decl=#{decl_axes.inspect} gamma=#{gamma_axes.inspect}" unless decl_axes == gamma_axes
 
-              body, yield_reg, callee_axis_regs = inline_callee_core(callee)
-              axis_map = remap_axes(callee_axis_regs, env)
+              body, yield_reg, callee_regs = inline_callee_core(callee)
+              remap = remap_axes(callee_regs, env)
 
+              # per-callsite freshening
               local_reg_map = {}
-              _acc, fresh_ops = freshen(body, local_reg_map, pre_map: axis_map)
-
-              nested_rename = {}
-              processed_inner, hoisted_inner =
-                process_and_hoist_block(fresh_ops, env, {}, nested_rename)
-
-              prelim = local_reg_map[yield_reg] || axis_map[yield_reg] || yield_reg
-              mapped_yield = resolve_rename(prelim, nested_rename)
-
-              # def/dominance guard
-              defs_inline  = defs_in(processed_inner)
-              defs_hoisted = defs_in(hoisted_inner)
-              unless defs_inline.include?(mapped_yield) || defs_hoisted.include?(mapped_yield)
-                msg = [
-                  "inliner: mapped yield #{mapped_yield} has no def in emitted ops for #{callee}",
-                  "  original yield: #{yield_reg}",
-                  "  prelim mapping: #{prelim}",
-                  "  nested_rename keys: #{nested_rename.keys.inspect}",
-                  "  inline defs size: #{defs_inline.size}",
-                  "  hoisted defs size: #{defs_hoisted.size}"
-                ].join("\n")
-                raise msg
+              _acc, fresh_ops = freshen(body, local_reg_map, pre_map: remap)
+
+              # recursively process nested calls
+              processed_inline, nested_pkgs = process_and_hoist_block(fresh_ops, env, {}, rename_map)
+
+              # compute yielded register mapping, then resolve through any renames created by nested inlines
+              mapped_yield =
+                local_reg_map[yield_reg] || remap[yield_reg] ||
+                (raise "inliner: yielded reg #{yield_reg} not produced in inlined body for #{callee}")
+              resolved_yield = resolve_rename(mapped_yield, rename_map)
+
+              # sanity: resolved_yield must be definable at site
+              emitted_defs = processed_inline.map(&:result_register).compact +
+                             nested_pkgs.flat_map { |p| p.ops }.map(&:result_register).compact
+              unless emitted_defs.include?(resolved_yield) || env.ambient_regs.include?(resolved_yield)
+                raise "inliner: mapped yield #{resolved_yield} has no def in emitted ops for #{callee}\n" \
+                      "original yield: #{yield_reg}\n" \
+                      "inline defs size: #{processed_inline.count { |x| x.result_register }}\n" \
+                      "nested hoist defs size: #{nested_pkgs.flat_map { |p| p.ops }.count { |x| x.result_register }}"
               end
 
-              outer_rename_map[call_ins.result_register] = mapped_yield if call_ins.result_register
+              # final rename for call site result uses the resolved register
+              rename_map[ins.result_register] = resolved_yield
+
+              # decide placement by depth
+              site_depth   = env.axes.length
+              callee_depth = decl_axes.length
+
+              if callee_depth < site_depth
+                forb = forbidden_ambient_after(callee_depth, env)
+                used = uses_of(processed_inline)
+                bad  = used & forb
+                unless bad.empty?
+                  raise "scope error: would hoist ops using deeper-axis regs #{bad.inspect} " \
+                        "(callee_depth=#{callee_depth}, site_depth=#{site_depth})"
+                end
+                pkgs = nested_pkgs + [Hoist.new(ops: processed_inline, target_depth: callee_depth)]
+                [[], pkgs]
+
+              elsif callee_depth == site_depth
+                emit, bubble = nested_pkgs.partition { |p| p.target_depth == site_depth }
+                [(emit.flat_map(&:ops) + processed_inline), bubble]
 
-              if prefix?(decl_axes, site_axes) && decl_axes.length < site_axes.length
-                [[], hoisted_inner + processed_inner]         # hoist
-              elsif decl_axes == site_axes
-                [hoisted_inner + processed_inner, []]         # inline in place
               else
-                [[rewrite(call_ins, reg_map, outer_rename_map)], []] # cannot inline
+                [[rewrite(ins, {}, rename_map)], []]
               end
             end
 
             # ---------------- helpers ----------------
+            def rewrite_block(ops, rename)
+              # Ensure late-added renames apply to a block we built earlier.
+              ops.map { |ins| rewrite(ins, {}, rename) }
+            end
 
-            def resolve_rename(reg, rename, limit: 64)
+            def resolve_rename(reg, rename)
               seen = {}
               cur = reg
-              limit.times do
-                nxt = rename[cur]
-                break unless nxt
-                raise "inliner: rename cycle at #{cur}" if seen[nxt]
-
-                seen[nxt] = true
-                cur = nxt
+              while (n = rename[cur]) && !seen[n]
+                seen[cur] = true
+                cur = n
               end
               cur
             end
 
-            def defs_in(ops)
-              ops.each_with_object(Set.new) { |ins, s| s << ins.result_register if ins.result_register }
+            def uses_of(ops)
+              ops.flat_map { |x| Array(x.inputs) }.compact
             end
 
-            def fetch_decl_axes(callee, call_ins)
-              attr_axes  = call_ins.attributes && call_ins.attributes[:axes]
-              gamma_axes = Array(@gamma.fetch(callee)&.axes || [])
-              ax = attr_axes.nil? ? gamma_axes : Array(attr_axes)
-              raise "LoadDeclaration missing :axes" if ax.nil?
-              raise "inliner: non-array axes for #{callee}: #{ax.inspect}" unless ax.is_a?(Array)
-
-              ax
+            def forbidden_ambient_after(depth, env)
+              env.frames_after(depth).flat_map { |f| [f[:el], f[:idx]] }
             end
 
             def find_matching_loop_end(ops, start_index)
@@ -195,6 +234,7 @@ module Kumi
             class Env
               def initialize = @frames = []
               def axes = @frames.map { _1[:axis] }
+              def ambient_regs = @frames.flat_map { |f| [f[:el], f[:idx]] }
 
               def push(loop_ins)
                 @frames << {
@@ -210,6 +250,10 @@ module Kumi
                 @frames.reverse.find { _1[:axis] == axis } ||
                   raise("no element for axis=#{axis.inspect}")
               end
+
+              def frames_after(depth)
+                @frames[depth..] || []
+              end
             end
 
             def detect_all_gammas(ops_by_decl)
@@ -240,10 +284,10 @@ module Kumi
             end
 
             def inline_callee_core(callee_name)
-              ops = Array(@ops_by_decl.fetch(callee_name)[:operations])
+              ops  = Array(@ops_by_decl.fetch(callee_name)[:operations])
               info = @gamma.fetch(callee_name)
               axes = info.axes
-              k = axes.length
+              k    = axes.length
 
               yi = ops.rindex { |x| x.opcode == :Yield } or raise "callee #{callee_name} has no Yield"
               yielded_reg = Array(ops[yi].inputs).first

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}"