ibex-runtime 0.2.0

data/sig/ibex/runtime/parser_sync_recovery.rbs

@@ -0,0 +1,60 @@
+# Generated from lib/ibex/runtime/parser_sync_recovery.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # Panic-mode synchronization used only when yacc's explicit `error` token
+    # cannot be shifted. Included by Parser to share its table and event paths.
+    module ParserSyncRecovery
+      ERROR_ACTION: [ :error ]
+
+      private def parser_tables: () -> Hash[Symbol, untyped]
+
+      private def table_lookup: (untyped, Integer, Integer) -> untyped
+
+      private def default_action: (Integer) -> untyped
+
+      private def token_to_str: (untyped) -> String
+
+      private def trace: (String) -> void
+
+      private def continue_recovery: () -> untyped
+
+      private def reject_recovery_eof: () -> [ :done, nil ]
+
+      private def finish_recovery: (untyped, untyped, untyped, untyped, Integer, Array[untyped], Hash[String, untyped]?, String, Array[Proc]?) -> [ :continue ]
+
+      private
+
+      # @rbs () -> bool
+      def sync_recovery_configured?: () -> bool
+
+      # @rbs () -> bool
+      def sync_recovery_active?: () -> bool
+
+      # @rbs (Hash[Symbol, untyped] context, Hash[String, untyped]? token_data,
+      #   Array[Proc]? observers) -> untyped
+      def begin_sync_recovery: (Hash[Symbol, untyped] context, Hash[String, untyped]? token_data, Array[Proc]? observers) -> untyped
+
+      # @rbs () -> untyped
+      def continue_sync_recovery: () -> untyped
+
+      # @rbs (untyped token_id) -> bool
+      def sync_token?: (untyped token_id) -> bool
+
+      # @rbs () -> bool
+      def synchronize_for_current_token: () -> bool
+
+      # @rbs (Integer state, Integer token_id) -> untyped
+      def sync_action: (Integer state, Integer token_id) -> untyped
+
+      # @rbs () -> [:continue]
+      def finish_sync_recovery: () -> [ :continue ]
+
+      # @rbs () -> [:done, nil]
+      def reject_sync_recovery_eof: () -> [ :done, nil ]
+
+      # @rbs () -> void
+      def clear_sync_recovery: () -> void
+    end
+  end
+end

data/sig/ibex/runtime/repair.rbs

@@ -0,0 +1,92 @@
+# Generated from lib/ibex/runtime/repair.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # Explicit bounded cost and search policy for automatic token repair.
+    class RepairPolicy
+      attr_reader insert_cost: Integer
+
+      attr_reader delete_cost: Integer
+
+      attr_reader replace_cost: Integer
+
+      attr_reader max_cost: Integer
+
+      attr_reader max_configurations: Integer
+
+      attr_reader max_lookahead: Integer
+
+      attr_reader success_shifts: Integer
+
+      attr_reader max_stack: Integer
+
+      # @rbs (?insert_cost: Integer, ?delete_cost: Integer, ?replace_cost: Integer, ?max_cost: Integer,
+      #   ?max_configurations: Integer, ?max_lookahead: Integer, ?success_shifts: Integer,
+      #   ?max_stack: Integer) -> void
+      def initialize: (?insert_cost: Integer, ?delete_cost: Integer, ?replace_cost: Integer, ?max_cost: Integer, ?max_configurations: Integer, ?max_lookahead: Integer, ?success_shifts: Integer, ?max_stack: Integer) -> void
+    end
+
+    # One immutable insertion, deletion, or replacement.
+    class RepairEdit
+      KINDS: Array[Symbol]
+
+      attr_reader kind: Symbol
+
+      attr_reader position: Integer
+
+      attr_reader token_id: Integer
+
+      attr_reader token_name: String
+
+      attr_reader cost: Integer
+
+      # @rbs (kind: Symbol, position: Integer, token_id: Integer, token_name: String, cost: Integer) -> void
+      def initialize: (kind: Symbol, position: Integer, token_id: Integer, token_name: String, cost: Integer) -> void
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+
+    # Deterministically selected repair.
+    class RepairPlan
+      attr_reader edits: Array[RepairEdit]
+
+      attr_reader cost: Integer
+
+      attr_reader configurations: Integer
+
+      # @rbs (edits: Array[RepairEdit], configurations: Integer) -> void
+      def initialize: (edits: Array[RepairEdit], configurations: Integer) -> void
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+
+    # Internal normalized input record retained while repair looks ahead.
+    class RepairInput
+      attr_reader token_id: Integer
+
+      attr_reader token_name: String
+
+      attr_reader value: untyped
+
+      attr_reader location: untyped
+
+      # @rbs (token_id: Integer, token_name: String, value: untyped, location: untyped) -> void
+      def initialize: (token_id: Integer, token_name: String, value: untyped, location: untyped) -> void
+
+      # @rbs () -> bool
+      def eof?: () -> bool
+    end
+
+    # Internal result of simulating reductions followed by one table action.
+    class RepairAdvance
+      attr_reader status: :shift | :accept
+
+      attr_reader stack: Array[Integer]
+
+      # @rbs (status: :shift | :accept, stack: Array[Integer]) -> void
+      def initialize: (status: :shift | :accept, stack: Array[Integer]) -> void
+    end
+  end
+end

data/sig/ibex/runtime/repair_priority_queue.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/ibex/runtime/repair_priority_queue.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # Minimal binary heap ordered by an immutable Array priority.
+    class RepairPriorityQueue
+      @entries: Array[[ Array[untyped], untyped ]]
+
+      # @rbs () -> void
+      def initialize: () -> void
+
+      # @rbs () -> bool
+      def empty?: () -> bool
+
+      # @rbs (Array[untyped] priority, untyped value) -> void
+      def push: (Array[untyped] priority, untyped value) -> void
+
+      # @rbs () -> [Array[untyped], untyped]?
+      def pop: () -> [ Array[untyped], untyped ]?
+
+      private
+
+      # @rbs ([Array[untyped], untyped] left, [Array[untyped], untyped] right) -> Integer
+      def compare: ([ Array[untyped], untyped ] left, [ Array[untyped], untyped ] right) -> Integer
+    end
+  end
+end

data/sig/ibex/runtime/repair_search.rbs

@@ -0,0 +1,114 @@
+# Generated from lib/ibex/runtime/repair_search.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # Bounded Dijkstra search over LR state stacks. Semantic actions never run.
+    # rubocop:disable Metrics/ClassLength -- queue policy and LR transitions form one bounded search invariant.
+    class RepairSearch
+      NEED_INPUT: Object
+
+      LIMIT: Object
+
+      class Configuration < Struct[untyped]
+        attr_accessor stack(): untyped
+
+        attr_accessor input_index(): untyped
+
+        attr_accessor shifts(): untyped
+
+        attr_accessor cost(): untyped
+
+        attr_accessor edits(): untyped
+
+        attr_accessor goal(): untyped
+
+        def self.new: (?stack: untyped, ?input_index: untyped, ?shifts: untyped, ?cost: untyped, ?edits: untyped, ?goal: untyped) -> instance
+                    | ({ ?stack: untyped, ?input_index: untyped, ?shifts: untyped, ?cost: untyped, ?edits: untyped, ?goal: untyped }) -> instance
+      end
+
+      @candidate_ids: Array[Integer]
+
+      @best: Hash[Array[untyped], Array[untyped]]
+
+      @heap: RepairPriorityQueue
+
+      @configurations: Integer
+
+      @complete: bool
+
+      @tokens: Array[RepairInput]
+
+      @policy: RepairPolicy
+
+      @tables: Hash[Symbol, untyped]
+
+      # @rbs (Hash[Symbol, untyped] tables, RepairPolicy policy, Array[RepairInput] tokens,
+      #   complete: bool) -> void
+      def initialize: (Hash[Symbol, untyped] tables, RepairPolicy policy, Array[RepairInput] tokens, complete: bool) -> void
+
+      # @rbs (Array[Integer] state_stack) -> (RepairPlan | Object | nil)
+      def search: (Array[Integer] state_stack) -> (RepairPlan | Object | nil)
+
+      private
+
+      # @rbs (Configuration configuration) -> (RepairPlan | Object | nil)
+      def visit: (Configuration configuration) -> (RepairPlan | Object | nil)
+
+      # @rbs (Configuration configuration) -> (RepairPlan | Object | nil)
+      def expand: (Configuration configuration) -> (RepairPlan | Object | nil)
+
+      # @rbs (Configuration configuration, RepairInput current) -> (RepairPlan | Object | nil)
+      def expand_edits: (Configuration configuration, RepairInput current) -> (RepairPlan | Object | nil)
+
+      # @rbs (Configuration configuration, :insert | :replace kind)
+      #   -> (RepairPlan | Object | nil)
+      def expand_candidates: (Configuration configuration, :insert | :replace kind) -> (RepairPlan | Object | nil)
+
+      # @rbs (Configuration configuration, :insert | :replace kind, Integer token_id, Integer cost) -> Object?
+      def expand_candidate: (Configuration configuration, :insert | :replace kind, Integer token_id, Integer cost) -> Object?
+
+      # @rbs (Configuration configuration, Symbol kind, Integer token_id, Integer cost) -> Array[RepairEdit]
+      def candidate_edits: (Configuration configuration, Symbol kind, Integer token_id, Integer cost) -> Array[RepairEdit]
+
+      # @rbs (Configuration configuration, RepairInput current) -> void
+      def push_delete: (Configuration configuration, RepairInput current) -> void
+
+      # @rbs (Array[Integer] stack, Integer token_id) -> (RepairAdvance | Object | nil)
+      def advance: (Array[Integer] stack, Integer token_id) -> (RepairAdvance | Object | nil)
+
+      # @rbs (Array[Integer] states, Integer production_id) -> Array[Integer]?
+      def apply_reduction: (Array[Integer] states, Integer production_id) -> Array[Integer]?
+
+      # @rbs (Integer state, Integer token_id) -> untyped
+      def action_for: (Integer state, Integer token_id) -> untyped
+
+      # @rbs (untyped table, Integer row, Integer column) -> untyped
+      def table_lookup: (untyped table, Integer row, Integer column) -> untyped
+
+      # @rbs (Configuration source, ?stack: Array[Integer], ?input_index: Integer, ?shifts: Integer,
+      #   ?cost: Integer, ?edits: Array[RepairEdit], ?goal: bool) -> Configuration
+      def configuration_with: (Configuration source, ?stack: Array[Integer], ?input_index: Integer, ?shifts: Integer, ?cost: Integer, ?edits: Array[RepairEdit], ?goal: bool) -> Configuration
+
+      # @rbs (Array[RepairEdit] edits) -> RepairPlan
+      def plan: (Array[RepairEdit] edits) -> RepairPlan
+
+      # @rbs (Integer token_id) -> String
+      def token_name: (Integer token_id) -> String
+
+      # @rbs (Configuration configuration) -> void
+      def push: (Configuration configuration) -> void
+
+      # @rbs () -> (Configuration | Object)
+      def pop: () -> (Configuration | Object)
+
+      # @rbs (Configuration configuration) -> Array[untyped]
+      def priority_for: (Configuration configuration) -> Array[untyped]
+
+      # Prefer punctuation edits when equal-cost repairs are otherwise
+      # ambiguous; inventing or discarding a word-like token is more likely to
+      # fabricate or lose an application semantic value.
+      # @rbs (RepairEdit edit) -> Integer
+      def semantic_value_risk: (RepairEdit edit) -> Integer
+    end
+  end
+end

data/sig/ibex/runtime/resource_limits.rbs

@@ -0,0 +1,39 @@
+# Generated from lib/ibex/runtime/resource_limits.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # Immutable per-parser-session resource budgets.
+    class ResourceLimits
+      DEFAULT_MAX_STACK_DEPTH: Integer
+
+      DEFAULT_MAX_RECOVERY_ATTEMPTS: Integer
+
+      DEFAULT_MAX_INCREMENTAL_DECOMPOSED_NODES: Integer
+
+      DEFAULT_MAX_SESSION_MEMO_BYTES: Integer
+
+      attr_reader max_stack_depth: Integer
+
+      attr_reader max_recovery_attempts: Integer
+
+      attr_reader max_incremental_decomposed_nodes: Integer
+
+      attr_reader max_session_memo_bytes: Integer
+
+      # @rbs (?max_stack_depth: Integer, ?max_recovery_attempts: Integer,
+      #   ?max_incremental_decomposed_nodes: Integer, ?max_session_memo_bytes: Integer) -> void
+      def initialize: (?max_stack_depth: Integer, ?max_recovery_attempts: Integer, ?max_incremental_decomposed_nodes: Integer, ?max_session_memo_bytes: Integer) -> void
+
+      # @rbs () -> Hash[Symbol, Integer]
+      def to_h: () -> Hash[Symbol, Integer]
+
+      private
+
+      # @rbs (Integer value, Symbol name) -> void
+      def validate_positive_integer: (Integer value, Symbol name) -> void
+
+      # @rbs (Integer value, Symbol name) -> void
+      def validate_nonnegative_integer: (Integer value, Symbol name) -> void
+    end
+  end
+end

data/sig/ibex/runtime/table_format.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/ibex/runtime/table_format.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # Current parser-table shape emitted by the generator.
+    PARSER_TABLE_FORMAT_VERSION: Integer
+
+    # Parser-table shapes this runtime can execute.
+    SUPPORTED_PARSER_TABLE_FORMAT_VERSIONS: Array[Integer]
+  end
+end

data/sig/ibex/runtime/version.rbs

@@ -0,0 +1,7 @@
+# Generated from lib/ibex/runtime/version.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    VERSION: ::String
+  end
+end

data/sig/ibex/runtime.rbs

@@ -0,0 +1,6 @@
+# Generated from lib/ibex/runtime.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+  end
+end

data/sig/ibex/tables/compact.rbs

@@ -0,0 +1,70 @@
+# Generated from lib/ibex/tables/compact.rb with RBS::Inline
+
+module Ibex
+  module Tables
+    # Encodes nonnegative integer arrays into compact generated-source
+    # literals. Zero represents nil; positive values are offset by one.
+    module PackedIntegers
+      # @rbs (Array[Integer?] values) -> String
+      def self?.encode: (Array[Integer?] values) -> String
+
+      # @rbs (String source) -> Array[Integer?]
+      def self?.decode: (String source) -> Array[Integer?]
+
+      # @rbs (String source) -> Array[Integer]
+      def self?.decode_required: (String source) -> Array[Integer]
+
+      # Zigzag-encode signed values after reserving zero for nil.
+      # @rbs (Array[Integer?] values) -> String
+      def self?.encode_signed: (Array[Integer?] values) -> String
+
+      # @rbs (String source) -> Array[Integer?]
+      def self?.decode_signed: (String source) -> Array[Integer?]
+    end
+
+    # Sparse table represented by per-row offsets and ownership checks.
+    class Compact
+      DENSE_CELL_LIMIT: Integer
+
+      attr_reader offsets: Array[Integer]
+
+      attr_reader values: Array[untyped]
+
+      attr_reader checks: Array[Integer?]
+
+      attr_reader row_count: Integer
+
+      attr_reader dense_values: Array[untyped]?
+
+      attr_reader dense_width: Integer?
+
+      # @rbs (Array[Hash[Integer, untyped]] rows, ?dense: bool) -> Compact
+      def self.build: (Array[Hash[Integer, untyped]] rows, ?dense: bool) -> Compact
+
+      # @rbs (String offsets, String values, String checks, row_count: Integer,
+      #   ?dense_width: Integer?) -> Compact
+      def self.packed: (String offsets, String values, String checks, row_count: Integer, ?dense_width: Integer?) -> Compact
+
+      # @rbs (Array[Integer] columns, Array[Integer?] checks, Hash[Array[Integer], Integer] next_offsets) -> Integer
+      private def self.find_offset: (Array[Integer] columns, Array[Integer?] checks, Hash[Array[Integer], Integer] next_offsets) -> Integer
+
+      # @rbs (offsets: Array[Integer], values: Array[untyped], checks: Array[Integer?],
+      #   row_count: Integer, ?dense_width: Integer?) -> void
+      def self?.initialize: (offsets: Array[Integer], values: Array[untyped], checks: Array[Integer?], row_count: Integer, ?dense_width: Integer?) -> void
+
+      # Keep predicate dispatch out of this lookup because every parser action
+      # and goto crosses it.
+      # rubocop:disable Style/NumericPredicate
+      # @rbs (Integer row, Integer column) -> untyped
+      def self?.lookup: (Integer row, Integer column) -> untyped
+
+      # @rbs (Integer row) -> Hash[Integer, untyped]
+      def self?.row: (Integer row) -> Hash[Integer, untyped]
+
+      private
+
+      # @rbs (Integer? dense_width) -> Array[untyped]?
+      def self?.dense_layout: (Integer? dense_width) -> Array[untyped]?
+    end
+  end
+end

data/sig/ibex/tables/compact_actions.rbs

@@ -0,0 +1,57 @@
+# Generated from lib/ibex/tables/compact_actions.rb with RBS::Inline
+
+module Ibex
+  module Tables
+    # Compact action table with an integer-coded hot representation and a
+    # compatible decoded lookup surface for the generic runtime.
+    class CompactActions < Compact
+      ACCEPT_CODE: Integer
+
+      ERROR_CODE: Integer
+
+      SHIFT_BASE: Integer
+
+      REDUCE_BASE: Integer
+
+      LEGACY_ERROR_CODE: Integer
+
+      LEGACY_SHIFT_BASE: Integer
+
+      LEGACY_REDUCE_BASE: Integer
+
+      attr_reader codes: Array[Integer?]
+
+      attr_reader dense_codes: Array[Integer?]?
+
+      attr_reader column_count: Integer?
+
+      # @rbs (Array[Hash[Integer, untyped]] rows) -> CompactActions
+      def self.build: (Array[Hash[Integer, untyped]] rows) -> CompactActions
+
+      # @rbs (String offsets, String codes, String checks, row_count: Integer,
+      #   ?encoding: Symbol, ?column_count: Integer?) -> CompactActions
+      def self.packed: (String offsets, String codes, String checks, row_count: Integer, ?encoding: Symbol, ?column_count: Integer?) -> CompactActions
+
+      # @rbs (untyped action) -> Integer?
+      def self.pack: (untyped action) -> Integer?
+
+      # @rbs (Integer? code) -> untyped
+      def self.unpack: (Integer? code) -> untyped
+
+      # Convert codes emitted before signed compact actions without changing
+      # their generated table literals.
+      # @rbs (Integer? code) -> Integer?
+      def self.legacy_to_signed: (Integer? code) -> Integer?
+
+      # @rbs (offsets: Array[Integer], codes: Array[Integer?], checks: Array[Integer?],
+      #   row_count: Integer, ?encoding: Symbol, ?column_count: Integer?) -> void
+      def initialize: (offsets: Array[Integer], codes: Array[Integer?], checks: Array[Integer?], row_count: Integer, ?encoding: Symbol, ?column_count: Integer?) -> void
+
+      private
+
+      # @rbs (Array[Integer] offsets, Array[Integer?] codes, Array[Integer?] checks,
+      #   Integer row_count, Integer? column_count) -> Array[Integer?]?
+      def dense_action_layout: (Array[Integer] offsets, Array[Integer?] codes, Array[Integer?] checks, Integer row_count, Integer? column_count) -> Array[Integer?]?
+    end
+  end
+end

data/sig/ibex/tables/compact_productions.rbs

@@ -0,0 +1,68 @@
+# Generated from lib/ibex/tables/compact_productions.rb with RBS::Inline
+
+module Ibex
+  module Tables
+    # Production metadata with parallel primitive arrays for the direct parser
+    # and a compatible Array-of-Hash surface for generic runtime consumers.
+    class CompactProductions < Array[Hash[Symbol, untyped]]
+      VALUES_ACTION: Integer
+
+      BORROWED_VALUES_ACTION: Integer
+
+      LOCATION_ACTION: Integer
+
+      COMPOSITION_ACTION: Integer
+
+      POSITIONAL_ACTION: Integer
+
+      VALID_FLAGS: Integer
+
+      CORE_FIELDS: Array[Symbol]
+
+      attr_reader lhs_ids: Array[Integer]
+
+      attr_reader lengths: Array[Integer]
+
+      attr_reader actions: Array[Symbol?]
+
+      attr_reader flags: Array[Integer]
+
+      # @rbs (Array[Hash[Symbol, untyped]] productions) -> CompactProductions
+      def self.build: (Array[Hash[Symbol, untyped]] productions) -> CompactProductions
+
+      # @rbs (String lhs_ids, String lengths, String flags,
+      #   ?metadata: Hash[Integer, Hash[Symbol, untyped]]) -> CompactProductions
+      def self.packed: (String lhs_ids, String lengths, String flags, ?metadata: Hash[Integer, Hash[Symbol, untyped]]) -> CompactProductions
+
+      # @rbs (Hash[Symbol, untyped] production) -> Integer
+      private def self.flags_for: (Hash[Symbol, untyped] production) -> Integer
+
+      # @rbs (lhs_ids: Array[Integer], lengths: Array[Integer], actions: Array[Symbol?],
+      #   flags: Array[Integer], ?metadata: Hash[Integer, Hash[Symbol, untyped]]) -> void
+      def initialize: (lhs_ids: Array[Integer], lengths: Array[Integer], actions: Array[Symbol?], flags: Array[Integer], ?metadata: Hash[Integer, Hash[Symbol, untyped]]) -> void
+
+      # @rbs () -> bool
+      def direct_values?: () -> bool
+
+      private
+
+      # @rbs (untyped value, String name) -> Integer
+      def nonnegative_integer!: (untyped value, String name) -> Integer
+
+      # @rbs (untyped value) -> Symbol?
+      def action!: (untyped value) -> Symbol?
+
+      # @rbs (untyped value) -> Integer
+      def flags!: (untyped value) -> Integer
+
+      # @rbs () -> void
+      def validate_markers!: () -> void
+
+      # @rbs (Hash[Integer, Hash[Symbol, untyped]] metadata, Integer size) -> void
+      def validate_metadata!: (Hash[Integer, Hash[Symbol, untyped]] metadata, Integer size) -> void
+
+      # @rbs (Integer index, Hash[Symbol, untyped]? metadata) -> Hash[Symbol, untyped]
+      def decode: (Integer index, Hash[Symbol, untyped]? metadata) -> Hash[Symbol, untyped]
+    end
+  end
+end