kumi 0.0.18 → 0.0.20

data/golden/chained_fusion/expected/lir_06_const_prop.txt

@@ -0,0 +1,97 @@
+(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
+    %t18 = const "manager" :: string
+    %t20 = const 1 :: integer
+    %t21 = const 0 :: integer
+    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
+        %t19 = call core.eq(%t17, %t18) :: boolean
+        %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 senior_employee_count
+    %t24 = load_input "departments" :: array
+    %t32 = const "senior" :: string
+    %t34 = const 1 :: integer
+    %t35 = const 0 :: integer
+    loop departments id=L5 in %t24 as el=%departments_el_25, idx=%departments_i_26
+      %acc_27 = decl_acc :: integer
+      %t28 = load_field departments_el_25["employees"] :: any
+      loop employees id=L6 in %t28 as el=%employees_el_29, idx=%employees_i_30
+        %t31 = load_field employees_el_29["role"] :: string
+        %t33 = call core.eq(%t31, %t32) :: boolean
+        %t36 = select %t33, %t34, %t35 :: integer
+        %acc_27 = acc_add agg.sum(%acc_27, %t36) :: integer
+      end_loop
+      %t37 = acc_load %acc_27 :: integer
+      yield %t37
+    end_loop
+  )
+  (Declaration max_salary
+    %t38 = load_input "departments" :: array
+    loop departments id=L7 in %t38 as el=%departments_el_39, idx=%departments_i_40
+      %acc_41 = decl_acc :: integer
+      %t42 = load_field departments_el_39["employees"] :: any
+      loop employees id=L8 in %t42 as el=%employees_el_43, idx=%employees_i_44
+        %t45 = load_field employees_el_43["salary"] :: integer
+        %acc_41 = acc_add agg.max(%acc_41, %t45) :: integer
+      end_loop
+      %t46 = acc_load %acc_41 :: integer
+      yield %t46
+    end_loop
+  )
+  (Declaration department_summary
+    %t47 = load_input "departments" :: array
+    %t67 = const "manager" :: string
+    %t69 = const 1 :: integer
+    %t70 = const 0 :: integer
+    %t78 = const "senior" :: string
+    loop departments id=L9 in %t47 as el=%departments_el_48, idx=%departments_i_49
+      %t50 = load_field departments_el_48["name"] :: string
+      %acc58 = decl_acc :: integer
+      %t59 = load_field departments_el_48["employees"] :: any
+      %acc64 = decl_acc :: integer
+      %acc75 = decl_acc :: integer
+      %acc86 = decl_acc :: integer
+      loop employees id=L10 in %t59 as el=%employees_el_6, idx=%employees_i_7
+        %t60 = load_field employees_el_6["salary"] :: integer
+        %acc58 = acc_add agg.sum(%acc58, %t60) :: integer
+        %t66 = load_field employees_el_6["role"] :: string
+        %t68 = call core.eq(%t66, %t67) :: boolean
+        %t71 = select %t68, %t69, %t70 :: integer
+        %acc64 = acc_add agg.sum(%acc64, %t71) :: integer
+        %acc86 = acc_add agg.max(%acc86, %t60) :: integer
+        %t79 = call core.eq(%t66, %t78) :: boolean
+        %t82 = select %t79, %t69, %t70 :: integer
+        %acc75 = acc_add agg.sum(%acc75, %t82) :: integer
+      end_loop
+      %t61 = acc_load %acc58 :: integer
+      %t72 = acc_load %acc64 :: integer
+      %t89 = acc_load %acc86 :: integer
+      %t83 = acc_load %acc75 :: integer
+      %t55 = make_object{name: %t50, total_payroll: %t61, manager_count: %t72, senior_count: %t83, top_salary: %t89} :: object
+      yield %t55
+    end_loop
+  )
+)

data/golden/chained_fusion/expected/nast.txt

@@ -0,0 +1,55 @@
+(NAST
+  (VALUE total_payroll
+    (Call :"agg.sum"
+    (InputRef [:departments, :dept, :employees, :emp, :salary])
+  )
+  )
+  (VALUE manager_count
+    (Call :sum
+    (Call :__select__
+      (Call :eq
+        (InputRef [:departments, :dept, :employees, :emp, :role])
+        (Const "manager")
+      )
+      (Const 1)
+      (Const 0)
+    )
+  )
+  )
+  (VALUE senior_employee_count
+    (Call :sum
+    (Call :__select__
+      (Call :eq
+        (InputRef [:departments, :dept, :employees, :emp, :role])
+        (Const "senior")
+      )
+      (Const 1)
+      (Const 0)
+    )
+  )
+  )
+  (VALUE max_salary
+    (Call :"agg.max"
+    (InputRef [:departments, :dept, :employees, :emp, :salary])
+  )
+  )
+  (VALUE department_summary
+    (Hash
+    (Pair name 
+      (InputRef [:departments, :dept, :name])
+    )
+    (Pair total_payroll 
+      (Ref total_payroll)
+    )
+    (Pair manager_count 
+      (Ref manager_count)
+    )
+    (Pair senior_count 
+      (Ref senior_employee_count)
+    )
+    (Pair top_salary 
+      (Ref max_salary)
+    )
+  )
+  )
+)

data/golden/chained_fusion/expected/schema_javascript.mjs

@@ -0,0 +1,116 @@
+export function _total_payroll(input) {
+  let out = [];
+  let t1 = input["departments"];
+  t1.forEach((departments_el_2, departments_i_3) => {
+    let acc_4 = 0;
+    let t5 = departments_el_2["employees"];
+    t5.forEach((employees_el_6, employees_i_7) => {
+      let t8 = employees_el_6["salary"];
+      acc_4 += t8;
+    });
+    out.push(acc_4);
+  });
+  return out;
+}
+
+export function _manager_count(input) {
+  let out = [];
+  let t10 = input["departments"];
+  const t18 = "manager";
+  const t20 = 1;
+  const t21 = 0;
+  t10.forEach((departments_el_11, departments_i_12) => {
+    let acc_13 = 0;
+    let t14 = departments_el_11["employees"];
+    t14.forEach((employees_el_15, employees_i_16) => {
+      let t17 = employees_el_15["role"];
+      let t19 = t17 == t18;
+      let t22 = t19 ? t20 : t21;
+      acc_13 += t22;
+    });
+    out.push(acc_13);
+  });
+  return out;
+}
+
+export function _senior_employee_count(input) {
+  let out = [];
+  let t24 = input["departments"];
+  const t32 = "senior";
+  const t34 = 1;
+  const t35 = 0;
+  t24.forEach((departments_el_25, departments_i_26) => {
+    let acc_27 = 0;
+    let t28 = departments_el_25["employees"];
+    t28.forEach((employees_el_29, employees_i_30) => {
+      let t31 = employees_el_29["role"];
+      let t33 = t31 == t32;
+      let t36 = t33 ? t34 : t35;
+      acc_27 += t36;
+    });
+    out.push(acc_27);
+  });
+  return out;
+}
+
+export function _max_salary(input) {
+  let out = [];
+  let t38 = input["departments"];
+  t38.forEach((departments_el_39, departments_i_40) => {
+    let acc_41 = null;
+    let t42 = departments_el_39["employees"];
+    t42.forEach((employees_el_43, employees_i_44) => {
+      let t45 = employees_el_43["salary"];
+      if (acc_41 === null || acc_41 === undefined) {
+        acc_41 = t45;
+      } else {
+        acc_41 = (acc_41 === null || t45 > acc_41) ? t45 : acc_41;
+      }
+    });
+    out.push(acc_41);
+  });
+  return out;
+}
+
+export function _department_summary(input) {
+  let out = [];
+  let t47 = input["departments"];
+  const t67 = "manager";
+  const t69 = 1;
+  const t70 = 0;
+  const t78 = "senior";
+  t47.forEach((departments_el_48, departments_i_49) => {
+    let t50 = departments_el_48["name"];
+    let acc58 = 0;
+    let t59 = departments_el_48["employees"];
+    let acc64 = 0;
+    let acc75 = 0;
+    let acc86 = null;
+    t59.forEach((employees_el_6, employees_i_7) => {
+      let t60 = employees_el_6["salary"];
+      acc58 += t60;
+      let t66 = employees_el_6["role"];
+      let t68 = t66 == t67;
+      let t71 = t68 ? t69 : t70;
+      acc64 += t71;
+      if (acc86 === null || acc86 === undefined) {
+        acc86 = t60;
+      } else {
+        acc86 = (acc86 === null || t60 > acc86) ? t60 : acc86;
+      }
+      let t79 = t66 == t78;
+      let t82 = t79 ? t69 : t70;
+      acc75 += t82;
+    });
+    let t55 = {
+      "name": t50,
+      "total_payroll": acc58,
+      "manager_count": acc64,
+      "senior_count": acc75,
+      "top_salary": acc86
+    };
+    out.push(t55);
+  });
+  return out;
+}
+

data/golden/chained_fusion/expected/schema_ruby.rb

@@ -0,0 +1,149 @@
+# Autogenerated by Kumi Codegen
+module Kumi::Compiled::KUMI_509c7b2dc9bbeff658a7cc53b4102928b79f1ea86c21bf5f477bd596a2b47bb4
+  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 :total_payroll then _total_payroll
+    when :manager_count then _manager_count
+    when :senior_employee_count then _senior_employee_count
+    when :max_salary then _max_salary
+    when :department_summary then _department_summary
+    else raise KeyError, "Unknown declaration"
+    end
+  end
+
+  def _total_payroll(input = @input)
+    out = []
+    t1 = input["departments"] || input[:departments]
+    t1.each_with_index do |departments_el_2, departments_i_3|
+      acc_4 = 0
+      t5 = departments_el_2["employees"] || departments_el_2[:employees]
+      t5.each_with_index do |employees_el_6, employees_i_7|
+        t8 = employees_el_6["salary"] || employees_el_6[:salary]
+        acc_4 += t8
+      end
+      t9 = acc_4
+      out << t9
+    end
+    out
+  end
+
+  def _manager_count(input = @input)
+    out = []
+    t10 = input["departments"] || input[:departments]
+    t18 = "manager"
+    t20 = 1
+    t21 = 0
+    t10.each_with_index do |departments_el_11, departments_i_12|
+      acc_13 = 0
+      t14 = departments_el_11["employees"] || departments_el_11[:employees]
+      t14.each_with_index do |employees_el_15, employees_i_16|
+        t17 = employees_el_15["role"] || employees_el_15[:role]
+        t19 = t17 == t18
+        t22 = t19 ? t20 : t21
+        acc_13 += t22
+      end
+      t23 = acc_13
+      out << t23
+    end
+    out
+  end
+
+  def _senior_employee_count(input = @input)
+    out = []
+    t24 = input["departments"] || input[:departments]
+    t32 = "senior"
+    t34 = 1
+    t35 = 0
+    t24.each_with_index do |departments_el_25, departments_i_26|
+      acc_27 = 0
+      t28 = departments_el_25["employees"] || departments_el_25[:employees]
+      t28.each_with_index do |employees_el_29, employees_i_30|
+        t31 = employees_el_29["role"] || employees_el_29[:role]
+        t33 = t31 == t32
+        t36 = t33 ? t34 : t35
+        acc_27 += t36
+      end
+      t37 = acc_27
+      out << t37
+    end
+    out
+  end
+
+  def _max_salary(input = @input)
+    out = []
+    t38 = input["departments"] || input[:departments]
+    t38.each_with_index do |departments_el_39, departments_i_40|
+      acc_41 = nil
+      t42 = departments_el_39["employees"] || departments_el_39[:employees]
+      t42.each_with_index do |employees_el_43, employees_i_44|
+        t45 = employees_el_43["salary"] || employees_el_43[:salary]
+        acc_41 ||= t45
+        acc_41 = t45 if t45 > acc_41
+      end
+      t46 = acc_41
+      out << t46
+    end
+    out
+  end
+
+  def _department_summary(input = @input)
+    out = []
+    t47 = input["departments"] || input[:departments]
+    t67 = "manager"
+    t69 = 1
+    t70 = 0
+    t78 = "senior"
+    t47.each_with_index do |departments_el_48, departments_i_49|
+      t50 = departments_el_48["name"] || departments_el_48[:name]
+      acc58 = 0
+      t59 = departments_el_48["employees"] || departments_el_48[:employees]
+      acc64 = 0
+      acc75 = 0
+      acc86 = nil
+      t59.each_with_index do |employees_el_6, employees_i_7|
+        t60 = employees_el_6["salary"] || employees_el_6[:salary]
+        acc58 += t60
+        t66 = employees_el_6["role"] || employees_el_6[:role]
+        t68 = t66 == t67
+        t71 = t68 ? t69 : t70
+        acc64 += t71
+        acc86 ||= t60
+        acc86 = t60 if t60 > acc86
+        t79 = t66 == t78
+        t82 = t79 ? t69 : t70
+        acc75 += t82
+      end
+      t61 = acc58
+      t72 = acc64
+      t89 = acc86
+      t83 = acc75
+      t55 = {
+        "name" => t50,
+        "total_payroll" => t61,
+        "manager_count" => t72,
+        "senior_count" => t83,
+        "top_salary" => t89
+      }
+      out << t55
+    end
+    out
+  end
+end

data/golden/chained_fusion/expected/snast.txt

@@ -0,0 +1,55 @@
+(SNAST
+  (VALUE total_payroll
+    (Reduce :agg.sum over [employees]
+      (InputRef departments.dept.employees.emp.salary key_chain=[]) :: [departments, employees] -> integer
+    ) :: [departments] -> integer
+  ) :: [departments] -> integer
+  (VALUE manager_count
+    (Reduce :agg.sum over [employees]
+      (Select
+        (Call :core.eq
+          (InputRef departments.dept.employees.emp.role key_chain=[]) :: [departments, employees] -> string
+          (Const "manager") :: [] -> string
+        ) :: [departments, employees] -> boolean
+        (Const 1) :: [] -> integer
+        (Const 0) :: [] -> integer
+      ) :: [departments, employees] -> integer
+    ) :: [departments] -> integer
+  ) :: [departments] -> integer
+  (VALUE senior_employee_count
+    (Reduce :agg.sum over [employees]
+      (Select
+        (Call :core.eq
+          (InputRef departments.dept.employees.emp.role key_chain=[]) :: [departments, employees] -> string
+          (Const "senior") :: [] -> string
+        ) :: [departments, employees] -> boolean
+        (Const 1) :: [] -> integer
+        (Const 0) :: [] -> integer
+      ) :: [departments, employees] -> integer
+    ) :: [departments] -> integer
+  ) :: [departments] -> integer
+  (VALUE max_salary
+    (Reduce :agg.max over [employees]
+      (InputRef departments.dept.employees.emp.salary key_chain=[]) :: [departments, employees] -> integer
+    ) :: [departments] -> integer
+  ) :: [departments] -> integer
+  (VALUE department_summary
+    (Hash
+      (Pair name
+        (InputRef departments.dept.name key_chain=[]) :: [departments] -> string
+      ) :: [departments] -> pair
+      (Pair total_payroll
+        (Ref total_payroll) :: [departments] -> integer
+      ) :: [departments] -> pair
+      (Pair manager_count
+        (Ref manager_count) :: [departments] -> integer
+      ) :: [departments] -> pair
+      (Pair senior_count
+        (Ref senior_employee_count) :: [departments] -> integer
+      ) :: [departments] -> pair
+      (Pair top_salary
+        (Ref max_salary) :: [departments] -> integer
+      ) :: [departments] -> pair
+    ) :: [departments] -> hash
+  ) :: [departments] -> hash
+)

data/golden/chained_fusion/expected.json

@@ -0,0 +1,45 @@
+{
+    "total_payroll": [
+        400000,
+        395000,
+        75000
+    ],
+    "manager_count": [
+        1,
+        1,
+        0
+    ],
+    "senior_employee_count": [
+        1,
+        1,
+        0
+    ],
+    "max_salary": [
+        150000,
+        120000,
+        75000
+    ],
+    "department_summary": [
+        {
+            "name": "Engineering",
+            "total_payroll": 400000,
+            "manager_count": 1,
+            "senior_count": 1,
+            "top_salary": 150000
+        },
+        {
+            "name": "Sales",
+            "total_payroll": 395000,
+            "manager_count": 1,
+            "senior_count": 1,
+            "top_salary": 120000
+        },
+        {
+            "name": "HR",
+            "total_payroll": 75000,
+            "manager_count": 0,
+            "senior_count": 0,
+            "top_salary": 75000
+        }
+    ]
+}

data/golden/chained_fusion/input.json

@@ -0,0 +1,51 @@
+{
+    "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": 75000,
+                    "role": "associate"
+                },
+                {
+                    "salary": 110000,
+                    "role": "senior"
+                }
+            ]
+        },
+        {
+            "name": "HR",
+            "employees": [
+                {
+                    "salary": 75000,
+                    "role": "generalist"
+                }
+            ]
+        }
+    ]
+}

data/golden/chained_fusion/schema.kumi

@@ -0,0 +1,52 @@
+# This schema is designed to test "chained" loop fusion.
+#
+# The `department_summary` value depends on FOUR other values, each
+# requiring a separate aggregation over the nested `employees` array.
+#
+# After the inlining and CSE passes, the LIR for `department_summary` will
+# contain four adjacent, independent loops over `employees`. A robust
+# LoopFusionPass should be able to detect this chain and merge all four
+# loops into a single, highly efficient pass over the data.
+
+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
+
+  # --- Intermediate Aggregations (Four distinct loops will be created) ---
+
+  # Aggregation 1: Sum of all salaries.
+  value :total_payroll, fn(:sum, input.departments.dept.employees.emp.salary)
+
+  # Aggregation 2: Count of employees with the "manager" role.
+  value :manager_count, fn(:count_if, input.departments.dept.employees.emp.role, "manager")
+
+  # Aggregation 3: Count of employees with the "senior" role.
+  value :senior_employee_count, fn(:count_if, input.departments.dept.employees.emp.role, "senior")
+
+  # Aggregation 4: The maximum salary in the department.
+  value :max_salary, fn(:max, input.departments.dept.employees.emp.salary)
+
+
+  # --- Final Value ---
+
+  # This value depends on all four aggregations above.
+  # The inliner will expand this, creating the chain of four fusable loops.
+  value :department_summary, {
+    name: input.departments.dept.name,
+    total_payroll: total_payroll,
+    manager_count: manager_count,
+    senior_count: senior_employee_count,
+    top_salary: max_salary
+  }
+end

data/golden/element_arrays/expected/ast.txt

@@ -0,0 +1,55 @@
+(Root
+  inputs: [
+    (InputDeclaration :cube :array
+      [
+        (InputDeclaration :layer :array
+          [
+            (InputDeclaration :row :array
+              [
+                (InputDeclaration :cell :integer)
+              ]
+            )
+          ]
+        )
+      ]
+    )
+  ]
+  values: [
+    (ValueDeclaration :cube
+      (InputReference :cube)
+    )
+    (ValueDeclaration :layer
+      (InputElementReference cube.layer)
+    )
+    (ValueDeclaration :row
+      (InputElementReference cube.layer.row)
+    )
+    (ValueDeclaration :cell
+      (InputElementReference cube.layer.row.cell)
+    )
+    (ValueDeclaration :cell_sum
+      (CallExpression :sum_if
+        (InputElementReference cube.layer.row.cell)
+        (DeclarationReference :cell_over_limit)
+      )
+    )
+    (ValueDeclaration :count_over_limit
+      (CallExpression :sum
+        (CallExpression :sum
+          (CallExpression :sum_if
+            (Literal 1)
+            (DeclarationReference :cell_over_limit)
+          )
+        )
+      )
+    )
+  ]
+  traits: [
+    (TraitDeclaration :cell_over_limit
+      (CallExpression :>
+        (InputElementReference cube.layer.row.cell)
+        (Literal 100)
+      )
+    )
+  ]
+)

data/golden/element_arrays/expected/input_plan.txt

@@ -0,0 +1,7 @@
+cube: array (array) access_mode=element
+  └─> layer: element_access → array_loop
+  layer: array (array) access_mode=element
+    └─> row: element_access → array_loop
+    row: array (array) access_mode=element
+      └─> cell: element_access
+      cell: integer