kumi 0.0.18 → 0.0.20

data/golden/tuples_and_arrays/expected/schema_javascript.mjs

@@ -0,0 +1,58 @@
+export function _x_is_large(input) {
+  let out = [];
+  let t1 = input["points"];
+  const t5 = 100;
+  t1.forEach((points_el_2, points_i_3) => {
+    let t4 = points_el_2["x"];
+    let t6 = t4 > t5;
+    out.push(t6);
+  });
+  return out;
+}
+
+export function _selected_value(input) {
+  let out = [];
+  let t7 = input["points"];
+  const t29 = 100;
+  t7.forEach((points_el_8, points_i_9) => {
+    let t28 = points_el_8["x"];
+    let t12 = points_el_8["y"];
+    let t30 = t28 > t29;
+    let t13 = t30 ? t28 : t12;
+    out.push(t13);
+  });
+  return out;
+}
+
+export function _final_value_per_point(input) {
+  let out = [];
+  let t14 = input["points"];
+  const t43 = 100;
+  t14.forEach((points_el_15, points_i_16) => {
+    let t42 = points_el_15["x"];
+    let t34 = points_el_15["y"];
+    let t44 = t42 > t43;
+    let t35 = t44 ? t42 : t34;
+    let t19 = [t35, t42];
+    let t20 = Math.max(...t19);
+    out.push(t20);
+  });
+  return out;
+}
+
+export function _grand_total(input) {
+  let acc_21 = 0;
+  let t22 = input["points"];
+  const t48 = 100;
+  t22.forEach((points_el_23, points_i_24) => {
+    let t47 = points_el_23["x"];
+    let t51 = points_el_23["y"];
+    let t49 = t47 > t48;
+    let t52 = t49 ? t47 : t51;
+    let t39 = [t52, t47];
+    let t40 = Math.max(...t39);
+    acc_21 += t40;
+  });
+  return acc_21;
+}
+

data/golden/tuples_and_arrays/expected/schema_ruby.rb

@@ -0,0 +1,88 @@
+# Autogenerated by Kumi Codegen
+module Kumi::Compiled::KUMI_891c764845b8c48158e2ba4637dc0ee94765e885752ebff413ce6186568789f5
+  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 :x_is_large then _x_is_large
+    when :selected_value then _selected_value
+    when :final_value_per_point then _final_value_per_point
+    when :grand_total then _grand_total
+    else raise KeyError, "Unknown declaration"
+    end
+  end
+
+  def _x_is_large(input = @input)
+    out = []
+    t1 = input["points"] || input[:points]
+    t5 = 100
+    t1.each_with_index do |points_el_2, points_i_3|
+      t4 = points_el_2["x"] || points_el_2[:x]
+      t6 = t4 > t5
+      out << t6
+    end
+    out
+  end
+
+  def _selected_value(input = @input)
+    out = []
+    t7 = input["points"] || input[:points]
+    t29 = 100
+    t7.each_with_index do |points_el_8, points_i_9|
+      t28 = points_el_8["x"] || points_el_8[:x]
+      t12 = points_el_8["y"] || points_el_8[:y]
+      t30 = t28 > t29
+      t13 = t30 ? t28 : t12
+      out << t13
+    end
+    out
+  end
+
+  def _final_value_per_point(input = @input)
+    out = []
+    t14 = input["points"] || input[:points]
+    t43 = 100
+    t14.each_with_index do |points_el_15, points_i_16|
+      t42 = points_el_15["x"] || points_el_15[:x]
+      t34 = points_el_15["y"] || points_el_15[:y]
+      t44 = t42 > t43
+      t35 = t44 ? t42 : t34
+      t19 = [t35, t42]
+      t20 = t19.max
+      out << t20
+    end
+    out
+  end
+
+  def _grand_total(input = @input)
+    acc_21 = 0
+    t22 = input["points"] || input[:points]
+    t48 = 100
+    t22.each_with_index do |points_el_23, points_i_24|
+      t47 = points_el_23["x"] || points_el_23[:x]
+      t51 = points_el_23["y"] || points_el_23[:y]
+      t49 = t47 > t48
+      t52 = t49 ? t47 : t51
+      t39 = [t52, t47]
+      t40 = t39.max
+      acc_21 += t40
+    end
+    acc_21
+  end
+end

data/golden/tuples_and_arrays/expected/snast.txt

@@ -0,0 +1,28 @@
+(SNAST
+  (TRAIT x_is_large
+    (Call :core.gt
+      (InputRef points.point.x key_chain=[]) :: [points] -> integer
+      (Const 100) :: [] -> integer
+    ) :: [points] -> boolean
+  ) :: [points] -> boolean
+  (VALUE selected_value
+    (Select
+      (Ref x_is_large) :: [points] -> boolean
+      (InputRef points.point.x key_chain=[]) :: [points] -> integer
+      (InputRef points.point.y key_chain=[]) :: [points] -> integer
+    ) :: [points] -> integer
+  ) :: [points] -> integer
+  (VALUE final_value_per_point
+    (Fold :agg.max
+      (Tuple
+        (Ref selected_value) :: [points] -> integer
+        (InputRef points.point.x key_chain=[]) :: [points] -> integer
+      ) :: [points] -> tuple<integer>
+    ) :: [points] -> integer
+  ) :: [points] -> integer
+  (VALUE grand_total
+    (Reduce :agg.sum over [points]
+      (Ref final_value_per_point) :: [points] -> integer
+    ) :: [] -> integer
+  ) :: [] -> integer
+)

data/golden/tuples_and_arrays/expected.json

@@ -0,0 +1,18 @@
+{
+    "x_is_large": [
+      true,
+      false,
+      false
+    ],
+    "selected_value": [
+      120,
+      90,
+      10
+    ],
+    "final_value_per_point": [
+      120,
+      90,
+      30
+    ],
+    "grand_total": 240
+  }

data/golden/tuples_and_arrays/input.json

@@ -0,0 +1,7 @@
+{
+    "points": [
+      { "x": 120, "y": 50 },
+      { "x": 80,  "y": 90 },
+      { "x": 30,  "y": 10 }
+    ]
+  }

data/golden/tuples_and_arrays/schema.kumi

@@ -0,0 +1,38 @@
+schema do
+  input do
+    # Input is an array of points, each with an x and y coordinate.
+    array :points do
+      hash :point do
+        integer :x
+        integer :y
+      end
+    end
+  end
+
+  # --- Part 1: Element-wise Logic ---
+
+  # First, create an element-wise boolean mask. This will be an array of booleans
+  # the same size as the input 'points' array.
+  trait :x_is_large, input.points.point.x > 100
+
+  # Next, use the mask to perform an element-wise selection.
+  # For each point, it will pick `x` if the condition is true, otherwise it picks `y`.
+  # The result, `selected_value`, is another array.
+  value :selected_value, select(x_is_large, input.points.point.x, input.points.point.y)
+
+  # --- Part 2: Vectorized Fold ---
+
+  # This is the most complex step. It mixes a tuple operation (a Fold)
+  # with element-wise processing.
+  # For EACH point in the array, Kumi will:
+  #   1. Create a temporary 2-element tuple: `[selected_value_for_point, x_for_point]`
+  #   2. Perform a `max` reduction on that small tuple (a Fold).
+  # The result, `final_value_per_point`, is a new array containing the result of each fold.
+  value :final_value_per_point, fn(:max, [selected_value, input.points.point.x])
+
+  # --- Part 3: Final Reduction ---
+
+  # Finally, we take the array produced by the vectorized fold and reduce it
+  # to a single scalar value by summing all its elements.
+  value :grand_total, fn(:sum, final_value_per_point)
+end

data/golden/with_constants/expected/ast.txt

@@ -0,0 +1,28 @@
+(Root
+  inputs: [
+    (InputDeclaration :income :float)
+    (InputDeclaration :age :integer)
+  ]
+  values: [
+    (ValueDeclaration :scores
+      (ArrayExpression
+        (Literal 100)
+        (Literal 85)
+        (Literal 92)
+      )
+    )
+    (ValueDeclaration :first_score
+      (CallExpression :at
+        (DeclarationReference :scores)
+        (Literal 0)
+      )
+    )
+    (ValueDeclaration :second_score
+      (CallExpression :at
+        (DeclarationReference :scores)
+        (Literal 1)
+      )
+    )
+  ]
+  traits: []
+)

data/golden/with_constants/expected/input_plan.txt

@@ -0,0 +1,2 @@
+income: float
+age: integer

data/golden/with_constants/expected/lir_00_unoptimized.txt

@@ -0,0 +1,17 @@
+(LIR
+  (Declaration scores
+    %t1 = const 100 :: integer
+    %t2 = const 85 :: integer
+    %t3 = const 92 :: integer
+    %t4 = make_tuple(%t1, %t2, %t3) :: tuple<integer>
+    yield %t4
+  )
+  (Declaration first_score
+    %t5 = const 100 :: integer
+    yield %t5
+  )
+  (Declaration second_score
+    %t6 = const 85 :: integer
+    yield %t6
+  )
+)

data/golden/with_constants/expected/lir_01_hoist_scalar_references.txt

@@ -0,0 +1,17 @@
+(LIR
+  (Declaration scores
+    %t1 = const 100 :: integer
+    %t2 = const 85 :: integer
+    %t3 = const 92 :: integer
+    %t4 = make_tuple(%t1, %t2, %t3) :: tuple<integer>
+    yield %t4
+  )
+  (Declaration first_score
+    %t5 = const 100 :: integer
+    yield %t5
+  )
+  (Declaration second_score
+    %t6 = const 85 :: integer
+    yield %t6
+  )
+)

data/golden/with_constants/expected/lir_02_inlined.txt

@@ -0,0 +1,17 @@
+(LIR
+  (Declaration scores
+    %t1 = const 100 :: integer
+    %t2 = const 85 :: integer
+    %t3 = const 92 :: integer
+    %t4 = make_tuple(%t1, %t2, %t3) :: tuple<integer>
+    yield %t4
+  )
+  (Declaration first_score
+    %t5 = const 100 :: integer
+    yield %t5
+  )
+  (Declaration second_score
+    %t6 = const 85 :: integer
+    yield %t6
+  )
+)

data/golden/with_constants/expected/lir_03_cse.txt

@@ -0,0 +1,17 @@
+(LIR
+  (Declaration scores
+    %t1 = const 100 :: integer
+    %t2 = const 85 :: integer
+    %t3 = const 92 :: integer
+    %t4 = make_tuple(%t1, %t2, %t3) :: tuple<integer>
+    yield %t4
+  )
+  (Declaration first_score
+    %t5 = const 100 :: integer
+    yield %t5
+  )
+  (Declaration second_score
+    %t6 = const 85 :: integer
+    yield %t6
+  )
+)

data/golden/with_constants/expected/lir_04_1_loop_fusion.txt

@@ -0,0 +1,17 @@
+(LIR
+  (Declaration scores
+    %t1 = const 100 :: integer
+    %t2 = const 85 :: integer
+    %t3 = const 92 :: integer
+    %t4 = make_tuple(%t1, %t2, %t3) :: tuple<integer>
+    yield %t4
+  )
+  (Declaration first_score
+    %t5 = const 100 :: integer
+    yield %t5
+  )
+  (Declaration second_score
+    %t6 = const 85 :: integer
+    yield %t6
+  )
+)

data/golden/with_constants/expected/lir_04_loop_invcm.txt

@@ -0,0 +1,17 @@
+(LIR
+  (Declaration scores
+    %t1 = const 100 :: integer
+    %t2 = const 85 :: integer
+    %t3 = const 92 :: integer
+    %t4 = make_tuple(%t1, %t2, %t3) :: tuple<integer>
+    yield %t4
+  )
+  (Declaration first_score
+    %t5 = const 100 :: integer
+    yield %t5
+  )
+  (Declaration second_score
+    %t6 = const 85 :: integer
+    yield %t6
+  )
+)

data/golden/with_constants/expected/lir_06_const_prop.txt

@@ -0,0 +1,17 @@
+(LIR
+  (Declaration scores
+    %t1 = const 100 :: integer
+    %t2 = const 85 :: integer
+    %t3 = const 92 :: integer
+    %t4 = make_tuple(%t1, %t2, %t3) :: tuple<integer>
+    yield %t4
+  )
+  (Declaration first_score
+    %t5 = const 100 :: integer
+    yield %t5
+  )
+  (Declaration second_score
+    %t6 = const 85 :: integer
+    yield %t6
+  )
+)

data/golden/with_constants/expected/nast.txt

@@ -0,0 +1,21 @@
+(NAST
+  (VALUE scores
+    (Tuple
+    (Const 100)
+    (Const 85)
+    (Const 92)
+  )
+  )
+  (VALUE first_score
+    (Call :"core.at"
+    (Ref scores)
+    (Const 0)
+  )
+  )
+  (VALUE second_score
+    (Call :"core.at"
+    (Ref scores)
+    (Const 1)
+  )
+  )
+)

data/golden/with_constants/expected/schema_javascript.mjs

@@ -0,0 +1,18 @@
+export function _scores(input) {
+  const t1 = 100;
+  const t2 = 85;
+  const t3 = 92;
+  let t4 = [t1, t2, t3];
+  return t4;
+}
+
+export function _first_score(input) {
+  const t5 = 100;
+  return t5;
+}
+
+export function _second_score(input) {
+  const t6 = 85;
+  return t6;
+}
+

data/golden/with_constants/expected/schema_ruby.rb

@@ -0,0 +1,44 @@
+# Autogenerated by Kumi Codegen
+module Kumi::Compiled::KUMI_806eaa2ab0d0860b647749fdc1ca08bd8b1ce44b98e985473bcc904f6b64c271
+  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 :scores then _scores
+    when :first_score then _first_score
+    when :second_score then _second_score
+    else raise KeyError, "Unknown declaration"
+    end
+  end
+
+  def _scores(input = @input)
+    t1 = 100
+    t2 = 85
+    t3 = 92
+    [t1, t2, t3]
+  end
+
+  def _first_score(input = @input)
+    100
+  end
+
+  def _second_score(input = @input)
+    85
+  end
+end

data/golden/with_constants/expected/snast.txt

@@ -0,0 +1,15 @@
+(SNAST
+  (VALUE scores
+    (Tuple
+      (Const 100) :: [] -> integer
+      (Const 85) :: [] -> integer
+      (Const 92) :: [] -> integer
+    ) :: [] -> tuple<integer>
+  ) :: [] -> tuple<integer>
+  (VALUE first_score
+    (Const 100) :: [] -> integer
+  ) :: [] -> integer
+  (VALUE second_score
+    (Const 85) :: [] -> integer
+  ) :: [] -> integer
+)

data/golden/with_constants/schema.kumi

@@ -0,0 +1,10 @@
+schema do
+  input do
+    float :income
+    integer :age
+  end
+
+  value :scores, [100, 85, 92]
+  value :first_score, scores[0]
+  value :second_score, scores[1]
+end

data/lib/kumi/analyzer.rb

@@ -3,33 +3,75 @@
 module Kumi
   module Analyzer
     Result = Struct.new(:definitions, :dependency_graph, :leaf_map, :topo_order, :decl_types, :state, keyword_init: true)
-    ERROR_THRESHOLD_PASS = Core::Analyzer::Passes::LowerToIRPass
+    Passes = Core::Analyzer::Passes
+    ERROR_THRESHOLD_PASS = Passes::NormalizeToNASTPass
 
     DEFAULT_PASSES = [
-      Core::Analyzer::Passes::NameIndexer,                     # 1. Finds all names and checks for duplicates.
-      Core::Analyzer::Passes::InputCollector,                  # 2. Collects field metadata from input declarations.
-      Core::Analyzer::Passes::DeclarationValidator,            # 4. Checks the basic structure of each rule.
-      Core::Analyzer::Passes::SemanticConstraintValidator,     # 5. Validates DSL semantic constraints at AST level.
-      Core::Analyzer::Passes::DependencyResolver,              # 6. Builds the dependency graph with conditional dependencies.
-      Core::Analyzer::Passes::UnsatDetector,                   # 7. Detects unsatisfiable constraints and analyzes cascade mutual exclusion.
-      Core::Analyzer::Passes::Toposorter,                      # 8. Creates the final evaluation order, allowing safe cycles.
-      Core::Analyzer::Passes::BroadcastDetector,               # 9. Detects which operations should be broadcast over arrays.
-      Core::Analyzer::Passes::TypeInferencerPass,              # 10. Infers types for all declarations (uses vectorization metadata).
-      Core::Analyzer::Passes::TypeChecker,                     # 11. Validates types using inferred information.
-      Core::Analyzer::Passes::InputAccessPlannerPass,          # 12. Plans access strategies for input fields.
-      Core::Analyzer::Passes::ScopeResolutionPass,             # 13. Plans execution scope and lifting needs for declarations.
-      Core::Analyzer::Passes::JoinReducePlanningPass,          # 14. Plans join/reduce operations (Generates IR Structs)
-      Core::Analyzer::Passes::LowerToIRPass,                   # 15. Lowers the schema to IR (Generates IR Structs)
-      Core::Analyzer::Passes::LoadInputCSE,                    # 16. Eliminates redundant load_input operations
-      Core::Analyzer::Passes::IRDependencyPass,                # 17. Extracts IR-level dependencies for VM execution optimization
-      Core::Analyzer::Passes::IRExecutionSchedulePass          # 18. Builds a precomputed execution schedule.
+      Passes::NameIndexer,                     # 1. Finds all names and checks for duplicates.
+      Passes::InputCollector,                  # 2. Collects field metadata from input declarations.
+      Passes::InputFormSchemaPass,             # 3. Builds minimal form schema from input metadata.
+      Passes::DeclarationValidator,            # 4. Checks the basic structure of each rule.
+      Passes::SemanticConstraintValidator,     # 5. Validates DSL semantic constraints at AST level.
+      Passes::DependencyResolver,              # 6. Builds the dependency graph with conditional dependencies.
+      Passes::UnsatDetector,                   # 7. Detects unsatisfiable constraints and analyzes cascade mutual exclusion.
+      Passes::Toposorter,                      # 8. Creates the final evaluation order, allowing safe cycles.
+      # Passes::BroadcastDetector,               # 9. Detects which operations should be broadcast over arrays.
+      # Passes::TypeInferencerPass,              # 10. Infers types for all declarations (uses vectorization metadata).
+      # Passes::TypeChecker,                     # 11. Validates types using inferred information.
+      Passes::InputAccessPlannerPass # 12. Plans access strategies for input fields.
+      # Passes::ScopeResolutionPass,             # 13. Plans execution scope and lifting needs for declarations.
+      # Passes::JoinReducePlanningPass,          # 14. Plans join/reduce operations (Generates IR Structs)
+      # Passes::LowerToIRPass,                   # 15. Lowers the schema to IR (Generates IR Structs)
+      # Passes::LoadInputCSE,                    # 16. Eliminates redundant load_input operations
+      # Passes::IRDependencyPass,                # 17. Extracts IR-level dependencies for VM execution optimization
+      # Passes::IRExecutionSchedulePass          # 18. Builds a precomputed execution schedule.
     ].freeze
 
-    def self.analyze!(schema, passes: DEFAULT_PASSES, **opts)
-      state = Core::Analyzer::AnalysisState.new(opts)
+    # Pipeline passes for the determinisitic NAST->LIR approach
+    HIR_TO_LIR_PASSES = [
+      Passes::NormalizeToNASTPass,             # Normalizes AST to uniform NAST representation
+      Passes::ConstantFoldingPass,             # Folds constant expressions in NAST
+      Passes::NASTDimensionalAnalyzerPass,     # Extracts dimensional and type metadata from NAST
+      Passes::SNASTPass,                       # Creates Semantic NAST with dimensional stamps and execution plans
+      Passes::OutputSchemaPass,                # Builds minimal output schema from SNAST
+      Passes::AttachTerminalInfoPass,          # Attaches key_chain info to InputRef nodes
+      Passes::AttachAnchorsPass,
+      Passes::PrecomputeAccessPathsPass,
+      Passes::LIR::LowerPass,                  # Lowers the schema to LIR (LIR Structs)
+      Passes::LIR::HoistScalarReferencesPass,
+      Passes::LIR::InlineDeclarationsPass,     # Inlines LoadDeclaration when site axes == decl axes
+      Passes::LIR::LocalCSEPass,               # Local CSE optimization for pure LIR operations
+      Passes::LIR::InstructionSchedulingPass,
+      Passes::LIR::LoopFusionPass,
+      Passes::LIR::LocalCSEPass,               # Local CSE optimization for pure LIR operations
+      Passes::LIR::DeadCodeEliminationPass, # Removes dead code
+      Passes::LIR::KernelBindingPass, # Binds kernels to LIR operations
+      Passes::LIR::LoopInvariantCodeMotionPass
+      # Passes::LIR::ValidationPass # Validates LIR structural and contextual correctness
+    ].freeze
+
+    RUBY_TARGET_PASSES = [
+      Passes::LIR::ConstantPropagationPass, # Ruby uses this Intra-block constant propagation
+      Passes::LIR::DeadCodeEliminationPass, # Removes dead code
+      Passes::Codegen::RubyPass, # Generates ruby code from LIR
+      Passes::Codegen::JsPass
+    ]
+
+    def self.analyze!(schema, passes: DEFAULT_PASSES, registry: nil, **opts)
       errors = []
+      schema_digest = schema.digest
+      stop_after = Core::Analyzer::Checkpoint.stop_after
+
+      registry ||= Kumi::RegistryV2.load
+      state = Core::Analyzer::AnalysisState.new(opts).with(:registry, registry).with(:schema_digest, schema_digest)
+      state, stopped = run_analysis_passes(schema, passes, state, errors)
+      return create_analysis_result(state) if stopped
+
+      state, stopped = run_analysis_passes(schema, HIR_TO_LIR_PASSES, state, errors)
+      return create_analysis_result(state) if stopped
+
+      state, stopped = run_analysis_passes(schema, RUBY_TARGET_PASSES, state, errors)
 
-      state = run_analysis_passes(schema, passes, state, errors)
       handle_analysis_errors(errors) unless errors.empty?
       create_analysis_result(state)
     end
@@ -42,9 +84,10 @@ module Kumi
       resume_at  = Core::Analyzer::Checkpoint.resume_at
       stop_after = Core::Analyzer::Checkpoint.stop_after
       skipping   = !!resume_at
+      stopped    = false
 
       passes.each_with_index do |pass_class, idx|
-        raise handle_analysis_errors(errors) if (ERROR_THRESHOLD_PASS == pass_class) && !errors.empty?
+        raise handle_analysis_errors(errors) if !errors.empty? && (ERROR_THRESHOLD_PASS == pass_class)
 
         pass_name = pass_class.name.split("::").last
 
@@ -84,6 +127,10 @@ module Kumi
 
           raise
         end
+        unless state.is_a? Kumi::Core::Analyzer::AnalysisState
+          raise "Pass #{pass_name} returned a '#{state.class}', expected 'AnalysisState'"
+        end
+
         elapsed_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round(2)
 
         if debug_on
@@ -112,12 +159,17 @@ module Kumi
 
         Core::Analyzer::Checkpoint.leaving(pass_name:, idx:, state:)
 
-        break if stop_after && pass_name == stop_after
+        if stop_after && pass_name == stop_after
+          stopped = true
+          break
+        end
       end
-      state
+      [state, stopped]
     end
 
     def self.handle_analysis_errors(errors)
+      raise Kumi::Errors::AnalysisError, "\n" + errors.join("\n") if errors.first.is_a? String
+
       type_errors = errors.select { |e| e.type == :type }
       first_error_location = errors.first.location