kumi 0.0.18 → 0.0.20

data/lib/kumi/core/analyzer/passes/codegen/ruby/output_buffer.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        module Codegen
+          module Ruby
+            class OutputBuffer
+              def initialize
+                @out = []
+                @indent = 0
+              end
+
+              def to_s = @out.join
+              def reset! = @out.clear
+
+              def indent!
+                @indent += 1
+              end
+
+              def dedent!
+                @indent -= 1
+              end
+
+              def emit_header(module_name)
+                write "# Autogenerated by Kumi Codegen"
+                write "module Kumi::Compiled::#{module_name}"
+                indent!
+              end
+
+              def emit_footer
+                dedent!
+                rewrite_line("end") if last_line == "end\n"
+                write "end"
+              end
+
+              def emit_class_methods(decl_names)
+                write "def self.from(input_data = nil)"
+                indented do
+                  write "instance = Object.new"
+                  write "instance.extend(self)"
+                  write "instance.instance_variable_set(:@input, input_data)"
+                  write "instance"
+                end
+                write "end\n"
+
+                write "def self.__kumi_executable__"
+                indented do
+                  write "instance = Object.new"
+                  write "instance.extend(self)"
+                  write "instance"
+                end
+                write "end\n"
+
+                write "def update(input_data)"
+                indented do
+                  write "@input = @input.merge(input_data)"
+                  write "self"
+                end
+                write "end\n"
+
+                return unless decl_names.size >= 1
+
+                write "def [](name)"
+                indented do
+                  write "case name"
+                  decl_names.each { |name| write "when :#{name} then _#{name}" }
+                  write "else raise KeyError, \"Unknown declaration\""
+                  write "end"
+                end
+                write "end\n"
+              end
+
+              def section(name)
+                write "#{name}\n"
+                yield
+              end
+
+              def indented
+                indent!
+                yield
+                dedent!
+              end
+
+              def write(s, indent = @indent)
+                @out << ("  " * indent) << s << "\n"
+              end
+
+              def last_line
+                line_at(-2)
+              end
+
+              def line_at(idx)
+                @out[idx]
+              end
+
+              # Replaces the last line in the buffer.
+              def rewrite_line(new_line_content, idx = -2)
+                return if @out.empty?
+
+                # Preserve the indentation of the line being replaced.
+                @out[idx] = new_line_content
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/analyzer/passes/codegen/ruby_pass.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        module Codegen
+          class RubyPass < PassBase
+            LIR = Kumi::Core::LIR
+
+            def run(_errors)
+              decls = get_state(:lir_module)
+              manifest = get_state(:binding_manifest)[:ruby]
+              schema_digest = get_state(:schema_digest)
+              hints = get_state(:hints)
+              # The codegen pass no longer needs direct access to the registry
+              emitter = Codegen::Ruby::Emitter.new(manifest["kernels"], manifest["bindings"])
+
+              decls = decls.reject { |n, v| hints[n][:inline] }
+              src = emitter.emit(decls, schema_digest:)
+
+              files = { "codegen.rb" => src }
+              state.with(:ruby_codegen_files, files)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/analyzer/passes/constant_folding_pass.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        class ConstantFoldingPass < PassBase
+          NAST = Kumi::Core::NAST
+
+          def run(errors)
+            nast_module = get_state(:nast_module, required: true)
+            order = get_state(:evaluation_order, required: true)
+            @registry = get_state(:registry, required: true)
+
+            debug "\n[FOLD] Starting constant folding pass..."
+
+            folder = Folder.new(self, nast_module, order, @registry)
+            optimized_module, changed = folder.fold
+
+            if changed
+              debug "[FOLD] Pass made changes."
+            else
+              debug "[FOLD] Pass made no changes. Nothing to do."
+            end
+
+            # Always update the state, as the pass returns a new module object.
+            state.with(:nast_module, optimized_module)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/analyzer/passes/contract_checker_pass.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        class ContractCheckerPass < PassBase
+          # In:  state[:snast_module], state[:input_table]
+          # Out: validates contracts and reports errors
+          def run(errors)
+            snast_module = get_state(:snast_module, required: true)
+            input_table = get_state(:input_table, required: true)
+            evaluation_order = get_state(:evaluation_order, required: true)
+
+            validate_snast_structure(snast_module, errors)
+            validate_input_table(input_table, errors)
+            validate_snast_consistency(snast_module, input_table, errors)
+            validate_evaluation_order_consistency(snast_module, evaluation_order, errors)
+            validate_snast_metadata_requirements(snast_module, errors)
+
+            state
+          end
+
+          private
+
+          def validate_snast_structure(snast_module, errors)
+            unless snast_module.respond_to?(:decls)
+              errors << "SNAST module missing declarations"
+              return
+            end
+
+            unless snast_module.decls.is_a?(Hash)
+              errors << "SNAST module declarations must be a Hash"
+              return
+            end
+
+            errors << "SNAST module must have at least one declaration" if snast_module.decls.empty?
+
+            snast_module.decls.each do |name, decl|
+              validate_snast_declaration(name, decl, errors)
+            end
+          end
+
+          def validate_snast_declaration(name, decl, errors)
+            errors << "SNAST declaration #{name} missing body" unless decl.respond_to?(:body)
+
+            validate_snast_node(name, decl.body, errors) if decl.respond_to?(:body)
+          end
+
+          def validate_snast_node(decl_name, node, errors)
+            return unless node
+
+            case node
+            when Kumi::Core::NAST::Const
+              # Constants are always valid
+            when Kumi::Core::NAST::InputRef
+              validate_input_ref(decl_name, node, errors)
+            when Kumi::Core::NAST::Ref
+              validate_declaration_ref(decl_name, node, errors)
+            when Kumi::Core::NAST::Tuple
+              validate_tuple_literal(decl_name, node, errors)
+            when Kumi::Core::NAST::Call
+              validate_call_node(decl_name, node, errors)
+            else
+              errors << "Declaration #{decl_name} contains unknown SNAST node type: #{node.class}"
+            end
+          end
+
+          def validate_input_ref(decl_name, node, errors)
+            unless node.respond_to?(:path)
+              errors << "Declaration #{decl_name} InputRef missing path"
+              return
+            end
+
+            errors << "Declaration #{decl_name} InputRef path must be Array" unless node.path.is_a?(Array)
+
+            return unless node.path.empty?
+
+            errors << "Declaration #{decl_name} InputRef path cannot be empty"
+          end
+
+          def validate_declaration_ref(decl_name, node, errors)
+            return if node.respond_to?(:name)
+
+            errors << "Declaration #{decl_name} Ref missing name"
+          end
+
+          def validate_tuple_literal(decl_name, node, errors)
+            unless node.respond_to?(:elements)
+              errors << "Declaration #{decl_name} Tuple missing elements"
+              return
+            end
+
+            unless node.elements.is_a?(Array)
+              errors << "Declaration #{decl_name} Tuple elements must be Array"
+              return
+            end
+
+            node.elements.each do |element|
+              validate_snast_node(decl_name, element, errors)
+            end
+          end
+
+          def validate_call_node(decl_name, node, errors)
+            errors << "Declaration #{decl_name} Call missing function name" unless node.respond_to?(:fn)
+
+            unless node.respond_to?(:args)
+              errors << "Declaration #{decl_name} Call missing arguments"
+              return
+            end
+
+            unless node.args.is_a?(Array)
+              errors << "Declaration #{decl_name} Call arguments must be Array"
+              return
+            end
+
+            node.args.each do |arg|
+              validate_snast_node(decl_name, arg, errors)
+            end
+          end
+
+          def validate_input_table(input_table, errors)
+            unless input_table.is_a?(Array)
+              errors << "Input table must be an Array"
+              return
+            end
+
+            input_table.each do |plan|
+              validate_input_table_plans(plan, errors)
+            end
+          end
+
+          def validate_input_table_plans(plan, errors)
+            errors << "Input table path must be Array, got: #{plan.class}" unless plan.is_a?(Kumi::Core::IRV2::InputPlan)
+
+            required_keys = %i[axes dtype]
+            required_keys.each do |key|
+              errors << "Input table entry #{plan.inspect} missing key: #{key}" unless plan.respond_to? key
+            end
+
+            return if plan.axes.is_a? Array
+
+            errors << "Input table entry #{plan.inspect} axis must be Array"
+          end
+
+          def validate_snast_consistency(snast_module, input_table, errors)
+            # Collect all input references from SNAST
+            referenced_paths = collect_input_references(snast_module)
+
+            # Check that all referenced paths exist in input table
+            referenced_paths.each do |path|
+              errors << "SNAST references undefined input path: #{path.inspect}" unless input_table.find do |imp|
+                imp.path_fqn == path.join(".")
+              end
+            end
+          end
+
+          def collect_input_references(snast_module)
+            references = Set.new
+
+            snast_module.decls.each do |_, decl|
+              collect_input_refs_from_node(decl.body, references) if decl.respond_to?(:body)
+            end
+
+            references
+          end
+
+          def collect_input_refs_from_node(node, references)
+            return unless node
+
+            case node
+            when Kumi::Core::NAST::InputRef
+              references.add(node.path) if node.respond_to?(:path)
+            when Kumi::Core::NAST::Tuple
+              node.elements.each { |elem| collect_input_refs_from_node(elem, references) } if node.respond_to?(:elements)
+            when Kumi::Core::NAST::Call
+              node.args.each { |arg| collect_input_refs_from_node(arg, references) } if node.respond_to?(:args)
+            end
+          end
+
+          def validate_evaluation_order_consistency(snast_module, evaluation_order, errors)
+            # Ensure all declarations in evaluation order exist in SNAST module
+            evaluation_order.each do |decl_name|
+              errors << "Declaration #{decl_name} from evaluation order not found in SNAST module" unless snast_module.decls.key?(decl_name)
+            end
+
+            # Ensure all SNAST declarations are included in evaluation order
+            snast_module.decls.keys.each do |decl_name|
+              errors << "Declaration #{decl_name} in SNAST module not found in evaluation order" unless evaluation_order.include?(decl_name)
+            end
+          end
+
+          def validate_snast_metadata_requirements(snast_module, errors)
+            # Validate that all nodes that require plans have them
+            snast_module.decls.each do |decl_name, decl|
+              validate_node_metadata_requirements(decl_name, decl.body, errors) if decl.respond_to?(:body)
+            end
+          end
+
+          def validate_node_metadata_requirements(decl_name, node, errors)
+            return unless node
+
+            case node
+            when Kumi::Core::NAST::Tuple
+              errors << "Declaration #{decl_name} Tuple missing required plan metadata" unless node.meta&.[](:plan)
+              node.elements.each { |elem| validate_node_metadata_requirements(decl_name, elem, errors) } if node.respond_to?(:elements)
+
+            when Kumi::Core::NAST::Call
+              errors << "Declaration #{decl_name} Call #{node.fn} missing required plan metadata" unless node.meta&.[](:plan)
+
+              node.args.each { |arg| validate_node_metadata_requirements(decl_name, arg, errors) } if node.respond_to?(:args)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/analyzer/passes/dependency_resolver.rb

@@ -93,8 +93,7 @@ module Kumi
 
             case node
             when CascadeExpression
-              # Visit condition nodes and result expressions (non-base cases)
-              node.cases[0...-1].each do |when_case|
+              node.cases[0..-1].each do |when_case|
                 if when_case.condition
                   # Visit condition normally
                   visit_with_context(when_case.condition, context, &block)
@@ -105,10 +104,10 @@ module Kumi
               end
 
               # Visit base case with conditional flag
-              if node.cases.last
-                base_context = context.merge(in_cascade_base: true)
-                visit_with_context(node.cases.last.result, base_context, &block)
-              end
+              # if node.cases.last
+              #   base_context = context.merge(in_cascade_base: true)
+              #   visit_with_context(node.cases.last.result, base_context, &block)
+              # end
             when CallExpression
               new_context = context.merge(via: node.fn_name)
               node.children.each { |child| visit_with_context(child, new_context, &block) }

data/lib/kumi/core/analyzer/passes/input_access_planner_pass.rb

@@ -14,13 +14,17 @@ module Kumi
             }
 
             # TODO : Allow by input definition on policies or at least general policy definition
-            plans = Kumi::Core::Compiler::AccessPlanner.plan(input_metadata, options)
+            # plans = Kumi::Core::Compiler::AccessPlanner.plan(input_metadata, options)
+
+            planner = Kumi::Core::Compiler::AccessPlannerV2.plan(input_metadata, options, debug_on: debug_enabled?)
+            plans = planner.plans
+            index_table = planner.index_table
 
             # Quick validation
-            validate_plans!(plans, errors)
+            # validate_plans!(plans, errors)
 
             # Create new state with access plans
-            state.with(:access_plans, plans.freeze)
+            state.with(:input_table, plans.freeze).with(:index_table, index_table.freeze)
           end
 
           private

data/lib/kumi/core/analyzer/passes/input_collector.rb

@@ -4,155 +4,107 @@ module Kumi
   module Core
     module Analyzer
       module Passes
-        # Emits per-node metadata:
-        #   :type, :domain
-        #   :container     => :scalar | :field | :array
-        #   :access_mode   => :field | :element          # how THIS node is read once reached
-        #   :enter_via     => :hash | :array           # how we HOP from parent to THIS node
-        #   :consume_alias => true|false               # inline array hop (alias is not a hash key)
-        #   :children      => { name => node_meta }    # optional
-        #
-        # Invariants:
-        # - Any nested array (child depth ≥ 1) must declare its element (i.e., have children).
-        # - Depth-0 inputs always: enter_via :hash, consume_alias false, access_mode :field.
         class InputCollector < PassBase
-          def run(errors)
-            input_meta = {}
+          Node = Struct.new(:type, :domain, :container, :children, :access_mode, :child_steps, :define_index, keyword_init: true) do
+            def as_json(*)
+              {
+                type: type,
+                domain: domain,
+                container: container,
+                children: children&.transform_values(&:as_json),
+                access_mode: access_mode,
+                child_steps: child_steps,
+                define_index: define_index
+              }
+            end
 
-            schema.inputs.each do |decl|
-              name = decl.name
-              input_meta[name] = collect_field_metadata(decl, errors, depth: 0, name: name)
+            def to_json(*args)
+              as_json.to_json(*args)
             end
+          end
+
+          def run(errors)
+            meta = {}
+            schema.inputs.each { |decl| meta[decl.name] = build_node(decl) }
+
+            # validate shape first (nice error messages with full path)
+            validate_arity!(meta, errors, path: [])
 
-            input_meta.each_value(&:deep_freeze!)
-            state.with(:input_metadata, input_meta.freeze)
+            # then annotate navigation info
+            annotate_children!(meta, errors)
+            state.with(:input_metadata, meta.freeze)
           end
 
           private
 
-          # ---------- builders ----------
-
-          def collect_field_metadata(decl, errors, depth:, name:)
-            children = nil
+          def build_node(decl)
+            container = kind_from_type(decl.type)
+            kids = nil
             if decl.children&.any?
-              children = {}
-              decl.children.each do |child|
-                children[child.name] = collect_field_metadata(child, errors, depth: depth + 1, name: child.name)
-              end
+              kids = {}
+              decl.children.each { |ch| kids[ch.name] = build_node(ch) }
             end
 
-            access_mode = decl.access_mode || :field
-
-            meta = Structs::InputMeta.new(
-              type: decl.type,
-              domain: decl.domain,
-              container: kind_from_type(decl.type),
-              access_mode: access_mode,
-              enter_via: :hash,
-              consume_alias: false,
-              children: children
-            )
-            stamp_edges_from!(meta, errors, parent_depth: depth)
-            validate_access_modes!(meta, errors, parent_depth: depth)
-            meta
+            Node.new(type: decl.type, domain: decl.domain, container: container, children: kids, child_steps: {}, define_index: decl.index)
           end
 
-          # ---------- edge stamping + validation ----------
-          #
-          # Sets child[:enter_via], child[:consume_alias], child[:access_mode] defaults,
-          # and validates nested arrays declare their element.
-          #
-          # Rules:
-          # - Common: any ARRAY child at child-depth ≥ 1 must have children (no bare nested array).
-          # - Parent :object → any child:
-          #     child.enter_via = :hash; child.consume_alias = false; child.access_mode ||= :field
-          # - Parent :array:
-          #     * If exactly one child:
-          #         - child.container ∈ {:scalar, :array} → via :array, consume_alias true, access_mode :element
-          #         - child.container == :field         → via :hash,  consume_alias false, access_mode :field
-          #     * Else (element object): every child → via :hash, consume_alias false, access_mode :field
-          def stamp_edges_from!(parent_meta, errors, parent_depth:)
-            kids = parent_meta.children || {}
-            return if kids.empty?
-
-            # Validate nested arrays anywhere below root
-            kids.each do |kname, child|
-              next unless child.container == :array
-
-              if !child.children || child.children.empty?
-                report_error(errors, "Nested array at :#{kname} must declare its element", location: nil)
-              end
-            end
+          def validate_arity!(meta, errors, path:)
+            meta.each do |name, node|
+              cur_path = (path + [name]).join(".")
 
-            case parent_meta.container
-            when :object, :hash
-              kids.each_value do |child|
-                child.enter_via = :hash
-                child.consume_alias = false
-                child.access_mode ||= :field  # Only set if not explicitly specified
+              if node.container == :array
+                chsz = (node.children || {}).size
+                report_error(errors, "Array at '#{cur_path}' must have exactly one child (declares the element)") unless chsz == 1
+                node.access_mode = :element
               end
 
-            when :array
-              # Array parents MUST explicitly declare their access mode
-              access_mode = parent_meta.access_mode
-              raise "Array must explicitly declare access_mode (:field or :element)" unless access_mode
-
-              case access_mode
-              when :field
-                # Array of objects: all children are fields accessed via hash
-                kids.each_value do |child|
-                  child.enter_via = :hash
-                  child.consume_alias = false
-                  child.access_mode = :field
-                end
-
-              when :element
-                _name, only = kids.first
-                only.enter_via = :array
-                only.consume_alias = true
-                only.access_mode = :element
-
-              else
-                raise "Invalid access_mode :#{access_mode} for array (must be :field or :element)"
-              end
+              validate_arity!(node.children || {}, errors, path: path + [name])
             end
           end
 
-          # Enforce access_mode semantics are only used in valid contexts.
-          def validate_access_modes!(parent_meta, errors, parent_depth:)
-            kids = parent_meta.children || {}
-            return if kids.empty?
-
-            kids.each do |kname, child|
-              mode = child.access_mode
-              next unless mode
+          # Annotate per-child hops (no arity checks here to avoid duplicates)
+          def annotate_children!(meta, _errors, indent: 0)
+            meta.each do |name, node|
+              prefix = "  " * indent
+              debug "#{prefix}[#{name}] (#{node.container})"
+              node.child_steps = {}
+              (node.children || {}).each do |cname, child|
+                steps =
+                  case node.container
+                  when :hash, :object
+                    if child.container == :array
+                      [
+                        { kind: :property_access, key: cname.to_s },
+                        { kind: :array_loop,      axis: cname.to_s }
+                      ]
+                    else
+                      [{ kind: :property_access, key: cname.to_s }]
+                    end
+                  when :array
+                    if child.container == :array
+                      [
+                        { kind: :element_access },
+                        { kind: :array_loop, axis: cname.to_s }
+                      ]
+                    else
+                      [{ kind: :element_access }]
+                    end
+                  else
+                    raise "unknown parent container #{node.container.inspect}"
+                  end
 
-              unless %i[field element].include?(mode)
-                report_error(errors, "Invalid access_mode for :#{kname}: #{mode.inspect}", location: nil)
-                next
+                step_str = steps.map { |s| s[:kind] == :array_loop ? "loop(#{s[:axis]})" : s[:kind].to_s.split("_").first }.join(" → ")
+                debug "#{prefix}  └─ #{cname}: #{step_str}"
+                node.child_steps[cname.to_sym] = steps
               end
 
-              if mode == :element
-                if parent_meta.container == :array
-                  single = (kids.size == 1)
-                  unless single && %i[scalar array].include?(child.container)
-                    report_error(errors, "access_mode :element only valid for single scalar/array element (at :#{kname})", location: nil)
-                  end
-                else
-                  # Only scalar children under non-array parents are invalid with :element mode
-                  # Arrays under hash/object parents can have :element mode (for arrays of scalars)
-                  if child.container == :scalar
-                    report_error(errors, "access_mode :element only valid under array parent (at :#{kname})", location: nil)
-                  end
-                end
-              end
+              annotate_children!(node.children || {}, _errors, indent: indent + 1)
             end
           end
 
           def kind_from_type(t)
             return :array if t == :array
-            return :hash if t == :hash
-            return :object if t == :field
+            return :hash  if t == :hash
 
             :scalar
           end