ibex 0.1.0 → 0.3.0

data/sig/ibex/frontend/source_cursor.rbs

@@ -23,20 +23,22 @@ module Ibex
     end
 
     # A grammar token and its source coordinate.
-    class Token < Struct[Symbol | token_value | Location]
+    class Token < Struct[Symbol | token_value | Location | SourceSpan?]
       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
+      attr_accessor span(): SourceSpan?
+
+      def self.new: (?type: Symbol, ?value: token_value, ?location: Location, ?span: SourceSpan?) -> instance
+                  | ({ ?type: Symbol, ?value: token_value, ?location: Location, ?span: SourceSpan? }) -> instance
     end
 
     class Token
-      # @rbs () -> Hash[Symbol, untyped]
-      def to_h: () -> Hash[Symbol, untyped]
+      # @rbs () -> Hash[Symbol, Object?]
+      def to_h: () -> Hash[Symbol, Object?]
     end
 
     # Advances through source text while maintaining one-based coordinates.
@@ -47,6 +49,8 @@ module Ibex
 
       attr_reader index: Integer
 
+      attr_reader byte_offset: Integer
+
       attr_reader line: Integer
 
       attr_reader column: Integer
@@ -66,8 +70,37 @@ module Ibex
       # @rbs () -> Location
       def location: () -> Location
 
+      # @rbs () -> SourcePosition
+      def position: () -> SourcePosition
+
+      # @rbs (SourcePosition start) -> SourceSpan
+      def span_from: (SourcePosition start) -> SourceSpan
+
       # @rbs (?Integer count) -> void
       def advance: (?Integer count) -> void
+
+      private
+
+      # @rbs (Integer count) -> void
+      def advance_ascii: (Integer count) -> void
+
+      # @rbs (Integer count) -> void
+      def advance_utf8: (Integer count) -> void
+
+      # @rbs (Integer character_index) -> Integer
+      def byte_offset_for_character: (Integer character_index) -> Integer
+
+      # @rbs (Integer byte_offset, Integer from_index, Integer to_index) -> Integer
+      def walk_to_character: (Integer byte_offset, Integer from_index, Integer to_index) -> Integer
+
+      # @rbs (Integer byte_offset) -> Integer
+      def previous_character_byte_offset: (Integer byte_offset) -> Integer
+
+      # @rbs (Integer byte_offset) -> Integer
+      def utf8_character_width: (Integer byte_offset) -> Integer
+
+      # @rbs (Integer byte) -> bool
+      def continuation_byte?: (Integer byte) -> bool
     end
   end
 end

data/sig/ibex/frontend/source_document.rbs

@@ -0,0 +1,119 @@
+# Generated from lib/ibex/frontend/source_document.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # An immutable lexical unit or trivia slice in a concrete syntax tree.
+    class Segment
+      TRIVIA_KINDS: Array[Symbol]
+
+      OPAQUE_KINDS: Array[Symbol]
+
+      attr_reader kind: Symbol
+
+      attr_reader span: SourceSpan
+
+      attr_reader text: String
+
+      attr_reader token_type: Symbol?
+
+      attr_reader token_index: Integer?
+
+      # @rbs (kind: Symbol, span: SourceSpan, text: String, ?token_type: Symbol?,
+      #   ?token_index: Integer?) -> void
+      def initialize: (kind: Symbol, span: SourceSpan, text: String, ?token_type: Symbol?, ?token_index: Integer?) -> void
+
+      # @rbs () -> bool
+      def trivia?: () -> bool
+
+      # @rbs () -> bool
+      def opaque?: () -> bool
+
+      # @rbs () -> bool
+      def token?: () -> bool
+
+      # @rbs () -> String
+      def render: () -> String
+    end
+
+    module CST
+      # The immutable lexical root of a grammar source document.
+      class Document
+        include Enumerable[Segment]
+
+        attr_reader segments: Array[Segment]
+
+        # @rbs (Array[Segment] segments) -> void
+        def initialize: (Array[Segment] segments) -> void
+
+        def each: () -> Enumerator[Segment, Document]
+                | () { (Segment) -> void } -> Document
+
+        # @rbs () -> String
+        def render: () -> String
+
+        private
+
+        # @rbs (Array[Segment] segments) -> void
+        def validate_contiguous: (Array[Segment] segments) -> void
+      end
+    end
+
+    # Lossless grammar source plus its semantic parse and lexical concrete syntax tree.
+    class SourceDocument
+      attr_reader source: String
+
+      attr_reader file: String
+
+      attr_reader tokens: Array[Token]
+
+      attr_reader cst: CST::Document
+
+      attr_reader ast: AST::Root | AST::Fragment | nil
+
+      # @rbs (source: String, file: String, tokens: Array[Token], cst: CST::Document,
+      #   ?ast: AST::Root | AST::Fragment | nil) -> void
+      def initialize: (source: String, file: String, tokens: Array[Token], cst: CST::Document, ?ast: AST::Root | AST::Fragment | nil) -> void
+
+      # @rbs () -> String
+      def render: () -> String
+
+      # @rbs (SourceSpan span) -> String
+      def slice: (SourceSpan span) -> String
+
+      # @rbs (Integer byte_offset) -> SourcePosition
+      def position_at: (Integer byte_offset) -> SourcePosition
+
+      # @rbs (Integer line, Integer column) -> Integer
+      def byte_offset_at: (Integer line, Integer column) -> Integer
+
+      # @rbs (Integer start_byte, Integer end_byte) -> SourceSpan
+      def span: (Integer start_byte, Integer end_byte) -> SourceSpan
+
+      # @rbs (Segment segment) -> Token?
+      def token_for: (Segment segment) -> Token?
+
+      # @rbs (AST::Root | AST::Fragment ast) -> SourceDocument
+      def with_ast: (AST::Root | AST::Fragment ast) -> SourceDocument
+
+      private
+
+      # @rbs () -> Array[Integer]
+      def build_line_starts: () -> Array[Integer]
+
+      # @rbs () -> void
+      def validate_render: () -> void
+
+      # @rbs () -> bool
+      def full_source_coverage?: () -> bool
+
+      # @rbs () -> bool
+      def segment_slices_match?: () -> bool
+
+      # @rbs (Integer byte_offset) -> void
+      def validate_byte_offset: (Integer byte_offset) -> void
+
+      # @rbs (SourceSpan span) -> void
+      def validate_span: (SourceSpan span) -> void
+    end
+  end
+end

data/sig/ibex/frontend/source_loader.rbs

@@ -0,0 +1,66 @@
+# Generated from lib/ibex/frontend/source_loader.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Resolves canonical grammar paths and reads either open-buffer overlays or disk.
+    class SourceLoader
+      @access_paths: Hash[String, Array[String]]
+
+      @record_reads: bool
+
+      @read_records: Hash[String, GenerationInput]
+
+      @aliases: Hash[String, String]
+
+      @overlays: Hash[String, String]
+
+      # @rbs () -> Array[GenerationInput]
+      def read_records: () -> Array[GenerationInput]
+
+      # Associate the lexical path used by a resolver with its canonical source.
+      # @rbs (String canonical, String access_path) -> void
+      def record_access: (String canonical, String access_path) -> void
+
+      # @rbs (?overlays: Hash[String, String], ?record_reads: bool) -> void
+      def initialize: (?overlays: Hash[String, String], ?record_reads: bool) -> void
+
+      # Canonicalize an existing file, or a missing path explicitly allowed by an open overlay.
+      # @rbs (String path, ?base: String, ?allow_missing: bool) -> String
+      def canonical_path: (String path, ?base: String, ?allow_missing: bool) -> String
+
+      # @rbs (String path) -> String
+      def read: (String path) -> String
+
+      # @rbs (String path) -> bool
+      def file?: (String path) -> bool
+
+      # @rbs (String path) -> bool
+      def overlay?: (String path) -> bool
+
+      # Install or replace an editor buffer without writing it to disk.
+      # @rbs (String path, String source) -> String
+      def set_overlay: (String path, String source) -> String
+
+      # Remove an editor buffer and return its canonical path.
+      # @rbs (String path) -> String
+      def delete_overlay: (String path) -> String
+
+      # Read disk while deliberately bypassing an open overlay.
+      # @rbs (String path) -> String
+      def disk_source: (String path) -> String
+
+      # @rbs (String path) -> bool
+      def disk_file?: (String path) -> bool
+
+      # Resolve the current disk target without consulting overlay aliases.
+      # @rbs (String path) -> String
+      def disk_path: (String path) -> String
+
+      private
+
+      # Resolve the nearest existing ancestor so symlink escapes remain visible for new files.
+      # @rbs (String expanded) -> String
+      def canonical_missing_path: (String expanded) -> String
+    end
+  end
+end

data/sig/ibex/frontend/source_span.rbs

@@ -0,0 +1,56 @@
+# Generated from lib/ibex/frontend/source_span.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Normalizes grammar source without changing its bytes.
+    module SourceEncoding
+      # @rbs (String source, String file) -> String
+      def self.validated_utf8: (String source, String file) -> String
+
+      # @rbs (String file) -> String
+      def self.validated_file: (String file) -> String
+    end
+
+    # An immutable position in grammar source.
+    class SourcePosition
+      attr_reader byte_offset: Integer
+
+      attr_reader line: Integer
+
+      attr_reader column: Integer
+
+      # @rbs (byte_offset: Integer, line: Integer, column: Integer) -> void
+      def initialize: (byte_offset: Integer, line: Integer, column: Integer) -> void
+
+      # @rbs () -> Hash[Symbol, Integer]
+      def to_h: () -> Hash[Symbol, Integer]
+    end
+
+    # An immutable half-open byte span in one grammar source.
+    class SourceSpan
+      attr_reader file: String
+
+      attr_reader start: SourcePosition
+
+      attr_reader finish: SourcePosition
+
+      # @rbs (file: String, start: SourcePosition, finish: SourcePosition) -> void
+      def initialize: (file: String, start: SourcePosition, finish: SourcePosition) -> void
+
+      # @rbs () -> Integer
+      def start_byte: () -> Integer
+
+      # @rbs () -> Integer
+      def end_byte: () -> Integer
+
+      # @rbs () -> Integer
+      def length: () -> Integer
+
+      # @rbs () -> bool
+      def empty?: () -> bool
+
+      # @rbs () -> Hash[Symbol, Object?]
+      def to_h: () -> Hash[Symbol, Object?]
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# Generated from lib/ibex/frontend/token_adapter/declaration_document_state.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    class TokenAdapter
+      # Root/fragment header and include-path transitions for declaration classification.
+      module DeclarationDocumentState
+        private
+
+        # @rbs (Token token) -> external_token
+        def class_keyword: (Token token) -> external_token
+
+        # @rbs (external_token type) -> external_token?
+        def classify_include: (external_token type) -> external_token?
+
+        # @rbs (Token token, String value) -> void
+        def reject_fragment_pragma: (Token token, String value) -> void
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# Generated from lib/ibex/frontend/token_adapter/declaration_lexer_state.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    class TokenAdapter
+      # Context transitions for the extended root-only lexer declaration.
+      module DeclarationLexerState
+        private
+
+        # @rbs () -> bool
+        def lexer_declaration_state?: () -> bool
+
+        # @rbs (Token token) -> external_token
+        def classify_lexer_identifier: (Token token) -> external_token
+
+        # @rbs (Token token) -> external_token
+        def begin_lexer_entry: (Token token) -> external_token
+
+        # @rbs () -> external_token
+        def finish_lexer_scope: () -> external_token
+
+        # @rbs (external_token type) -> external_token?
+        def classify_lexer_scalar: (external_token type) -> external_token?
+      end
+    end
+  end
+end

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

@@ -4,7 +4,13 @@ module Ibex
   module Frontend
     class TokenAdapter
       # Classifies tokens through the class header and declaration section.
+      # rubocop:disable Metrics/ClassLength, Metrics/CyclomaticComplexity
+      # One state machine owns declaration-boundary classification.
       class DeclarationState
+        include DeclarationDocumentState
+
+        include DeclarationLexerState
+
         DECLARATIONS: Hash[String, [ external_token, Symbol ]]
 
         ASSOCIATIONS: Hash[String, external_token]
@@ -21,8 +27,16 @@ module Ibex
 
         attr_reader state: Symbol
 
-        # @rbs () -> void
-        def initialize: () -> void
+        @pragma_location: Location?
+
+        @pragmas: Hash[String, Location]
+
+        @fragment: bool?
+
+        @extended_mode: bool
+
+        # @rbs (?extended: bool) -> void
+        def initialize: (?extended: bool) -> void
 
         # @rbs (Token token, Array[Token] remaining) -> external_token
         def classify: (Token token, Array[Token] remaining) -> external_token
@@ -33,6 +47,15 @@ module Ibex
         # @rbs () -> bool
         def extended_pragma?: () -> bool
 
+        # @rbs () -> bool
+        def cst_pragma?: () -> bool
+
+        # @rbs () -> Location?
+        def extended_pragma_location: () -> Location?
+
+        # @rbs () -> Location?
+        def cst_pragma_location: () -> Location?
+
         # @rbs (Token? token) -> String?
         def expectation: (Token? token) -> String?
 
@@ -42,7 +65,10 @@ module Ibex
         def classify_identifier: (Token token, Array[Token] remaining) -> external_token
 
         # @rbs (Token token) -> external_token
-        def class_keyword: (Token token) -> external_token
+        def begin_parser_setting: (Token token) -> external_token
+
+        # @rbs () -> external_token
+        def finish_parser_setting: () -> external_token
 
         # @rbs (Array[Token] remaining) -> external_token
         def constant_name: (Array[Token] remaining) -> external_token
@@ -62,6 +88,9 @@ module Ibex
         # @rbs (String value) -> bool
         def declaration_boundary?: (String value) -> bool
 
+        # @rbs () -> bool
+        def extended_features?: () -> bool
+
         # @rbs (Token token) -> external_token
         def precedence_identifier: (Token token) -> external_token
 
@@ -74,9 +103,60 @@ module Ibex
         # @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 classify_single_symbol: (external_token type) -> external_token?
+
+        # @rbs (external_token type) -> external_token?
+        def continue_first_symbol: (external_token type) -> external_token?
+
+        # @rbs (Token token, external_token type) -> external_token?
+        def classify_token_alias: (Token token, external_token type) -> external_token?
+
+        # @rbs (external_token type) -> external_token?
+        def classify_metadata: (external_token type) -> external_token?
+
+        # @rbs (external_token type) -> external_token?
+        def classify_printer: (external_token type) -> external_token?
+
+        # @rbs (external_token type) -> external_token?
+        def classify_grammar_test: (external_token type) -> external_token?
+
+        # @rbs (Token token, external_token type, Array[Token] remaining) -> external_token?
+        def classify_conversion: (Token token, external_token type, 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 continue_start_symbols: (external_token type) -> external_token
+
+        # @rbs (external_token type) -> external_token
+        def continue_recovery_symbols: (external_token type) -> external_token
+
+        # @rbs (external_token type) -> external_token
+        def continue_on_error_reduce_symbols: (external_token type) -> external_token
+
+        # @rbs (external_token type) -> external_token
+        def begin_metadata_value: (external_token type) -> external_token
+
+        # @rbs () -> external_token
+        def begin_param_type: () -> external_token
+
+        # @rbs (external_token type) -> external_token
+        def begin_printer_action: (external_token type) -> external_token
+
+        # @rbs (Token token) -> external_token
+        def begin_recovery_colon: (Token token) -> external_token
+
+        # @rbs (Token token) -> external_token
+        def begin_test_source: (Token token) -> external_token
+
+        # @rbs (external_token type) -> external_token
+        def finish_param_type: (external_token type) -> external_token
+
+        # @rbs (external_token type) -> external_token
+        def finish_metadata_value: (external_token type) -> external_token
+
         # @rbs (external_token type) -> external_token
         def finish_conversion: (external_token type) -> external_token
 

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

@@ -11,6 +11,8 @@ module Ibex
 
         attr_reader state: Symbol
 
+        @node_annotation: bool?
+
         @rule_seen: bool?
 
         @lhs_column: Integer?
@@ -35,10 +37,16 @@ module Ibex
 
         private
 
+        # @rbs () -> external_token
+        def classify_inline: () -> external_token
+
         # @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, Array[Token] remaining) -> external_token
+        def classify_rhs_identifier: (Token token, Array[Token] remaining) -> external_token
+
         # @rbs (Token token) -> external_token
         def rule_lhs: (Token token) -> external_token
 
@@ -48,6 +56,12 @@ module Ibex
         # @rbs (Token token, Token following) -> bool
         def rule_boundary?: (Token token, Token following) -> bool
 
+        # @rbs (Token token, Array[Token] remaining) -> bool
+        def parameterized_rule_boundary?: (Token token, Array[Token] remaining) -> bool
+
+        # @rbs (Array[Token] tail) -> bool
+        def parameter_definition_tail?: (Array[Token] tail) -> bool
+
         # @rbs (Token token) -> external_token
         def start_rule: (Token token) -> external_token
 
@@ -60,6 +74,12 @@ module Ibex
         # @rbs (Token token) -> external_token
         def separated_terminal: (Token token) -> external_token
 
+        # @rbs (Token token, Token following) -> bool
+        def parameterized_call?: (Token token, Token following) -> bool
+
+        # @rbs (Token left, Token right) -> bool
+        def adjacent?: (Token left, Token right) -> bool
+
         # @rbs (Token token) -> external_token
         def classify_punctuation: (Token token) -> external_token
 

data/sig/ibex/frontend/token_adapter.rbs

@@ -22,8 +22,8 @@ module Ibex
 
       @tokens: Array[Token]
 
-      # @rbs (Array[Token] tokens) -> void
-      def initialize: (Array[Token] tokens) -> void
+      # @rbs (Array[Token] tokens, ?extended: bool) -> void
+      def initialize: (Array[Token] tokens, ?extended: bool) -> void
 
       # @rbs () -> ([external_token, Token] | false)
       def next_token: () -> ([ external_token, Token ] | false)
@@ -40,6 +40,15 @@ module Ibex
       # @rbs () -> bool
       def extended_pragma?: () -> bool
 
+      # @rbs () -> bool
+      def cst_pragma?: () -> bool
+
+      # @rbs () -> Location?
+      def extended_pragma_location: () -> Location?
+
+      # @rbs () -> Location?
+      def cst_pragma_location: () -> Location?
+
       # @rbs () -> parser_section
       def section: () -> parser_section
 

data/sig/ibex/frontend.rbs

@@ -10,6 +10,6 @@ module Ibex
 
     type parser_section = :declarations | :rules | :user_code
 
-    type delimiter_kind = :group | :separated
+    type delimiter_kind = :group | :separated | :parameter
   end
 end

data/sig/ibex/fuzz.rbs

@@ -0,0 +1,71 @@
+# Generated from lib/ibex/fuzz.rb with RBS::Inline
+
+module Ibex
+  type fuzz_outcome = Symbol | [ Symbol, String, String ]
+
+  type fuzz_mismatch = { tokens: Array[String], kind: Symbol, sentence: Integer, outcomes: Hash[Symbol, fuzz_outcome], bounds: Hash[Symbol, Integer] }
+
+  type fuzz_budget = { message: String, bounds: Hash[Symbol, Integer], ?tokens: Array[String], ?phase: String }
+
+  # Bounded grammar-derived differential fuzzing without semantic execution.
+  class Fuzz
+    ALGORITHMS: Array[Symbol]
+
+    DEFAULT_MAX_ACTIONS: Integer
+
+    DEFAULT_MAX_STACK: Integer
+
+    class Mismatch < Ibex::Error
+      attr_reader details: fuzz_mismatch
+
+      # @rbs (fuzz_mismatch details) -> void
+      def initialize: (fuzz_mismatch details) -> void
+    end
+
+    class BudgetExceeded < Ibex::Error
+      attr_reader details: fuzz_budget
+
+      # @rbs (fuzz_budget details) -> void
+      def initialize: (fuzz_budget details) -> void
+    end
+
+    # @rbs (IR::Grammar grammar, ?seed: Integer, ?count: Integer, ?max_tokens: Integer,
+    #   ?max_depth: Integer, ?max_expansions: Integer, ?max_actions: Integer, ?max_stack: Integer,
+    #   ?coverage_guided: bool, ?path_length: Integer, ?algorithms: Array[Symbol],
+    #   ?ielr_strategy: Symbol, ?automata: Hash[Symbol, IR::Automaton]?, ?against: (^(Array[String]) -> Symbol)?,
+    #   ?against_description: Hash[Symbol, Object?]?) -> void
+    # rubocop:disable Metrics/ParameterLists
+    def initialize: (IR::Grammar grammar, ?seed: Integer, ?count: Integer, ?max_tokens: Integer, ?max_depth: Integer, ?max_expansions: Integer, ?max_actions: Integer, ?max_stack: Integer, ?coverage_guided: bool, ?path_length: Integer, ?algorithms: Array[Symbol], ?ielr_strategy: Symbol, ?automata: Hash[Symbol, IR::Automaton]?, ?against: (^(Array[String]) -> Symbol)?, ?against_description: Hash[Symbol, Object?]?) -> void
+
+    # @rbs () -> Hash[Symbol, Object?]
+    def run: () -> Hash[Symbol, Object?]
+
+    # Minimize one observed mismatch without changing its kind or outcomes.
+    # @rbs (Mismatch mismatch, ?max_trials: Integer) -> DeltaReducer::Result
+    def minimize: (Mismatch mismatch, ?max_trials: Integer) -> DeltaReducer::Result
+
+    private
+
+    # @rbs () -> Array[Array[String]]
+    def generate_sentences: () -> Array[Array[String]]
+
+    # @rbs (Integer sentence_count, Integer mutation_count) -> untyped
+    def successful_report: (Integer sentence_count, Integer mutation_count) -> untyped
+
+    # @rbs () -> Hash[Symbol, IR::Automaton]
+    def build_automata: () -> Hash[Symbol, IR::Automaton]
+
+    # @rbs (Array[String] tokens, kind: Symbol, sentence: Integer) -> void
+    def compare!: (Array[String] tokens, kind: Symbol, sentence: Integer) -> void
+
+    # @rbs (Array[String] tokens) -> Array[Array[String]]
+    def mutations: (Array[String] tokens) -> Array[Array[String]]
+
+    # @rbs (Array[String] tokens, kind: Symbol, sentence: Integer,
+    #   outcomes: Hash[Symbol, fuzz_outcome]) -> bool
+    def mismatch_reproduced?: (Array[String] tokens, kind: Symbol, sentence: Integer, outcomes: Hash[Symbol, fuzz_outcome]) -> bool
+
+    # @rbs (Ibex::Error error) -> bool
+    def budget_error?: (Ibex::Error error) -> bool
+  end
+end