ibex 0.1.0 → 0.2.0

data/sig/ibex/racc_migration/checker.rbs

@@ -0,0 +1,36 @@
+# Generated from lib/ibex/racc_migration/checker.rb with RBS::Inline
+
+module Ibex
+  module RaccMigration
+    # Checks syntax, normalization, superclass, and runtime-coupling hazards.
+    # Semantic action code is treated as opaque data and never executed.
+    class Checker
+      RACC_REQUIRE: Regexp
+
+      RACC_CONSTANT: Regexp
+
+      # @rbs (String source, file: String) -> Report
+      def check: (String source, file: String) -> Report
+
+      private
+
+      # @rbs (Frontend::Diagnostic diagnostic) -> Finding
+      def syntax_finding: (Frontend::Diagnostic diagnostic) -> Finding
+
+      # @rbs (Frontend::AST::Root ast) -> Array[Finding]
+      def superclass_findings: (Frontend::AST::Root ast) -> Array[Finding]
+
+      # @rbs (Frontend::AST::Root ast) -> Array[Finding]
+      def user_code_findings: (Frontend::AST::Root ast) -> Array[Finding]
+
+      # @rbs (Frontend::AST::Root ast) -> Array[Finding]
+      def normalization_findings: (Frontend::AST::Root ast) -> Array[Finding]
+
+      # @rbs (String message, Frontend::Location fallback) -> [Frontend::Location, String]
+      def error_location: (String message, Frontend::Location fallback) -> [ Frontend::Location, String ]
+
+      # @rbs (Array[Finding] findings) -> Array[Finding]
+      def sort_findings: (Array[Finding] findings) -> Array[Finding]
+    end
+  end
+end

data/sig/ibex/racc_migration/harness.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/ibex/racc_migration/harness.rb with RBS::Inline
+
+module Ibex
+  module RaccMigration
+    # Emits, but never executes, a subprocess-separated differential harness.
+    class Harness
+      CLASS_NAME: Regexp
+
+      # @rbs (String class_name) -> String
+      def self.generate: (String class_name) -> String
+
+      # @rbs () -> String
+      def self.template: () -> String
+    end
+  end
+end

data/sig/ibex/racc_migration/report.rbs

@@ -0,0 +1,53 @@
+# Generated from lib/ibex/racc_migration/report.rb with RBS::Inline
+
+module Ibex
+  module RaccMigration
+    # One immutable migration compatibility observation.
+    class Finding
+      SEVERITIES: Array[Symbol]
+
+      attr_reader code: String
+
+      attr_reader severity: Symbol
+
+      attr_reader message: String
+
+      attr_reader location: Frontend::Location?
+
+      attr_reader suggestion: String
+
+      # @rbs (code: String, severity: Symbol, message: String, location: Frontend::Location?,
+      #   suggestion: String) -> void
+      def initialize: (code: String, severity: Symbol, message: String, location: Frontend::Location?, suggestion: String) -> void
+
+      # @rbs () -> Hash[String, untyped]
+      def to_h: () -> Hash[String, untyped]
+    end
+
+    # Versioned result of checking one grammar without executing its code.
+    class Report
+      SCHEMA_VERSION: Integer
+
+      attr_reader file: String
+
+      attr_reader class_name: String?
+
+      attr_reader findings: Array[Finding]
+
+      # @rbs (file: String, class_name: String?, findings: Array[Finding]) -> void
+      def initialize: (file: String, class_name: String?, findings: Array[Finding]) -> void
+
+      # @rbs () -> bool
+      def compatible?: () -> bool
+
+      # @rbs () -> Hash[String, untyped]
+      def to_h: () -> Hash[String, untyped]
+
+      # @rbs (*untyped) -> String
+      def to_json: (*untyped) -> String
+
+      # @rbs () -> String
+      def to_text: () -> String
+    end
+  end
+end

data/sig/ibex/racc_migration.rbs

@@ -0,0 +1,8 @@
+# Generated from lib/ibex/racc_migration.rb with RBS::Inline
+
+module Ibex
+  # Static checks and explicitly generated differential tooling for migration
+  # from racc grammar files.
+  module RaccMigration
+  end
+end

data/sig/ibex/rake_task.rbs

@@ -0,0 +1,51 @@
+# Generated from lib/ibex/rake_task.rb with RBS::Inline
+
+module Ibex
+  # Declares grammar-to-parser generation in a Rakefile.
+  class RakeTask < Rake::TaskLib
+    attr_accessor grammar: String?
+
+    attr_accessor output: String?
+
+    attr_accessor options: Array[String]
+
+    attr_accessor action_source: String | true | nil
+
+    # @rbs (String | Symbol name) ?{ (RakeTask) -> void } -> void
+    def initialize: (String | Symbol name) ?{ (RakeTask) -> void } -> void
+
+    private
+
+    # @rbs () -> void
+    def define: () -> void
+
+    # @rbs () -> void
+    def reject_watch_option!: () -> void
+
+    # @rbs (String target) -> String?
+    def configured_action_source: (String target) -> String?
+
+    # @rbs (String target) -> String
+    def default_action_source_path: (String target) -> String
+
+    # @rbs (String source) -> Array[String]
+    def grammar_prerequisites: (String source) -> Array[String]
+
+    # @rbs () -> Symbol
+    def configured_mode: () -> Symbol
+  end
+end
+
+module Rake
+  class TaskLib
+    def initialize: () -> void
+  end
+
+  class Task
+    def self.define_task: (Hash[String | Symbol, String | Array[String]]) -> Task
+                        | (Hash[String | Symbol, String | Array[String]]) { (untyped, untyped) -> void } -> Task
+  end
+
+  class FileTask < Task
+  end
+end

data/sig/ibex/samples.rbs

@@ -0,0 +1,51 @@
+# Generated from lib/ibex/samples.rb with RBS::Inline
+
+module Ibex
+  # Generates bounded terminal sentences from Grammar IR.
+  class Samples
+    DEFAULT_MAX_EXPANSIONS: Integer
+
+    # @rbs (IR::Grammar grammar, ?seed: Integer, ?max_tokens: Integer, ?max_depth: Integer,
+    #   ?max_expansions: Integer) -> void
+    def initialize: (IR::Grammar grammar, ?seed: Integer, ?max_tokens: Integer, ?max_depth: Integer, ?max_expansions: Integer) -> void
+
+    # @rbs (?count: Integer) -> Array[Array[String]]
+    def generate: (?count: Integer) -> Array[Array[String]]
+
+    private
+
+    # @rbs () -> Hash[Integer, Integer?]
+    def compute_minimum_costs: () -> Hash[Integer, Integer?]
+
+    # @rbs () -> Hash[Integer, Integer?]
+    def compute_minimum_heights: () -> Hash[Integer, Integer?]
+
+    # @rbs (Integer terminal_value) { (IR::Production, Hash[Integer, Integer?]) -> Integer? }
+    #   -> Hash[Integer, Integer?]
+    def compute_minimum_values: (Integer terminal_value) { (IR::Production, Hash[Integer, Integer?]) -> Integer? } -> Hash[Integer, Integer?]
+
+    # @rbs (Hash[Integer, Integer?] values, Integer terminal_value) -> Array[Integer]
+    def seed_terminal_values: (Hash[Integer, Integer?] values, Integer terminal_value) -> Array[Integer]
+
+    # @rbs (Hash[Integer, Integer?] values, Array[Integer] queue, Integer symbol_id, Integer? candidate) -> void
+    def update_minimum: (Hash[Integer, Integer?] values, Array[Integer] queue, Integer symbol_id, Integer? candidate) -> void
+
+    # @rbs (IR::Production production, Hash[Integer, Integer?] values) -> Array[Integer]?
+    def resolved_rhs_values: (IR::Production production, Hash[Integer, Integer?] values) -> Array[Integer]?
+
+    # @rbs (IR::GrammarSymbol start, Integer remaining_expansions) -> [Array[String], Integer]
+    def expand: (IR::GrammarSymbol start, Integer remaining_expansions) -> [ Array[String], Integer ]
+
+    # @rbs (Integer nonterminal_id, Integer budget, Integer depth) -> IR::Production
+    def choose_production: (Integer nonterminal_id, Integer budget, Integer depth) -> IR::Production
+
+    # @rbs (Integer symbol_id) -> Integer
+    def minimum_cost!: (Integer symbol_id) -> Integer
+
+    # @rbs (IR::Production production) -> Integer?
+    def production_cost: (IR::Production production) -> Integer?
+
+    # @rbs (IR::Production production) -> Integer?
+    def production_height: (IR::Production production) -> Integer?
+  end
+end

data/sig/ibex/table_simulation/result.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/ibex/table_simulation/result.rb with RBS::Inline
+
+module Ibex
+  module TableSimulation
+    # Final immutable simulation document.
+    class Result
+      IDENTIFIER: String
+
+      SCHEMA_VERSION: Integer
+
+      attr_reader grammar_digest: String
+
+      attr_reader algorithm: String
+
+      attr_reader tokens: Array[String]
+
+      attr_reader status: Symbol
+
+      attr_reader steps: Array[Step]
+
+      # @rbs (grammar_digest: String, algorithm: String, tokens: Array[String], status: Symbol,
+      #   steps: Array[Step]) -> void
+      def initialize: (grammar_digest: String, algorithm: String, tokens: Array[String], status: Symbol, steps: Array[Step]) -> void
+
+      # @rbs () -> Hash[String, untyped]
+      def to_h: () -> Hash[String, untyped]
+
+      # @rbs (*untyped) -> String
+      def to_json: (*untyped) -> String
+    end
+  end
+end

data/sig/ibex/table_simulation/simulator.rbs

@@ -0,0 +1,98 @@
+# Generated from lib/ibex/table_simulation/simulator.rb with RBS::Inline
+
+module Ibex
+  module TableSimulation
+    # Deterministic, semantic-action-free table interpreter.
+    class Simulator
+      DEFAULT_MAX_STEPS: Integer
+
+      DEFAULT_MAX_STACK: Integer
+
+      EOF_NAME: String
+
+      ERROR_NAME: String
+
+      IMPLICIT_ERROR: IR::error_action
+
+      attr_reader automaton: IR::Automaton
+
+      attr_reader max_steps: Integer
+
+      attr_reader max_stack: Integer
+
+      attr_reader eof: IR::GrammarSymbol
+
+      # @rbs (IR::Automaton automaton, ?max_steps: Integer, ?max_stack: Integer) -> void
+      def initialize: (IR::Automaton automaton, ?max_steps: Integer, ?max_stack: Integer) -> void
+
+      # @rbs () -> Session
+      def start: () -> Session
+
+      # @rbs (Array[String] tokens) -> Result
+      def simulate: (Array[String] tokens) -> Result
+
+      # @rbs (String spelling) -> IR::GrammarSymbol
+      def terminal: (String spelling) -> IR::GrammarSymbol
+
+      private
+
+      # @rbs (Array[IR::GrammarSymbol] terminals) -> Hash[String, Array[IR::GrammarSymbol]]
+      def terminal_aliases: (Array[IR::GrammarSymbol] terminals) -> Hash[String, Array[IR::GrammarSymbol]]
+    end
+
+    # Stateful token-at-a-time table simulation session.
+    class Session
+      @tokens: Array[String]
+
+      @steps: Array[Step]
+
+      attr_reader status: Symbol?
+
+      # @rbs (Simulator simulator) -> void
+      def initialize: (Simulator simulator) -> void
+
+      # @rbs (String spelling) -> Array[Step]
+      def push: (String spelling) -> Array[Step]
+
+      # @rbs () -> Array[Step]
+      def steps: () -> Array[Step]
+
+      # @rbs () -> Array[String]
+      def tokens: () -> Array[String]
+
+      # @rbs () -> Result
+      def finish: () -> Result
+
+      private
+
+      # @rbs (IR::GrammarSymbol terminal, eof: bool) -> Array[Step]
+      def process: (IR::GrammarSymbol terminal, eof: bool) -> Array[Step]
+
+      # @rbs (IR::AutomatonState state, Integer token_id) -> [IR::parser_action, String]
+      def action_for: (IR::AutomatonState state, Integer token_id) -> [ IR::parser_action, String ]
+
+      # @rbs (IR::AutomatonState state, IR::GrammarSymbol terminal, IR::parser_action action, String source) -> void
+      def record_shift: (IR::AutomatonState state, IR::GrammarSymbol terminal, IR::parser_action action, String source) -> void
+
+      # @rbs (IR::AutomatonState state, IR::GrammarSymbol terminal, IR::parser_action action, String source) -> void
+      def record_reduce: (IR::AutomatonState state, IR::GrammarSymbol terminal, IR::parser_action action, String source) -> void
+
+      # @rbs (IR::AutomatonState state, IR::GrammarSymbol terminal, String action, String source) -> void
+      def record_terminal: (IR::AutomatonState state, IR::GrammarSymbol terminal, String action, String source) -> void
+
+      # @rbs (IR::AutomatonState state, IR::GrammarSymbol terminal, String action, String source,
+      #   before: Integer, ?production_id: Integer?, ?lhs: String?, ?rhs_length: Integer?,
+      #   ?target_state: Integer?) -> void
+      def append_step: (IR::AutomatonState state, IR::GrammarSymbol terminal, String action, String source, before: Integer, ?production_id: Integer?, ?lhs: String?, ?rhs_length: Integer?, ?target_state: Integer?) -> void
+
+      # @rbs () -> IR::AutomatonState
+      def current_state: () -> IR::AutomatonState
+
+      # @rbs () -> void
+      def enforce_stack_budget!: () -> void
+
+      # @rbs () -> void
+      def ensure_active!: () -> void
+    end
+  end
+end

data/sig/ibex/table_simulation/step.rbs

@@ -0,0 +1,40 @@
+# Generated from lib/ibex/table_simulation/step.rb with RBS::Inline
+
+module Ibex
+  module TableSimulation
+    # One immutable parser-table action.
+    class Step
+      attr_reader sequence: Integer
+
+      attr_reader state: Integer
+
+      attr_reader token_id: Integer
+
+      attr_reader token: String
+
+      attr_reader action: String
+
+      attr_reader action_source: String
+
+      attr_reader production_id: Integer?
+
+      attr_reader lhs: String?
+
+      attr_reader rhs_length: Integer?
+
+      attr_reader target_state: Integer?
+
+      attr_reader stack_depth_before: Integer
+
+      attr_reader stack_depth_after: Integer
+
+      # @rbs (sequence: Integer, state: Integer, token_id: Integer, token: String, action: String,
+      #   action_source: String, production_id: Integer?, lhs: String?, rhs_length: Integer?,
+      #   target_state: Integer?, stack_depth_before: Integer, stack_depth_after: Integer) -> void
+      def initialize: (sequence: Integer, state: Integer, token_id: Integer, token: String, action: String, action_source: String, production_id: Integer?, lhs: String?, rhs_length: Integer?, target_state: Integer?, stack_depth_before: Integer, stack_depth_after: Integer) -> void
+
+      # @rbs () -> Hash[String, untyped]
+      def to_h: () -> Hash[String, untyped]
+    end
+  end
+end

data/sig/ibex/table_simulation/text.rbs

@@ -0,0 +1,14 @@
+# Generated from lib/ibex/table_simulation/text.rb with RBS::Inline
+
+module Ibex
+  module TableSimulation
+    # Stable one-line renderer for simulation steps.
+    module Text
+      # @rbs (Step step) -> String
+      def self.render_step: (Step step) -> String
+
+      # @rbs (Result result) -> String
+      def self.render: (Result result) -> String
+    end
+  end
+end

data/sig/ibex/table_simulation.rbs

@@ -0,0 +1,7 @@
+# Generated from lib/ibex/table_simulation.rb with RBS::Inline
+
+module Ibex
+  # Safe LR table simulation over validated Automaton IR.
+  module TableSimulation
+  end
+end

data/sig/ibex/tables.rbs

@@ -18,32 +18,6 @@ module Ibex
                   | ({ ?actions: untyped, ?gotos: untyped, ?default_actions: untyped }) -> instance
     end
 
-    # Sparse table represented by per-row offsets and ownership checks.
-    class Compact
-      attr_reader offsets: Array[Integer]
-
-      attr_reader values: Array[untyped]
-
-      attr_reader checks: Array[Integer?]
-
-      attr_reader row_count: Integer
-
-      # @rbs (Array[Hash[Integer, untyped]] rows) -> Compact
-      def self.build: (Array[Hash[Integer, untyped]] rows) -> Compact
-
-      # @rbs (Array[Integer] columns, Array[Integer?] checks) -> Integer
-      private def self.find_offset: (Array[Integer] columns, Array[Integer?] checks) -> Integer
-
-      # @rbs (offsets: Array[Integer], values: Array[untyped], checks: Array[Integer?], row_count: Integer) -> void
-      def initialize: (offsets: Array[Integer], values: Array[untyped], checks: Array[Integer?], row_count: Integer) -> void
-
-      # @rbs (Integer row, Integer column) -> untyped
-      def lookup: (Integer row, Integer column) -> untyped
-
-      # @rbs (Integer row) -> Hash[Integer, untyped]
-      def row: (Integer row) -> Hash[Integer, untyped]
-    end
-
     # @rbs (IR::Automaton automaton, ?format: Symbol | String) -> TableSet
     def self?.build: (IR::Automaton automaton, ?format: Symbol | String) -> TableSet
   end

data/sig/ibex/watch/runner.rbs

@@ -0,0 +1,48 @@
+# Generated from lib/ibex/watch/runner.rb with RBS::Inline
+
+module Ibex
+  module Watch
+    # 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: ^() -> untyped, publish: ^(untyped, SourceSnapshot, ^() -> bool) -> void, failure_paths: ^() -> Array[String], stderr: untyped, 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: ^() -> untyped, publish: ^(untyped, SourceSnapshot, ^() -> bool) -> void, failure_paths: ^() -> Array[String], stderr: untyped, 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,42 @@
+# 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
+      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, Hash[Symbol, untyped]]
+
+      # @rbs (String path) -> Hash[Symbol, untyped]?
+      def entry: (String path) -> Hash[Symbol, untyped]?
+
+      private
+
+      # @rbs (String path) -> Hash[Symbol, untyped]
+      def fingerprint: (String path) -> Hash[Symbol, untyped]
+
+      # @rbs (File::Stat stat) -> Hash[Symbol, untyped]
+      def stat_signature: (File::Stat stat) -> Hash[Symbol, untyped]
+
+      # @rbs (File::Stat stat) -> Symbol
+      def file_kind: (File::Stat stat) -> Symbol
+
+      # @rbs (Time time) -> Integer
+      def nanoseconds: (Time time) -> Integer
+
+      # @rbs (Hash[Symbol, untyped] value, String path) -> void
+      def add_resolved_target: (Hash[Symbol, untyped] 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