kumi 0.0.24 → 0.0.25

data/golden/us_tax_2024/expected/schema_javascript.mjs

@@ -1,26 +1,26 @@
 export function _summary(input) {
-  let acc3280 = 0.0;
-  let t3281 = input["fed"];
-  let t3282 = t3281["single"];
-  let t3283 = t3282["rates"];
-  let acc3349 = 0.0;
   let t3301 = input["income"];
   let t3302 = input["fed"];
-  const t3306 = 0;
-  const t3325 = -1;
-  const t3327 = 100000000000.0;
   let t3303 = t3302["single"];
   let t3304 = t3303["std"];
   let t3305 = t3301 - t3304;
+  const t3306 = 0;
   let t3307 = [t3305, t3306];
   let t3308 = Math.max(...t3307);
+  let acc3280 = 0.0;
+  let t3281 = input["fed"];
+  let t3282 = t3281["single"];
+  let t3283 = t3282["rates"];
+  let acc3349 = 0.0;
+  const t3325 = -1;
+  const t3327 = 100000000000.0;
   t3283.forEach((t3284, t3285) => {
     let t3320 = t3284["lo"];
     let t3333 = t3284["hi"];
     let t3341 = t3284["rate"];
+    let t3297 = t3308 >= t3320;
     let t3326 = t3333 == t3325;
     let t3329 = t3326 ? t3327 : t3333;
-    let t3297 = t3308 >= t3320;
     let t3299 = t3308 < t3329;
     let t3300 = t3297 && t3299;
     let t3289 = t3300 ? t3341 : t3306;
@@ -170,22 +170,22 @@ export function _summary(input) {
     "retirement_contrib": t558,
     "take_home": t3815
   };
-  let acc3914 = 0.0;
-  let t3916 = t3281["married_joint"];
-  let t3917 = t3916["rates"];
-  let acc3983 = 0.0;
   let t3937 = t3302["married_joint"];
   let t3938 = t3937["std"];
   let t3939 = t3301 - t3938;
   let t3941 = [t3939, t3306];
   let t3942 = Math.max(...t3941);
+  let acc3914 = 0.0;
+  let t3916 = t3281["married_joint"];
+  let t3917 = t3916["rates"];
+  let acc3983 = 0.0;
   t3917.forEach((t3918, t3919) => {
     let t3954 = t3918["lo"];
     let t3967 = t3918["hi"];
     let t3975 = t3918["rate"];
+    let t3931 = t3942 >= t3954;
     let t3960 = t3967 == t3325;
     let t3963 = t3960 ? t3327 : t3967;
-    let t3931 = t3942 >= t3954;
     let t3933 = t3942 < t3963;
     let t3934 = t3931 && t3933;
     let t3923 = t3934 ? t3975 : t3306;
@@ -308,22 +308,22 @@ export function _summary(input) {
     "retirement_contrib": t558,
     "take_home": t4459
   };
-  let acc4560 = 0.0;
-  let t4562 = t3281["married_separate"];
-  let t4563 = t4562["rates"];
-  let acc4629 = 0.0;
   let t4583 = t3302["married_separate"];
   let t4584 = t4583["std"];
   let t4585 = t3301 - t4584;
   let t4587 = [t4585, t3306];
   let t4588 = Math.max(...t4587);
+  let acc4560 = 0.0;
+  let t4562 = t3281["married_separate"];
+  let t4563 = t4562["rates"];
+  let acc4629 = 0.0;
   t4563.forEach((t4564, t4565) => {
     let t4600 = t4564["lo"];
     let t4613 = t4564["hi"];
     let t4621 = t4564["rate"];
+    let t4577 = t4588 >= t4600;
     let t4606 = t4613 == t3325;
     let t4609 = t4606 ? t3327 : t4613;
-    let t4577 = t4588 >= t4600;
     let t4579 = t4588 < t4609;
     let t4580 = t4577 && t4579;
     let t4569 = t4580 ? t4621 : t3306;
@@ -446,22 +446,22 @@ export function _summary(input) {
     "retirement_contrib": t558,
     "take_home": t5105
   };
-  let acc5206 = 0.0;
-  let t5208 = t3281["head_of_household"];
-  let t5209 = t5208["rates"];
-  let acc5275 = 0.0;
   let t5229 = t3302["head_of_household"];
   let t5230 = t5229["std"];
   let t5231 = t3301 - t5230;
   let t5233 = [t5231, t3306];
   let t5234 = Math.max(...t5233);
+  let acc5206 = 0.0;
+  let t5208 = t3281["head_of_household"];
+  let t5209 = t5208["rates"];
+  let acc5275 = 0.0;
   t5209.forEach((t5210, t5211) => {
     let t5246 = t5210["lo"];
     let t5259 = t5210["hi"];
     let t5267 = t5210["rate"];
+    let t5223 = t5234 >= t5246;
     let t5252 = t5259 == t3325;
     let t5255 = t5252 ? t3327 : t5259;
-    let t5223 = t5234 >= t5246;
     let t5225 = t5234 < t5255;
     let t5226 = t5223 && t5225;
     let t5215 = t5226 ? t5267 : t3306;

data/golden/us_tax_2024/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_579630ac2e4efb73c2ff1d43016b1220da91788dd8ebe96021285d536e08ec39
+module Kumi::Compiled::KUMI_f6cd45a92014eb42b276ebc3f95d8fc9ce044e3e8e8d7326dbe60f6d699e146a
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)
@@ -26,28 +26,28 @@ module Kumi::Compiled::KUMI_579630ac2e4efb73c2ff1d43016b1220da91788dd8ebe9602128
   end
 
   def _summary(input = @input)
-    acc3280 = 0.0
-    t3281 = input["fed"] || input[:fed]
-    t3282 = t3281["single"] || t3281[:single]
-    t3283 = t3282["rates"] || t3282[:rates]
-    acc3349 = 0.0
     t3301 = input["income"] || input[:income]
     t3302 = input["fed"] || input[:fed]
-    t3306 = 0
-    t3325 = -1
-    t3327 = 100000000000.0
     t3303 = t3302["single"] || t3302[:single]
     t3304 = t3303["std"] || t3303[:std]
     t3305 = t3301 - t3304
+    t3306 = 0
     t3307 = [t3305, t3306]
     t3308 = t3307.max
+    acc3280 = 0.0
+    t3281 = input["fed"] || input[:fed]
+    t3282 = t3281["single"] || t3281[:single]
+    t3283 = t3282["rates"] || t3282[:rates]
+    acc3349 = 0.0
+    t3325 = -1
+    t3327 = 100000000000.0
     t3283.each_with_index do |t3284, t3285|
       t3320 = t3284["lo"] || t3284[:lo]
       t3333 = t3284["hi"] || t3284[:hi]
       t3341 = t3284["rate"] || t3284[:rate]
+      t3297 = t3308 >= t3320
       t3326 = t3333 == t3325
       t3329 = t3326 ? t3327 : t3333
-      t3297 = t3308 >= t3320
       t3299 = t3308 < t3329
       t3300 = t3297 && t3299
       t3289 = t3300 ? t3341 : t3306
@@ -204,22 +204,22 @@ module Kumi::Compiled::KUMI_579630ac2e4efb73c2ff1d43016b1220da91788dd8ebe9602128
       "retirement_contrib" => t558,
       "take_home" => t3815
     }
-    acc3914 = 0.0
-    t3916 = t3281["married_joint"] || t3281[:married_joint]
-    t3917 = t3916["rates"] || t3916[:rates]
-    acc3983 = 0.0
     t3937 = t3302["married_joint"] || t3302[:married_joint]
     t3938 = t3937["std"] || t3937[:std]
     t3939 = t3301 - t3938
     t3941 = [t3939, t3306]
     t3942 = t3941.max
+    acc3914 = 0.0
+    t3916 = t3281["married_joint"] || t3281[:married_joint]
+    t3917 = t3916["rates"] || t3916[:rates]
+    acc3983 = 0.0
     t3917.each_with_index do |t3918, t3919|
       t3954 = t3918["lo"] || t3918[:lo]
       t3967 = t3918["hi"] || t3918[:hi]
       t3975 = t3918["rate"] || t3918[:rate]
+      t3931 = t3942 >= t3954
       t3960 = t3967 == t3325
       t3963 = t3960 ? t3327 : t3967
-      t3931 = t3942 >= t3954
       t3933 = t3942 < t3963
       t3934 = t3931 && t3933
       t3923 = t3934 ? t3975 : t3306
@@ -349,22 +349,22 @@ module Kumi::Compiled::KUMI_579630ac2e4efb73c2ff1d43016b1220da91788dd8ebe9602128
       "retirement_contrib" => t558,
       "take_home" => t4459
     }
-    acc4560 = 0.0
-    t4562 = t3281["married_separate"] || t3281[:married_separate]
-    t4563 = t4562["rates"] || t4562[:rates]
-    acc4629 = 0.0
     t4583 = t3302["married_separate"] || t3302[:married_separate]
     t4584 = t4583["std"] || t4583[:std]
     t4585 = t3301 - t4584
     t4587 = [t4585, t3306]
     t4588 = t4587.max
+    acc4560 = 0.0
+    t4562 = t3281["married_separate"] || t3281[:married_separate]
+    t4563 = t4562["rates"] || t4562[:rates]
+    acc4629 = 0.0
     t4563.each_with_index do |t4564, t4565|
       t4600 = t4564["lo"] || t4564[:lo]
       t4613 = t4564["hi"] || t4564[:hi]
       t4621 = t4564["rate"] || t4564[:rate]
+      t4577 = t4588 >= t4600
       t4606 = t4613 == t3325
       t4609 = t4606 ? t3327 : t4613
-      t4577 = t4588 >= t4600
       t4579 = t4588 < t4609
       t4580 = t4577 && t4579
       t4569 = t4580 ? t4621 : t3306
@@ -494,22 +494,22 @@ module Kumi::Compiled::KUMI_579630ac2e4efb73c2ff1d43016b1220da91788dd8ebe9602128
       "retirement_contrib" => t558,
       "take_home" => t5105
     }
-    acc5206 = 0.0
-    t5208 = t3281["head_of_household"] || t3281[:head_of_household]
-    t5209 = t5208["rates"] || t5208[:rates]
-    acc5275 = 0.0
     t5229 = t3302["head_of_household"] || t3302[:head_of_household]
     t5230 = t5229["std"] || t5229[:std]
     t5231 = t3301 - t5230
     t5233 = [t5231, t3306]
     t5234 = t5233.max
+    acc5206 = 0.0
+    t5208 = t3281["head_of_household"] || t3281[:head_of_household]
+    t5209 = t5208["rates"] || t5208[:rates]
+    acc5275 = 0.0
     t5209.each_with_index do |t5210, t5211|
       t5246 = t5210["lo"] || t5210[:lo]
       t5259 = t5210["hi"] || t5210[:hi]
       t5267 = t5210["rate"] || t5210[:rate]
+      t5223 = t5234 >= t5246
       t5252 = t5259 == t3325
       t5255 = t5252 ? t3327 : t5259
-      t5223 = t5234 >= t5246
       t5225 = t5234 < t5255
       t5226 = t5223 && t5225
       t5215 = t5226 ? t5267 : t3306

data/golden/with_constants/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_637cda4c2c7cf245cb3f0b33719df27309bc57cdf29851183113d43acd8b22fe
+module Kumi::Compiled::KUMI_ee04981edda49a2945319fd2a0457a60507a9e934cb7a4fdf3eeb6545dd1ef47
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kumi
-  VERSION = "0.0.24"
+  VERSION = "0.0.25"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kumi
 version: !ruby/object:Gem::Version
-  version: 0.0.24
+  version: 0.0.25
 platform: ruby
 authors:
 - André Muta