ibex 0.1.0 → 0.2.0

data/sig/ibex/frontend/ast.rbs

@@ -2,14 +2,36 @@
 
 module Ibex
   module Frontend
+    # Keeps the public Rule constructor compatible with ASTs built before parameters and inline rules existed.
+    module ASTRuleDefaults
+      # @rbs (*untyped arguments, **untyped keywords) -> void
+      def initialize: (*untyped arguments, **untyped keywords) -> void
+    end
+
     # Grammar frontend node types.
+    # rubocop:disable Metrics/ModuleLength -- the public node vocabulary is intentionally kept together.
     module AST
-      type declaration = Tokens | Precedence | Options | Expect | Start | Convert
+      type symbol_metadata = DisplayName | SemanticType
+
+      type declaration = Include | Tokens | Precedence | Options | Expect | ExpectRR | Start | Recovery | OnErrorReduce | GrammarTest | Lexer | Convert | Parameter | Printer | symbol_metadata
+
+      type lexer_entry = LexerRule | LexerState
 
-      type item = SymbolReference | InlineAction | Optional | Star | Plus | Group | SeparatedList
+      type item = SymbolReference | ParameterizedReference | InlineAction | Optional | Star | Plus | Group | SeparatedList | Empty
 
       type user_code = Hash[String, Array[UserCode]]
 
+      class Rule < Struct[String | Array[String] | Array[Alternative] | Location | String? | bool]
+        attr_accessor lhs: String
+        attr_accessor parameters: Array[String]
+        attr_accessor alternatives: Array[Alternative]
+        attr_accessor loc: Location
+        attr_accessor documentation: String?
+        attr_accessor inline: bool
+        def self.new: (?lhs: String, ?parameters: Array[String]?, ?alternatives: Array[Alternative], ?loc: Location, ?documentation: String?, ?inline: bool?) -> instance
+                    | ({ ?lhs: String, ?parameters: Array[String]?, ?alternatives: Array[Alternative], ?loc: Location, ?documentation: String?, ?inline: bool? }) -> instance
+      end
+
       # Adds deterministic, recursively serializable hashes to Struct nodes.
       # @rbs module-self Struct[untyped]
       module Node : Struct[untyped]
@@ -20,7 +42,7 @@ module Ibex
         def serialize: (untyped value) -> untyped
       end
 
-      class Root < Struct[String | String? | Array[declaration] | Array[Rule] | user_code | Location]
+      class Root < Struct[String | String? | Array[declaration] | Array[Rule] | user_code | Location | bool?]
         attr_accessor class_name(): String
 
         attr_accessor superclass(): String?
@@ -33,17 +55,43 @@ module Ibex
 
         attr_accessor loc(): Location
 
-        def self.new: (?class_name: String, ?superclass: String?, ?declarations: Array[declaration], ?rules: Array[Rule], ?user_code: user_code, ?loc: Location) -> instance
-                    | ({ ?class_name: String, ?superclass: String?, ?declarations: Array[declaration], ?rules: Array[Rule], ?user_code: user_code, ?loc: Location }) -> instance
+        attr_accessor extended(): bool?
+
+        attr_accessor cst(): bool?
+
+        def self.new: (?class_name: String, ?superclass: String?, ?declarations: Array[declaration], ?rules: Array[Rule], ?user_code: user_code, ?loc: Location, ?extended: bool?, ?cst: bool?) -> instance
+                    | ({ ?class_name: String, ?superclass: String?, ?declarations: Array[declaration], ?rules: Array[Rule], ?user_code: user_code, ?loc: Location, ?extended: bool?, ?cst: bool? }) -> instance
+      end
+
+      class Fragment < Struct[Array[declaration] | Array[Rule] | Location]
+        attr_accessor declarations(): Array[declaration]
+
+        attr_accessor rules(): Array[Rule]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?declarations: Array[declaration], ?rules: Array[Rule], ?loc: Location) -> instance
+                    | ({ ?declarations: Array[declaration], ?rules: Array[Rule], ?loc: Location }) -> instance
+      end
+
+      class Include < Struct[String | Location]
+        attr_accessor path(): String
+
+        attr_accessor loc(): Location
+
+        def self.new: (?path: String, ?loc: Location) -> instance
+                    | ({ ?path: String, ?loc: Location }) -> instance
       end
 
-      class Tokens < Struct[Array[String] | Location]
+      class Tokens < Struct[Array[String] | Hash[String, String]? | Location]
         attr_accessor names(): Array[String]
 
+        attr_accessor aliases(): Hash[String, String]?
+
         attr_accessor loc(): Location
 
-        def self.new: (?names: Array[String], ?loc: Location) -> instance
-                    | ({ ?names: Array[String], ?loc: Location }) -> instance
+        def self.new: (?names: Array[String], ?aliases: Hash[String, String]?, ?loc: Location) -> instance
+                    | ({ ?names: Array[String], ?aliases: Hash[String, String]?, ?loc: Location }) -> instance
       end
 
       class Precedence < Struct[Symbol | Array[PrecedenceLevel] | Location]
@@ -86,13 +134,88 @@ module Ibex
                     | ({ ?conflicts: Integer, ?loc: Location }) -> instance
       end
 
-      class Start < Struct[String | Location]
+      class ExpectRR < Struct[Integer | Location]
+        attr_accessor conflicts(): Integer
+
+        attr_accessor loc(): Location
+
+        def self.new: (?conflicts: Integer, ?loc: Location) -> instance
+                    | ({ ?conflicts: Integer, ?loc: Location }) -> instance
+      end
+
+      class Start < Struct[Array[String] | Location]
+        attr_accessor names(): Array[String]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?names: Array[String], ?loc: Location) -> instance
+                    | ({ ?names: Array[String], ?loc: Location }) -> instance
+      end
+
+      class Recovery < Struct[Array[String] | Location]
+        attr_accessor sync_tokens(): Array[String]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?sync_tokens: Array[String], ?loc: Location) -> instance
+                    | ({ ?sync_tokens: Array[String], ?loc: Location }) -> instance
+      end
+
+      class OnErrorReduce < Struct[Array[String] | Location]
+        attr_accessor names(): Array[String]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?names: Array[String], ?loc: Location) -> instance
+                    | ({ ?names: Array[String], ?loc: Location }) -> instance
+      end
+
+      class GrammarTest < Struct[Symbol | String | Location]
+        attr_accessor expectation(): Symbol
+
+        attr_accessor source(): String
+
+        attr_accessor loc(): Location
+
+        def self.new: (?expectation: Symbol, ?source: String, ?loc: Location) -> instance
+                    | ({ ?expectation: Symbol, ?source: String, ?loc: Location }) -> instance
+      end
+
+      class Lexer < Struct[Array[lexer_entry] | Location]
+        attr_accessor definitions(): Array[lexer_entry]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?definitions: Array[lexer_entry], ?loc: Location) -> instance
+                    | ({ ?definitions: Array[lexer_entry], ?loc: Location }) -> instance
+      end
+
+      class LexerRule < Struct[Symbol | String? | String | Location]
+        attr_accessor kind(): Symbol
+
+        attr_accessor token(): String?
+
+        attr_accessor pattern(): String
+
+        attr_accessor pattern_kind(): Symbol
+
+        attr_accessor action(): String?
+
+        attr_accessor loc(): Location
+
+        def self.new: (?kind: Symbol, ?token: String?, ?pattern: String, ?pattern_kind: Symbol, ?action: String?, ?loc: Location) -> instance
+                    | ({ ?kind: Symbol, ?token: String?, ?pattern: String, ?pattern_kind: Symbol, ?action: String?, ?loc: Location }) -> instance
+      end
+
+      class LexerState < Struct[String | Array[lexer_entry] | Location]
         attr_accessor name(): String
 
+        attr_accessor definitions(): Array[lexer_entry]
+
         attr_accessor loc(): Location
 
-        def self.new: (?name: String, ?loc: Location) -> instance
-                    | ({ ?name: String, ?loc: Location }) -> instance
+        def self.new: (?name: String, ?definitions: Array[lexer_entry], ?loc: Location) -> instance
+                    | ({ ?name: String, ?definitions: Array[lexer_entry], ?loc: Location }) -> instance
       end
 
       class Convert < Struct[Array[Conversion] | Location]
@@ -115,28 +238,74 @@ module Ibex
                     | ({ ?name: String, ?expression: String, ?loc: Location }) -> instance
       end
 
-      class Rule < Struct[String | Array[Alternative] | Location]
-        attr_accessor lhs(): String
+      class DisplayName < Struct[String | Location]
+        attr_accessor name(): String
+
+        attr_accessor value(): String
+
+        attr_accessor loc(): Location
+
+        def self.new: (?name: String, ?value: String, ?loc: Location) -> instance
+                    | ({ ?name: String, ?value: String, ?loc: Location }) -> instance
+      end
+
+      class SemanticType < Struct[String | Location]
+        attr_accessor name(): String
+
+        attr_accessor value(): String
+
+        attr_accessor loc(): Location
+
+        def self.new: (?name: String, ?value: String, ?loc: Location) -> instance
+                    | ({ ?name: String, ?value: String, ?loc: Location }) -> instance
+      end
+
+      class Parameter < Struct[String | String? | Location]
+        attr_accessor name(): String
+
+        attr_accessor semantic_type(): String?
+
+        attr_accessor loc(): Location
+
+        def self.new: (?name: String, ?semantic_type: String?, ?loc: Location) -> instance
+                    | ({ ?name: String, ?semantic_type: String?, ?loc: Location }) -> instance
+      end
+
+      class Printer < Struct[String | Location]
+        attr_accessor name(): String
 
-        attr_accessor alternatives(): Array[Alternative]
+        attr_accessor code(): String
 
         attr_accessor loc(): Location
 
-        def self.new: (?lhs: String, ?alternatives: Array[Alternative], ?loc: Location) -> instance
-                    | ({ ?lhs: String, ?alternatives: Array[Alternative], ?loc: Location }) -> instance
+        def self.new: (?name: String, ?code: String, ?loc: Location) -> instance
+                    | ({ ?name: String, ?code: String, ?loc: Location }) -> instance
       end
 
-      class Alternative < Struct[Array[item] | InlineAction? | String? | Location]
+      class Alternative < Struct[Array[item] | InlineAction? | String? | NodeAnnotation? | Location]
         attr_accessor items(): Array[item]
 
         attr_accessor action(): InlineAction?
 
         attr_accessor precedence(): String?
 
+        attr_accessor node_annotation(): NodeAnnotation?
+
+        attr_accessor loc(): Location
+
+        def self.new: (?items: Array[item], ?action: InlineAction?, ?precedence: String?, ?node_annotation: NodeAnnotation?, ?loc: Location) -> instance
+                    | ({ ?items: Array[item], ?action: InlineAction?, ?precedence: String?, ?node_annotation: NodeAnnotation?, ?loc: Location }) -> instance
+      end
+
+      class NodeAnnotation < Struct[String | Array[String] | Location]
+        attr_accessor name(): String
+
+        attr_accessor fields(): Array[String]
+
         attr_accessor loc(): Location
 
-        def self.new: (?items: Array[item], ?action: InlineAction?, ?precedence: String?, ?loc: Location) -> instance
-                    | ({ ?items: Array[item], ?action: InlineAction?, ?precedence: String?, ?loc: Location }) -> instance
+        def self.new: (?name: String, ?fields: Array[String], ?loc: Location) -> instance
+                    | ({ ?name: String, ?fields: Array[String], ?loc: Location }) -> instance
       end
 
       class SymbolReference < Struct[String | String? | Location]
@@ -150,6 +319,19 @@ module Ibex
                     | ({ ?name: String, ?named_reference: String?, ?loc: Location }) -> instance
       end
 
+      class ParameterizedReference < Struct[String | Array[item] | String? | Location]
+        attr_accessor name(): String
+
+        attr_accessor arguments(): Array[item]
+
+        attr_accessor named_reference(): String?
+
+        attr_accessor loc(): Location
+
+        def self.new: (?name: String, ?arguments: Array[item], ?named_reference: String?, ?loc: Location) -> instance
+                    | ({ ?name: String, ?arguments: Array[item], ?named_reference: String?, ?loc: Location }) -> instance
+      end
+
       class InlineAction < Struct[String | Location]
         attr_accessor code(): String
 
@@ -159,6 +341,13 @@ module Ibex
                     | ({ ?code: String, ?loc: Location }) -> instance
       end
 
+      class Empty < Struct[Location]
+        attr_accessor loc(): Location
+
+        def self.new: (?loc: Location) -> instance
+                    | ({ ?loc: Location }) -> instance
+      end
+
       class Optional < Struct[item | Location]
         attr_accessor item(): item
 

data/sig/ibex/frontend/bootstrap_parser.rbs

@@ -8,6 +8,8 @@ module Ibex
 
       include BootstrapParserRules
 
+      include BootstrapParserParameters
+
       @mode: Symbol
 
       @index: Integer
@@ -20,8 +22,17 @@ module Ibex
       # @rbs () -> AST::Root
       def parse: () -> AST::Root
 
+      # @rbs () -> AST::Fragment
+      def parse_fragment: () -> AST::Fragment
+
       private
 
+      # @rbs (Array[AST::declaration] declarations) -> void
+      def reject_fragment_root_declarations: (Array[AST::declaration] declarations) -> void
+
+      # @rbs (AST::declaration declaration) -> String?
+      def fragment_root_declaration_name: (AST::declaration declaration) -> String?
+
       # @rbs () -> String
       def parse_constant_path: () -> String
 

data/sig/ibex/frontend/diagnostic.rbs

@@ -0,0 +1,53 @@
+# Generated from lib/ibex/frontend/diagnostic.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # An immutable machine-readable frontend error.
+    class Diagnostic
+      attr_reader code: String
+
+      attr_reader phase: Symbol
+
+      attr_reader message: String
+
+      attr_reader location: Location
+
+      attr_reader span: SourceSpan?
+
+      attr_reader expected: Array[String]
+
+      attr_reader received: String?
+
+      # @rbs (code: String, phase: Symbol, message: String, location: Location, ?span: SourceSpan?,
+      #   ?expected: Array[String], ?received: String?, ?rendered: String?) -> void
+      def initialize: (code: String, phase: Symbol, message: String, location: Location, ?span: SourceSpan?, ?expected: Array[String], ?received: String?, ?rendered: String?) -> void
+
+      # @rbs () -> String
+      def severity: () -> String
+
+      # @rbs () -> String
+      def to_s: () -> String
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+
+    # Immutable output from a diagnostic parse.
+    class ParseResult
+      attr_reader diagnostics: Array[Diagnostic]
+
+      attr_reader ast: AST::Root?
+
+      attr_reader document: SourceDocument?
+
+      # @rbs (diagnostics: Array[Diagnostic], ast: AST::Root?, document: SourceDocument?) -> void
+      def initialize: (diagnostics: Array[Diagnostic], ast: AST::Root?, document: SourceDocument?) -> void
+
+      # @rbs () -> bool
+      def success?: () -> bool
+
+      # @rbs () -> bool
+      def partial?: () -> bool
+    end
+  end
+end

data/sig/ibex/frontend/diagnostic_recovery.rbs

@@ -0,0 +1,98 @@
+# Generated from lib/ibex/frontend/diagnostic_recovery.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Re-runs the generated parser after suppressing only conservative source regions.
+    class DiagnosticRecovery
+      DECLARATION_STARTS: Array[String]
+
+      @suppressed: Hash[Integer, bool]
+
+      @max_diagnostics: Integer
+
+      @mode: Symbol
+
+      @tokens: Array[Token]
+
+      # @rbs (Array[Token] tokens, mode: Symbol, max_diagnostics: Integer) -> void
+      def initialize: (Array[Token] tokens, mode: Symbol, max_diagnostics: Integer) -> void
+
+      # @rbs () -> [AST::Root | AST::Fragment | nil, Array[Diagnostic]]
+      def parse: () -> [ AST::Root | AST::Fragment | nil, Array[Diagnostic] ]
+
+      private
+
+      # @rbs () -> (AST::Root | AST::Fragment | nil)
+      def parse_until_stable: () -> (AST::Root | AST::Fragment | nil)
+
+      # @rbs () -> Array[Token]
+      def working_tokens: () -> Array[Token]
+
+      # @rbs (Diagnostic diagnostic) -> void
+      def append_diagnostic: (Diagnostic diagnostic) -> void
+
+      # @rbs (Diagnostic diagnostic) -> [String, String, Integer, Integer, String]
+      def diagnostic_key: (Diagnostic diagnostic) -> [ String, String, Integer, Integer, String ]
+
+      # @rbs () -> Array[Diagnostic]
+      def sorted_diagnostics: () -> Array[Diagnostic]
+
+      # @rbs (Diagnostic diagnostic) -> [String, Integer, Integer, String, String]
+      def diagnostic_sort_key: (Diagnostic diagnostic) -> [ String, Integer, Integer, String, String ]
+
+      # @rbs (Token? token, Exception error) -> Range[Integer]?
+      def suppression_range: (Token? token, Exception error) -> Range[Integer]?
+
+      # @rbs (Token? token) -> Integer?
+      def token_index: (Token? token) -> Integer?
+
+      # @rbs (String message) -> Integer?
+      def token_index_for_message: (String message) -> Integer?
+
+      # @rbs () -> Integer?
+      def rule_marker_index: () -> Integer?
+
+      # @rbs (Integer failure, Integer rule_marker) -> Range[Integer]?
+      def declaration_range: (Integer failure, Integer rule_marker) -> Range[Integer]?
+
+      # @rbs (Integer index) -> bool
+      def declaration_start?: (Integer index) -> bool
+
+      # @rbs (Integer start, Integer rule_marker, Array[Integer] starts) -> Integer
+      def declaration_finish: (Integer start, Integer rule_marker, Array[Integer] starts) -> Integer
+
+      # @rbs (Integer start, Integer fallback, String closer) -> Integer
+      def matching_declaration_end: (Integer start, Integer fallback, String closer) -> Integer
+
+      # @rbs (Integer failure, Integer rule_marker) -> Range[Integer]?
+      def rule_range: (Integer failure, Integer rule_marker) -> Range[Integer]?
+
+      # @rbs (Integer rule_marker) -> Integer
+      def grammar_end_index: (Integer rule_marker) -> Integer
+
+      # @rbs (Integer rule_marker, Integer grammar_end) -> Array[Integer]
+      def rule_definition_starts: (Integer rule_marker, Integer grammar_end) -> Array[Integer]
+
+      # @rbs (Integer index, Integer? lhs_column) -> bool
+      def lhs_candidate?: (Integer index, Integer? lhs_column) -> bool
+
+      # @rbs (Integer failure, Integer start, Integer finish) -> Range[Integer]?
+      def alternative_range: (Integer failure, Integer start, Integer finish) -> Range[Integer]?
+
+      # @rbs (Integer? previous, Integer? following, Integer colon, Integer finish) -> Range[Integer]?
+      def alternative_slice: (Integer? previous, Integer? following, Integer colon, Integer finish) -> Range[Integer]?
+
+      # @rbs (Integer start, Integer finish) -> Array[Integer]
+      def top_level_pipes: (Integer start, Integer finish) -> Array[Integer]
+
+      # @rbs (Range[Integer] range) -> bool
+      def suppress: (Range[Integer] range) -> bool
+
+      # @rbs (Exception error, Token? token, phase: Symbol) -> Diagnostic
+      def diagnostic_from: (Exception error, Token? token, phase: Symbol) -> Diagnostic
+
+      # @rbs (String message) -> [Array[String], String?]
+      def expected_and_received: (String message) -> [ Array[String], String? ]
+    end
+  end
+end

data/sig/ibex/frontend/dsl.rbs

@@ -35,12 +35,36 @@ module Ibex
         # @rbs (Integer conflicts) -> void
         def expect: (Integer conflicts) -> void
 
-        # @rbs (Object name) -> void
-        def start: (Object name) -> void
+        # @rbs (*Object names) -> void
+        def start: (*Object names) -> void
+
+        # @rbs (*Object names) -> void
+        def recover_sync: (*Object names) -> void
+
+        # @rbs (*Object names) -> void
+        def on_error_reduce: (*Object names) -> void
+
+        # @rbs (Object source) -> void
+        def test_accept: (Object source) -> void
+
+        # @rbs (Object source) -> void
+        def test_reject: (Object source) -> void
 
         # @rbs (Object name, Object expression) -> void
         def convert: (Object name, Object expression) -> void
 
+        # @rbs (Object name, Object value) -> void
+        def display: (Object name, Object value) -> void
+
+        # @rbs (Object name, Object value) -> void
+        def type: (Object name, Object value) -> void
+
+        # @rbs (Object name, ?Object? semantic_type) -> void
+        def param: (Object name, ?Object? semantic_type) -> void
+
+        # @rbs (Object name, Object code) -> void
+        def printer: (Object name, Object code) -> void
+
         # @rbs (?direction: Symbol) { (PrecedenceBuilder) -> void } -> void
         def precedence: (?direction: Symbol) { (PrecedenceBuilder) -> void } -> void
 
@@ -79,6 +103,11 @@ module Ibex
 
         # @rbs () -> Location
         def next_location: () -> Location
+
+        private
+
+        # @rbs (Object value, String feature) -> String
+        def metadata_value: (Object value, String feature) -> String
       end
 
       # Collects ordered associativity levels.
@@ -116,8 +145,8 @@ module Ibex
         # @rbs (Builder grammar, Location default_location) -> void
         def initialize: (Builder grammar, Location default_location) -> void
 
-        # @rbs (*Object items, ?action: Object?, ?precedence: Object?) -> void
-        def alt: (*Object items, ?action: Object?, ?precedence: Object?) -> void
+        # @rbs (*Object items, ?action: Object?, ?precedence: Object?, ?node: AST::NodeAnnotation?) -> void
+        def alt: (*Object items, ?action: Object?, ?precedence: Object?, ?node: AST::NodeAnnotation?) -> void
       end
     end
   end

data/sig/ibex/frontend/formatter.rbs

@@ -0,0 +1,135 @@
+# Generated from lib/ibex/frontend/formatter.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Deterministically formats grammar trivia and rejects any semantic change.
+    # rubocop:disable Metrics/ClassLength -- token layout policy stays together so adjacency rules remain auditable.
+    class Formatter
+      DECLARATION_STARTS: Array[Symbol]
+
+      ASSOCIATIONS: Array[Symbol]
+
+      CALLABLES: Array[Symbol]
+
+      SUFFIXES: Array[String]
+
+      CLOSERS: Array[String]
+
+      ADJACENT_AFTER: Array[String]
+
+      type formatter_element = { segment: Segment, external: external_token?, role: Symbol?, gap: Array[Segment] }
+
+      # @rbs (String source, ?file: String, ?mode: Symbol) -> String
+      def self.format: (String source, ?file: String, ?mode: Symbol) -> String
+
+      # @rbs (?mode: Symbol) -> void
+      def initialize: (?mode: Symbol) -> void
+
+      # @rbs (String source, ?file: String) -> String
+      def format: (String source, ?file: String) -> String
+
+      private
+
+      # @rbs (SourceDocument document) -> String
+      def render: (SourceDocument document) -> String
+
+      # @rbs (SourceDocument document) -> Array[formatter_element]
+      def build_elements: (SourceDocument document) -> Array[formatter_element]
+
+      # @rbs (Array[Token] tokens) -> Hash[Integer, external_token]
+      def external_types: (Array[Token] tokens) -> Hash[Integer, external_token]
+
+      # @rbs (Array[formatter_element] elements) -> void
+      def annotate_roles: (Array[formatter_element] elements) -> void
+
+      # @rbs (Array[formatter_element] elements) -> void
+      def annotate_comment_indentation: (Array[formatter_element] elements) -> void
+
+      # @rbs (external_token external, Hash[Symbol, untyped] state) -> Symbol?
+      def token_role: (external_token external, Hash[Symbol, untyped] state) -> Symbol?
+
+      # @rbs (external_token external, Hash[Symbol, untyped] state) -> Symbol?
+      def document_token_role: (external_token external, Hash[Symbol, untyped] state) -> Symbol?
+
+      # @rbs (Hash[Symbol, untyped] state) -> Symbol?
+      def section_end_role: (Hash[Symbol, untyped] state) -> Symbol?
+
+      # @rbs (external_token external, Hash[Symbol, untyped] state) -> Symbol?
+      def rule_token_role: (external_token external, Hash[Symbol, untyped] state) -> Symbol?
+
+      # @rbs (external_token external, Hash[Symbol, untyped] state) -> Symbol
+      def precedence_role: (external_token external, Hash[Symbol, untyped] state) -> Symbol
+
+      # @rbs (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
+      def advance_role_state: (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
+
+      # @rbs (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
+      def advance_precedence_state: (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
+
+      # @rbs (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
+      def advance_conversion_state: (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
+
+      # @rbs (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
+      def advance_rule_state: (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
+
+      # @rbs (formatter_element? previous, formatter_element current) -> String
+      def separator: (formatter_element? previous, formatter_element current) -> String
+
+      # @rbs (formatter_element current, Array[Segment] gap) -> String
+      def leading_separator: (formatter_element current, Array[Segment] gap) -> String
+
+      # @rbs (formatter_element previous, Array[Segment] gap) -> String
+      def trailing_separator: (formatter_element previous, Array[Segment] gap) -> String
+
+      # @rbs (Segment previous, Segment current) -> bool
+      def direct_opaque_pair?: (Segment previous, Segment current) -> bool
+
+      # @rbs (Segment segment) -> bool
+      def comment?: (Segment segment) -> bool
+
+      # @rbs (formatter_element previous, formatter_element current, Array[Segment] gap) -> String
+      def comment_separator: (formatter_element previous, formatter_element current, Array[Segment] gap) -> String
+
+      # @rbs (formatter_element previous, formatter_element current) -> Symbol
+      def separator_kind: (formatter_element previous, formatter_element current) -> Symbol
+
+      # @rbs (external_token? previous_external, external_token? current_external,
+      #   Symbol? previous_role, Symbol? current_role) -> bool
+      def adjacent_tokens?: (external_token? previous_external, external_token? current_external, Symbol? previous_role, Symbol? current_role) -> bool
+
+      # @rbs (Symbol? previous_role, Symbol? current_role, formatter_element previous,
+      #   formatter_element current) -> bool
+      def line_boundary?: (Symbol? previous_role, Symbol? current_role, formatter_element previous, formatter_element current) -> bool
+
+      # @rbs (formatter_element element) -> Integer
+      def indentation: (formatter_element element) -> Integer
+
+      # @rbs (Symbol kind, Array[Segment] gap, Integer indentation) -> String
+      def render_separator: (Symbol kind, Array[Segment] gap, Integer indentation) -> String
+
+      # @rbs (Array[Segment] gap) -> bool
+      def newline_in?: (Array[Segment] gap) -> bool
+
+      # @rbs (String text) -> bool
+      def text_ends_with_newline?: (String text) -> bool
+
+      # @rbs (untyped left, untyped right) -> bool
+      def same_semantic_projection?: (untyped left, untyped right) -> bool
+
+      # @rbs (untyped left, untyped right) -> bool
+      def comparable_semantic_values?: (untyped left, untyped right) -> bool
+
+      # @rbs (Hash[untyped, untyped] left, untyped right) -> bool
+      def comparable_semantic_hashes?: (Hash[untyped, untyped] left, untyped right) -> bool
+
+      # @rbs (Array[[untyped, untyped]] pending, untyped left, untyped right) -> void
+      def append_semantic_children: (Array[[ untyped, untyped ]] pending, untyped left, untyped right) -> void
+
+      # @rbs (Struct[untyped] value) -> Array[Symbol]
+      def semantic_members: (Struct[untyped] value) -> Array[Symbol]
+
+      # @rbs (Hash[untyped, untyped] value) -> Array[untyped]
+      def semantic_keys: (Hash[untyped, untyped] value) -> Array[untyped]
+    end
+  end
+end