ibex-runtime 0.2.0

data/sig/ibex/runtime/cst/kind.rbs

@@ -0,0 +1,93 @@
+# Generated from lib/ibex/runtime/cst/kind.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Flags cached on Green elements and propagated by Green nodes.
+      module Flags
+        CONTAINS_ERROR: Integer
+
+        CONTAINS_MISSING: Integer
+
+        CONTAINS_SKIPPED: Integer
+
+        HAS_ANNOTATION: Integer
+
+        SYNTHETIC: Integer
+
+        INCOMPLETE_INPUT: Integer
+      end
+
+      # Grammar-specific integer kind names and interval predicates.
+      class Kind
+        type kind_map = Hash[String, Integer]
+
+        type field_slot = Integer | { index: Integer, extraction: Symbol }
+
+        type slot = { node_kind: Integer, node_name: String, fields: Hash[String, field_slot] }
+
+        type metadata = { names: Array[String], terminal_range: Array[Integer], nonterminal_range: Array[Integer], named: kind_map, named_nonterminals: Hash[Integer, Integer], trivia: kind_map, synthetic: kind_map }
+
+        @field_slots: Hash[Integer, Hash[String, field_slot]]
+
+        @synthetic: Hash[String, Integer]
+
+        @trivia: Hash[String, Integer]
+
+        @named_nonterminals: Hash[Integer, Integer]
+
+        @named: Hash[String, Integer]
+
+        @nonterminal_range: Array[Integer]
+
+        @terminal_range: Array[Integer]
+
+        @names: Array[String]
+
+        # @rbs (metadata metadata, ?slots: Hash[Integer, slot]) -> void
+        def initialize: (metadata metadata, ?slots: Hash[Integer, slot]) -> void
+
+        # @rbs (Integer kind) -> String
+        def name: (Integer kind) -> String
+
+        # @rbs (String | Symbol name) -> Integer
+        def fetch: (String | Symbol name) -> Integer
+
+        # @rbs (Integer kind) -> bool
+        def terminal?: (Integer kind) -> bool
+
+        # @rbs (Integer kind) -> bool
+        def nonterminal?: (Integer kind) -> bool
+
+        # @rbs (Integer kind) -> bool
+        def trivia?: (Integer kind) -> bool
+
+        # @rbs (Integer kind) -> bool
+        def error?: (Integer kind) -> bool
+
+        # Map a named node kind to its physical nonterminal kind.
+        # @rbs (Integer kind) -> Integer
+        def nonterminal_of: (Integer kind) -> Integer
+
+        # Return the named field-to-physical-slot mapping for a kind.
+        # @rbs (Integer kind) -> Hash[String, field_slot]
+        def fields: (Integer kind) -> Hash[String, field_slot]
+
+        # Return the serialization-safe kind metadata.
+        # @rbs () -> metadata
+        def to_h: () -> metadata
+
+        private
+
+        # : Hash[String, field_slot]
+        EMPTY_FIELDS: untyped
+
+        # @rbs (Hash[Integer, slot] slots) -> Hash[Integer, Hash[String, field_slot]]
+        def build_field_slots: (Hash[Integer, slot] slots) -> Hash[Integer, Hash[String, field_slot]]
+
+        # @rbs (Array[Integer] range, Integer kind) -> bool
+        def within?: (Array[Integer] range, Integer kind) -> bool
+      end
+    end
+  end
+end

data/sig/ibex/runtime/cst/parse_result.rbs

@@ -0,0 +1,35 @@
+# Generated from lib/ibex/runtime/cst/parse_result.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Immutable result returned by syntax-aware parser entry points.
+      class ParseResult
+        attr_reader value: untyped
+
+        attr_reader syntax_root: SyntaxNode
+
+        attr_reader diagnostics: Array[untyped]
+
+        # @rbs (value: untyped, syntax_root: SyntaxNode, diagnostics: Array[untyped]) -> void
+        def initialize: (value: untyped, syntax_root: SyntaxNode, diagnostics: Array[untyped]) -> void
+      end
+
+      # Syntax-only result used by incremental sessions.
+      class SyntaxResult
+        attr_reader syntax_root: SyntaxNode
+
+        attr_reader diagnostics: Array[untyped]
+
+        attr_reader reused_ratio: Float
+
+        # @rbs (syntax_root: SyntaxNode, diagnostics: Array[untyped], reused_ratio: Float) -> void
+        def initialize: (syntax_root: SyntaxNode, diagnostics: Array[untyped], reused_ratio: Float) -> void
+      end
+    end
+
+    ParseResult: untyped
+
+    SyntaxResult: untyped
+  end
+end

data/sig/ibex/runtime/cst/rewriter.rbs

@@ -0,0 +1,31 @@
+# Generated from lib/ibex/runtime/cst/rewriter.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Bottom-up syntax rewriter with kind-name dispatch.
+      class SyntaxRewriter
+        type element = SyntaxNode | SyntaxToken
+
+        type green = GreenNode | GreenToken
+
+        # @rbs (SyntaxNode root) -> SyntaxNode
+        def rewrite: (SyntaxNode root) -> SyntaxNode
+
+        # @rbs (element element) -> green
+        def visit: (element element) -> green
+
+        private
+
+        # @rbs (SyntaxNode node) -> GreenNode
+        def visit_children: (SyntaxNode node) -> GreenNode
+
+        # @rbs (element original, green rewritten) -> element
+        def rewritten_view: (element original, green rewritten) -> element
+
+        # @rbs (String name) -> String
+        def method_name: (String name) -> String
+      end
+    end
+  end
+end

data/sig/ibex/runtime/cst/serialize.rbs

@@ -0,0 +1,39 @@
+# Generated from lib/ibex/runtime/cst/serialize.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      class SerializationError < StandardError
+      end
+
+      # Stable JSON serialization for `ibex_cst` schema version 1.
+      module Serialize
+        SCHEMA_VERSION: Integer
+
+        # @rbs (SyntaxNode | SerializedTree value, ?grammar_digest: String?, ?table_format: Integer?,
+        #   ?state_count: Integer?, ?production_count: Integer?, ?memo: ParseMemo?) -> String
+        def self?.dump: (SyntaxNode | SerializedTree value, ?grammar_digest: String?, ?table_format: Integer?, ?state_count: Integer?, ?production_count: Integer?, ?memo: ParseMemo?) -> String
+
+        # @rbs (String source, ?grammar_digest: String?, ?state_count: Integer?,
+        #   ?production_count: Integer?) -> SerializedTree
+        def self?.load: (String source, ?grammar_digest: String?, ?state_count: Integer?, ?production_count: Integer?) -> SerializedTree
+
+        # @rbs (SyntaxNode | SerializedTree value, grammar_digest: String?, table_format: Integer?,
+        #   state_count: Integer?, production_count: Integer?, memo: ParseMemo?) -> SerializedTree
+        def self?.serialization_tree: (SyntaxNode | SerializedTree value, grammar_digest: String?, table_format: Integer?, state_count: Integer?, production_count: Integer?, memo: ParseMemo?) -> SerializedTree
+
+        # @rbs (Kind kinds) -> Hash[String, untyped]
+        def self?.kinds_document: (Kind kinds) -> Hash[String, untyped]
+
+        # @rbs (GreenNode | GreenToken element) -> Hash[String, untyped]
+        def self?.element_document: (GreenNode | GreenToken element) -> Hash[String, untyped]
+
+        # @rbs (GreenTrivia trivia) -> Array[untyped]
+        def self?.trivia_document: (GreenTrivia trivia) -> Array[untyped]
+
+        # @rbs (String text) -> (String | Hash[String, String])
+        def self?.encode_text: (String text) -> (String | Hash[String, String])
+      end
+    end
+  end
+end

data/sig/ibex/runtime/cst/serialized_tree.rbs

@@ -0,0 +1,34 @@
+# Generated from lib/ibex/runtime/cst/serialized_tree.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Validated CST serialization document and its reconstructed Red root.
+      class SerializedTree
+        attr_reader grammar_digest: String
+
+        attr_reader table_format: Integer
+
+        attr_reader state_count: Integer
+
+        attr_reader production_count: Integer
+
+        attr_reader trivia_policy: Symbol
+
+        attr_reader kinds: Kind
+
+        attr_reader green_root: GreenNode
+
+        attr_reader memo: ParseMemo?
+
+        # @rbs (grammar_digest: String, table_format: Integer, state_count: Integer,
+        #   production_count: Integer, trivia_policy: Symbol, kinds: Kind, green_root: GreenNode,
+        #   ?memo: ParseMemo?) -> void
+        def initialize: (grammar_digest: String, table_format: Integer, state_count: Integer, production_count: Integer, trivia_policy: Symbol, kinds: Kind, green_root: GreenNode, ?memo: ParseMemo?) -> void
+
+        # @rbs () -> SyntaxNode
+        def syntax_root: () -> SyntaxNode
+      end
+    end
+  end
+end

data/sig/ibex/runtime/cst/source_text.rbs

@@ -0,0 +1,51 @@
+# Generated from lib/ibex/runtime/cst/source_text.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Immutable byte-oriented source with lazy line/column conversion.
+      class SourceText
+        type position = [ Integer, Integer ]
+
+        attr_reader text: String
+
+        attr_reader file: String?
+
+        # @rbs (String text, ?file: String?) -> void
+        def initialize: (String text, ?file: String?) -> void
+
+        # @rbs () -> Integer
+        def bytesize: () -> Integer
+
+        # Apply non-overlapping byte edits expressed against this source.
+        # @rbs (Array[TextEdit] edits) -> SourceText
+        def apply: (Array[TextEdit] edits) -> SourceText
+
+        # Return one-based line and Unicode-scalar column for a byte offset.
+        # Invalid UTF-8 bytes count as one replacement scalar each.
+        # @rbs (Integer offset) -> position
+        def position: (Integer offset) -> position
+
+        # @rbs (Range[Integer] range) -> Ibex::Location
+        def location: (Range[Integer] range) -> Ibex::Location
+
+        # @rbs (Integer line) -> String
+        def line_text: (Integer line) -> String
+
+        private
+
+        # @rbs () -> Array[Integer]
+        def build_line_starts: () -> Array[Integer]
+
+        # @rbs (Integer offset) -> void
+        def validate_offset: (Integer offset) -> void
+
+        # @rbs (Range[Integer] range) -> position
+        def normalized_range: (Range[Integer] range) -> position
+
+        # @rbs (String bytes) -> Integer
+        def unicode_scalar_length: (String bytes) -> Integer
+      end
+    end
+  end
+end

data/sig/ibex/runtime/cst/syntax_node.rbs

@@ -0,0 +1,195 @@
+# Generated from lib/ibex/runtime/cst/syntax_node.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Lazy Red navigation facade for one Green node occurrence.
+      class SyntaxNode
+        include Enumerable[element]
+
+        type element = SyntaxNode | SyntaxToken
+
+        attr_reader green: GreenNode
+
+        attr_reader parent: SyntaxNode?
+
+        attr_reader index: Integer
+
+        attr_reader offset: Integer
+
+        attr_reader kinds: Kind
+
+        attr_reader trivia_policy: Symbol
+
+        attr_reader source_text: SourceText
+
+        # @rbs (green: GreenNode, kinds: Kind, ?parent: SyntaxNode?, ?index: Integer, ?offset: Integer,
+        #   ?trivia_policy: Symbol, ?source_text: SourceText?) -> void
+        def initialize: (green: GreenNode, kinds: Kind, ?parent: SyntaxNode?, ?index: Integer, ?offset: Integer, ?trivia_policy: Symbol, ?source_text: SourceText?) -> void
+
+        # @rbs () -> Integer
+        def kind: () -> Integer
+
+        # @rbs () -> String
+        def kind_name: () -> String
+
+        # Compatibility name for the physical grammar symbol.
+        # @rbs () -> String
+        def symbol: () -> String
+
+        # Green kinds replace occurrence-local production ids. Keep the legacy
+        # key and reader with the historical synthetic sentinel.
+        # @rbs () -> Integer
+        def production_id: () -> Integer
+
+        # @rbs () -> Array[element]
+        def children: () -> Array[element]
+
+        def each: () -> Enumerator[element, self]
+                | () { (element) -> void } -> self
+
+        # @rbs (Integer child_index) -> element
+        def child_at: (Integer child_index) -> element
+
+        # @rbs () -> Array[SyntaxNode]
+        def child_nodes: () -> Array[SyntaxNode]
+
+        # @rbs () -> Array[SyntaxToken]
+        def tokens: () -> Array[SyntaxToken]
+
+        # @rbs () -> SyntaxToken?
+        def first_token: () -> SyntaxToken?
+
+        # @rbs () -> SyntaxToken?
+        def last_token: () -> SyntaxToken?
+
+        # @rbs () -> element?
+        def next_sibling: () -> element?
+
+        # @rbs () -> element?
+        def prev_sibling: () -> element?
+
+        # @rbs () -> Enumerator[SyntaxNode, void]
+        def ancestors: () -> Enumerator[SyntaxNode, void]
+
+        # @rbs () -> Enumerator[element, void]
+        def descendants: () -> Enumerator[element, void]
+
+        # @rbs () -> SyntaxNode
+        def root: () -> SyntaxNode
+
+        # @rbs () -> Range[Integer]
+        def full_span: () -> Range[Integer]
+
+        # @rbs () -> Range[Integer]
+        def span: () -> Range[Integer]
+
+        # @rbs () -> Ibex::Location
+        def location: () -> Ibex::Location
+
+        # @rbs () -> String
+        def full_text: () -> String
+
+        alias to_source full_text
+
+        # @rbs () -> String
+        def text: () -> String
+
+        # Compatibility view of file-tail trivia. The Red/Green layout owns it
+        # on EOF rather than on the start node.
+        # @rbs () -> Array[GreenTrivia]
+        def trailing_trivia: () -> Array[GreenTrivia]
+
+        # @rbs () -> bool
+        def error?: () -> bool
+
+        # @rbs () -> bool
+        def missing?: () -> bool
+
+        # @rbs () -> bool
+        def contains_error?: () -> bool
+
+        # @rbs () -> bool
+        def incomplete_input?: () -> bool
+
+        # @rbs (GreenNode | GreenToken | SyntaxNode | SyntaxToken replacement) -> SyntaxNode
+        def replace_with: (GreenNode | GreenToken | SyntaxNode | SyntaxToken replacement) -> SyntaxNode
+
+        # @rbs (Integer child_index, GreenNode | GreenToken | SyntaxNode | SyntaxToken child) -> SyntaxNode
+        def with_child: (Integer child_index, GreenNode | GreenToken | SyntaxNode | SyntaxToken child) -> SyntaxNode
+
+        # @rbs (Integer child_index, GreenNode | GreenToken | SyntaxNode | SyntaxToken child) -> SyntaxNode
+        def insert_child: (Integer child_index, GreenNode | GreenToken | SyntaxNode | SyntaxToken child) -> SyntaxNode
+
+        # @rbs (Integer child_index) -> SyntaxNode
+        def remove_child: (Integer child_index) -> SyntaxNode
+
+        # @rbs (SyntaxAnnotation annotation) -> SyntaxNode
+        def annotate: (SyntaxAnnotation annotation) -> SyntaxNode
+
+        # @rbs (SyntaxAnnotation annotation) -> Enumerator[SyntaxNode, void]
+        def annotated: (SyntaxAnnotation annotation) -> Enumerator[SyntaxNode, void]
+
+        # Find the full-span-owning token for a byte offset.
+        # @rbs (Integer source_offset) -> SyntaxToken?
+        def token_at: (Integer source_offset) -> SyntaxToken?
+
+        # Return the smallest syntax element whose full span covers a range.
+        # @rbs (Range[Integer] range) -> element?
+        def covering: (Range[Integer] range) -> element?
+
+        # @rbs (kind: Integer | String | Symbol) -> Enumerator[element, void]
+        def find: (kind: Integer | String | Symbol) -> Enumerator[element, void]
+
+        # @rbs () -> Enumerator[element, void]
+        # @rbs () { (element) -> void } -> self
+        def each_error: () -> Enumerator[element, void]
+                      | () { (element) -> void } -> self
+
+        # @rbs () { (Symbol, element) -> void } -> self
+        def walk: () { (Symbol, element) -> void } -> self
+
+        # @rbs () -> Cursor
+        def cursor: () -> Cursor
+
+        # @rbs (SyntaxNode other) -> bool
+        def same_node?: (SyntaxNode other) -> bool
+
+        # @rbs (untyped other) -> bool
+        def ==: (untyped other) -> bool
+
+        # @rbs () -> Array[element]
+        def deconstruct: () -> Array[element]
+
+        # @rbs (Array[Symbol]?) -> Hash[Symbol, untyped]
+        def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, untyped]
+
+        # @rbs () -> Hash[Symbol, untyped]
+        def to_h: () -> Hash[Symbol, untyped]
+
+        # @rbs (Integer source_offset) -> element?
+        def child_covering_offset: (Integer source_offset) -> element?
+
+        private
+
+        # @rbs () -> SyntaxToken?
+        def compatibility_eof: () -> SyntaxToken?
+
+        # @rbs () -> String
+        def root_source: () -> String
+
+        # @rbs (Integer child_index) -> Integer
+        def offset_for: (Integer child_index) -> Integer
+
+        # @rbs () -> void
+        def ensure_coordinates!: () -> void
+
+        # @rbs (Range[Integer] range) -> [Integer, Integer]
+        def normalize_range: (Range[Integer] range) -> [ Integer, Integer ]
+
+        # @rbs (Integer start_offset, Integer end_offset) -> bool
+        def covers_offsets?: (Integer start_offset, Integer end_offset) -> bool
+      end
+    end
+  end
+end

data/sig/ibex/runtime/cst/syntax_token.rbs

@@ -0,0 +1,112 @@
+# Generated from lib/ibex/runtime/cst/syntax_token.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Raised when source-coordinate APIs are used on a trivia-dropped tree.
+      class TriviaDroppedError < StandardError
+      end
+
+      # Lightweight Red facade for one Green token occurrence.
+      class SyntaxToken
+        attr_reader green: GreenToken
+
+        attr_reader parent: SyntaxNode
+
+        attr_reader index: Integer
+
+        attr_reader offset: Integer
+
+        # @rbs (green: GreenToken, parent: SyntaxNode, index: Integer, offset: Integer) -> void
+        def initialize: (green: GreenToken, parent: SyntaxNode, index: Integer, offset: Integer) -> void
+
+        # @rbs () -> Integer
+        def kind: () -> Integer
+
+        # @rbs () -> String
+        def kind_name: () -> String
+
+        # @rbs () -> String
+        def symbol: () -> String
+
+        # @rbs () -> String
+        def text: () -> String
+
+        # Compatibility projection for the legacy token API. Semantic lexer
+        # values remain on the parser value path; syntax exposes source bytes.
+        # @rbs () -> String
+        def value: () -> String
+
+        # @rbs () -> Array[GreenTrivia]
+        def leading_trivia: () -> Array[GreenTrivia]
+
+        # @rbs () -> Array[untyped]
+        def children: () -> Array[untyped]
+
+        # @rbs () -> String
+        def full_text: () -> String
+
+        alias to_source full_text
+
+        # @rbs () -> Range[Integer]
+        def full_span: () -> Range[Integer]
+
+        # @rbs () -> Range[Integer]
+        def span: () -> Range[Integer]
+
+        # @rbs () -> Ibex::Location
+        def location: () -> Ibex::Location
+
+        # @rbs () -> bool
+        def error?: () -> bool
+
+        # @rbs () -> bool
+        def missing?: () -> bool
+
+        # @rbs () -> bool
+        def contains_error?: () -> bool
+
+        # @rbs (GreenNode | GreenToken | SyntaxNode | SyntaxToken replacement) -> SyntaxNode
+        def replace_with: (GreenNode | GreenToken | SyntaxNode | SyntaxToken replacement) -> SyntaxNode
+
+        # @rbs (String value) -> SyntaxNode
+        def with_text: (String value) -> SyntaxNode
+
+        # @rbs (Array[GreenTrivia] trivia) -> SyntaxNode
+        def with_leading: (Array[GreenTrivia] trivia) -> SyntaxNode
+
+        # @rbs (Array[GreenTrivia] trivia) -> SyntaxNode
+        def with_trailing: (Array[GreenTrivia] trivia) -> SyntaxNode
+
+        # @rbs () -> (SyntaxNode | SyntaxToken)?
+        def next_sibling: () -> (SyntaxNode | SyntaxToken)?
+
+        # @rbs () -> (SyntaxNode | SyntaxToken)?
+        def prev_sibling: () -> (SyntaxNode | SyntaxToken)?
+
+        # @rbs () -> SyntaxNode
+        def root: () -> SyntaxNode
+
+        # @rbs (SyntaxToken other) -> bool
+        def same_node?: (SyntaxToken other) -> bool
+
+        # @rbs (untyped other) -> bool
+        def ==: (untyped other) -> bool
+
+        # @rbs () -> Array[untyped]
+        def deconstruct: () -> Array[untyped]
+
+        # @rbs (Array[Symbol]?) -> Hash[Symbol, untyped]
+        def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, untyped]
+
+        # @rbs () -> Hash[Symbol, untyped]
+        def to_h: () -> Hash[Symbol, untyped]
+
+        private
+
+        # @rbs () -> void
+        def ensure_coordinates!: () -> void
+      end
+    end
+  end
+end

data/sig/ibex/runtime/cst/text_edit.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/ibex/runtime/cst/text_edit.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # One byte-oriented source replacement.
+      class TextEdit
+        # Sort and merge adjacent edits while rejecting intersecting source ranges.
+        # All edits remain expressed against the unedited source.
+        # @rbs (Array[TextEdit] edits) -> Array[TextEdit]
+        def self.normalize: (Array[TextEdit] edits) -> Array[TextEdit]
+
+        # @rbs (Array[TextEdit] ordered) -> Array[TextEdit]
+        private def self.merge_adjacent: (Array[TextEdit] ordered) -> Array[TextEdit]
+
+        # @rbs (Array[TextEdit] normalized, TextEdit previous, TextEdit edit) -> void
+        private def self.merge_with_previous: (Array[TextEdit] normalized, TextEdit previous, TextEdit edit) -> void
+
+        attr_reader start: Integer
+
+        attr_reader delete_length: Integer
+
+        attr_reader insert_text: String
+
+        # @rbs (start: Integer, delete_length: Integer, insert_text: String) -> void
+        def initialize: (start: Integer, delete_length: Integer, insert_text: String) -> void
+
+        # @rbs () -> Range[Integer]
+        def range: () -> Range[Integer]
+      end
+    end
+  end
+end

data/sig/ibex/runtime/cst/typed_node.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/ibex/runtime/cst/typed_node.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Grammar-generated typed view over one Red syntax node.
+      class TypedNode
+        type element = SyntaxNode | SyntaxToken
+
+        attr_reader node: SyntaxNode
+
+        # @rbs (SyntaxNode node) -> void
+        def initialize: (SyntaxNode node) -> void
+
+        # @rbs () -> Integer
+        def kind: () -> Integer
+
+        # @rbs () -> String
+        def kind_name: () -> String
+
+        # @rbs (Integer index) -> element
+        def child_at_slot: (Integer index) -> element
+
+        # @rbs (Integer index) -> SyntaxNode
+        def node_at_slot: (Integer index) -> SyntaxNode
+
+        # @rbs (Integer index) -> SyntaxToken
+        def token_at_slot: (Integer index) -> SyntaxToken
+
+        # @rbs () -> Array[element]
+        def deconstruct: () -> Array[element]
+
+        # @rbs (Array[Symbol]?) -> Hash[Symbol, untyped]
+        def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, untyped]
+
+        # @rbs () -> String
+        def to_source: () -> String
+
+        # Flatten a lowered repetition helper and enumerate elements or separators.
+        # @rbs (Integer index, separated: bool, ?separators: bool) -> Enumerator[element, void]
+        def list_items: (Integer index, separated: bool, ?separators: bool) -> Enumerator[element, void]
+
+        private
+
+        # @rbs (SyntaxNode current, Integer helper_kind, Array[element] result) -> void
+        def flatten_list: (SyntaxNode current, Integer helper_kind, Array[element] result) -> void
+      end
+    end
+  end
+end