ibex 0.1.0 → 0.3.0

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,42 @@
+# Generated from lib/ibex/table_simulation/step.rb with RBS::Inline
+
+module Ibex
+  module TableSimulation
+    # One immutable parser-table action.
+    class Step
+      type document_value = String | Integer | nil
+
+      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, document_value]
+      def to_h: () -> Hash[String, document_value]
+    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

@@ -3,45 +3,20 @@
 module Ibex
   # Parser table construction and row-displacement compression.
   module Tables
-    private def runtime_action: (IR::parser_action action) -> IR::runtime_action
-
-    private def self.runtime_action: (IR::parser_action action) -> IR::runtime_action
-
-    class TableSet < Struct[untyped]
-      attr_accessor actions(): untyped
-
-      attr_accessor gotos(): untyped
-
-      attr_accessor default_actions(): untyped
-
-      def self.new: (?actions: untyped, ?gotos: untyped, ?default_actions: untyped) -> instance
-                  | ({ ?actions: untyped, ?gotos: untyped, ?default_actions: untyped }) -> instance
-    end
+    type action_table = Array[Hash[Integer, IR::runtime_action]] | CompactActions
 
-    # Sparse table represented by per-row offsets and ownership checks.
-    class Compact
-      attr_reader offsets: Array[Integer]
+    type goto_table = Array[Hash[Integer, Integer]] | Compact
 
-      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
+    private def runtime_action: (IR::parser_action action) -> IR::runtime_action
 
-      # @rbs (Integer row, Integer column) -> untyped
-      def lookup: (Integer row, Integer column) -> untyped
+    private def self.runtime_action: (IR::parser_action action) -> IR::runtime_action
 
-      # @rbs (Integer row) -> Hash[Integer, untyped]
-      def row: (Integer row) -> Hash[Integer, untyped]
+    class TableSet < Struct[Object?]
+      attr_accessor actions: action_table
+      attr_accessor gotos: goto_table
+      attr_accessor default_actions: Array[IR::runtime_action?]
+      def self.new: (?actions: action_table, ?gotos: goto_table, ?default_actions: Array[IR::runtime_action?]) -> instance
+                  | ({ ?actions: action_table, ?gotos: goto_table, ?default_actions: Array[IR::runtime_action?] }) -> instance
     end
 
     # @rbs (IR::Automaton automaton, ?format: Symbol | String) -> TableSet

data/sig/ibex/verifiable_generation_bundle.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/ibex/verifiable_generation_bundle.rb with RBS::Inline
+
+module Ibex
+  # Explicitly renders and publishes one manifest-bound verification bundle.
+  class VerifiableGenerationBundle
+    # rubocop:disable Metrics/ParameterLists -- persisted artifact paths and verification bounds are explicit inputs.
+    # @rbs (IR::Automaton automaton, wrapper_path: String, wrapper_source: String,
+    #   table_path: String, report_path: String, manifest_path: String,
+    #   source_records: Array[GenerationInput], ?manifest_options: Hash[String, Object?],
+    #   ?wrapper_mode: Integer?, ?representation: Symbol | String, ?cst_trivia: Symbol | String?,
+    #   ?omit_action_call: bool?, ?strict: bool, ?max_states: Integer, ?max_items: Integer) -> void
+    def initialize: (IR::Automaton automaton, wrapper_path: String, wrapper_source: String, table_path: String, report_path: String, manifest_path: String, source_records: Array[GenerationInput], ?manifest_options: Hash[String, Object?], ?wrapper_mode: Integer?, ?representation: Symbol | String, ?cst_trivia: Symbol | String?, ?omit_action_call: bool?, ?strict: bool, ?max_states: Integer, ?max_items: Integer) -> void
+
+    # Render table, wrapper, and report before the non-cyclic manifest marker.
+    # @rbs () -> ArtifactSet
+    def render: () -> ArtifactSet
+
+    # @rbs (?warning: ^(String) -> void, ?stability_check: ^() -> bool) -> ArtifactSet
+    def publish: (?warning: ^(String) -> void, ?stability_check: ^() -> bool) -> ArtifactSet
+
+    # @rbs (String manifest_path) -> Hash[String, VerificationReport::Validator::json_value]
+    def self.validate_file: (String manifest_path) -> Hash[String, VerificationReport::Validator::json_value]
+  end
+end

data/sig/ibex/verification_report/builder.rbs

@@ -0,0 +1,53 @@
+# Generated from lib/ibex/verification_report/builder.rb with RBS::Inline
+
+module Ibex
+  module VerificationReport
+    # Builds deterministic evidence from an Automaton IR verification run.
+    class Builder
+      type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+
+      # @rbs (IR::Automaton automaton, table: TableArtifact::Document,
+      #   source_records: Array[GenerationInput], table_path: String, strict: bool,
+      #   max_states: Integer, max_items: Integer) -> void
+      def initialize: (IR::Automaton automaton, table: TableArtifact::Document, source_records: Array[GenerationInput], table_path: String, strict: bool, max_states: Integer, max_items: Integer) -> void
+
+      # @rbs () -> String
+      def render: () -> String
+
+      private
+
+      # @rbs () -> Hash[Symbol, Integer]
+      def bounds: () -> Hash[Symbol, Integer]
+
+      # @rbs () -> Array[String]
+      def requested_checks: () -> Array[String]
+
+      # @rbs () -> Hash[String, json_value]
+      def verification_outcome: () -> Hash[String, json_value]
+
+      # @rbs () -> Hash[String, json_value]
+      def input_identity: () -> Hash[String, json_value]
+
+      # @rbs () -> Hash[String, json_value]
+      def ir_identity: () -> Hash[String, json_value]
+
+      # @rbs () -> Hash[String, json_value]
+      def table_identity: () -> Hash[String, json_value]
+
+      # @rbs () -> void
+      def validate_table_identity!: () -> void
+
+      # @rbs () -> String
+      def grammar_digest: () -> String
+
+      # @rbs () -> String
+      def automaton_digest: () -> String
+
+      # @rbs (String digest) -> String
+      def prefixed_digest: (String digest) -> String
+
+      # @rbs (Hash[Symbol, String] value) -> Hash[String, String]
+      def stringify_keys: (Hash[Symbol, String] value) -> Hash[String, String]
+    end
+  end
+end

data/sig/ibex/verification_report/canonical_ir.rbs

@@ -0,0 +1,41 @@
+# Generated from lib/ibex/verification_report/canonical_ir.rb with RBS::Inline
+
+module Ibex
+  module VerificationReport
+    # Rebuilds immutable IR with source locations expressed as report logical identities.
+    class CanonicalIR
+      type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[json_value, json_value]
+
+      LOGICAL_ROOT: String
+
+      # @rbs (IR::Automaton automaton, source_records: Array[GenerationInput]) -> void
+      def initialize: (IR::Automaton automaton, source_records: Array[GenerationInput]) -> void
+
+      # @rbs () -> IR::Automaton
+      def build: () -> IR::Automaton
+
+      private
+
+      # @rbs (json_value value) -> json_value
+      def normalize_source_identity!: (json_value value) -> json_value
+
+      # @rbs (json_value value) -> String
+      def generate_json: (json_value value) -> String
+
+      # @rbs (json_value value) -> json_value
+      def normalize_for_json: (json_value value) -> json_value
+
+      # @rbs (String file) -> String
+      def logical_file: (String file) -> String
+
+      # @rbs (GenerationInput record, String file) -> bool
+      def record_matches?: (GenerationInput record, String file) -> bool
+
+      # @rbs (String file) -> bool
+      def absolute_file?: (String file) -> bool
+
+      # @rbs (IR::Grammar grammar) -> String
+      def digest: (IR::Grammar grammar) -> String
+    end
+  end
+end

data/sig/ibex/verification_report/logical_path.rbs

@@ -0,0 +1,34 @@
+# Generated from lib/ibex/verification_report/logical_path.rb with RBS::Inline
+
+module Ibex
+  module VerificationReport
+    # Closed logical identities used by version 1 verification reports.
+    module LogicalPath
+      MAX_INPUT_FILES: Integer
+
+      BASENAME: Regexp
+
+      INPUT: Regexp
+
+      TABLE: Regexp
+
+      # @rbs (String path, Integer index) -> String
+      def self?.input: (String path, Integer index) -> String
+
+      # @rbs (String path) -> String
+      def self?.table: (String path) -> String
+
+      # @rbs (Object? value, Integer index) -> bool
+      def self?.canonical_input?: (Object? value, Integer index) -> bool
+
+      # @rbs (Object? value) -> bool
+      def self?.canonical_table?: (Object? value) -> bool
+
+      # @rbs (String path) -> String
+      def self?.basename: (String path) -> String
+
+      # @rbs (String value) -> bool
+      def self?.usable_basename?: (String value) -> bool
+    end
+  end
+end

data/sig/ibex/verification_report/validator.rbs

@@ -0,0 +1,114 @@
+# Generated from lib/ibex/verification_report/validator.rb with RBS::Inline
+
+module Ibex
+  module VerificationReport
+    # Validates a report and its cross-artifact manifest/table bindings.
+    # rubocop:disable Metrics/ClassLength -- closed report and cross-artifact invariants form one validator contract.
+    class Validator
+      type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+
+      ROOT_KEYS: Array[String]
+
+      CHECKER_KEYS: Array[String]
+
+      BOUNDS_KEYS: Array[String]
+
+      INPUT_KEYS: Array[String]
+
+      INPUT_FILE_KEYS: Array[String]
+
+      IR_KEYS: Array[String]
+
+      GRAMMAR_KEYS: Array[String]
+
+      AUTOMATON_KEYS: Array[String]
+
+      TABLE_KEYS: Array[String]
+
+      OUTCOME_KEYS: Array[String]
+
+      VIOLATION_KEYS: Array[String]
+
+      EXHAUSTION_KEYS: Array[String]
+
+      DIGEST: Regexp
+
+      ALGORITHMS: Array[String]
+
+      # @rbs (String source) -> Hash[String, json_value]
+      def validate: (String source) -> Hash[String, json_value]
+
+      # @rbs (manifest_source: String, report_source: String, table_source: String) -> Hash[String, json_value]
+      def validate_bundle: (manifest_source: String, report_source: String, table_source: String) -> Hash[String, json_value]
+
+      # @rbs (String manifest_path) -> Hash[String, json_value]
+      def validate_bundle_file: (String manifest_path) -> Hash[String, json_value]
+
+      private
+
+      # @rbs (json_value document) -> void
+      def validate_document: (json_value document) -> void
+
+      # @rbs (json_value value) -> void
+      def validate_checker: (json_value value) -> void
+
+      # @rbs (json_value value) -> void
+      def validate_bounds: (json_value value) -> void
+
+      # @rbs (json_value value) -> void
+      def validate_input: (json_value value) -> void
+
+      # @rbs (json_value value) -> void
+      def validate_ir: (json_value value) -> void
+
+      # @rbs (json_value value) -> void
+      def validate_table: (json_value value) -> void
+
+      # @rbs (json_value value, String profile) -> void
+      def validate_outcome: (json_value value, String profile) -> void
+
+      # @rbs (json_value value, Array[String] requested) -> Array[json_value]
+      def validate_violations: (json_value value, Array[String] requested) -> Array[json_value]
+
+      # @rbs (Hash[String, json_value] manifest, String kind) -> Hash[String, json_value]
+      def unique_artifact: (Hash[String, json_value] manifest, String kind) -> Hash[String, json_value]
+
+      # @rbs (Hash[String, json_value] entry, String source, String label) -> void
+      def validate_manifest_bytes!: (Hash[String, json_value] entry, String source, String label) -> void
+
+      # @rbs (Hash[String, json_value] manifest, Hash[String, json_value] report) -> void
+      def validate_inputs!: (Hash[String, json_value] manifest, Hash[String, json_value] report) -> void
+
+      # @rbs (Hash[String, json_value] report, TableArtifact::Document table,
+      #   Hash[String, json_value] table_entry) -> void
+      def validate_table_binding!: (Hash[String, json_value] report, TableArtifact::Document table, Hash[String, json_value] table_entry) -> void
+
+      # @rbs (json_value value, String path) -> Array[String]
+      def checks: (json_value value, String path) -> Array[String]
+
+      # @rbs (json_value value, Array[String] keys, String path) -> Hash[String, json_value]
+      def object: (json_value value, Array[String] keys, String path) -> Hash[String, json_value]
+
+      # @rbs (json_value value, String path) -> Array[json_value]
+      def array: (json_value value, String path) -> Array[json_value]
+
+      # @rbs (json_value value, String path, ?allow_empty: bool) -> String
+      def string: (json_value value, String path, ?allow_empty: bool) -> String
+
+      # @rbs (json_value value, String path) -> String
+      def digest: (json_value value, String path) -> String
+
+      # @rbs (json_value value, String path) -> Integer
+      def positive_integer: (json_value value, String path) -> Integer
+
+      # @rbs (json_value value, String path) -> Integer
+      def nonnegative_integer: (json_value value, String path) -> Integer
+
+      # @rbs [T] (T value, Array[T] values, String path) -> T
+      def enum: [T] (T value, Array[T] values, String path) -> T
+
+      # @rbs (json_value actual, json_value expected, String path) -> void
+      def equal: (json_value actual, json_value expected, String path) -> void
+    end
+  end
+end

data/sig/ibex/verification_report.rbs

@@ -0,0 +1,44 @@
+# Generated from lib/ibex/verification_report.rb with RBS::Inline
+
+module Ibex
+  # A versioned, scoped report that binds bounded verification to input and
+  # data-only parser table identities without claiming to verify opaque code.
+  module VerificationReport
+    IDENTIFIER: String
+
+    SCHEMA_VERSION: Integer
+
+    IR_IDENTITY_SCOPE: String
+
+    DEFAULT_MAX_STATES: Integer
+
+    DEFAULT_MAX_ITEMS: Integer
+
+    EXCLUDED_TRUST: Array[String]
+
+    class ValidationError < Ibex::Error
+    end
+
+    # Rebuild the supplied Automaton IR with path-neutral source locations for one bundle.
+    # @rbs (IR::Automaton automaton, source_records: Array[GenerationInput]) -> IR::Automaton
+    def self?.canonical_automaton: (IR::Automaton automaton, source_records: Array[GenerationInput]) -> IR::Automaton
+
+    # @rbs (IR::Automaton automaton, table: TableArtifact::Document,
+    #   source_records: Array[GenerationInput], table_path: String, ?strict: bool,
+    #   ?max_states: Integer, ?max_items: Integer) -> String
+    def self?.render: (IR::Automaton automaton, table: TableArtifact::Document, source_records: Array[GenerationInput], table_path: String, ?strict: bool, ?max_states: Integer, ?max_items: Integer) -> String
+
+    # Validate the closed report shape and its canonical evidence digest.
+    # @rbs (String source) -> Hash[String, VerificationReport::Validator::json_value]
+    def self?.validate: (String source) -> Hash[String, VerificationReport::Validator::json_value]
+
+    # Validate report, table, and manifest bytes as one non-cyclic bundle.
+    # @rbs (manifest_source: String, report_source: String, table_source: String) -> Hash[String, VerificationReport::Validator::json_value]
+    def self?.validate_bundle: (manifest_source: String, report_source: String, table_source: String) -> Hash[String, VerificationReport::Validator::json_value]
+
+    # Resolve the report and table through a manifest and validate every
+    # published artifact before checking the cross-artifact identities.
+    # @rbs (String manifest_path) -> Hash[String, VerificationReport::Validator::json_value]
+    def self?.validate_bundle_file: (String manifest_path) -> Hash[String, VerificationReport::Validator::json_value]
+  end
+end

data/sig/ibex/verify/action_correspondence.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/ibex/verify/action_correspondence.rb with RBS::Inline
+
+module Ibex
+  module Verify
+    type correspondence_action = IR::parser_action
+
+    # Compares resolved ACTION/GOTO behavior over all paired viable prefixes.
+    class ActionCorrespondence
+      class Difference < Struct[Symbol | Integer? | correspondence_action?]
+        attr_accessor kind: Symbol
+        attr_accessor canonical_state: Integer
+        attr_accessor target_state: Integer
+        attr_accessor symbol: Integer?
+        attr_accessor canonical: correspondence_action?
+        attr_accessor target: correspondence_action?
+        def self.new: (kind: Symbol, canonical_state: Integer, target_state: Integer, symbol: Integer?, canonical: correspondence_action?, target: correspondence_action?) -> instance
+      end
+
+      class Result < Struct[Array[Difference] | Integer | bool]
+        attr_accessor differences: Array[Difference]
+        attr_accessor explored: Integer
+        attr_accessor truncated: bool
+        def self.new: (differences: Array[Difference], explored: Integer, truncated: bool) -> instance
+        def ok?: () -> bool
+      end
+
+      # @rbs (IR::Automaton canonical, IR::Automaton target, ?max_pairs: Integer) -> void
+      def initialize: (IR::Automaton canonical, IR::Automaton target, ?max_pairs: Integer) -> void
+
+      # @rbs () -> Result
+      def verify: () -> Result
+
+      private
+
+      # @rbs (Integer, Integer, IR::AutomatonState, IR::AutomatonState,
+      #   Array[Difference], Array[Array[Integer]]) -> void
+      def compare_terminals: (Integer, Integer, IR::AutomatonState, IR::AutomatonState, Array[Difference], Array[Array[Integer]]) -> void
+
+      # @rbs (Integer, Integer, IR::AutomatonState, IR::AutomatonState,
+      #   Array[Difference], Array[Array[Integer]]) -> void
+      def compare_gotos: (Integer, Integer, IR::AutomatonState, IR::AutomatonState, Array[Difference], Array[Array[Integer]]) -> void
+
+      # @rbs (IR::AutomatonState, Integer) -> IR::parser_action
+      def effective_action: (IR::AutomatonState, Integer) -> IR::parser_action
+
+      # @rbs (IR::parser_action) -> Array[Object]
+      def action_signature: (IR::parser_action) -> Array[Object]
+    end
+  end
+end