kumi 0.0.16 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f51be8774c472629e599ce3edd4ab02551edfd52fea8676e2ee93eed5198800
-  data.tar.gz: 26532cec84e5c59553031dc86d82abff310d2a79c857776e1d793af2b35e00ea
+  metadata.gz: f48b3c1d3dc46f7725b1f138fd4eafd2f1c197ed9bdcc0465a26206ed0b3ec56
+  data.tar.gz: 758a5ed295dda7ab9ca97f8caa888b502c0485abfb80ad13ccf6e0a0c03a716e
 SHA512:
-  metadata.gz: 3ba28da3acbf5cd430902c29e34e5786562e7121f9c3851a2e9db3a04a13fc8b1a5e9729649f3daadb523ea55f2c97a1e4560139b9809aa636eff21e9716abbf
-  data.tar.gz: 6683358d25786a5e15cba975e785b3178ec0ea13f40a3eeb940e72f25886f5004c499f3e80ddded31fdd23f3981cbe5244db1ab0aec1405b3c52acb68c4b1e60
+  metadata.gz: ebdd2e94fe3e3146018fbb4487601b8cbb5c10b1574c3fe7858cc230d8b69f1884d4bab7e8f9f352523754e4a6f1ed39d512659812569248f41584a4c692b341
+  data.tar.gz: 3d588dac5c01a4c6773d43383b3f0ed54ea21c43bf6d8aeefbc933518b74d00cd2b5b3b02cac5ce86cf633d930c4733c8a55d851e770063325b4a94d56f64d15

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [0.0.18] – 2025-09-03
+- Fixed bug missing updated Gemfile.lock
+
+## [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

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

@@ -15,17 +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::IRExecutionSchedulePass # 20. Builds a precomputed execution schedule.
-
+      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)

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/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,52 +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
-            node.children.each { |child| index_node_recursive(child, index) } if node.respond_to?(:children)
-
-            # Index expression for declaration nodes
-            return unless node.respond_to?(:expression)
-
-            index_node_recursive(node.expression, index)
-          end
-
           def compute_topological_order(graph, definitions, errors)
             temp_marks = Set.new
             perm_marks = Set.new

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

@@ -6,7 +6,6 @@ module Kumi
       module Passes
         # RESPONSIBILITY: Detect unsatisfiable constraints and analyze cascade mutual exclusion
         # DEPENDENCIES: :declarations from NameIndexer, :input_metadata from InputCollector
-        # PRODUCES: :cascades - Hash of cascade mutual exclusion analysis results
         # INTERFACE: new(schema, state).run(errors)
         class UnsatDetector < VisitorPass
           include Syntax
@@ -20,142 +19,31 @@ module Kumi
             @definitions = definitions
             @evaluator = ConstantEvaluator.new(definitions)
 
-            # First pass: analyze cascade conditions for mutual exclusion
-            cascades = {}
             each_decl do |decl|
-              cascades[decl.name] = analyze_cascade_mutual_exclusion(decl, definitions) if decl.expression.is_a?(CascadeExpression)
-
-              # Store cascade metadata for later passes
-
-              # Second pass: check for unsatisfiable constraints
               if decl.expression.is_a?(CascadeExpression)
-                # Special handling for cascade expressions
                 check_cascade_expression(decl, definitions, errors)
               elsif decl.expression.is_a?(CallExpression) && decl.expression.fn_name == :or
-                # Check for OR expressions which need special disjunctive handling
                 impossible = check_or_expression(decl.expression, definitions, errors)
                 report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
               else
-                # Normal handling for non-cascade expressions
                 atoms = gather_atoms(decl.expression, definitions, Set.new)
                 next if atoms.empty?
 
-                # DEBUG: Add detailed logging for hierarchical broadcasting debugging
-                if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
-                  puts "DEBUG UNSAT: Checking declaration '#{decl.name}' at #{decl.loc}"
-                  puts "  Expression: #{decl.expression.inspect}"
-                  puts "  Gathered atoms: #{atoms.map(&:inspect)}"
-                  puts "  Input meta: #{@input_meta.keys.inspect}" if @input_meta
-                end
-
-                # Use enhanced solver that can detect cross-variable mathematical constraints
-                if definitions && !definitions.empty?
-                  result = Kumi::Core::ConstraintRelationshipSolver.unsat?(atoms, definitions, input_meta: @input_meta)
-                  if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
-                    puts "  Enhanced solver result: #{result}"
-                  end
-                else
-                  result = Kumi::Core::AtomUnsatSolver.unsat?(atoms)
-                  if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
-                    puts "  Basic solver result: #{result}"
-                  end
-                end
+                result = if definitions && !definitions.empty?
+                           Kumi::Core::ConstraintRelationshipSolver.unsat?(atoms, definitions, input_meta: @input_meta)
+                         else
+                           Kumi::Core::AtomUnsatSolver.unsat?(atoms)
+                         end
                 impossible = result
 
-                if impossible && (ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257"))
-                  puts "  -> FLAGGING AS IMPOSSIBLE: #{decl.name}"
-                end
-
                 report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
               end
             end
-            state.with(:cascades, cascades)
-          end
-
-          private
-
-          def analyze_cascade_mutual_exclusion(decl, definitions)
-            conditions = []
-            condition_traits = []
-
-            # Extract all cascade conditions (except base case)
-            decl.expression.cases[0...-1].each do |when_case|
-              next unless when_case.condition
-
-              next unless when_case.condition.fn_name == :cascade_and
-
-              when_case.condition.args.each do |arg|
-                if arg.is_a?(ArrayExpression)
-                  # Handle array elements (for array broadcasting)
-                  arg.elements.each do |element|
-                    next unless element.is_a?(DeclarationReference)
-
-                    trait_name = element.name
-                    trait = definitions[trait_name]
-                    if trait
-                      conditions << trait.expression
-                      condition_traits << trait_name
-                    end
-                  end
-                elsif arg.is_a?(DeclarationReference)
-                  # Handle direct trait references (simple case)
-                  trait_name = arg.name
-                  trait = definitions[trait_name]
-                  if trait
-                    conditions << trait.expression
-                    condition_traits << trait_name
-                  end
-                end
-              end
-              # end
-            end
-
-            # Check mutual exclusion for all pairs
-            total_pairs = conditions.size * (conditions.size - 1) / 2
-            exclusive_pairs = 0
-
-            if conditions.size >= 2
-              conditions.combination(2).each do |cond1, cond2|
-                exclusive_pairs += 1 if conditions_mutually_exclusive?(cond1, cond2)
-              end
-            end
-
-            all_mutually_exclusive = total_pairs.positive? && (exclusive_pairs == total_pairs)
-
-            {
-              condition_traits: condition_traits,
-              condition_count: conditions.size,
-              all_mutually_exclusive: all_mutually_exclusive,
-              exclusive_pairs: exclusive_pairs,
-              total_pairs: total_pairs
-            }
-          end
-
-          def conditions_mutually_exclusive?(cond1, cond2)
-            if cond1.is_a?(CallExpression) && cond1.fn_name == :== &&
-               cond2.is_a?(CallExpression) && cond2.fn_name == :==
-
-              c1_field, c1_value = cond1.args
-              c2_field, c2_value = cond2.args
-
-              # Same field, different values = mutually exclusive
-              return true if same_field?(c1_field, c2_field) && different_values?(c1_value, c2_value)
-            end
 
-            false
+            state
           end
 
-          def same_field?(field1, field2)
-            return false unless field1.is_a?(InputReference) && field2.is_a?(InputReference)
-
-            field1.name == field2.name
-          end
-
-          def different_values?(val1, val2)
-            return false unless val1.is_a?(Literal) && val2.is_a?(Literal)
-
-            val1.value != val2.value
-          end
+          private
 
           def check_or_expression(or_expr, definitions, _errors)
             # For OR expressions: A | B is impossible only if BOTH A AND B are impossible
@@ -199,23 +87,16 @@ module Kumi
               if current.is_a?(CallExpression) && COMPARATORS.include?(current.fn_name)
                 lhs, rhs = current.args
 
-                # Check for domain constraint violations before creating atom
                 list << if impossible_constraint?(lhs, rhs, current.fn_name)
-                          # Create a special impossible atom that will always trigger unsat
                           Atom.new(:==, :__impossible__, true)
                         else
                           Atom.new(current.fn_name, term(lhs, defs), term(rhs, defs))
                         end
               elsif current.is_a?(CallExpression) && current.fn_name == :or
-                # Special handling for OR expressions - they are disjunctive, not conjunctive
-                # We should NOT add OR children to the stack as they would be treated as AND
-                # OR expressions need separate analysis in the main run() method
                 next
               elsif current.is_a?(CallExpression) && current.fn_name == :cascade_and
-                # cascade_and takes individual arguments (not wrapped in array)
                 current.args.each { |arg| stack << arg }
               elsif current.is_a?(ArrayExpression)
-                # For ArrayExpression, add all elements to the stack
                 current.elements.each { |elem| stack << elem }
               elsif current.is_a?(DeclarationReference)
                 name = current.name
@@ -225,10 +106,6 @@ module Kumi
                 end
               end
 
-              # Add children to stack for processing
-              # IMPORTANT: Skip CascadeExpression children to avoid false positives
-              # Cascades are handled separately by check_cascade_expression() and are disjunctive,
-              # but gather_atoms() treats all collected atoms as conjunctive
               current.children.each { |child| stack << child } if current.respond_to?(:children) && !current.is_a?(CascadeExpression)
             end
 
@@ -247,32 +124,24 @@ module Kumi
             end
 
             decl.expression.cases.each_with_index do |when_case, index|
-              # DEBUG: Log each case
               if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
                 puts "  Case #{index}: condition=#{when_case.condition.inspect}"
               end
 
-              # Skip the base case (it's typically a literal true condition)
               next if when_case.condition.is_a?(Literal) && when_case.condition.value == true
 
-              # Skip non-conjunctive conditions (any?, none?) as they are disjunctive
               next if when_case.condition.is_a?(CallExpression) && %i[any? none?].include?(when_case.condition.fn_name)
 
-              # Skip single-trait 'on' branches: trait-level unsat detection covers these
               if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :cascade_and && (when_case.condition.args.size == 1)
-                # cascade_and uses individual arguments - skip if only one trait
                 next
               end
 
-              # Gather atoms from this individual condition only
               condition_atoms = gather_atoms(when_case.condition, definitions, Set.new, [])
 
-              # DEBUG: Add detailed logging for hierarchical broadcasting debugging
               if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
                 puts "    Condition atoms: #{condition_atoms.map(&:inspect)}"
               end
 
-              # Use enhanced solver for cascade conditions too
               if definitions && !definitions.empty?
                 result = Kumi::Core::ConstraintRelationshipSolver.unsat?(condition_atoms, definitions, input_meta: @input_meta)
                 if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
@@ -287,9 +156,7 @@ module Kumi
               impossible = result
               next unless !condition_atoms.empty? && impossible
 
-              # For multi-trait on-clauses, report the trait names rather than the value name
               if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :cascade_and
-                # cascade_and uses individual arguments
                 trait_bindings = when_case.condition.args
 
                 if trait_bindings.all?(DeclarationReference)
@@ -314,9 +181,6 @@ module Kumi
               val = @evaluator.evaluate(node)
               val == :unknown ? node.name : val
             when InputElementReference
-              # For hierarchical paths like input.companies.regions.offices.teams.department,
-              # create a unique identifier that represents the specific path
-              # This prevents false positives where different paths are treated as the same :unknown
               path_identifier = node.path.join(".").to_s
               path_identifier.to_sym
             when Literal
@@ -326,51 +190,10 @@ module Kumi
             end
           end
 
-          def check_domain_constraints(node, definitions, errors)
-            case node
-            when InputReference
-              # Check if InputReference points to a field with domain constraints
-              field_meta = @input_meta[node.name]
-              nil unless field_meta&.dig(:domain)
-
-              # For InputReference, the constraint comes from trait conditions
-              # We don't flag here since the InputReference itself is valid
-            when DeclarationReference
-              # Check if this binding evaluates to a value that violates domain constraints
-              definition = definitions[node.name]
-              return unless definition
-
-              if definition.expression.is_a?(Literal)
-                literal_value = definition.expression.value
-                check_value_against_domains(node.name, literal_value, errors, definition.loc)
-              end
-            end
-          end
-
-          def check_value_against_domains(_var_name, value, _errors, _location)
-            # Check if this value violates any input domain constraints
-            @input_meta.each_value do |field_meta|
-              domain = field_meta[:domain]
-              next unless domain
-
-              if violates_domain?(value, domain)
-                # This indicates a constraint that can never be satisfied
-                # Rather than flagging the cascade, flag the impossible condition
-                return true
-              end
-            end
-            false
-          end
-
           def violates_domain?(value, domain)
             case domain
-            when Range
-              !domain.include?(value)
-            when Array
+            when Range, Array
               !domain.include?(value)
-            when Proc
-              # For Proc domains, we can't statically analyze
-              false
             else
               false
             end
@@ -381,7 +204,6 @@ module Kumi
             if lhs.is_a?(InputReference) && rhs.is_a?(Literal)
               return field_literal_impossible?(lhs, rhs, operator)
             elsif rhs.is_a?(InputReference) && lhs.is_a?(Literal)
-              # Reverse case: literal compared to field
               return field_literal_impossible?(rhs, lhs, flip_operator(operator))
             end
 
@@ -404,13 +226,10 @@ module Kumi
 
             case operator
             when :==
-              # field == value where value is not in domain
               violates_domain?(literal_value, domain)
             when :!=
-              # field != value where value is not in domain is always true (not impossible)
               false
             else
-              # For other operators, we'd need more sophisticated analysis
               false
             end
           end
@@ -424,10 +243,8 @@ module Kumi
 
             case operator
             when :==
-              # binding == value where binding evaluates to different value
               evaluated_value != literal_value
             else
-              # For other operators, we could add more sophisticated checking
               false
             end
           end

data/lib/kumi/core/compiler/access_builder.rb

@@ -3,17 +3,14 @@ module Kumi
     module Compiler
       class AccessBuilder
         class << self
-          attr_accessor :strategy
+          attr_accessor :yjit
         end
+        self.yjit = defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?
 
-        self.strategy = if defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?
-                          :interp
-                        else
-                          :codegen
-                        end
-
-        def self.build(plans)
+        def self.build(plans, strategy: nil)
+          strategy ||= yjit ? :interp : :codegen
           accessors = {}
+
           plans.each_value do |variants|
             variants.each do |plan|
               accessors[plan.accessor_key] =

data/lib/kumi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kumi
-  VERSION = "0.0.16"
+  VERSION = "0.0.18"
 end