ibex 0.1.0 → 0.2.0

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,53 @@
+# 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
+    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, untyped]
+      def to_h: () -> Hash[Symbol, untyped]
+    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, bool]
+
+        @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,9 @@ module Ibex
         # @rbs () -> bool
         def extended_pragma?: () -> bool
 
+        # @rbs () -> bool
+        def cst_pragma?: () -> bool
+
         # @rbs (Token? token) -> String?
         def expectation: (Token? token) -> String?
 
@@ -41,9 +58,6 @@ module Ibex
         # @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
 
@@ -62,6 +76,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 +91,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,9 @@ module Ibex
       # @rbs () -> bool
       def extended_pragma?: () -> bool
 
+      # @rbs () -> bool
+      def cst_pragma?: () -> bool
+
       # @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/generation_input.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/ibex/generation_input.rb with RBS::Inline
+
+module Ibex
+  # Digest and identity of source bytes actually consumed by one generation.
+  class GenerationInput
+    attr_reader path: String
+
+    attr_reader sha256: String
+
+    attr_reader bytesize: Integer
+
+    attr_reader dev: Integer
+
+    attr_reader ino: Integer
+
+    attr_reader access_paths: Array[String]
+
+    # @rbs (String path, String source, ?access_path: String) -> void
+    def initialize: (String path, String source, ?access_path: String) -> void
+
+    # Record another lexical path that supplied these canonical bytes.
+    # @rbs (String path) -> void
+    def add_access_path: (String path) -> void
+
+    # @rbs () -> Hash[String, untyped]
+    def to_h: () -> Hash[String, untyped]
+
+    # Detect content changes even when size and timestamps are preserved.
+    # @rbs () -> bool
+    def current?: () -> bool
+
+    private
+
+    # @rbs () -> bool
+    def lexical_paths_current?: () -> bool
+  end
+end

data/sig/ibex/generation_manifest.rbs

@@ -0,0 +1,67 @@
+# Generated from lib/ibex/generation_manifest.rb with RBS::Inline
+
+module Ibex
+  # Deterministic description of one published parser generation.
+  module GenerationManifest
+    SCHEMA_VERSION: Integer
+
+    IDENTIFIER: String
+
+    ROOT_KEYS: Array[String]
+
+    INPUT_KEYS: Array[String]
+
+    FILE_KEYS: Array[String]
+
+    ARTIFACT_KEYS: Array[String]
+
+    # @rbs (ArtifactSet artifacts, source_records: Array[GenerationInput], options: Hash[String, untyped]) -> String
+    def self?.render: (ArtifactSet artifacts, source_records: Array[GenerationInput], options: Hash[String, untyped]) -> String
+
+    # Validate the manifest shape and, by default, every published artifact digest.
+    # @rbs (String source, ?verify_artifacts: bool) -> Hash[String, untyped]
+    def self?.validate: (String source, ?verify_artifacts: bool) -> Hash[String, untyped]
+
+    # @rbs (String path, ?verify_artifacts: bool) -> Hash[String, untyped]
+    def self?.validate_file: (String path, ?verify_artifacts: bool) -> Hash[String, untyped]
+
+    # @rbs (Artifact artifact) -> Hash[String, untyped]
+    def self?.artifact_entry: (Artifact artifact) -> Hash[String, untyped]
+
+    # @rbs (Array[Hash[String, untyped]] files) -> String
+    def self?.input_digest: (Array[Hash[String, untyped]] files) -> String
+
+    # @rbs (Hash[String, untyped] value) -> Hash[String, untyped]
+    def self?.sorted_hash: (Hash[String, untyped] value) -> Hash[String, untyped]
+
+    # @rbs (untyped document) -> void
+    def self?.validate_document: (untyped document) -> void
+
+    # @rbs (Hash[untyped, untyped] document) -> void
+    def self?.validate_identity: (Hash[untyped, untyped] document) -> void
+
+    # @rbs (untyped input) -> void
+    def self?.validate_input: (untyped input) -> void
+
+    # @rbs (Array[untyped] entries, String label, ?require_kind: bool) -> void
+    def self?.validate_entries: (Array[untyped] entries, String label, ?require_kind: bool) -> void
+
+    # @rbs (untyped entry, String label, bool require_kind) -> void
+    def self?.validate_entry: (untyped entry, String label, bool require_kind) -> void
+
+    # @rbs (untyped path, String label) -> void
+    def self?.validate_path: (untyped path, String label) -> void
+
+    # @rbs (untyped kind, String label) -> void
+    def self?.validate_kind: (untyped kind, String label) -> void
+
+    # @rbs (untyped digest, String label) -> void
+    def self?.validate_digest: (untyped digest, String label) -> void
+
+    # @rbs (Hash[untyped, untyped] value, Array[String] expected, String label) -> void
+    def self?.exact_keys!: (Hash[untyped, untyped] value, Array[String] expected, String label) -> void
+
+    # @rbs (Array[untyped] entries) -> void
+    def self?.verify_entries: (Array[untyped] entries) -> void
+  end
+end

data/sig/ibex/generation_transaction.rbs

@@ -0,0 +1,82 @@
+# Generated from lib/ibex/generation_transaction.rb with RBS::Inline
+
+module Ibex
+  # Publishes a rendered ArtifactSet with rollback and a manifest-last marker.
+  class GenerationTransaction
+    include GenerationTransactionRecovery
+
+    include GenerationTransactionValidation
+
+    class SourceChanged < Ibex::Error
+    end
+
+    class Error < Ibex::Error
+      attr_reader rollback_failed: bool
+
+      attr_reader recovery_artifacts: Array[String]
+
+      # @rbs (String message, ?rollback_failed: bool, ?recovery_artifacts: Array[String]) -> void
+      def initialize: (String message, ?rollback_failed: bool, ?recovery_artifacts: Array[String]) -> void
+    end
+
+    # rubocop:disable Layout/LineLength
+    # @rbs (ArtifactSet artifacts, ?warning: ^(String) -> void, ?stability_check: ^() -> bool, ?source_records: Array[GenerationInput], ?lock_sleeper: ^(Float) -> void) -> void
+    def initialize: (ArtifactSet artifacts, ?warning: ^(String) -> void, ?stability_check: ^() -> bool, ?source_records: Array[GenerationInput], ?lock_sleeper: ^(Float) -> void) -> void
+
+    # @rbs () -> void
+    def commit: () -> void
+
+    private
+
+    # @rbs () -> void
+    def prepare_records: () -> void
+
+    # @rbs (Artifact artifact, String target) -> Integer
+    def target_mode: (Artifact artifact, String target) -> Integer
+
+    # @rbs () -> void
+    def acquire_locks: () -> void
+
+    # @rbs (File lock, String path) -> void
+    def acquire_lock: (File lock, String path) -> void
+
+    # @rbs (String target) -> String
+    def lock_path: (String target) -> String
+
+    # @rbs () -> void
+    def stage_records: () -> void
+
+    # @rbs () -> void
+    def backup_records: () -> void
+
+    # @rbs (String directory, String suffix) -> File
+    def create_temporary_file: (String directory, String suffix) -> File
+
+    # @rbs (String target, String directory) -> String
+    def create_backup_link: (String target, String directory) -> String
+
+    # @rbs (String directory, String suffix) { (String) -> void } -> void
+    def with_temporary_path: (String directory, String suffix) { (String) -> void } -> void
+
+    # @rbs (Symbol group) -> void
+    def install_group: (Symbol group) -> void
+
+    # @rbs (Artifact artifact) -> Symbol
+    def publication_group: (Artifact artifact) -> Symbol
+
+    # @rbs () -> void
+    def sync_directories!: () -> void
+
+    # @rbs () -> void
+    def cleanup_success: () -> void
+
+    # @rbs (Exception error) -> void
+    def report_post_commit_failure: (Exception error) -> void
+
+    # @rbs (String message) -> void
+    def warn_best_effort: (String message) -> void
+
+    # @rbs () -> void
+    def release_locks: () -> void
+  end
+end