ibex 0.1.0 → 0.3.0

data/sig/ibex/verify/language_witness.rbs

@@ -0,0 +1,112 @@
+# Generated from lib/ibex/verify/language_witness.rb with RBS::Inline
+
+module Ibex
+  module Verify
+    type witness_status = :accepted | :error | :missing_entry | :shifted
+
+    # Compares canonical and submitted parser acceptance over a bounded set of
+    # terminal sequences.  This is a semantic witness, not a proof of language
+    # equivalence: the reference collection is complete within its budgets and
+    # the token enumeration is deliberately finite.
+    class LanguageWitness
+      class Difference
+        attr_reader entry: String
+
+        attr_reader tokens: Array[String]
+
+        attr_reader canonical: witness_status
+
+        attr_reader target: witness_status
+
+        # @rbs (entry: String, tokens: Array[String], canonical: witness_status,
+        #   target: witness_status) -> void
+        def initialize: (entry: String, tokens: Array[String], canonical: witness_status, target: witness_status) -> void
+      end
+
+      class Result
+        attr_reader differences: Array[Difference]
+
+        attr_reader explored: Integer
+
+        attr_reader truncated: bool
+
+        attr_reader max_tokens: Integer
+
+        attr_reader max_cases: Integer
+
+        # @rbs (differences: Array[Difference], explored: Integer, truncated: bool,
+        #   max_tokens: Integer, max_cases: Integer) -> void
+        def initialize: (differences: Array[Difference], explored: Integer, truncated: bool, max_tokens: Integer, max_cases: Integer) -> void
+
+        # @rbs () -> bool
+        def ok?: () -> bool
+      end
+
+      # @rbs (IR::Grammar grammar, IR::Automaton target, ?max_tokens: Integer,
+      #   ?max_cases: Integer, ?max_states: Integer, ?max_items: Integer) -> void
+      def initialize: (IR::Grammar grammar, IR::Automaton target, ?max_tokens: Integer, ?max_cases: Integer, ?max_states: Integer, ?max_items: Integer) -> void
+
+      # @rbs () -> Result
+      def verify: () -> Result
+
+      private
+
+      # @rbs () -> Array[IR::GrammarSymbol]
+      def input_tokens: () -> Array[IR::GrammarSymbol]
+
+      # @rbs (String, Array[Integer], Array[Difference], Integer) -> [Integer, bool]
+      def verify_entry: (String, Array[Integer], Array[Difference], Integer) -> [ Integer, bool ]
+
+      # @rbs (Integer id) -> String
+      def token_name: (Integer id) -> String
+
+      # @rbs (String entry, Array[Integer]) -> witness_status
+      def simulate_target: (String entry, Array[Integer]) -> witness_status
+
+      # Canonical collection is intentionally built here rather than through
+      # the production construction entry point, keeping this witness
+      # independent from construction code.
+      class CanonicalMachine
+        # @rbs (IR::Grammar grammar, max_states: Integer, max_items: Integer) -> void
+        def initialize: (IR::Grammar grammar, max_states: Integer, max_items: Integer) -> void
+
+        # @rbs (String entry, Array[Integer]) -> witness_status
+        def simulate: (String entry, Array[Integer]) -> witness_status
+
+        private
+
+        # @rbs (ReferenceCollection::Collection) -> Array[IR::AutomatonState]
+        def build_states: (ReferenceCollection::Collection) -> Array[IR::AutomatonState]
+
+        # @rbs (ReferenceCollection::Collection, Set[Array[Integer]], Integer) -> IR::AutomatonState
+        def build_state: (ReferenceCollection::Collection, Set[Array[Integer]], Integer) -> IR::AutomatonState
+
+        # @rbs (Array[IR::AutomatonItem], Hash[Integer, Integer]) -> Hash[Integer, IR::parser_action]
+        def resolve_actions: (Array[IR::AutomatonItem], Hash[Integer, Integer]) -> Hash[Integer, IR::parser_action]
+
+        # @rbs (Hash[Integer, Integer]) -> Hash[Integer, Array[IR::parser_action]]
+        def transition_candidates: (Hash[Integer, Integer]) -> Hash[Integer, Array[IR::parser_action]]
+
+        # @rbs (Array[IR::AutomatonItem], Hash[Integer, Array[IR::parser_action]]) -> void
+        def completed_candidates: (Array[IR::AutomatonItem], Hash[Integer, Array[IR::parser_action]]) -> void
+
+        # @rbs (Integer production_id) -> Array[Integer]
+        def rhs_for: (Integer production_id) -> Array[Integer]
+      end
+
+      # A stack machine shared by the canonical reference and submitted IR.
+      class Machine
+        # @rbs (Array[IR::AutomatonState] states, IR::Grammar grammar) -> void
+        def initialize: (Array[IR::AutomatonState] states, IR::Grammar grammar) -> void
+
+        # @rbs (Integer initial, Array[Integer]) -> witness_status
+        def simulate: (Integer initial, Array[Integer]) -> witness_status
+
+        private
+
+        # @rbs (Array[Integer], Integer) -> witness_status
+        def consume: (Array[Integer], Integer) -> witness_status
+      end
+    end
+  end
+end

data/sig/ibex/verify/reference_collection.rbs

@@ -0,0 +1,63 @@
+# Generated from lib/ibex/verify/reference_collection.rb with RBS::Inline
+
+module Ibex
+  module Verify
+    # Independently derives canonical LR(1) and LR(0) item collections.
+    class ReferenceCollection
+      # Immutable canonical collection and its symbol transitions.
+      class Collection
+        attr_reader states: Array[Set[Array[Integer]]]
+
+        attr_reader transitions: Array[Hash[Integer, Integer]]
+
+        # @rbs (states: Array[Set[Array[Integer]]], transitions: Array[Hash[Integer, Integer]]) -> void
+        def initialize: (states: Array[Set[Array[Integer]]], transitions: Array[Hash[Integer, Integer]]) -> void
+      end
+
+      # @rbs (IR::Grammar grammar, ?max_states: Integer, ?max_items: Integer) -> void
+      def initialize: (IR::Grammar grammar, ?max_states: Integer, ?max_items: Integer) -> void
+
+      # @rbs (Symbol kind) -> Collection
+      def build: (Symbol kind) -> Collection
+
+      private
+
+      # @rbs (Array[Set[Array[Integer]]] seeds, Symbol kind) -> Collection
+      def collection: (Array[Set[Array[Integer]]] seeds, Symbol kind) -> Collection
+
+      # @rbs (Array[Set[Array[Integer]]] states, Hash[Array[Array[Integer]], Integer] indexes,
+      #   Set[Array[Integer]] state) -> Integer
+      def insert_state: (Array[Set[Array[Integer]]] states, Hash[Array[Array[Integer]], Integer] indexes, Set[Array[Integer]] state) -> Integer
+
+      # @rbs (Set[Array[Integer]] seed, Symbol kind) -> Set[Array[Integer]]
+      def closure: (Set[Array[Integer]] seed, Symbol kind) -> Set[Array[Integer]]
+
+      # @rbs (Set[Array[Integer]] state, Integer symbol_id, Symbol kind) -> Set[Array[Integer]]
+      def go_to: (Set[Array[Integer]] state, Integer symbol_id, Symbol kind) -> Set[Array[Integer]]
+
+      # @rbs (Set[Array[Integer]] items, Array[Array[Integer]] queue, Array[Integer] item) -> void
+      def add_item: (Set[Array[Integer]] items, Array[Array[Integer]] queue, Array[Integer] item) -> void
+
+      # @rbs () -> void
+      def account_item: () -> void
+
+      # @rbs (Set[Array[Integer]] state) -> Array[Integer]
+      def next_symbols: (Set[Array[Integer]] state) -> Array[Integer]
+
+      # @rbs (Integer production_id, Integer dot, Integer? inherited) -> Array[Integer]
+      def closure_lookaheads: (Integer production_id, Integer dot, Integer? inherited) -> Array[Integer]
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for: (Integer production_id) -> Array[Integer]
+
+      # @rbs (Integer production_id) -> IR::GrammarSymbol
+      def start_symbol: (Integer production_id) -> IR::GrammarSymbol
+
+      # @rbs () -> Integer
+      def eof_id: () -> Integer
+
+      # @rbs () -> Hash[Symbol, Integer]
+      def bounds: () -> Hash[Symbol, Integer]
+    end
+  end
+end

data/sig/ibex/verify/result.rbs

@@ -0,0 +1,52 @@
+# Generated from lib/ibex/verify/result.rb with RBS::Inline
+
+module Ibex
+  module Verify
+    # One stable verifier finding.
+    class Violation
+      attr_reader id: String
+
+      attr_reader location: String
+
+      attr_reader message: String
+
+      # @rbs (id: String, location: String, message: String) -> void
+      def initialize: (id: String, location: String, message: String) -> void
+
+      # @rbs () -> Hash[Symbol, String]
+      def to_h: () -> Hash[Symbol, String]
+    end
+
+    # Immutable independent-verification report.
+    class Result
+      type report_value = String | Integer | bool | Array[String] | Hash[Symbol, Integer] | Array[Hash[Symbol, String]]
+
+      attr_reader algorithm: String
+
+      attr_reader strict: bool
+
+      attr_reader checks: Array[String]
+
+      attr_reader violations: Array[Violation]
+
+      attr_reader bounds: Hash[Symbol, Integer]
+
+      # @rbs (algorithm: String, strict: bool, checks: Array[String], violations: Array[Violation],
+      #   bounds: Hash[Symbol, Integer]) -> void
+      def initialize: (algorithm: String, strict: bool, checks: Array[String], violations: Array[Violation], bounds: Hash[Symbol, Integer]) -> void
+
+      # @rbs () -> bool
+      def valid?: () -> bool
+
+      # @rbs () -> Hash[Symbol, report_value]
+      def to_h: () -> Hash[Symbol, report_value]
+    end
+
+    class BudgetExceeded < Ibex::Error
+      attr_reader bounds: Hash[Symbol, Integer]
+
+      # @rbs (String message, bounds: Hash[Symbol, Integer]) -> void
+      def initialize: (String message, bounds: Hash[Symbol, Integer]) -> void
+    end
+  end
+end

data/sig/ibex/verify/verifier.rbs

@@ -0,0 +1,170 @@
+# Generated from lib/ibex/verify/verifier.rb with RBS::Inline
+
+module Ibex
+  module Verify
+    # Checks Automaton IR semantics against an independently derived collection.
+    # rubocop:disable Metrics/ClassLength -- V1-V9 share one violation and item-identity model.
+    class Verifier
+      DEFAULT_CHECKS: Array[String]
+
+      STRICT_CHECKS: Array[String]
+
+      ERROR_ACTION: IR::error_action
+
+      # @rbs (IR::Automaton automaton, ?strict: bool, ?max_states: Integer, ?max_items: Integer) -> void
+      def initialize: (IR::Automaton automaton, ?strict: bool, ?max_states: Integer, ?max_items: Integer) -> void
+
+      # @rbs () -> Result
+      def verify: () -> Result
+
+      private
+
+      # V9 is a bounded semantic witness for IELR only.  It deliberately does
+      # not replace V1/V2 or claim unbounded language equivalence.
+      # @rbs () -> void
+      def verify_ielr_adequacy: () -> void
+
+      # @rbs () -> void
+      def verify_grammar_digest: () -> void
+
+      # @rbs () -> void
+      def verify_item_collection: () -> void
+
+      # SLR lookaheads affect completed items only. The builder may retain
+      # propagation lookaheads on non-completed items, but they cannot select
+      # an ACTION cell and therefore are outside the SLR semantic contract.
+      # @rbs (Array[Set[Array[Integer]]] expected_states) -> void
+      def compare_slr_states: (Array[Set[Array[Integer]]] expected_states) -> void
+
+      # @rbs (IR::AutomatonState state,
+      #   Hash[Array[Array[Integer]], Array[Set[Array[Integer]]]] expected_by_core) ->
+      #   Array[Array[Integer]]?
+      def verify_slr_state: (IR::AutomatonState state, Hash[Array[Array[Integer]], Array[Set[Array[Integer]]]] expected_by_core) -> Array[Array[Integer]]?
+
+      # @rbs (IR::AutomatonState state, IR::AutomatonItem item) -> void
+      def verify_slr_lookaheads: (IR::AutomatonState state, IR::AutomatonItem item) -> void
+
+      # @rbs () -> Array[Set[Array[Integer]]]
+      def lr1_states: () -> Array[Set[Array[Integer]]]
+
+      # @rbs () -> Array[Set[Array[Integer]]]
+      def lalr_states: () -> Array[Set[Array[Integer]]]
+
+      # @rbs () -> Array[Set[Array[Integer]]]
+      def canonical_lr1_states: () -> Array[Set[Array[Integer]]]
+
+      # @rbs (Array[Set[Array[Integer]]] expected_states) -> void
+      def compare_expected_states: (Array[Set[Array[Integer]]] expected_states) -> void
+
+      # @rbs (Array[Set[Array[Integer]]] expected_states) -> void
+      def compare_ielr_states: (Array[Set[Array[Integer]]] expected_states) -> void
+
+      # @rbs () -> void
+      def verify_transitions_and_actions: () -> void
+
+      # @rbs (IR::AutomatonState state) -> void
+      def verify_transition_items: (IR::AutomatonState state) -> void
+
+      # @rbs (IR::AutomatonState state) -> void
+      def verify_state_actions: (IR::AutomatonState state) -> void
+
+      # @rbs (IR::AutomatonState state, IR::GrammarSymbol terminal, Array[IR::parser_action] expected,
+      #   IR::parser_action actual, Array[Integer] conflict_tokens) -> void
+      def verify_terminal_action: (IR::AutomatonState state, IR::GrammarSymbol terminal, Array[IR::parser_action] expected, IR::parser_action actual, Array[Integer] conflict_tokens) -> void
+
+      # @rbs (IR::AutomatonState state, IR::GrammarSymbol terminal, IR::parser_action actual) -> void
+      def verify_error_cell: (IR::AutomatonState state, IR::GrammarSymbol terminal, IR::parser_action actual) -> void
+
+      # @rbs (IR::AutomatonState state, IR::GrammarSymbol terminal, IR::parser_action expected,
+      #   IR::parser_action actual) -> void
+      def verify_single_action: (IR::AutomatonState state, IR::GrammarSymbol terminal, IR::parser_action expected, IR::parser_action actual) -> void
+
+      # @rbs (IR::AutomatonState state, IR::GrammarSymbol terminal, Array[IR::parser_action] expected,
+      #   IR::parser_action actual, Array[Integer] conflict_tokens) -> void
+      def verify_conflicted_action: (IR::AutomatonState state, IR::GrammarSymbol terminal, Array[IR::parser_action] expected, IR::parser_action actual, Array[Integer] conflict_tokens) -> void
+
+      # @rbs () -> void
+      def verify_table_formats: () -> void
+
+      # @rbs (Tables::action_table table, Integer row) -> Hash[Integer, IR::runtime_action]
+      def action_row: (Tables::action_table table, Integer row) -> Hash[Integer, IR::runtime_action]
+
+      # @rbs (Tables::goto_table table, Integer row) -> Hash[Integer, untyped]
+      def goto_row: (Tables::goto_table table, Integer row) -> Hash[Integer, untyped]
+
+      # @rbs () -> void
+      def verify_reachability_and_productivity: () -> void
+
+      # @rbs () -> void
+      def verify_epsilon_termination: () -> void
+
+      # @rbs () -> void
+      def verify_conflict_determinism: () -> void
+
+      # @rbs (IR::AutomatonState state, IR::conflict conflict) -> void
+      def verify_conflict_resolution: (IR::AutomatonState state, IR::conflict conflict) -> void
+
+      # @rbs (IR::conflict conflict) -> Array[IR::parser_action]
+      def conflict_candidates: (IR::conflict conflict) -> Array[IR::parser_action]
+
+      # @rbs (IR::conflict conflict) -> IR::parser_action?
+      def resolved_conflict_action: (IR::conflict conflict) -> IR::parser_action?
+
+      # @rbs (IR::AutomatonState state) -> Hash[Integer, Array[IR::parser_action]]
+      def action_candidates: (IR::AutomatonState state) -> Hash[Integer, Array[IR::parser_action]]
+
+      # @rbs (IR::AutomatonState state, Integer symbol_id) -> Array[Array[Integer]]
+      def shifted_items: (IR::AutomatonState state, Integer symbol_id) -> Array[Array[Integer]]
+
+      # @rbs (IR::AutomatonState state, Integer terminal_id) -> IR::parser_action
+      def effective_action: (IR::AutomatonState state, Integer terminal_id) -> IR::parser_action
+
+      # @rbs () -> Set[Integer]
+      def reachable_states: () -> Set[Integer]
+
+      # @rbs () -> Set[Integer]
+      def productive_nonterminals: () -> Set[Integer]
+
+      # @rbs (Hash[Integer, Integer] edges) -> bool
+      def directed_cycle?: (Hash[Integer, Integer] edges) -> bool
+
+      # @rbs (IR::AutomatonState state) -> Set[Array[Integer]]
+      def expanded_items: (IR::AutomatonState state) -> Set[Array[Integer]]
+
+      # Automaton IR intentionally exposes every augmented production as -1,
+      # even when construction internally assigned one per start symbol.
+      # @rbs (Set[Array[Integer]] state) -> Set[Array[Integer]]
+      def visible_state: (Set[Array[Integer]] state) -> Set[Array[Integer]]
+
+      # @rbs (Set[Array[Integer]] state) -> Array[Array[Integer]]
+      def core_key: (Set[Array[Integer]] state) -> Array[Array[Integer]]
+
+      # @rbs (Array[Set[Array[Integer]]] states) -> Hash[Array[Array[Integer]], Integer]
+      def multiset: (Array[Set[Array[Integer]]] states) -> Hash[Array[Array[Integer]], Integer]
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def follow_ids: (Integer production_id) -> Array[Integer]
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for: (Integer production_id) -> Array[Integer]
+
+      # @rbs (Integer production_id) -> IR::GrammarSymbol
+      def start_symbol: (Integer production_id) -> IR::GrammarSymbol
+
+      # @rbs () -> Integer
+      def eof_id: () -> Integer
+
+      # @rbs () -> Array[Integer]
+      def start_symbol_ids: () -> Array[Integer]
+
+      # @rbs () -> ReferenceCollection
+      def reference: () -> ReferenceCollection
+
+      # @rbs (String id, String location, String message) -> void
+      def violation: (String id, String location, String message) -> void
+
+      # @rbs (IR::AutomatonState state) -> String
+      def state_path: (IR::AutomatonState state) -> String
+    end
+  end
+end

data/sig/ibex/verify.rbs

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

data/sig/ibex/watch/runner.rbs

@@ -0,0 +1,58 @@
+# Generated from lib/ibex/watch/runner.rb with RBS::Inline
+
+module Ibex
+  module Watch
+    interface _BuildResult
+      def source_paths: () -> Array[String]
+
+      def attempted_paths: () -> Array[String]
+    end
+
+    interface _Output
+      def puts: (*Object?) -> Object?
+    end
+
+    # Polls source fingerprints, debounces changes, and publishes stable builds.
+    class Runner
+      DEFAULT_INTERVAL: Float
+
+      DEFAULT_DEBOUNCE: Float
+
+      # rubocop:disable Layout/LineLength
+      # @rbs (paths: Array[String], build: ^() -> _BuildResult, publish: ^(_BuildResult, SourceSnapshot, ^() -> bool) -> void, failure_paths: ^() -> Array[String], stderr: _Output, clock: ^() -> Float, sleeper: ^(Float) -> void, iteration_hook: ^(Symbol, Integer, Array[String]) -> (Integer | Symbol | nil), ?interval: Float, ?debounce: Float) -> void
+      def initialize: (paths: Array[String], build: ^() -> _BuildResult, publish: ^(_BuildResult, SourceSnapshot, ^() -> bool) -> void, failure_paths: ^() -> Array[String], stderr: _Output, clock: ^() -> Float, sleeper: ^(Float) -> void, iteration_hook: ^(Symbol, Integer, Array[String]) -> (Integer | Symbol | nil), ?interval: Float, ?debounce: Float) -> void
+
+      # @rbs () -> Integer
+      def run: () -> Integer
+
+      private
+
+      # @rbs (SourceSnapshot before) -> [SourceSnapshot, bool]
+      def build_once: (SourceSnapshot before) -> [ SourceSnapshot, bool ]
+
+      # @rbs (SourceSnapshot snapshot) -> SourceSnapshot
+      def wait_for_change: (SourceSnapshot snapshot) -> SourceSnapshot
+
+      # @rbs (SourceSnapshot changed) -> SourceSnapshot
+      def debounce: (SourceSnapshot changed) -> SourceSnapshot
+
+      # @rbs (Exception error) -> void
+      def report_failure: (Exception error) -> void
+
+      # @rbs (SourceSnapshot before, Exception error) -> [SourceSnapshot, bool]
+      def failed_build: (SourceSnapshot before, Exception error) -> [ SourceSnapshot, bool ]
+
+      # @rbs (Exception error, SourceSnapshot snapshot) -> void
+      def report_failure_once: (Exception error, SourceSnapshot snapshot) -> void
+
+      # @rbs (Symbol event) -> Integer?
+      def stop_status: (Symbol event) -> Integer?
+
+      # @rbs (Array[String] paths) -> Array[String]
+      def normalize_paths: (Array[String] paths) -> Array[String]
+
+      # @rbs () { () -> Integer } -> Integer
+      def with_signal_handlers: () { () -> Integer } -> Integer
+    end
+  end
+end

data/sig/ibex/watch/source_snapshot.rbs

@@ -0,0 +1,46 @@
+# Generated from lib/ibex/watch/source_snapshot.rb with RBS::Inline
+
+module Ibex
+  module Watch
+    # Stable metadata and content fingerprints for watched source paths.
+    class SourceSnapshot
+      type fingerprint_value = Symbol | String | Integer | nil | Hash[Symbol, fingerprint_value]
+
+      type fingerprint = Hash[Symbol, fingerprint_value]
+
+      attr_reader paths: Array[String]
+
+      # @rbs (Array[String] paths) -> void
+      def initialize: (Array[String] paths) -> void
+
+      # @rbs (SourceSnapshot other) -> bool
+      def ==: (SourceSnapshot other) -> bool
+
+      # Every path in this snapshot must have had the same value in the older snapshot.
+      # @rbs (SourceSnapshot older) -> bool
+      def unchanged_since?: (SourceSnapshot older) -> bool
+
+      attr_reader entries: Hash[String, fingerprint]
+
+      # @rbs (String path) -> fingerprint?
+      def entry: (String path) -> fingerprint?
+
+      private
+
+      # @rbs (String path) -> fingerprint
+      def fingerprint: (String path) -> fingerprint
+
+      # @rbs (File::Stat stat) -> fingerprint
+      def stat_signature: (File::Stat stat) -> fingerprint
+
+      # @rbs (File::Stat stat) -> Symbol
+      def file_kind: (File::Stat stat) -> Symbol
+
+      # @rbs (Time time) -> Integer
+      def nanoseconds: (Time time) -> Integer
+
+      # @rbs (fingerprint value, String path) -> void
+      def add_resolved_target: (fingerprint value, String path) -> void
+    end
+  end
+end

data/sig/ibex/watch.rbs

@@ -0,0 +1,7 @@
+# Generated from lib/ibex/watch.rb with RBS::Inline
+
+module Ibex
+  # Portable polling support for repeatable parser generation.
+  module Watch
+  end
+end

data/sig/ibex.rbs

@@ -3,4 +3,6 @@
 # Ibex generates and runs Pure Ruby LR parsers.
 module Ibex
   ParseError: singleton(Runtime::ParseError)
+
+  ResourceLimitError: singleton(Runtime::ResourceLimitError)
 end