kumi 0.0.18 → 0.0.19

data/lib/kumi/core/analyzer/passes/codegen/js/emitter.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        module Codegen
+          module Js
+            class Emitter
+              KernelInfo = Struct.new(:id, :fn_id, :impl, :attrs, keyword_init: true)
+              BindsInfo = Struct.new(:op_result_reg, :fn_id, keyword_init: true)
+
+              def initialize(kernels_data, binds_data)
+                @kernels = kernels_data.map { |k| KernelInfo.new(**k.slice("id", "fn_id", "impl", "attrs").transform_keys(&:to_sym)) }
+                                       .to_h { |k| [k.fn_id, k] }
+
+                @binds = binds_data.map { |b| BindsInfo.new(**b.slice("op_result_reg", "fn_id").transform_keys(&:to_sym)) }
+                                   .to_h { |b| [b.op_result_reg, b] }
+                @buffer = OutputBuffer.new
+              end
+
+              def emit(declarations, schema_digest:)
+                @buffer.reset!
+                # @buffer.emit_header(schema_digest)
+                # @buffer.emit_class_methods(declarations.keys)
+                emit_private_helpers
+                # @buffer.emit_footer
+
+                declarations.each do |name, payload|
+                  emit_declaration(name, Array(payload[:operations]))
+                end
+
+                @buffer.to_s
+              end
+
+              private
+
+              def emit_declaration(name, ops)
+                DeclarationEmitter.new(@buffer, @binds, @kernels).emit(name, ops)
+              end
+
+              def emit_private_helpers
+                kernels_to_write = @kernels.values.reject do |k|
+                  (k.attrs["js_inline"] || k.attrs["inline"]) || k.impl.nil? || k.impl.strip.empty?
+                end.sort_by(&:id)
+
+                return if kernels_to_write.empty?
+
+                @buffer.section("PRIVATE HELPERS") do
+                  kernels_to_write.each do |kernel|
+                    fn_name = kernel_method_name(kernel.fn_id)
+
+                    # Assuming the impl is Ruby-like, extract args and body
+                    impl_lines = kernel.impl.strip.split("\n", 2)
+                    args = impl_lines.first.gsub(/[()]/, "").strip
+                    body = impl_lines[1..].join("\n").strip
+
+                    @buffer.write "#{fn_name}(#{args}) {"
+                    @buffer.indented do
+                      # The body is assumed to be valid JS.
+                      @buffer.write body, @buffer.instance_variable_get(:@indent)
+                    end
+                    @buffer.write "}\n"
+                  end
+                end
+              end
+
+              def kernel_method_name(fn_id) = "__#{fn_id.tr('.', '_')}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        module Codegen
+          module Js
+            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 if @indent.positive?
+              end
+
+              def emit_header(schema_digest)
+                write "// Autogenerated by Kumi Codegen for schema #{schema_digest}"
+                write "export class KumiCompiledModule {"
+                indent!
+              end
+
+              def emit_footer
+                dedent!
+                write "}"
+              end
+
+              def emit_class_methods(decl_names)
+                write "constructor(inputData = {}) {"
+                indented { write "this.input = inputData;" }
+                write "}\n"
+
+                write "static from(inputData = {}) {"
+                indented { write "return new KumiCompiledModule(inputData);" }
+                write "}\n"
+
+                write "update(inputData) {"
+                indented do
+                  write "this.input = { ...this.input, ...inputData };"
+                  write "return this;"
+                end
+                write "}\n"
+
+                return if decl_names.empty?
+
+                write "get(name) {"
+                indented do
+                  write "switch (name) {"
+                  decl_names.each { |name| write "  case '#{name}': return _$#{name}(this.input);" }
+                  write "  default: throw new Error(`Unknown declaration: ${name}`);"
+                  write "}"
+                end
+                write "}\n"
+              end
+
+              def section(name)
+                write ""
+                write "// --- #{name} ---"
+                yield
+                write "// --- END #{name} ---"
+                write ""
+              end
+
+              def indented
+                indent!
+                yield
+                dedent!
+              end
+
+              def write(s, indent = @indent)
+                @out << ("  " * indent) << s << "\n"
+              end
+
+              def last_line
+                # In our array, the last item is the full line with newline
+                @out.last
+              end
+
+              def rewrite_line(new_line_content)
+                return if @out.empty?
+
+                # Preserve the indentation of the line being replaced.
+                current_indent_str = @out.last.match(/^\s*/)[0]
+                @out[-1] = "#{current_indent_str}#{new_line_content}\n"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        module Codegen
+          class JsPass < PassBase
+            def run(_errors)
+              decls = get_state(:lir_module)
+              manifest = get_state(:binding_manifest)[:javascript]
+              schema_digest = get_state(:schema_digest)
+              hints = get_state(:hints)
+
+              decls = decls.reject { |n, v| hints[n][:inline] }
+              emitter = Codegen::Js::Emitter.new(manifest["kernels"], manifest["bindings"])
+              src = emitter.emit(decls, schema_digest: schema_digest)
+
+              files = { "codegen.mjs" => src }
+              state.with(:javascript_codegen_files, files)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        module Codegen
+          module Ruby
+            class DeclarationEmitter
+              extend Forwardable
+
+              def_delegators :@buffer, :write, :indent!, :dedent!, :last_line, :rewrite_line, :line_at
+
+              LIR = Kumi::Core::LIR
+              def initialize(buffer, binds, kernels)
+                @buffer = buffer
+                @binds = binds
+                @kernels = kernels
+                @stack = []
+                @out_containers = []
+              end
+
+              def emit(name, ops)
+                @ops = ops
+                # Pre-calculate the depth of the single Yield instruction.
+                @yield_depth = find_yield_depth(ops)
+
+                write "def _#{name}(input = @input)"
+                indent!
+
+                # Setup the top-level 'out' container if the result is an array.
+                write "out = []" if @yield_depth.positive?
+                @out_containers = ["out"]
+
+                # Simple, robust iteration.
+                @ops.each_with_index { |ins, i| emit_ins(ins, i) }
+
+                # Determine the final return value.
+                if @ops.any? { _1.opcode == :Yield } && @yield_depth.zero?
+                  # Scalar result is handled by emit_yield's optimization.
+                else
+                  write "out"
+                end
+
+                dedent!
+                write "end\n"
+              end
+
+              private
+
+              def emit_ins(ins, i)
+                # Pass index `i` to loop handlers, others don't need it.
+                if ins.opcode == :LoopStart
+                  emit_loopstart(ins, i)
+                elsif ins.opcode == :LoopEnd
+                  emit_loopend(ins, i)
+                elsif ins.opcode == :Yield
+                  emit_yield(ins, i)
+                else
+                  # Dynamically call other emit_* methods without the index.
+                  send("emit_#{ins.opcode.to_s.downcase}", ins, i)
+                end
+              end
+
+              # --- SIMPLIFIED AND CORRECTED LOOP LOGIC ---
+
+              def emit_loopstart(ins, i)
+                coll = areg(ins.inputs.first)
+                el = to_local(ins.attributes[:as_element])
+                ix = to_local(ins.attributes[:as_index])
+
+                write "#{coll}.each_with_index do |#{el}, #{ix}|"
+                indent!
+
+                @stack.push({ el: el, ix: ix })
+
+                # A loop needs a new sub-container if it contains a yield AND
+                # its depth is less than the final yield's depth.
+                return unless loop_contain_yield?(i) && @stack.length < @yield_depth
+
+                container = "out_#{@stack.length}"
+                @out_containers.push(container)
+                write "#{container} = []"
+              end
+
+              def emit_loopend(ins, i)
+                is_yield_container_loop = @stack.length < @yield_depth && loop_contain_yield?(find_loop_start_for_end(i))
+
+                if is_yield_container_loop
+                  child = @out_containers.pop
+                  parent = @out_containers.last
+                  write "#{parent} << #{child}"
+                end
+
+                @stack.pop
+                dedent!
+                write "end"
+              end
+
+              def emit_yield(ins, i)
+                v = operands_for(ins)
+
+                # Find the loop depth at the yield site.
+                current_depth = 0
+                @ops[0...i].each do |op|
+                  current_depth += 1 if op.opcode == :LoopStart
+                  current_depth -= 1 if op.opcode == :LoopEnd
+                end
+
+                if current_depth.zero?
+                  if last_line.match?(/^#{v.first} = /)
+                    new_end = last_line.sub("#{v.first} = ", "")
+                    rewrite_line(new_end)
+                  else
+                    write v.first.to_s
+                  end
+                else
+                  write "#{@out_containers.last} << #{v.first}"
+                end
+              end
+
+              # ... other emit_* methods need to accept the index `i` ...
+              # (The content of most of them doesn't change)
+              def emit_kernelcall(ins, _i)
+                kernel = kernel_for(ins.result_register)
+                args = operands_for(ins)
+
+                if (template = kernel[:attrs]["inline"])
+                  inlined_code = _inline_kernel(template, args)
+                  if template.start_with?("=") || template.include?("$0")
+                    write "#{vreg(ins)} #{inlined_code}"
+                  else
+                    # For +=, -= etc.
+                    write "#{vreg(ins)} #{inlined_code}".lstrip
+                  end
+                else
+                  fn_name = kernel_method_name(kernel[:fn_id])
+                  write "#{vreg(ins)} = #{fn_name}(#{args.join(', ')})"
+                end
+              end
+
+              def emit_fold(ins, _i)
+                kernel = kernel_for(ins.result_register)
+                args = operands_for(ins)
+
+                if (template = kernel[:attrs]["fold_inline"])
+                  inlined_code = _inline_kernel(template, args)
+                  write "#{vreg(ins)} #{inlined_code}"
+                else
+                  raise "Can't fold - no template defined"
+                end
+              end
+
+              def emit_accumulate(ins, _i)
+                kernel = kernel_for(ins.result_register)
+                args = [vreg(ins), operands_for(ins).first]
+
+                write "#{args[0]} ||= #{args[1]}" if kernel[:attrs]["first_element"]
+
+                if (template = kernel[:attrs]["inline"])
+                  inlined_code = _inline_kernel(template, args)
+                  if template.include?("$0")
+                    write "#{args[0]} #{inlined_code}"
+                  else
+                    write "#{args[0]} #{inlined_code}"
+                  end
+                else
+                  fn_name = kernel_method_name(kernel[:fn_id])
+                  write "#{args[0]} = #{fn_name}(#{args.join(', ')})"
+                end
+              end
+
+              def emit_constant(ins, _i)
+                write "#{vreg(ins)} = #{lit(ins.immediates.first)}"
+              end
+
+              def emit_loadinput(ins, _i)
+                key = imm_key(ins)
+                write "#{vreg(ins)} = input[#{key.inspect}] || input[:#{key}]"
+              end
+
+              def emit_loadfield(ins, _i)
+                obj = areg(ins.inputs.first)
+                key = imm_key(ins)
+                write "#{vreg(ins)} = #{obj}[#{key.inspect}] || #{obj}[:#{key}]"
+              end
+
+              def emit_select(ins, _i)
+                c, t, f = operands_for(ins)
+                write "#{vreg(ins)} = #{c} ? #{t} : #{f}"
+              end
+
+              def emit_declareaccumulator(ins, _i)
+                kernel = kernel_for(ins.result_register)
+                # Handling cases where identity might be a hash {integer: 0} or just 0
+                identity_attrs = kernel[:attrs]["identity"]
+                identity = identity_attrs.is_a?(Hash) ? identity_attrs["integer"] || identity_attrs["any"] : identity_attrs
+                write "#{vreg(ins)} = #{identity.inspect}"
+              end
+
+              def emit_loadaccumulator(ins, _i)
+                acc_reg = ins.inputs.first or raise "No accumulator bound"
+                write "#{vreg(ins)} = #{acc_reg}"
+              end
+
+              def emit_loaddeclaration(ins, _i)
+                write "#{vreg(ins)} = _#{ins.immediates.first.value}(input)"
+              end
+
+              def emit_maketuple(ins, _i)
+                elements = operands_for(ins).join(", ")
+                write "#{vreg(ins)} = [#{elements}]"
+              end
+
+              def emit_makeobject(ins, _i)
+                values, keys = operands_for(ins, split: true)
+                write "#{vreg(ins)} = {"
+                indent!
+                last = keys.size - 1
+                keys.each_with_index do |key, idx|
+                  postfix = last == idx ? "" : ","
+                  write "#{key} => #{values[idx]}#{postfix}"
+                end
+                dedent!
+                write "}"
+              end
+
+              def emit_length(ins, _i)
+                arr = ins.inputs[0]
+                write "#{vreg(ins)} = #{arr}.length"
+              end
+
+              def emit_gather(ins, _i)
+                arr = ins.inputs[0]
+                idx = ins.inputs[1]
+                write "#{vreg(ins)} = #{arr}[#{idx}]"
+              end
+
+              def find_matching_loop_end(start_index)
+                depth = 1; (start_index + 1...@ops.length).each do |i|
+                  op = @ops[i].opcode
+                  depth += 1 if op == :LoopStart
+                  depth -= 1 if op == :LoopEnd
+                  return i if depth.zero?
+                end
+                raise "Unbalanced LoopStart at index #{start_index}"
+              end
+
+              def find_loop_start_for_end(end_index)
+                depth = 1; (end_index - 1).downto(0) do |i|
+                  op = @ops[i].opcode
+                  depth += 1 if op == :LoopEnd
+                  depth -= 1 if op == :LoopStart
+                  return i if depth.zero?
+                end
+                raise "Unbalanced LoopEnd at index #{end_index}"
+              end
+
+              def loop_contain_yield?(loop_start_index)
+                end_index = find_matching_loop_end(loop_start_index)
+                @ops[(loop_start_index + 1)...end_index].any? { |ins| ins.opcode == :Yield }
+              end
+
+              def find_yield_depth(ops)
+                yield_op_index = ops.index { _1.opcode == :Yield }
+                return 0 unless yield_op_index
+
+                depth = 0
+                ops[0...yield_op_index].each do |op|
+                  depth += 1 if op.opcode == :LoopStart
+                  depth -= 1 if op.opcode == :LoopEnd
+                end
+                depth
+              end
+
+              # --- Unchanged helpers ---
+              def operands_for(ins, split: false)
+                immediates = Array(ins.immediates).map { |imm| lit(imm) }
+                inputs = Array(ins.inputs).map do |input|
+                  if input == :__immediate_placeholder__
+                    immediates.shift
+                  else
+                    areg(input)
+                  end
+                end
+
+                return [inputs, immediates] if split
+
+                inputs + immediates
+              end
+
+              def lit(l)
+                v = l.value
+                v.is_a?(Symbol) ? v.inspect : v.inspect
+              end
+
+              def imm_key(ins) = ins.immediates&.first&.value
+              def to_local(sym) = sym.to_s.delete("%")
+              def areg(r) = r.nil? ? "nil" : to_local(r)
+              def vreg(ins) = to_local(ins.result_register)
+              def kernel_method_name(fn_id) = "__#{fn_id.tr('.', '_')}"
+
+              def kernel_for(reg)
+                bind = @binds.fetch(reg)
+                @kernels[bind.fn_id]
+              end
+
+              def _inline_kernel(template, args)
+                inlined = template.dup
+                args.each_with_index { |arg, i| inlined.gsub!("$#{i}", arg.to_s) }
+                inlined
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        module Codegen
+          module Ruby
+            # Emitter is responsible for turning the final LIR into a Ruby source code string.
+            class Emitter
+              KernelInfo = Struct.new(:id, :fn_id, :impl, :attrs, keyword_init: true)
+              BindsInfo = Struct.new(:op_result_reg, :fn_id, keyword_init: true)
+
+              def initialize(kernels_data, binds_data)
+                @all_kernels_inlined = true
+                @kernels = kernels_data.map { |k| KernelInfo.new(**k.slice("id", "fn_id", "impl", "attrs").transform_keys(&:to_sym)) }
+                                       .to_h { |k| [k.fn_id, k] }
+
+                @binds = binds_data.map { |b| BindsInfo.new(**b.slice("op_result_reg", "fn_id").transform_keys(&:to_sym)) }
+                                   .to_h { |b| [b.op_result_reg, b] }
+                @buffer = OutputBuffer.new
+              end
+
+              def emit(declarations, schema_digest:)
+                @buffer.reset!
+                @buffer.emit_header(schema_digest)
+                @buffer.emit_class_methods(declarations.keys)
+
+                declarations.each do |name, payload|
+                  emit_declaration(name, Array(payload[:operations]))
+                end
+
+                emit_private_helpers
+                @buffer.emit_footer
+                @buffer.to_s
+              end
+
+              private
+
+              def emit_declaration(name, ops)
+                DeclarationEmitter.new(@buffer, @binds, @kernels).emit(name, ops)
+              end
+
+              def emit_private_helpers
+                all_kernels_inlined = true
+                to_write = []
+                sorted_kernels = @kernels.values.sort_by(&:id)
+                sorted_kernels.each do |kernel|
+                  # --- ADD THIS CHECK ---
+                  # If the kernel has an inline template, we don't need a separate method for it.
+                  next if kernel.attrs["inline"]
+
+                  fn_name = kernel_method_name(kernel.fn_id)
+                  @all_kernels_inlined = false
+                  # The `impl` might be nil or empty for inline-only kernels, so protect against that.
+                  next unless kernel.impl && !kernel.impl.strip.empty?
+
+                  impl_lines = kernel.impl.strip.split("\n", 2)
+                  args = impl_lines.first.gsub(/[()]/, "").strip
+                  body = impl_lines[1..].join("\n").strip
+
+                  to_write << ["def #{fn_name}(#{args})", 1]
+                  to_write << [body, 2]
+                  to_write << ["end\n", 1]
+                end
+
+                return if all_kernels_inlined
+
+                @buffer.section("private") do
+                  to_write.each_value do |text, ident|
+                    @buffer.write text, ident
+                  end
+                end
+              end
+
+              def kernel_method_name(fn_id)
+                "__#{fn_id.tr('.', '_')}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end