ibex 0.1.0

data/sig/ibex/frontend/source_cursor.rbs

@@ -0,0 +1,73 @@
+# Generated from lib/ibex/frontend/source_cursor.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # A source coordinate retained by frontend and IR objects.
+    class Location < Struct[String | Integer]
+      attr_accessor file(): String
+
+      attr_accessor line(): Integer
+
+      attr_accessor column(): Integer
+
+      def self.new: (?file: String, ?line: Integer, ?column: Integer) -> instance
+                  | ({ ?file: String, ?line: Integer, ?column: Integer }) -> instance
+    end
+
+    class Location
+      # @rbs () -> IR::location
+      def to_h: () -> IR::location
+
+      # @rbs () -> String
+      def to_s: () -> String
+    end
+
+    # A grammar token and its source coordinate.
+    class Token < Struct[Symbol | token_value | Location]
+      attr_accessor type(): Symbol
+
+      attr_accessor value(): token_value
+
+      attr_accessor location(): Location
+
+      def self.new: (?type: Symbol, ?value: token_value, ?location: Location) -> instance
+                  | ({ ?type: Symbol, ?value: token_value, ?location: Location }) -> instance
+    end
+
+    class Token
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+
+    # Advances through source text while maintaining one-based coordinates.
+    class SourceCursor
+      attr_reader source: String
+
+      attr_reader file: String
+
+      attr_reader index: Integer
+
+      attr_reader line: Integer
+
+      attr_reader column: Integer
+
+      # @rbs (String source, String file) -> void
+      def initialize: (String source, String file) -> void
+
+      # @rbs () -> bool
+      def eof?: () -> bool
+
+      # @rbs (?Integer offset) -> String?
+      def peek: (?Integer offset) -> String?
+
+      # @rbs () -> String
+      def rest: () -> String
+
+      # @rbs () -> Location
+      def location: () -> Location
+
+      # @rbs (?Integer count) -> void
+      def advance: (?Integer count) -> void
+    end
+  end
+end

data/sig/ibex/frontend/token_adapter/declaration_state.rbs

@@ -0,0 +1,97 @@
+# Generated from lib/ibex/frontend/token_adapter/declaration_state.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    class TokenAdapter
+      # Classifies tokens through the class header and declaration section.
+      class DeclarationState
+        DECLARATIONS: Hash[String, [ external_token, Symbol ]]
+
+        ASSOCIATIONS: Hash[String, external_token]
+
+        SCALAR_TYPES: Hash[Symbol, external_token]
+
+        EXPECTATIONS: Hash[Symbol, String]
+
+        attr_reader conversion_name: Token?
+
+        attr_reader declaration: Symbol?
+
+        attr_reader precedence_closer: String?
+
+        attr_reader state: Symbol
+
+        # @rbs () -> void
+        def initialize: () -> void
+
+        # @rbs (Token token, Array[Token] remaining) -> external_token
+        def classify: (Token token, Array[Token] remaining) -> external_token
+
+        # @rbs () -> bool
+        def rules?: () -> bool
+
+        # @rbs () -> bool
+        def extended_pragma?: () -> bool
+
+        # @rbs (Token? token) -> String?
+        def expectation: (Token? token) -> String?
+
+        private
+
+        # @rbs (Token token, Array[Token] remaining) -> external_token
+        def classify_identifier: (Token token, Array[Token] remaining) -> external_token
+
+        # @rbs (Token token) -> external_token
+        def class_keyword: (Token token) -> external_token
+
+        # @rbs (Array[Token] remaining) -> external_token
+        def constant_name: (Array[Token] remaining) -> external_token
+
+        # @rbs (Token token) -> external_token
+        def begin_declaration: (Token token) -> external_token
+
+        # @rbs (Token token) -> external_token
+        def finish_pragma: (Token token) -> external_token
+
+        # @rbs (Token token) -> external_token
+        def begin_precedence: (Token token) -> external_token
+
+        # @rbs (Token token) -> external_token
+        def declaration_symbol: (Token token) -> external_token
+
+        # @rbs (String value) -> bool
+        def declaration_boundary?: (String value) -> bool
+
+        # @rbs (Token token) -> external_token
+        def precedence_identifier: (Token token) -> external_token
+
+        # @rbs (Token token) -> external_token
+        def finish_precedence: (Token token) -> external_token
+
+        # @rbs (Token token, external_token type, Array[Token] remaining) -> external_token
+        def begin_conversion: (Token token, external_token type, Array[Token] remaining) -> external_token
+
+        # @rbs (Token token, Array[Token] remaining) -> external_token
+        def classify_scalar: (Token token, Array[Token] remaining) -> external_token
+
+        # @rbs (external_token type) -> external_token
+        def finish_single_symbol: (external_token type) -> external_token
+
+        # @rbs (external_token type) -> external_token
+        def finish_conversion: (external_token type) -> external_token
+
+        # @rbs (Token token) -> external_token
+        def classify_punctuation: (Token token) -> external_token
+
+        # @rbs (Token name, Array[Token] remaining) -> void
+        def validate_conversion_line: (Token name, Array[Token] remaining) -> void
+
+        # @rbs (Token? token) -> String?
+        def precedence_expectation: (Token? token) -> String?
+
+        # @rbs (Token token) -> String
+        def string_value: (Token token) -> String
+      end
+    end
+  end
+end

data/sig/ibex/frontend/token_adapter/delimiter_tracker.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/ibex/frontend/token_adapter/delimiter_tracker.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    class TokenAdapter
+      # Tracks ordinary EBNF groups separately from separated-list calls.
+      class DelimiterTracker
+        attr_reader group_opening: Token?
+
+        attr_reader open_kind: delimiter_kind?
+
+        @stack: Array[[ delimiter_kind, Token ]]
+
+        # @rbs () -> void
+        def initialize: () -> void
+
+        # @rbs () -> bool
+        def empty?: () -> bool
+
+        # @rbs (Token token, external_token external, external_token? previous_external) -> void
+        def observe: (Token token, external_token external, external_token? previous_external) -> void
+      end
+    end
+  end
+end

data/sig/ibex/frontend/token_adapter/rule_state.rbs

@@ -0,0 +1,77 @@
+# Generated from lib/ibex/frontend/token_adapter/rule_state.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    class TokenAdapter
+      # Classifies context-dependent tokens in the grammar rule section.
+      class RuleState
+        SCALAR_TYPES: Hash[Symbol, external_token]
+
+        attr_reader section: parser_section
+
+        attr_reader state: Symbol
+
+        @rule_seen: bool?
+
+        @lhs_column: Integer?
+
+        @delimiters: DelimiterTracker
+
+        # @rbs () -> void
+        def initialize: () -> void
+
+        # @rbs (Token token, Array[Token] remaining, last_external: external_token?,
+        #   previous_external: external_token?) -> external_token
+        def classify: (Token token, Array[Token] remaining, last_external: external_token?, previous_external: external_token?) -> external_token
+
+        # @rbs () -> Token?
+        def group_opening: () -> Token?
+
+        # @rbs () -> delimiter_kind?
+        def open_delimiter_kind: () -> delimiter_kind?
+
+        # @rbs (Token? token) -> String?
+        def expectation: (Token? token) -> String?
+
+        private
+
+        # @rbs (Token token, Array[Token] remaining, external_token? last_external,
+        #   external_token? previous_external) -> external_token
+        def classify_identifier: (Token token, Array[Token] remaining, external_token? last_external, external_token? previous_external) -> external_token
+
+        # @rbs (Token token) -> external_token
+        def rule_lhs: (Token token) -> external_token
+
+        # @rbs (external_token? last_external, external_token? previous_external) -> bool
+        def named_reference_name?: (external_token? last_external, external_token? previous_external) -> bool
+
+        # @rbs (Token token, Token following) -> bool
+        def rule_boundary?: (Token token, Token following) -> bool
+
+        # @rbs (Token token) -> external_token
+        def start_rule: (Token token) -> external_token
+
+        # @rbs () -> external_token
+        def finish_rules: () -> external_token
+
+        # @rbs (Token token, Token following) -> bool
+        def separated_list_call?: (Token token, Token following) -> bool
+
+        # @rbs (Token token) -> external_token
+        def separated_terminal: (Token token) -> external_token
+
+        # @rbs (Token token) -> external_token
+        def classify_punctuation: (Token token) -> external_token
+
+        # @rbs () -> void
+        def reset_rule_boundary: () -> void
+
+        # @rbs (Token? token) -> String
+        def rules_lhs_expectation: (Token? token) -> String
+
+        # @rbs (Token token) -> String
+        def string_value: (Token token) -> String
+      end
+    end
+  end
+end

data/sig/ibex/frontend/token_adapter.rbs

@@ -0,0 +1,67 @@
+# Generated from lib/ibex/frontend/token_adapter.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Delivers lexer tokens through declaration and rule context classifiers.
+    class TokenAdapter
+      attr_reader eof_token: Token?
+
+      attr_reader last_token: Token?
+
+      attr_reader previous_external: external_token?
+
+      @last_external: external_token?
+
+      @rules: RuleState?
+
+      @classifier: DeclarationState | RuleState
+
+      @declarations: DeclarationState
+
+      @index: Integer
+
+      @tokens: Array[Token]
+
+      # @rbs (Array[Token] tokens) -> void
+      def initialize: (Array[Token] tokens) -> void
+
+      # @rbs () -> ([external_token, Token] | false)
+      def next_token: () -> ([ external_token, Token ] | false)
+
+      # @rbs () -> Token?
+      def conversion_name: () -> Token?
+
+      # @rbs () -> Symbol?
+      def declaration: () -> Symbol?
+
+      # @rbs () -> String?
+      def precedence_closer: () -> String?
+
+      # @rbs () -> bool
+      def extended_pragma?: () -> bool
+
+      # @rbs () -> parser_section
+      def section: () -> parser_section
+
+      # @rbs () -> Symbol
+      def state: () -> Symbol
+
+      # @rbs () -> Token?
+      def group_opening: () -> Token?
+
+      # @rbs () -> delimiter_kind?
+      def open_delimiter_kind: () -> delimiter_kind?
+
+      # @rbs (Token? token) -> String?
+      def expectation: (Token? token) -> String?
+
+      private
+
+      # @rbs (Token token) -> external_token
+      def classify: (Token token) -> external_token
+
+      # @rbs () -> void
+      def enter_rules: () -> void
+    end
+  end
+end

data/sig/ibex/frontend.rbs

@@ -0,0 +1,15 @@
+# Generated from lib/ibex/frontend.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    type user_code_token = { name: String, code: String }
+
+    type token_value = String | Integer | user_code_token | nil
+
+    type external_token = Symbol | String
+
+    type parser_section = :declarations | :rules | :user_code
+
+    type delimiter_kind = :group | :separated
+  end
+end

data/sig/ibex/ir/automaton_ir.rbs

@@ -0,0 +1,77 @@
+# Generated from lib/ibex/ir/automaton_ir.rb with RBS::Inline
+
+module Ibex
+  module IR
+    # A merged LALR item with its lookahead token ids.
+    class AutomatonItem
+      attr_reader production: Integer
+
+      attr_reader dot: Integer
+
+      attr_reader lookaheads: Array[Integer]
+
+      # @rbs (production: Integer, dot: Integer, lookaheads: Array[Integer]) -> void
+      def initialize: (production: Integer, dot: Integer, lookaheads: Array[Integer]) -> void
+
+      # @rbs (Grammar grammar) -> Hash[Symbol, untyped]
+      def to_h: (Grammar grammar) -> Hash[Symbol, untyped]
+    end
+
+    # A deterministic LALR automaton state.
+    class AutomatonState
+      attr_reader id: Integer
+
+      attr_reader items: Array[AutomatonItem]
+
+      attr_reader transitions: Hash[Integer, Integer]
+
+      attr_reader actions: Hash[Integer, parser_action]
+
+      attr_reader gotos: Hash[Integer, Integer]
+
+      attr_reader default_action: parser_action?
+
+      attr_reader conflicts: Array[conflict]
+
+      # @rbs (id: Integer, items: Array[AutomatonItem], transitions: Hash[Integer, Integer],
+      #   actions: Hash[Integer, parser_action], gotos: Hash[Integer, Integer], ?default_action: parser_action?,
+      #   ?conflicts: Array[conflict]) -> void
+      def initialize: (id: Integer, items: Array[AutomatonItem], transitions: Hash[Integer, Integer], actions: Hash[Integer, parser_action], gotos: Hash[Integer, Integer], ?default_action: parser_action?, ?conflicts: Array[conflict]) -> void
+
+      # @rbs (Grammar grammar) -> Hash[Symbol, untyped]
+      def to_h: (Grammar grammar) -> Hash[Symbol, untyped]
+
+      private
+
+      # @rbs (Hash[Integer, untyped] values, Grammar grammar) -> Hash[String, untyped]
+      def named_keys: (Hash[Integer, untyped] values, Grammar grammar) -> Hash[String, untyped]
+    end
+
+    # Immutable LALR automaton and its source grammar.
+    class Automaton
+      attr_reader algorithm: String
+
+      attr_reader grammar_digest: String
+
+      attr_reader grammar: Grammar
+
+      attr_reader states: Array[AutomatonState]
+
+      attr_reader conflict_summary: conflict_summary
+
+      attr_reader schema_version: Integer
+
+      # @rbs (grammar: Grammar, states: Array[AutomatonState], conflict_summary: conflict_summary,
+      #   ?algorithm: String, ?grammar_digest: String?, ?schema_version: Integer) -> void
+      def initialize: (grammar: Grammar, states: Array[AutomatonState], conflict_summary: conflict_summary, ?algorithm: String, ?grammar_digest: String?, ?schema_version: Integer) -> void
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h: () -> Hash[Symbol, untyped]
+
+      private
+
+      # @rbs (Grammar grammar) -> String
+      def digest_for: (Grammar grammar) -> String
+    end
+  end
+end

data/sig/ibex/ir/grammar_ir.rbs

@@ -0,0 +1,143 @@
+# Generated from lib/ibex/ir/grammar_ir.rb with RBS::Inline
+
+module Ibex
+  module IR
+    SCHEMA_VERSION: ::Integer
+
+    # @rbs (untyped value) -> untyped
+    def self?.deep_freeze: (untyped value) -> untyped
+
+    # An interned terminal or nonterminal.
+    class GrammarSymbol
+      attr_reader id: Integer
+
+      attr_reader name: String
+
+      attr_reader kind: Symbol
+
+      attr_reader reserved: bool
+
+      attr_reader precedence: precedence?
+
+      attr_reader location: location?
+
+      # @rbs (id: Integer, name: String, kind: Symbol, ?reserved: bool, ?precedence: precedence?,
+      #   ?location: location?) -> void
+      def initialize: (id: Integer, name: String, kind: Symbol, ?reserved: bool, ?precedence: precedence?, ?location: location?) -> void
+
+      # @rbs () -> bool
+      def terminal?: () -> bool
+
+      # @rbs () -> bool
+      def nonterminal?: () -> bool
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+
+    # Opaque Ruby semantic action metadata.
+    class Action
+      attr_reader code: String
+
+      attr_reader location: location
+
+      attr_reader named_refs: Array[named_ref]
+
+      attr_reader context_length: Integer
+
+      # @rbs (code: String, location: location, ?named_refs: Array[named_ref], ?context_length: Integer) -> void
+      def initialize: (code: String, location: location, ?named_refs: Array[named_ref], ?context_length: Integer) -> void
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+
+    # A normalized BNF production using symbol ids.
+    class Production
+      attr_reader id: Integer
+
+      attr_reader lhs: Integer
+
+      attr_reader rhs: Array[Integer]
+
+      attr_reader action: Action?
+
+      attr_reader precedence_override: Integer?
+
+      attr_reader origin: Hash[Symbol, untyped]
+
+      # @rbs (id: Integer, lhs: Integer, rhs: Array[Integer], action: Action?, precedence_override: Integer?,
+      #   origin: Hash[Symbol, untyped]) -> void
+      def initialize: (id: Integer, lhs: Integer, rhs: Array[Integer], action: Action?, precedence_override: Integer?, origin: Hash[Symbol, untyped]) -> void
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+
+    # One opaque user-code block and the location of its first code line.
+    class UserCodeChunk
+      attr_reader code: String
+
+      attr_reader location: location
+
+      # @rbs (code: String, location: location) -> void
+      def initialize: (code: String, location: location) -> void
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+
+    # Immutable normalized grammar exchanged between pipeline stages.
+    class Grammar
+      attr_reader class_name: String
+
+      attr_reader superclass: String?
+
+      attr_reader start: String
+
+      attr_reader expect: Integer
+
+      attr_reader options: grammar_options
+
+      attr_reader symbols: Array[GrammarSymbol]
+
+      attr_reader productions: Array[Production]
+
+      attr_reader user_code: Hash[String, String]
+
+      attr_reader user_code_chunks: user_code_chunks
+
+      attr_reader conversions: Hash[String, String]
+
+      attr_reader warnings: Array[grammar_warning]
+
+      attr_reader schema_version: Integer
+
+      # @rbs (class_name: String, superclass: String?, start: String, expect: Integer, options: grammar_options,
+      #   symbols: Array[GrammarSymbol], productions: Array[Production], user_code: Hash[String, String],
+      #   conversions: Hash[String, String], warnings: Array[grammar_warning], ?user_code_chunks: user_code_chunks?,
+      #   ?schema_version: Integer) -> void
+      def initialize: (class_name: String, superclass: String?, start: String, expect: Integer, options: grammar_options, symbols: Array[GrammarSymbol], productions: Array[Production], user_code: Hash[String, String], conversions: Hash[String, String], warnings: Array[grammar_warning], ?user_code_chunks: user_code_chunks?, ?schema_version: Integer) -> void
+
+      # @rbs (String name) -> GrammarSymbol?
+      def symbol: (String name) -> GrammarSymbol?
+
+      # @rbs (Integer? id) -> GrammarSymbol?
+      def symbol_by_id: (Integer? id) -> GrammarSymbol?
+
+      # @rbs () -> Array[GrammarSymbol]
+      def terminals: () -> Array[GrammarSymbol]
+
+      # @rbs () -> Array[GrammarSymbol]
+      def nonterminals: () -> Array[GrammarSymbol]
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h: () -> Hash[Symbol, untyped]
+
+      private
+
+      # @rbs () -> void
+      def validate_user_code_chunks: () -> void
+    end
+  end
+end

data/sig/ibex/ir/serialize.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/ibex/ir/serialize.rb with RBS::Inline
+
+module Ibex
+  module IR
+    # Stable JSON serialization for versioned pipeline IR.
+    module Serialize
+      private def validate_version: (untyped data) -> untyped
+
+      private def self.validate_version: (untyped data) -> untyped
+
+      private def load_grammar: (untyped data) -> untyped
+
+      private def self.load_grammar: (untyped data) -> untyped
+
+      private def load_automaton: (untyped data) -> untyped
+
+      private def self.load_automaton: (untyped data) -> untyped
+
+      private def load_state: (untyped state, untyped grammar) -> untyped
+
+      private def self.load_state: (untyped state, untyped grammar) -> untyped
+
+      private def symbol_keyed: (untyped values, untyped grammar, ?actions: untyped) -> untyped
+
+      private def self.symbol_keyed: (untyped values, untyped grammar, ?actions: untyped) -> untyped
+
+      private def normalize_action: (untyped value) -> untyped
+
+      private def self.normalize_action: (untyped value) -> untyped
+
+      private def load_production: (untyped production) -> untyped
+
+      private def self.load_production: (untyped production) -> untyped
+
+      private def load_user_code_chunks: (untyped chunks) -> untyped
+
+      private def self.load_user_code_chunks: (untyped chunks) -> untyped
+
+      private def symbolize: (untyped value) -> untyped
+
+      private def self.symbolize: (untyped value) -> untyped
+
+      # @rbs (Grammar | Automaton value) -> String
+      def self?.dump: (Grammar | Automaton value) -> String
+
+      # @rbs (String source) -> (Grammar | Automaton)
+      def self?.load: (String source) -> (Grammar | Automaton)
+    end
+  end
+end

data/sig/ibex/ir.rbs

@@ -0,0 +1,43 @@
+# Generated from lib/ibex/ir.rb with RBS::Inline
+
+module Ibex
+  module IR
+    type location = { file: String, line: Integer, column: Integer }
+
+    type precedence = { associativity: Symbol, level: Integer }
+
+    type named_ref = { name: String, index: Integer }
+
+    type user_code_chunks = Hash[String, Array[UserCodeChunk]]
+
+    type grammar_options = { result_var: bool, omit_action_call: bool }
+
+    type grammar_warning = { type: Symbol, ?symbol: String, ?production: Integer, ?original: Integer, loc: location? }
+
+    type shift_action = { type: :shift, state: Integer }
+
+    type reduce_action = { type: :reduce, production: Integer }
+
+    type accept_action = { type: :accept }
+
+    type error_action = { type: :error }
+
+    type parser_action = shift_action | reduce_action | accept_action | error_action
+
+    type runtime_action = [ :shift, Integer ] | [ :reduce, Integer ] | [ :accept ] | [ :error ]
+
+    type conflict_resolution = { by: Symbol, chose: Symbol | Integer, ?associativity: Symbol }
+
+    type shift_reduce_conflict = { type: :shift_reduce, symbol: String, shift_to: Integer, reduce: Integer, resolution: conflict_resolution }
+
+    type reduce_reduce_conflict = { type: :reduce_reduce, symbol: String, reductions: Array[Integer], resolution: conflict_resolution }
+
+    type conflict = shift_reduce_conflict | reduce_reduce_conflict
+
+    type conflict_summary = { sr: Integer, resolved_sr: Integer, rr: Integer, expected_sr: Integer, expectation_met: bool }
+
+    type interpretation = Hash[Symbol, untyped]
+
+    type counterexample = { state: Integer, type: Symbol, symbol_path: Array[String], sentence: Array[String], lookahead_index: Integer, unifying: bool, interpretations: Array[interpretation] }
+  end
+end