antlr4ruby 0.1.0

data/sig/antlr4ruby/atn/state/invalid_state.rbs

@@ -0,0 +1,7 @@
+
+
+module Antlr4ruby
+  class InvalidState
+    def get_state_type: -> Integer
+  end
+end

data/sig/antlr4ruby/atn/state/loop_end_state.rbs

@@ -0,0 +1,7 @@
+module Antlr4ruby
+
+  # @final
+  class LoopEndState < ATNState
+    attr_accessor loop_back_state: ATNState
+  end
+end

data/sig/antlr4ruby/atn/state/plus_block_start_state.rbs

@@ -0,0 +1,6 @@
+module Antlr4ruby
+
+  class PlusBlockStartState < BlockStartState
+    attr_accessor loop_back_state: PlusLoopbackState
+  end
+end

data/sig/antlr4ruby/atn/state/plus_loopback_state.rbs

@@ -0,0 +1,6 @@
+module Antlr4ruby
+
+  # @final
+  class PlusLoopbackState < DecisionState
+  end
+end

data/sig/antlr4ruby/atn/state/rule_start_state.rbs

@@ -0,0 +1,7 @@
+module Antlr4ruby
+
+  class RuleStartState < ATNState
+    attr_accessor is_left_recursive_rule: bool
+    attr_accessor stop_state: RuleStopState
+  end
+end

data/sig/antlr4ruby/atn/state/rule_stop_state.rbs

@@ -0,0 +1,6 @@
+module Antlr4ruby
+
+  class RuleStopState < ATNState
+  end
+
+end

data/sig/antlr4ruby/atn/state/simulator_state.rbs

@@ -0,0 +1,12 @@
+
+
+module Antlr4ruby
+  class SimulatorState
+    attr_accessor outer_context: ParserRuleContext
+    attr_accessor remaining_outer_context: ParserRuleContext?
+    attr_accessor s0: DFAState
+    attr_accessor use_context: bool
+
+    def initialize: (ParserRuleContext, DFAState, bool, ParserRuleContext?) -> void
+  end
+end

data/sig/antlr4ruby/atn/state/star_block_start_state.rbs

@@ -0,0 +1,6 @@
+module Antlr4ruby
+
+  class StarBlockStartState < BlockStartState
+  end
+
+end

data/sig/antlr4ruby/atn/state/star_loop_entry_state.rbs

@@ -0,0 +1,8 @@
+module Antlr4ruby
+
+  class StarLoopEntryState < ATNState
+    attr_accessor is_precedence_decision: bool
+    attr_accessor loop_back_state: StarLoopbackState
+  end
+
+end

data/sig/antlr4ruby/atn/state/star_loopback_state.rbs

@@ -0,0 +1,5 @@
+module Antlr4ruby
+
+  class StarLoopbackState < DecisionState
+  end
+end

data/sig/antlr4ruby/atn/state/tokens_start_state.rbs

@@ -0,0 +1,6 @@
+module Antlr4ruby
+
+  class TokensStartState < DecisionState
+  end
+
+end

data/sig/antlr4ruby/atn/transition/abstract_predicate_transition.rbs

@@ -0,0 +1,10 @@
+module Antlr4ruby
+
+  # @abstract
+  class AbstractPredicateTransition < Transition
+
+  end
+end
+
+
+

data/sig/antlr4ruby/atn/transition/action_transition.rbs

@@ -0,0 +1,15 @@
+module Antlr4ruby
+
+  # @final
+  class ActionTransition < Transition
+    @rule_index: Integer
+    @action_index: Integer
+    @is_ctx_dependent: bool
+
+    attr_reader action_index: Integer
+    attr_reader is_ctx_dependent: Integer
+    attr_reader rule_index: Integer
+
+    def initialize: (ATNState, Integer, Integer, bool) -> void
+  end
+end

data/sig/antlr4ruby/atn/transition/atom_transition.rbs

@@ -0,0 +1,10 @@
+module Antlr4ruby
+
+  # @final
+  class AtomTransition < Transition
+    attr_reader atom_label: Integer
+    # attr_reader label: Integer
+
+    def initialize: (ATNState, Integer) -> void
+  end
+end

data/sig/antlr4ruby/atn/transition/code_point_transitions.rbs

@@ -0,0 +1,5 @@
+module Antlr4ruby
+  # @abstract
+  class CodePointTransitions
+  end
+end

data/sig/antlr4ruby/atn/transition/epsilon_transition.rbs

@@ -0,0 +1,12 @@
+module Antlr4ruby
+
+  # @final
+  class EpsilonTransition < Transition
+
+    def initialize: (ATNState, Integer) -> void
+
+    @outermost_precedence_return: Integer
+
+    attr_reader outermost_precedence_return: Integer
+  end
+end

data/sig/antlr4ruby/atn/transition/not_set_transition.rbs

@@ -0,0 +1,7 @@
+module Antlr4ruby
+
+  # @final
+  class NotSetTransition < SetTransition
+  end
+
+end

data/sig/antlr4ruby/atn/transition/precedence_predicate_transition.rbs

@@ -0,0 +1,10 @@
+module Antlr4ruby
+
+  # @final
+  class PrecedencePredicateTransition < AbstractPredicateTransition
+    attr_reader precedence: Integer
+
+    def initialize: (ATNState, Integer) -> void
+    def get_predicate: -> untyped
+  end
+end

data/sig/antlr4ruby/atn/transition/predicate_transition.rbs

@@ -0,0 +1,11 @@
+module Antlr4ruby
+
+  class PredicateTransition < AbstractPredicateTransition
+    attr_reader is_ctx_dependent: bool
+    attr_reader pred_index: Integer
+    attr_reader rule_index: Integer
+
+    def initialize: (ATNState, Integer, Integer, bool) -> void
+  end
+
+end

data/sig/antlr4ruby/atn/transition/range_transition.rbs

@@ -0,0 +1,8 @@
+module Antlr4ruby
+
+  class RangeTransition < Transition
+    attr_reader from: Integer
+    attr_reader to: Integer
+    def initialize: (ATNState, Integer, Integer) -> void
+  end
+end

data/sig/antlr4ruby/atn/transition/rule_transition.rbs

@@ -0,0 +1,10 @@
+module Antlr4ruby
+
+  class RuleTransition < Transition
+    attr_accessor follow_state: ATNState
+    attr_reader precedence: Integer
+    attr_reader rule_index: Integer
+
+    def initialize: (RuleStartState, Integer, Integer, ATNState) -> void
+  end
+end

data/sig/antlr4ruby/atn/transition/set_transition.rbs

@@ -0,0 +1,8 @@
+module Antlr4ruby
+
+  class SetTransition < Transition
+    attr_reader range_set: RangeSet[Integer]
+
+    def initialize: (ATNState, RangeSet[Integer]?) -> void
+  end
+end

data/sig/antlr4ruby/atn/transition/transition.rbs

@@ -0,0 +1,40 @@
+module Antlr4ruby
+
+  # @abstract
+  class Transition
+    EPSILON : Integer
+    RANGE : Integer
+    RULE : Integer
+    PREDICATE : Integer
+    ATOM : Integer
+    ACTION : Integer
+    SET : Integer
+    NOT_SET : Integer
+    WILDCARD : Integer
+    PRECEDENCE : Integer
+
+    @@serialization_names: Array[String]
+    @@serialization_types: Hash[Class, Integer]
+
+    @target: ATNState
+
+    def self.serialization_names: -> Array[String]
+
+    def self.serialization_types: -> Hash[Class, Integer]
+
+    attr_accessor target: ATNState
+
+    def initialize: (ATNState) -> void
+
+    # @!abstract
+    def get_serialization_type: -> Integer
+
+    def is_epsilon?: -> bool
+
+    def label: -> RangeSet[Integer]?
+
+    # @abstract
+    def matches?: (Integer, Integer, Integer) -> bool
+
+  end
+end

data/sig/antlr4ruby/atn/transition/wildcard_transition.rbs

@@ -0,0 +1,5 @@
+module Antlr4ruby
+
+  class WildcardTransition < Transition
+  end
+end

data/sig/antlr4ruby/bail_error_strategy.rbs

@@ -0,0 +1,7 @@
+# TODO
+
+module Antlr4ruby
+  class BailErrorStrategy < DefaultErrorStrategy
+    # 什么都不需要写
+  end
+end

data/sig/antlr4ruby/base_error_listener.rbs

@@ -0,0 +1,6 @@
+
+module Antlr4ruby
+  class BaseErrorListener
+    include _ANTLRErrorListener
+  end
+end

data/sig/antlr4ruby/buffered_token_stream.rbs

@@ -0,0 +1,48 @@
+module Antlr4ruby
+  class BufferedTokenStream
+    include _TokenStream
+
+    def initialize: (_TokenSource) -> void
+
+    def adjust_seek_index: (Integer) -> Integer
+
+    def fetch: (Integer) -> Integer
+
+    def fill: -> void
+
+    def filter_for_channel: (Integer, Integer, Integer) -> Array[_Token]
+
+    def get_hidden_tokens_to_left: (Integer, Integer) -> Array[_Token]
+
+    def get_hidden_tokens_to_right: (Integer, Integer) -> Array[_Token]
+
+    attr_accessor fetched_eof: bool
+    attr_accessor p: Integer
+    attr_accessor token_source: _TokenSource
+    attr_accessor tokens: Array[_Token]
+
+    def get_multi: (Integer, Integer) -> Array[_Token]
+
+    def get_tokens:
+      () -> Array[_Token]
+      | (Integer, Integer) -> Array[_Token]
+      | (Integer, Integer, Set[Integer]) -> Array[_Token]
+      | (Integer, Integer, Integer) -> Array[_Token]
+
+    def lazy_init: -> void
+
+    def lb: (Integer) -> _Token?
+
+    def next_token_on_channel: (Integer, Integer) -> Integer
+
+    def previous_token_on_channel: (Integer, Integer) -> Integer
+
+    def set_token_source: (_TokenSource) -> void
+
+    def setup: -> void
+
+    def sync: (Integer) -> bool
+
+    # def get: (Integer) -> _Token
+  end
+end

data/sig/antlr4ruby/char_stream.rbs

@@ -0,0 +1,9 @@
+# 已完成
+
+module Antlr4ruby
+  interface _CharStream
+    include _IntStream
+
+    def get_text: (Range[Integer]) -> String
+  end
+end

data/sig/antlr4ruby/char_streams.rbs

@@ -0,0 +1,14 @@
+
+module Antlr4ruby
+  class CharStreams
+    DEFAULT_BUFFER_SIZE: Integer
+
+    def self.from_file: (File) -> _CharStream
+
+    def self.from_file_name: (String, String?) -> _CharStream
+
+    def self.from_path: (String, String?) -> _CharStream
+
+    def self.from_string: (String, String) -> CodePointCharStream
+  end
+end

data/sig/antlr4ruby/code_point_buffer.rbs

@@ -0,0 +1,20 @@
+
+module Antlr4ruby
+  class CodePointBuffer
+    BYTE: Symbol
+    CHAR: Symbol
+    INT: Symbol
+
+    @type: Symbol
+
+    def array_offset: -> Integer
+
+    def get: (Integer) -> Integer
+
+    def get_type: -> Symbol
+
+    def position: (Integer?) -> void
+
+    def remaining: -> Integer
+  end
+end

data/sig/antlr4ruby/code_point_char_stream.rbs

@@ -0,0 +1,19 @@
+
+module Antlr4ruby
+  # @abstract
+  class CodePointCharStream
+    include _CharStream
+
+    def self.from_buffer: (CodePointBuffer, String)-> CodePointCharStream
+
+    def self.from_string: (String, String) -> CodePointCharStream
+
+    attr_reader data: Array[Integer]
+    attr_reader name: String
+    attr_accessor position: Integer
+    attr_reader size: Integer
+
+    def get_internal_storage: -> Object
+    def initialize: (Array[Integer], String) -> void
+  end
+end

data/sig/antlr4ruby/common_token.rbs

@@ -0,0 +1,35 @@
+
+module Antlr4ruby
+  class CommonToken
+    include _WritableToken
+
+    @type: Integer
+    @line: Integer
+    @char_position_in_line: Integer
+    @channel: Integer
+    @text: String
+    @index: Integer
+    @start: Integer
+    @stop: Integer
+    @source: Pair[_TokenSource, _CharStream]
+    EMPTY_SOURCE: Pair[_TokenSource, _CharStream]
+
+    attr_accessor channel: Integer
+    attr_accessor char_position_in_line: Integer
+    attr_accessor index: Integer
+    attr_accessor line: Integer
+    attr_accessor source: Pair[_TokenSource, _CharStream]
+    attr_accessor start: Integer
+    attr_accessor stop: Integer
+    attr_accessor text: String
+    attr_accessor type: Integer
+
+    def initialize: (type: Integer?, source: Pair[_TokenSource, _CharStream]?, channel: Integer?, start: Integer?, stop: Integer?, text: String?, old_token: _Token?) -> void
+
+    def set_start_index: (Integer) -> void
+
+    def set_stop_index: (Integer) -> void
+
+    def to_s: (Recognizer[untyped, untyped]?) -> String
+  end
+end

data/sig/antlr4ruby/common_token_factory.rbs

@@ -0,0 +1,12 @@
+
+module Antlr4ruby
+  class CommonTokenFactory
+    DEFAULT: CommonTokenFactory
+
+    include _TokenFactory[CommonToken]
+
+    attr_reader copy_text: bool
+
+    def initialize: (bool) -> void
+  end
+end

data/sig/antlr4ruby/common_token_stream.rbs

@@ -0,0 +1,9 @@
+
+module Antlr4ruby
+  class CommonTokenStream < BufferedTokenStream
+    attr_accessor channel: Integer
+    def initialize: (_TokenSource, Integer) -> void
+
+    def get_number_of_on_channel_tokens: -> Integer
+  end
+end

data/sig/antlr4ruby/console_error_listener.rbs

@@ -0,0 +1,6 @@
+
+module Antlr4ruby
+  class ConsoleErrorListener < BaseErrorListener
+    INSTANCE: ConsoleErrorListener
+  end
+end

data/sig/antlr4ruby/default_error_strategy.rbs

@@ -0,0 +1,56 @@
+
+module Antlr4ruby
+  class DefaultErrorStrategy
+    include _ANTLRErrorStrategy
+
+    @error_recovery_mode: bool
+    @last_error_index: Integer
+    @last_error_states: IntervalSet
+    @next_tokens_context: ParserRuleContext
+    @next_tokens_state: Integer
+
+    attr_accessor error_recovery_mode: bool
+
+    attr_accessor last_error_index: Integer
+
+    attr_accessor last_error_states: IntervalSet
+
+    attr_accessor next_tokens_context: ParserRuleContext
+
+    attr_accessor next_tokens_state: Integer
+
+    def begin_error_condition: (Parser) -> void
+
+    def end_error_condition: (Parser) -> void
+
+    def report_no_viable_alternative: (Parser, NoViableAltException) -> void
+
+    def report_input_mismatch: (Parser, InputMismatchException) -> void
+
+    def report_failed_predicate: (Parser, FailedPredicateException) -> void
+
+    def report_unwanted_token: (Parser) -> void
+
+    def report_missing_token: (Parser) -> void
+
+    def single_token_insertion: (Parser) -> bool
+
+    def single_token_deletion: (Parser) -> _Token
+
+    def get_missing_symbol: (Parser) -> _Token
+
+    def get_expected_tokens: (Parser) -> IntervalSet
+
+    def get_token_error_display: (_Token) -> String
+
+    def get_symbol_text: (_Token) -> String
+
+    def get_symbol_type: (_Token) -> Integer
+
+    def escape_ws_and_quote: (String) -> String
+
+    def get_error_recovery_set: (Parser) -> IntervalSet
+
+    def consume_until: (Parser, IntervalSet) -> void
+  end
+end

data/sig/antlr4ruby/dfa/dfa.rbs

@@ -0,0 +1,29 @@
+module Antlr4ruby
+
+  class DFA
+    @states: Hash[DFAState, DFAState]
+    @s0: DFAState
+    @decision: Integer
+    @atn_start_state: DecisionState
+
+    @precedence_dfa: bool
+
+    attr_accessor atn_start_state: DecisionState
+    attr_accessor decision: Integer
+    attr_accessor s0: DFAState
+    attr_accessor states: Hash[DFAState, DFAState]
+
+    def initialize: (DecisionState, Integer) -> void
+
+    def get_precedence_start_state: (Integer) -> DFAState
+
+    def get_states: -> Array[DFAState]
+
+    def is_precedence_dfa: -> bool
+
+    def set_precedence_start_state: (Integer, DFAState) -> void
+
+    def to_lexer_string: -> String
+  end
+end
+

data/sig/antlr4ruby/dfa/dfa_serializer.rbs

@@ -0,0 +1,11 @@
+module Antlr4ruby
+
+  class DFASerializer
+    @dfa: DFA
+    @vocabulary: Vocabulary
+
+    def get_edge_label: (Integer) -> String
+
+    def get_state_string: (DFAState) -> String
+  end
+end

data/sig/antlr4ruby/dfa/dfa_state.rbs

@@ -0,0 +1,50 @@
+module Antlr4ruby
+
+  class DFAState
+    BASIC: Integer
+    BLOCK_END: Integer
+    BLOCK_START: Integer
+    INITIAL_NUM_TRANSITIONS: Integer
+    INVALID_TYPE: Integer
+    LOOP_END: Integer
+    PLUS_BLOCK_START: Integer
+    PLUS_LOOP_BACK: Integer
+    RULE_START: Integer
+    RULE_STOP: Integer
+    STAR_BLOCK_START: Integer
+    STAR_LOOP_BACK: Integer
+    STAR_LOOP_ENTRY: Integer
+    TOKEN_START: Integer
+
+    @state_number: Integer
+    @configs: ATNConfigSet
+    @edges: Array[DFAState]
+    @is_accept_state: bool
+    @prediction: Integer
+    @lexer_action_executor: LexerActionExecutor
+    @requires_full_context: bool
+
+    class PredPrediction
+      @pred: SemanticContext
+      @alt: Integer
+
+      def initialize: (SemanticContext, Integer) -> void
+    end
+
+    @predicates: Array[PredPrediction]
+
+    attr_accessor configs: ATNConfigSet
+    attr_accessor edges: Array[DFAState]
+    attr_accessor is_accept_state: bool
+    attr_accessor lexer_action_executor: LexerActionExecutor
+    attr_accessor predicates: Array[PredPrediction]
+    attr_accessor prediction: Integer
+    attr_accessor requires_full_context: bool
+    attr_accessor state_number: Integer
+
+    def initialize: (Integer | ATNConfigSet | nil) -> void
+
+    def get_alt_set: -> Set[Integer]
+
+  end
+end

data/sig/antlr4ruby/dfa/lexer_dfa_serializer.rbs

@@ -0,0 +1,5 @@
+module Antlr4ruby
+
+  class LexerDFASerializer < DFASerializer
+  end
+end

data/sig/antlr4ruby/diagnostic_error_listener.rbs

@@ -0,0 +1,10 @@
+
+module Antlr4ruby
+  class DiagnosticErrorListener < BaseErrorListener
+    attr_reader exact_only: bool
+
+    def get_conflicting_alts: (BitSet, ATNConfigSet) -> BitSet
+
+    def get_decision_description: (Parser, DFA) -> String
+  end
+end

data/sig/antlr4ruby/exception/failed_predicate_exception.rbs

@@ -0,0 +1,23 @@
+
+module Antlr4ruby
+  class FailedPredicateException < RecognitionException
+
+    # private
+    # attr_reader :rule_index, :predicate_index
+
+    attr_reader predicate: String
+    attr_reader predicate_index: Integer
+
+    def get_pred_index: -> Integer
+
+    def get_predicate: -> String
+
+    def get_rule_index: -> Integer
+
+    def initialize: (Parser, String?, String?) -> void
+
+    private
+
+    attr_reader rule_index: Integer
+  end
+end

data/sig/antlr4ruby/exception/input_mismatch_exception.rbs

@@ -0,0 +1,7 @@
+
+module Antlr4ruby
+  class InputMismatchException < RecognitionException
+
+    def initialize: (Parser, Integer?, ParserRuleContext?) -> void
+  end
+end