kumi 0.0.18 → 0.0.20

data/golden/interleaved_fusion/expected.json

@@ -0,0 +1,37 @@
+{
+    "total_payroll": [
+      400000,
+      320000,
+      75000
+    ],
+    "payroll_tax": [
+      60000.0,
+      48000.0,
+      11250.0
+    ],
+    "manager_count": [
+      1,
+      1,
+      0
+    ],
+    "department_summary": [
+      {
+        "name": "Engineering",
+        "payroll": 400000,
+        "tax": 60000.0,
+        "managers": 1
+      },
+      {
+        "name": "Sales",
+        "payroll": 320000,
+        "tax": 48000.0,
+        "managers": 1
+      },
+      {
+        "name": "HR",
+        "payroll": 75000,
+        "tax": 11250.0,
+        "managers": 0
+      }
+    ]
+  }

data/golden/interleaved_fusion/input.json

@@ -0,0 +1,26 @@
+{
+    "departments": [
+      {
+        "name": "Engineering",
+        "employees": [
+          { "salary": 150000, "role": "manager" },
+          { "salary": 100000, "role": "engineer" },
+          { "salary": 150000, "role": "senior" }
+        ]
+      },
+      {
+        "name": "Sales",
+        "employees": [
+          { "salary": 120000, "role": "manager" },
+          { "salary": 90000,  "role": "associate" },
+          { "salary": 110000, "role": "senior" }
+        ]
+      },
+      {
+        "name": "HR",
+        "employees": [
+          { "salary": 75000, "role": "generalist" }
+        ]
+      }
+    ]
+  }

data/golden/interleaved_fusion/schema.kumi

@@ -0,0 +1,57 @@
+# interleaved_fusion_schema.kumi
+#
+# Written on: Saturday, September 20, 2025
+# Location: São Paulo, Brazil
+#
+# This schema tests an advanced case for the LoopFusionPass.
+#
+# It creates a situation with three calculations: A, B, and C.
+#   - Calc A (`total_payroll`) is a loop over `employees`.
+#   - Calc B (`payroll_tax`) depends on the result of A.
+#   - Calc C (`manager_count`) is another loop over `employees`, independent of A and B.
+#
+# The final summary uses them in the order A, B, C. This will create LIR where
+# Loop A and Loop C are separated by the code for Calc B.
+#
+# A simple fusion pass will fail this test. An advanced pass would need to
+# reorder the code for Calc B to make Loop A and Loop C adjacent before fusing.
+
+schema do
+  input do
+    array :departments do
+      hash :dept do
+        string :name
+        array :employees do
+          hash :emp do
+            integer :salary
+            string  :role
+          end
+        end
+      end
+    end
+  end
+
+  # --- Interleaved Calculations ---
+
+  # Calculation A: Requires a loop over employees.
+  value :total_payroll, fn(:sum, input.departments.dept.employees.emp.salary)
+
+  # Calculation B: Depends on the final result of A. This creates the barrier.
+  value :payroll_tax, total_payroll * 0.15
+
+  # Calculation C: Another loop over employees, but independent of A and B.
+  value :manager_count, fn(:count_if, input.departments.dept.employees.emp.role, "manager")
+
+
+  # --- Final Value ---
+
+  # The dependency order here (A, B, C) is critical.
+  # An intelligent optimizer should be able to reorder the calculation for B
+  # to allow the loops from A and C to be fused.
+  value :department_summary, {
+    name: input.departments.dept.name,
+    payroll: total_payroll,
+    tax: payroll_tax,
+    managers: manager_count
+  }
+end

data/golden/let_inline/expected/ast.txt

@@ -0,0 +1,33 @@
+(Root
+  inputs: [
+    (InputDeclaration :x :integer)
+    (InputDeclaration :y :integer)
+  ]
+  values: [
+    (ValueDeclaration :x_sq
+      (CallExpression :multiply
+        (InputReference :x)
+        (InputReference :x)
+      )
+    )
+    (ValueDeclaration :y_sq
+      (CallExpression :multiply
+        (InputReference :y)
+        (InputReference :y)
+      )
+    )
+    (ValueDeclaration :distance_sq
+      (CallExpression :add
+        (DeclarationReference :x_sq)
+        (DeclarationReference :y_sq)
+      )
+    )
+    (ValueDeclaration :distance
+      (CallExpression :power
+        (DeclarationReference :distance_sq)
+        (Literal 0.5)
+      )
+    )
+  ]
+  traits: []
+)

data/golden/let_inline/expected/input_plan.txt

@@ -0,0 +1,2 @@
+x: integer
+y: integer

data/golden/let_inline/expected/lir_00_unoptimized.txt

@@ -0,0 +1,26 @@
+(LIR
+  (Declaration x_sq
+    %t1 = load_input "x" :: integer
+    %t2 = load_input "x" :: integer
+    %t3 = call core.mul(%t1, %t2) :: integer
+    yield %t3
+  )
+  (Declaration y_sq
+    %t4 = load_input "y" :: integer
+    %t5 = load_input "y" :: integer
+    %t6 = call core.mul(%t4, %t5) :: integer
+    yield %t6
+  )
+  (Declaration distance_sq
+    %t7 = load_decl x_sq :: integer
+    %t8 = load_decl y_sq :: integer
+    %t9 = call core.add(%t7, %t8) :: integer
+    yield %t9
+  )
+  (Declaration distance
+    %t10 = load_decl distance_sq :: integer
+    %t11 = const 0.5 :: float
+    %t12 = call core.pow(%t10, %t11) :: float
+    yield %t12
+  )
+)

data/golden/let_inline/expected/lir_01_hoist_scalar_references.txt

@@ -0,0 +1,26 @@
+(LIR
+  (Declaration x_sq
+    %t1 = load_input "x" :: integer
+    %t2 = load_input "x" :: integer
+    %t3 = call core.mul(%t1, %t2) :: integer
+    yield %t3
+  )
+  (Declaration y_sq
+    %t4 = load_input "y" :: integer
+    %t5 = load_input "y" :: integer
+    %t6 = call core.mul(%t4, %t5) :: integer
+    yield %t6
+  )
+  (Declaration distance_sq
+    %t7 = load_decl x_sq :: integer
+    %t8 = load_decl y_sq :: integer
+    %t9 = call core.add(%t7, %t8) :: integer
+    yield %t9
+  )
+  (Declaration distance
+    %t10 = load_decl distance_sq :: integer
+    %t11 = const 0.5 :: float
+    %t12 = call core.pow(%t10, %t11) :: float
+    yield %t12
+  )
+)

data/golden/let_inline/expected/lir_02_inlined.txt

@@ -0,0 +1,36 @@
+(LIR
+  (Declaration x_sq
+    %t1 = load_input "x" :: integer
+    %t2 = load_input "x" :: integer
+    %t3 = call core.mul(%t1, %t2) :: integer
+    yield %t3
+  )
+  (Declaration y_sq
+    %t4 = load_input "y" :: integer
+    %t5 = load_input "y" :: integer
+    %t6 = call core.mul(%t4, %t5) :: integer
+    yield %t6
+  )
+  (Declaration distance_sq
+    %t13 = load_input "x" :: integer
+    %t14 = load_input "x" :: integer
+    %t15 = call core.mul(%t13, %t14) :: integer
+    %t16 = load_input "y" :: integer
+    %t17 = load_input "y" :: integer
+    %t18 = call core.mul(%t16, %t17) :: integer
+    %t9 = call core.add(%t15, %t18) :: integer
+    yield %t9
+  )
+  (Declaration distance
+    %t22 = load_input "x" :: integer
+    %t23 = load_input "x" :: integer
+    %t24 = call core.mul(%t22, %t23) :: integer
+    %t25 = load_input "y" :: integer
+    %t26 = load_input "y" :: integer
+    %t27 = call core.mul(%t25, %t26) :: integer
+    %t21 = call core.add(%t24, %t27) :: integer
+    %t11 = const 0.5 :: float
+    %t12 = call core.pow(%t21, %t11) :: float
+    yield %t12
+  )
+)

data/golden/let_inline/expected/lir_03_cse.txt

@@ -0,0 +1,30 @@
+(LIR
+  (Declaration x_sq
+    %t1 = load_input "x" :: integer
+    %t3 = call core.mul(%t1, %t1) :: integer
+    yield %t3
+  )
+  (Declaration y_sq
+    %t4 = load_input "y" :: integer
+    %t6 = call core.mul(%t4, %t4) :: integer
+    yield %t6
+  )
+  (Declaration distance_sq
+    %t13 = load_input "x" :: integer
+    %t15 = call core.mul(%t13, %t13) :: integer
+    %t16 = load_input "y" :: integer
+    %t18 = call core.mul(%t16, %t16) :: integer
+    %t9 = call core.add(%t15, %t18) :: integer
+    yield %t9
+  )
+  (Declaration distance
+    %t22 = load_input "x" :: integer
+    %t24 = call core.mul(%t22, %t22) :: integer
+    %t25 = load_input "y" :: integer
+    %t27 = call core.mul(%t25, %t25) :: integer
+    %t21 = call core.add(%t24, %t27) :: integer
+    %t11 = const 0.5 :: float
+    %t12 = call core.pow(%t21, %t11) :: float
+    yield %t12
+  )
+)

data/golden/let_inline/expected/lir_04_1_loop_fusion.txt

@@ -0,0 +1,30 @@
+(LIR
+  (Declaration x_sq
+    %t1 = load_input "x" :: integer
+    %t3 = call core.mul(%t1, %t1) :: integer
+    yield %t3
+  )
+  (Declaration y_sq
+    %t4 = load_input "y" :: integer
+    %t6 = call core.mul(%t4, %t4) :: integer
+    yield %t6
+  )
+  (Declaration distance_sq
+    %t13 = load_input "x" :: integer
+    %t15 = call core.mul(%t13, %t13) :: integer
+    %t16 = load_input "y" :: integer
+    %t18 = call core.mul(%t16, %t16) :: integer
+    %t9 = call core.add(%t15, %t18) :: integer
+    yield %t9
+  )
+  (Declaration distance
+    %t22 = load_input "x" :: integer
+    %t24 = call core.mul(%t22, %t22) :: integer
+    %t25 = load_input "y" :: integer
+    %t27 = call core.mul(%t25, %t25) :: integer
+    %t21 = call core.add(%t24, %t27) :: integer
+    %t11 = const 0.5 :: float
+    %t12 = call core.pow(%t21, %t11) :: float
+    yield %t12
+  )
+)

data/golden/let_inline/expected/lir_04_loop_invcm.txt

@@ -0,0 +1,30 @@
+(LIR
+  (Declaration x_sq
+    %t1 = load_input "x" :: integer
+    %t3 = call core.mul(%t1, %t1) :: integer
+    yield %t3
+  )
+  (Declaration y_sq
+    %t4 = load_input "y" :: integer
+    %t6 = call core.mul(%t4, %t4) :: integer
+    yield %t6
+  )
+  (Declaration distance_sq
+    %t13 = load_input "x" :: integer
+    %t15 = call core.mul(%t13, %t13) :: integer
+    %t16 = load_input "y" :: integer
+    %t18 = call core.mul(%t16, %t16) :: integer
+    %t9 = call core.add(%t15, %t18) :: integer
+    yield %t9
+  )
+  (Declaration distance
+    %t22 = load_input "x" :: integer
+    %t24 = call core.mul(%t22, %t22) :: integer
+    %t25 = load_input "y" :: integer
+    %t27 = call core.mul(%t25, %t25) :: integer
+    %t21 = call core.add(%t24, %t27) :: integer
+    %t11 = const 0.5 :: float
+    %t12 = call core.pow(%t21, %t11) :: float
+    yield %t12
+  )
+)

data/golden/let_inline/expected/lir_06_const_prop.txt

@@ -0,0 +1,30 @@
+(LIR
+  (Declaration x_sq
+    %t1 = load_input "x" :: integer
+    %t3 = call core.mul(%t1, %t1) :: integer
+    yield %t3
+  )
+  (Declaration y_sq
+    %t4 = load_input "y" :: integer
+    %t6 = call core.mul(%t4, %t4) :: integer
+    yield %t6
+  )
+  (Declaration distance_sq
+    %t13 = load_input "x" :: integer
+    %t15 = call core.mul(%t13, %t13) :: integer
+    %t16 = load_input "y" :: integer
+    %t18 = call core.mul(%t16, %t16) :: integer
+    %t9 = call core.add(%t15, %t18) :: integer
+    yield %t9
+  )
+  (Declaration distance
+    %t22 = load_input "x" :: integer
+    %t24 = call core.mul(%t22, %t22) :: integer
+    %t25 = load_input "y" :: integer
+    %t27 = call core.mul(%t25, %t25) :: integer
+    %t21 = call core.add(%t24, %t27) :: integer
+    %t11 = const 0.5 :: float
+    %t12 = call core.pow(%t21, %t11) :: float
+    yield %t12
+  )
+)

data/golden/let_inline/expected/nast.txt

@@ -0,0 +1,26 @@
+(NAST
+  (VALUE x_sq
+    (Call :"core.mul"
+    (InputRef [:x])
+    (InputRef [:x])
+  )
+  )
+  (VALUE y_sq
+    (Call :"core.mul"
+    (InputRef [:y])
+    (InputRef [:y])
+  )
+  )
+  (VALUE distance_sq
+    (Call :"core.add"
+    (Ref x_sq)
+    (Ref y_sq)
+  )
+  )
+  (VALUE distance
+    (Call :"core.pow"
+    (Ref distance_sq)
+    (Const 0.5)
+  )
+  )
+)

data/golden/let_inline/expected/schema_javascript.mjs

@@ -0,0 +1,11 @@
+export function _distance(input) {
+  let t22 = input["x"];
+  let t24 = t22 * t22;
+  let t25 = input["y"];
+  let t27 = t25 * t25;
+  let t21 = t24 + t27;
+  const t11 = 0.5;
+  let t12 = Math.pow(t21, t11);
+  return t12;
+}
+

data/golden/let_inline/expected/schema_ruby.rb

@@ -0,0 +1,37 @@
+# Autogenerated by Kumi Codegen
+module Kumi::Compiled::KUMI_e1b6ea8c9c0e0caff4b221e24755552775604680e28bf1c6b8fa4fd27b823c89
+  def self.from(input_data = nil)
+    instance = Object.new
+    instance.extend(self)
+    instance.instance_variable_set(:@input, input_data)
+    instance
+  end
+
+  def self.__kumi_executable__
+    instance = Object.new
+    instance.extend(self)
+    instance
+  end
+
+  def update(input_data)
+    @input = @input.merge(input_data)
+    self
+  end
+
+  def [](name)
+    case name
+    when :distance then _distance
+    else raise KeyError, "Unknown declaration"
+    end
+  end
+
+  def _distance(input = @input)
+    t22 = input["x"] || input[:x]
+    t24 = t22 * t22
+    t25 = input["y"] || input[:y]
+    t27 = t25 * t25
+    t21 = t24 + t27
+    t11 = 0.5
+    t21 ** t11
+  end
+end

data/golden/let_inline/expected/snast.txt

@@ -0,0 +1,26 @@
+(SNAST
+  (VALUE x_sq
+    (Call :core.mul
+      (InputRef x key_chain=[]) :: [] -> integer
+      (InputRef x key_chain=[]) :: [] -> integer
+    ) :: [] -> integer
+  ) :: [] -> integer
+  (VALUE y_sq
+    (Call :core.mul
+      (InputRef y key_chain=[]) :: [] -> integer
+      (InputRef y key_chain=[]) :: [] -> integer
+    ) :: [] -> integer
+  ) :: [] -> integer
+  (VALUE distance_sq
+    (Call :core.add
+      (Ref x_sq) :: [] -> integer
+      (Ref y_sq) :: [] -> integer
+    ) :: [] -> integer
+  ) :: [] -> integer
+  (VALUE distance
+    (Call :core.pow
+      (Ref distance_sq) :: [] -> integer
+      (Const 0.5) :: [] -> float
+    ) :: [] -> float
+  ) :: [] -> float
+)

data/golden/let_inline/expected.json

@@ -0,0 +1 @@
+{"distance": 5}

data/golden/let_inline/input.json

@@ -0,0 +1 @@
+{"x": 3, "y": 4}

data/golden/let_inline/schema.kumi

@@ -0,0 +1,11 @@
+schema do
+  input do
+    integer :x
+    integer :y
+  end
+
+  let   :x_sq, input.x * input.x
+  let   :y_sq, input.y * input.y
+  let   :distance_sq, x_sq + y_sq
+  value :distance, distance_sq**0.5
+end

data/golden/loop_fusion/expected/ast.txt

@@ -0,0 +1,44 @@
+(Root
+  inputs: [
+    (InputDeclaration :departments :array
+      [
+        (InputDeclaration :dept :hash
+          [
+            (InputDeclaration :name :string)
+            (InputDeclaration :employees :array
+              [
+                (InputDeclaration :emp :hash
+                  [
+                    (InputDeclaration :salary :integer)
+                    (InputDeclaration :role :string)
+                  ]
+                )
+              ]
+            )
+          ]
+        )
+      ]
+    )
+  ]
+  values: [
+    (ValueDeclaration :total_payroll
+      (CallExpression :sum
+        (InputElementReference departments.dept.employees.emp.salary)
+      )
+    )
+    (ValueDeclaration :manager_count
+      (CallExpression :count_if
+        (InputElementReference departments.dept.employees.emp.role)
+        (Literal "manager")
+      )
+    )
+    (ValueDeclaration :department_summary
+      (HashExpression
+        ((Literal :name) (InputElementReference departments.dept.name))
+        ((Literal :total_payroll) (DeclarationReference :total_payroll))
+        ((Literal :manager_count) (DeclarationReference :manager_count))
+      )
+    )
+  ]
+  traits: []
+)

data/golden/loop_fusion/expected/input_plan.txt

@@ -0,0 +1,13 @@
+departments: array (array) access_mode=element
+  └─> dept: element_access
+  dept: hash (hash)
+    └─> name: property_access
+    └─> employees: property_access → array_loop
+    name: string
+    employees: array (array) access_mode=element
+      └─> emp: element_access
+      emp: hash (hash)
+        └─> salary: property_access
+        └─> role: property_access
+        salary: integer
+        role: string

data/golden/loop_fusion/expected/lir_00_unoptimized.txt

@@ -0,0 +1,43 @@
+(LIR
+  (Declaration total_payroll
+    %t1 = load_input "departments" :: array
+    loop departments id=L1 in %t1 as el=%departments_el_2, idx=%departments_i_3
+      %acc_4 = decl_acc :: integer
+      %t5 = load_field departments_el_2["employees"] :: any
+      loop employees id=L2 in %t5 as el=%employees_el_6, idx=%employees_i_7
+        %t8 = load_field employees_el_6["salary"] :: integer
+        %acc_4 = acc_add agg.sum(%acc_4, %t8) :: integer
+      end_loop
+      %t9 = acc_load %acc_4 :: integer
+      yield %t9
+    end_loop
+  )
+  (Declaration manager_count
+    %t10 = load_input "departments" :: array
+    loop departments id=L3 in %t10 as el=%departments_el_11, idx=%departments_i_12
+      %acc_13 = decl_acc :: integer
+      %t14 = load_field departments_el_11["employees"] :: any
+      loop employees id=L4 in %t14 as el=%employees_el_15, idx=%employees_i_16
+        %t17 = load_field employees_el_15["role"] :: string
+        %t18 = const "manager" :: string
+        %t19 = call core.eq(%t17, %t18) :: boolean
+        %t20 = const 1 :: integer
+        %t21 = const 0 :: integer
+        %t22 = select %t19, %t20, %t21 :: integer
+        %acc_13 = acc_add agg.sum(%acc_13, %t22) :: integer
+      end_loop
+      %t23 = acc_load %acc_13 :: integer
+      yield %t23
+    end_loop
+  )
+  (Declaration department_summary
+    %t24 = load_input "departments" :: array
+    loop departments id=L5 in %t24 as el=%departments_el_25, idx=%departments_i_26
+      %t27 = load_field departments_el_25["name"] :: string
+      %t28 = load_decl total_payroll axes=[departments] :: integer
+      %t29 = load_decl manager_count axes=[departments] :: integer
+      %t30 = make_object{name: %t27, total_payroll: %t28, manager_count: %t29} :: object
+      yield %t30
+    end_loop
+  )
+)

data/golden/loop_fusion/expected/lir_01_hoist_scalar_references.txt

@@ -0,0 +1,43 @@
+(LIR
+  (Declaration total_payroll
+    %t1 = load_input "departments" :: array
+    loop departments id=L1 in %t1 as el=%departments_el_2, idx=%departments_i_3
+      %acc_4 = decl_acc :: integer
+      %t5 = load_field departments_el_2["employees"] :: any
+      loop employees id=L2 in %t5 as el=%employees_el_6, idx=%employees_i_7
+        %t8 = load_field employees_el_6["salary"] :: integer
+        %acc_4 = acc_add agg.sum(%acc_4, %t8) :: integer
+      end_loop
+      %t9 = acc_load %acc_4 :: integer
+      yield %t9
+    end_loop
+  )
+  (Declaration manager_count
+    %t10 = load_input "departments" :: array
+    loop departments id=L3 in %t10 as el=%departments_el_11, idx=%departments_i_12
+      %acc_13 = decl_acc :: integer
+      %t14 = load_field departments_el_11["employees"] :: any
+      loop employees id=L4 in %t14 as el=%employees_el_15, idx=%employees_i_16
+        %t17 = load_field employees_el_15["role"] :: string
+        %t18 = const "manager" :: string
+        %t19 = call core.eq(%t17, %t18) :: boolean
+        %t20 = const 1 :: integer
+        %t21 = const 0 :: integer
+        %t22 = select %t19, %t20, %t21 :: integer
+        %acc_13 = acc_add agg.sum(%acc_13, %t22) :: integer
+      end_loop
+      %t23 = acc_load %acc_13 :: integer
+      yield %t23
+    end_loop
+  )
+  (Declaration department_summary
+    %t24 = load_input "departments" :: array
+    loop departments id=L5 in %t24 as el=%departments_el_25, idx=%departments_i_26
+      %t27 = load_field departments_el_25["name"] :: string
+      %t28 = load_decl total_payroll axes=[departments] :: integer
+      %t29 = load_decl manager_count axes=[departments] :: integer
+      %t30 = make_object{name: %t27, total_payroll: %t28, manager_count: %t29} :: object
+      yield %t30
+    end_loop
+  )
+)