kumi 0.0.15 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5405d7d0612a81e5154bd1d452fdfc150691b022137fc0ee132c47ede1a58e2e
-  data.tar.gz: '093cf7a6d305c02f92de600b06f62be39f8af90d798a0f93ed3ef59f539ada9b'
+  metadata.gz: 3ffbd312f8f3706fb9accbec91a07cc41af173f0d0fcf2a308c2730e730d08ff
+  data.tar.gz: 75d5d08b1bb6c9d2aaa4bd175cc3be59a7074e631e2093bf33f5d499a4d7ff43
 SHA512:
-  metadata.gz: b3ea711bf465e0c11cc95fabb3809dd632ebbfcc8c36297b161fb1f179fffdda5df1e5c033968e837dd8ed3f983639416de08bd371f30be9f2cefd5543efe1ff
-  data.tar.gz: 0a63fe824fb604639b4efb9cfc2ce24a93429110adc75cfd3edc905c58b3501273ad07a3cf66415eabce4e099c5fd4d202bd2c4064875d7a73e0c2a26f0689cb
+  metadata.gz: 3634f946464d08da52743531023a4edca7a6780f010689109abb478679b4f89e8c249181cfc9e5d484c9f5dfeafa8727d582d95d6bc9798ff0df90fe2c2ae2ca
+  data.tar.gz: dcada1e031b7bc1114297ea9704251bcc4ab009c42a1f7d282fc926f7f59c963812a5850f4b274846d8c267be35b61bbae29d4604e031d74e50da9887159750a

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [0.0.17] – 2025-09-03
+
+### Removed  
+- Reverted experimental function registry v2 implementation
+- Cleaned up unused analyzer passes and simplified unsat detector logic
+
+## [0.0.16] – 2025-08-22
+
+### Performance
+- Input accessor code generation replaces nested lambda chains with compiled Ruby methods
+- Fix cache handling in Runtime - it was being recreated on updates
+- Add early shortcut for Analyzer Passes.
+
 ## [0.0.15] – 2025-08-21
 ### Added
 - (DX) Schema-aware VM profiling with multi-schema performance analysis

data/golden/cascade_logic/schema.kumi

@@ -6,9 +6,11 @@ schema do
   
   trait :x_positive, input.x > 0
   trait :y_positive, input.y > 0
+
+  trait :both_positive, y_positive & x_positive
   
   value :status do
-    on x_positive, y_positive, "both positive"
+    on both_positive, "both positive"
     on x_positive, "x positive"  
     on y_positive, "y positive"
     base "neither positive"

data/lib/kumi/analyzer.rb

@@ -3,6 +3,7 @@
 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
 
     DEFAULT_PASSES = [
       Core::Analyzer::Passes::NameIndexer,                     # 1. Finds all names and checks for duplicates.
@@ -14,15 +15,14 @@ module Kumi
       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::TypeConsistencyChecker,          # 11. Validates declared vs inferred type consistency.
-      Core::Analyzer::Passes::FunctionSignaturePass,           # 12. Resolves NEP-20 signatures for function calls.
-      Core::Analyzer::Passes::TypeChecker,                     # 13. Validates types using inferred information.
-      Core::Analyzer::Passes::InputAccessPlannerPass,          # 14. Plans access strategies for input fields.
-      Core::Analyzer::Passes::ScopeResolutionPass,             # 15. Plans execution scope and lifting needs for declarations.
-      Core::Analyzer::Passes::JoinReducePlanningPass,          # 16. Plans join/reduce operations (Generates IR Structs)
-      Core::Analyzer::Passes::LowerToIRPass,                   # 17. Lowers the schema to IR (Generates IR Structs)
-      Core::Analyzer::Passes::LoadInputCSE,                    # 18. Eliminates redundant load_input operations
-      Core::Analyzer::Passes::IRDependencyPass                 # 19. Extracts IR-level dependencies for VM execution optimization
+      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.
     ].freeze
 
     def self.analyze!(schema, passes: DEFAULT_PASSES, **opts)
@@ -44,6 +44,8 @@ module Kumi
       skipping   = !!resume_at
 
       passes.each_with_index do |pass_class, idx|
+        raise handle_analysis_errors(errors) if (ERROR_THRESHOLD_PASS == pass_class) && !errors.empty?
+
         pass_name = pass_class.name.split("::").last
 
         if skipping

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

@@ -656,87 +656,6 @@ module Kumi
             end
           end
 
-          def extract_dimensional_info_with_context(info, _array_fields, _nested_paths, vectorized_values)
-            case info[:source]
-            when :array_field_access, :nested_array_access
-              # Direct array field access - use the path
-              source = info[:path]&.first
-              dimension = info[:path]
-              [source, dimension]
-            when :vectorized_declaration
-              # Reference to another vectorized declaration - look it up
-              if info[:name] && vectorized_values[info[:name]]
-                vectorized_info = vectorized_values[info[:name]]
-                if vectorized_info[:array_source]
-                  # This declaration references an array field, use that source
-                  [vectorized_info[:array_source], [vectorized_info[:array_source]]]
-                else
-                  # This is a derived vectorized value, try to trace its source
-                  [:vectorized_reference, [:vectorized_reference]]
-                end
-              else
-                [:unknown_declaration, [:unknown_declaration]]
-              end
-            else
-              # Operations and other cases - try to extract from operation args
-              if info[:operation] && info[:vectorized_args]
-                # This is an operation result - trace the vectorized arguments
-                # For now, assume operations inherit the dimension of their first vectorized arg
-                [:operation_result, [:operation_result]]
-              else
-                [:unknown, [:unknown]]
-              end
-            end
-          end
-
-          def extract_dimensional_source(info, _array_fields)
-            case info[:source]
-            when :array_field_access
-              info[:path]&.first
-            when :nested_array_access
-              info[:path]&.first
-            when :vectorized_declaration, :vectorized_value
-              # Try to extract from the vectorized value info if available
-              if info[:name] && info.dig(:info, :path)
-                info[:info][:path].first
-              else
-                :vectorized_reference
-              end
-            else
-              # For operations and other cases, try to infer from vectorized args
-              if info[:vectorized_args]
-                # This is likely an operation - we should look at its arguments
-                :operation_result
-              else
-                :unknown
-              end
-            end
-          end
-
-          def extract_dimensions(info, _array_fields, _nested_paths)
-            case info[:source]
-            when :array_field_access
-              info[:path]
-            when :nested_array_access
-              info[:path]
-            when :vectorized_declaration, :vectorized_value
-              # Try to extract from the vectorized value info if available
-              if info[:name] && info.dig(:info, :path)
-                info[:info][:path]
-              else
-                [:vectorized_reference]
-              end
-            else
-              # For operations, try to infer from the operation context
-              if info[:vectorized_args]
-                # This is likely an operation - we should trace its arguments
-                [:operation_result]
-              else
-                [:unknown]
-              end
-            end
-          end
-
           def extract_nested_paths_from_dimensions(dimension, nested_paths)
             return nil unless dimension.is_a?(Array)
 

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

@@ -7,19 +7,19 @@ module Kumi
         # RESPONSIBILITY: Extract IR-level dependencies for VM execution optimization
         # DEPENDENCIES: :ir_module from LowerToIRPass
         # PRODUCES: :ir_dependencies - Hash mapping declaration names to referenced bindings
-        #           :name_index - Hash mapping stored binding names to producing declarations
+        #           :ir_name_index - Hash mapping stored binding names to producing declarations
         # INTERFACE: new(schema, state).run(errors)
-        # 
+        #
         # NOTE: This pass extracts actual IR-level dependencies by analyzing :ref operations
         # in the generated IR, providing the dependency information needed for optimized VM scheduling.
         class IRDependencyPass < PassBase
           def run(errors)
             ir_module = get_state(:ir_module, required: true)
-            
+
             ir_dependencies = build_ir_dependency_map(ir_module)
-            name_index = build_name_index(ir_module)
-            
-            state.with(:ir_dependencies, ir_dependencies).with(:name_index, name_index)
+            ir_name_index = build_ir_name_index(ir_module)
+
+            state.with(:ir_dependencies, ir_dependencies).with(:ir_name_index, ir_name_index)
           end
 
           private
@@ -27,41 +27,39 @@ module Kumi
           # Build a map of declaration -> [stored_bindings_it_references] from the IR
           def build_ir_dependency_map(ir_module)
             deps_map = {}
-            
+
             ir_module.decls.each do |decl|
               refs = []
               decl.ops.each do |op|
-                if op.tag == :ref
-                  refs << op.attrs[:name]
-                end
+                refs << op.attrs[:name] if op.tag == :ref
               end
               deps_map[decl.name] = refs
             end
-            
+
             deps_map.freeze
           end
 
           # Build name index to map stored binding names to their producing declarations
-          def build_name_index(ir_module)
-            name_index = {}
-            
+          def build_ir_name_index(ir_module)
+            ir_name_index = {}
+
             ir_module.decls.each do |decl|
               # Map the primary declaration name
-              name_index[decl.name] = decl
-              
+              ir_name_index[decl.name] = decl
+
               # Also map any vectorized twin names produced by this declaration
               decl.ops.each do |op|
                 if op.tag == :store
                   stored_name = op.attrs[:name]
-                  name_index[stored_name] = decl
+                  ir_name_index[stored_name] = decl
                 end
               end
             end
-            
-            name_index.freeze
+
+            ir_name_index.freeze
           end
         end
       end
     end
   end
-end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        # PRODUCES: :execution_schedules => { store_name(Symbol) => [Decl, ...] }
+        class IRExecutionSchedulePass < PassBase
+          def run(errors)
+            ir          = get_state(:ir_module, required: true)
+            deps        = get_state(:ir_dependencies, required: true)    # decl_name => [binding_name, ...]
+            name_index  = get_state(:ir_name_index, required: true)      # binding_name => Decl  (← use IR-specific index)
+
+            by_name     = ir.decls.to_h { |d| [d.name, d] }
+            pos         = ir.decls.each_with_index.to_h                  # for deterministic ordering
+
+            closure_cache = {}
+            visiting      = {}
+
+            visit = lambda do |dn|
+              return closure_cache[dn] if closure_cache.key?(dn)
+
+              raise Kumi::Core::Errors::TypeError, "cycle detected in IR at #{dn.inspect}" if visiting[dn]
+
+              visiting[dn] = true
+
+              # Resolve binding refs -> producing decl names
+              preds = Array(deps[dn]).filter_map { |b| name_index[b]&.name }.uniq
+
+              # Deterministic order: earlier IR decls first
+              preds.sort_by! { |n| pos[n] || Float::INFINITY }
+
+              order = []
+              preds.each do |p|
+                next if p == dn # guard against self-deps; treat as error if you prefer
+
+                order.concat(visit.call(p))
+              end
+              order << dn unless order.last == dn
+
+              visiting.delete(dn)
+              closure_cache[dn] = order.uniq.freeze
+            end
+
+            schedules = {}
+
+            ir.decls.each do |decl|
+              target_names = [decl.name] + decl.ops.select { _1.tag == :store }.map { _1.attrs[:name] }
+
+              seq = visit.call(decl.name).map { |dn| by_name.fetch(dn) }.freeze
+
+              target_names.each do |t|
+                if schedules.key?(t) && schedules[t] != seq
+                  raise Kumi::Core::Errors::TypeError,
+                        "duplicate schedule target #{t.inspect} produced by #{schedules[t].last.name} and #{decl.name}"
+                end
+                schedules[t] = seq
+              end
+            end
+
+            state.with(:ir_execution_schedules, schedules.freeze)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -426,9 +426,6 @@ module Kumi
               when Syntax::CallExpression
                 entry = Kumi::Registry.entry(expr.fn_name)
 
-                # Validate signature metadata from FunctionSignaturePass (read-only assertions)
-                validate_signature_metadata(expr, entry)
-
                 # Constant folding optimization: evaluate expressions with all literal arguments
                 if can_constant_fold?(expr, entry)
                   folded_value = constant_fold(expr, entry)
@@ -888,39 +885,6 @@ module Kumi
             expr.args.all? { |arg| arg.is_a?(Syntax::Literal) }
           end
 
-          def validate_signature_metadata(expr, entry)
-            # Get the node index to access signature metadata
-            node_index = get_state(:node_index, required: false)
-            return unless node_index
-
-            node_entry = node_index[expr.object_id]
-            return unless node_entry
-
-            metadata = node_entry[:metadata]
-            return unless metadata
-
-            # Validate that dropped axes make sense for reduction functions
-            if entry&.reducer && metadata[:dropped_axes]
-              dropped_axes = metadata[:dropped_axes]
-              unless dropped_axes.is_a?(Array)
-                raise "Invalid dropped_axes metadata for reducer #{expr.fn_name}: expected Array, got #{dropped_axes.class}"
-              end
-
-              # For reductions, we should have at least one dropped axis (or empty for scalar reductions)
-              puts "  SIGNATURE[#{expr.fn_name}] dropped_axes: #{dropped_axes.inspect}" if ENV["DEBUG_LOWER"]
-            end
-
-            # Validate join_policy is recognized
-            if metadata[:join_policy] && !%i[zip product].include?(metadata[:join_policy])
-              raise "Invalid join_policy for #{expr.fn_name}: #{metadata[:join_policy].inspect}"
-            end
-
-            # Warn about join_policy when no join op exists yet (future integration point)
-            return unless metadata[:join_policy] && ENV["DEBUG_LOWER"]
-
-            puts "  SIGNATURE[#{expr.fn_name}] join_policy: #{metadata[:join_policy]} (join op not yet implemented)"
-          end
-
           def constant_fold(expr, entry)
             literal_values = expr.args.map(&:value)
 

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "pry"
 module Kumi
   module Core
     module Analyzer
@@ -8,54 +7,18 @@ module Kumi
         # RESPONSIBILITY: Compute topological ordering of declarations, blocking all cycles
         # DEPENDENCIES: :dependencies from DependencyResolver, :declarations from NameIndexer
         # PRODUCES: :evaluation_order - Array of declaration names in evaluation order
-        #           :node_index - Hash mapping object_id to node metadata for later passes
         # INTERFACE: new(schema, state).run(errors)
         class Toposorter < PassBase
           def run(errors)
             dependency_graph = get_state(:dependencies, required: false) || {}
             definitions = get_state(:declarations, required: false) || {}
 
-            # Create node index for later passes to use
-            node_index = build_node_index(definitions)
             order = compute_topological_order(dependency_graph, definitions, errors)
-            
-            state.with(:evaluation_order, order).with(:node_index, node_index)
+            state.with(:evaluation_order, order)
           end
 
           private
 
-          def build_node_index(definitions)
-            index = {}
-            
-            # Walk all declarations and their expressions to index every node
-            definitions.each_value do |decl|
-              index_node_recursive(decl, index)
-            end
-            
-            index
-          end
-          
-          def index_node_recursive(node, index)
-            return unless node
-            
-            # Index this node by its object_id
-            index[node.object_id] = {
-              node: node,
-              type: node.class.name.split('::').last,
-              metadata: {}
-            }
-            
-            # Use the same approach as the visitor pattern - recursively index all children
-            if node.respond_to?(:children)
-              node.children.each { |child| index_node_recursive(child, index) }
-            end
-            
-            # Index expression for declaration nodes
-            if node.respond_to?(:expression)
-              index_node_recursive(node.expression, index)
-            end
-          end
-
           def compute_topological_order(graph, definitions, errors)
             temp_marks = Set.new
             perm_marks = Set.new
@@ -96,7 +59,6 @@ module Kumi
             order.freeze
           end
 
-
           def report_unexpected_cycle(temp_marks, current_node, errors)
             cycle_path = temp_marks.to_a.join(" → ") + " → #{current_node}"