antlr4ruby 0.1.0

data/sig/antlr4ruby/atn/action/lexer_type_action.rbs

@@ -0,0 +1,12 @@
+module Antlr4ruby
+
+  class LexerTypeAction
+    include _LexerAction
+
+    def get_type: -> Integer
+
+    private
+
+    attr_reader type: Integer
+  end
+end

data/sig/antlr4ruby/atn/atn.rbs

@@ -0,0 +1,32 @@
+module Antlr4ruby
+
+  class ATN
+    INVALID_ALT_NUMBER: Integer
+
+    attr_reader decision_to_state: Array[DecisionState]
+    attr_reader grammar_type: Symbol
+    attr_accessor lexer_actions: Array[_LexerAction]
+    attr_reader max_token_type: Integer
+    attr_reader mode_name_to_start_state: Hash[String, TokensStartState]
+    attr_reader mode_to_start_state: Array[TokensStartState]
+    attr_accessor rule_to_start_state: Array[RuleStartState]
+    attr_accessor rule_to_stop_state: Array[RuleStopState]
+    attr_accessor rule_to_token_type: Array[Integer]
+    attr_reader states: Array[ATNState]
+
+    def add_state: (ATNState?) -> void
+
+    def define_decision_state: (DecisionState) -> Integer
+
+    def get_decision_state: (Integer) -> DecisionState
+
+    def get_expected_tokens: (Integer, RuleContext) -> RangeSet[Integer]
+
+    def get_number_of_decisions: -> Integer
+
+    def next_tokens: (ATNState, RuleContext?) -> RangeSet[Integer]
+    def initialize: (Symbol, Integer) -> void
+
+    def remove_state: (ATNState) -> void
+  end
+end

data/sig/antlr4ruby/atn/atn_deserialization_options.rbs

@@ -0,0 +1,27 @@
+module Antlr4ruby
+
+  class ATNDeserializationOptions
+    @@default_options: ATNDeserializationOptions
+
+    def self.get_default_options: -> ATNDeserializationOptions
+
+    attr_reader generate_rule_bypass_transitions: bool
+    attr_reader verify_atn: bool
+
+    def is_generate_rule_bypass_transitions?: -> bool
+
+    def is_read_only?: -> bool
+
+    def is_verify_atn?: -> bool
+
+    def make_read_only: (bool) -> void
+
+    def set_generate_rule_bypass_transitions: (bool) -> void
+
+    def set_verify_atn: (bool) -> void
+
+    private
+
+    attr_reader read_only: bool
+  end
+end

data/sig/antlr4ruby/atn/atn_deserializer.rbs

@@ -0,0 +1,26 @@
+module Antlr4ruby
+
+  class ATNDeserializer
+    SERIALIZED_VERSION: Integer
+
+    def check_condition: (bool, String?) -> void
+
+    def deserialize: (Array[Integer]) -> ATN
+
+    def edge_factory: (ATN, Integer, Integer, Integer,Integer,Integer,Integer,Array[RangeSet[Integer]]) -> Transition
+
+    def lexer_action_factory: (Symbol, Integer, Integer) -> _LexerAction
+
+    def mark_precedence_decisions: (ATN) -> void
+
+    def state_factory: (Integer, Integer) -> ATNState
+
+    def verify_atn: (ATN) -> void
+
+    private
+
+    attr_reader deserialization_options: ATNDeserializationOptions
+
+    def deserialize_sets: (Array[Integer], Integer, Array[RangeSet[Integer]]) -> Integer
+  end
+end

data/sig/antlr4ruby/atn/atn_serializer.rbs

@@ -0,0 +1,5 @@
+module Antlr4ruby
+
+  class ATNSerializer
+  end
+end

data/sig/antlr4ruby/atn/atn_simulator.rbs

@@ -0,0 +1,19 @@
+module Antlr4ruby
+
+  # @abstract
+  class ATNSimulator
+    ERROR: DFAState
+
+    attr_reader atn: ATN
+    attr_reader shared_context_cache: PredictionContextCache
+
+    def clear_dfa: -> void
+
+    def get_cached_context: (PredictionContext) -> PredictionContext
+
+    def get_shared_context_cache: -> PredictionContextCache
+
+    def reset: -> void
+  end
+
+end

data/sig/antlr4ruby/atn/atn_type.rbs

@@ -0,0 +1,7 @@
+module Antlr4ruby
+
+  module ATNType
+
+  end
+
+end

data/sig/antlr4ruby/atn/config/atn_config.rbs

@@ -0,0 +1,21 @@
+module Antlr4ruby
+
+  class ATNConfig
+    SUPPRESS_PRECEDENCE_FILTER: Integer
+
+    attr_reader alt: Integer
+    attr_accessor context: PredictionContext
+    attr_accessor reaches_into_outer_context: Integer
+    attr_reader semantic_context: SemanticContext
+    attr_reader state: ATNState
+
+    def get_outer_context_depth: -> Integer
+
+    def is_precedence_filter_suppressed: -> bool
+
+    def set_precedence_filter_suppressed: (bool) -> void
+
+    def eql?: (Object) -> bool
+    def to_s: (recognizer: Recognizer[untyped, untyped]?, show_alt: bool) -> String
+  end
+end

data/sig/antlr4ruby/atn/config/atn_config_set.rbs

@@ -0,0 +1,5 @@
+module Antlr4ruby
+
+  class ATNConfigSet < Set[ATNConfig]
+  end
+end

data/sig/antlr4ruby/atn/config/lexer_atn_config.rbs

@@ -0,0 +1,19 @@
+module Antlr4ruby
+
+  class LexerATNConfig < ATNConfig
+
+    def initialize: (state: ATNState, alt:Integer?, context: PredictionContext?,
+        config: LexerATNConfig?, executor: LexerActionExecutor?) -> void
+    def self.check_non_greedy_decision: (LexerATNConfig, ATNState) -> bool
+
+    attr_reader passed_through_non_greedy_decision: bool
+
+    def get_lexer_action_executor: -> LexerActionExecutor
+
+    def has_passed_through_non_greedy_decision?: -> bool
+
+    private
+
+    attr_reader lexer_action_executor: LexerActionExecutor
+  end
+end

data/sig/antlr4ruby/atn/config/ordered_atn_config_set.rbs

@@ -0,0 +1,5 @@
+module Antlr4ruby
+
+  class OrderedATNConfigSet < ATNConfigSet
+  end
+end

data/sig/antlr4ruby/atn/context/array_prediction_context.rbs

@@ -0,0 +1,11 @@
+module Antlr4ruby
+
+  class ArrayPredictionContext < PredictionContext
+    attr_reader parents: Array[PredictionContext]
+    attr_reader return_states: Array[Integer]
+
+    def initialize: (context: SingletonPredictionContext?,
+        parents: Array[PredictionContext],
+      return_states: Array[Integer]) -> void
+  end
+end

data/sig/antlr4ruby/atn/context/empty_prediction_context.rbs

@@ -0,0 +1,6 @@
+module Antlr4ruby
+
+  class EmptyPredictionContext < SingletonPredictionContext
+    INSTANCE: EmptyPredictionContext
+  end
+end

data/sig/antlr4ruby/atn/context/prediction_context.rbs

@@ -0,0 +1,52 @@
+module Antlr4ruby
+
+  # @abstract
+  class PredictionContext
+    EMPTY_RETURN_STATE: Integer
+    INITIAL_HASH: Integer
+
+    @@global_node_count: Integer
+
+    def self.calculate_empty_hash_code: -> Integer
+
+    def self.calculate_hash_code: (parent: PredictionContext?, parents: Array[PredictionContext], return_state: Integer, return_states: Array[Integer]) -> Integer
+
+    def self.combine_common_parents: (Array[PredictionContext]) -> void
+
+    def self.from_rule_context: (ATN, RuleContext) -> PredictionContext
+
+    def self.get_all_context_nodes: (PredictionContext) -> Array[PredictionContext]
+
+    def self.get_all_context_nodes_: (PredictionContext, Array[PredictionContext], Hash[PredictionContext, PredictionContext]) -> void
+
+    def self.get_cached_context: (PredictionContext, PredictionContextCache, Hash[Integer, PredictionContext]) -> PredictionContext
+
+    def self.merge: (PredictionContext, PredictionContext, bool, Hash[PredictionContext, Hash[PredictionContext, PredictionContext]]) -> PredictionContext
+
+    def self.merge_arrays: (ArrayPredictionContext, ArrayPredictionContext, bool, Hash[PredictionContext, Hash[PredictionContext, PredictionContext]]) -> PredictionContext
+
+    def self.merge_root: (SingletonPredictionContext, SingletonPredictionContext, bool) -> PredictionContext
+
+    def self.merge_singletons: (SingletonPredictionContext, SingletonPredictionContext, bool, Hash[PredictionContext, Hash[PredictionContext, PredictionContext]]) -> PredictionContext
+
+    def self.to_dot_string: (PredictionContext) -> String
+
+    attr_reader cached_hash_code: Integer
+    attr_reader id: Integer
+
+    def initialize: (Integer) -> void
+
+    def get_parent: (Integer) -> PredictionContext?
+
+    def get_return_state: (Integer) -> Integer
+
+    def has_empty_path?: -> bool
+
+    def is_empty?: -> bool
+
+    def size: -> Integer
+
+    def to_s: (Recognizer[untyped, untyped]) -> String
+  end
+
+end

data/sig/antlr4ruby/atn/context/prediction_context_cache.rbs

@@ -0,0 +1,12 @@
+module Antlr4ruby
+
+  class PredictionContextCache
+    attr_reader cache: Hash[PredictionContext, PredictionContext]
+
+    def add: (PredictionContext) -> PredictionContext
+
+    def get: (PredictionContext) -> PredictionContext
+
+    def size: -> Integer
+  end
+end

data/sig/antlr4ruby/atn/context/semantic_context.rbs

@@ -0,0 +1,36 @@
+module Antlr4ruby
+
+  # @abstract
+  class SemanticContext
+    def self.and: (SemanticContext, SemanticContext) -> SemanticContext
+
+    def self.or: (SemanticContext, SemanticContext) -> SemanticContext
+
+    def eval_precedence: (Recognizer[untyped, untyped], RuleContext) -> SemanticContext
+    def eval: (Recognizer[untyped, untyped], RuleContext) -> bool
+
+    class Empty < SemanticContext
+      INSTANCE: Empty
+    end
+
+    class Predicate < SemanticContext
+
+      attr_reader is_ctx_dependent: bool
+      attr_reader pred_index: Integer
+      attr_reader rule_index: Integer
+    end
+
+    class PrecedencePredicate < SemanticContext
+      # todo
+    end
+
+    class Operator < SemanticContext
+      def get_operands: -> Array[SemanticContext]
+
+    end
+
+    private
+
+    def filter_precedence_predicates: (Array[SemanticContext]) -> Array[PrecedencePredicate]
+  end
+end

data/sig/antlr4ruby/atn/context/singleton_prediction_context.rbs

@@ -0,0 +1,11 @@
+module Antlr4ruby
+
+  class SingletonPredictionContext < PredictionContext
+    def self.create: (PredictionContext, Integer) -> SingletonPredictionContext
+
+    attr_reader parent: PredictionContext
+    attr_reader return_state: Integer
+
+    def initialize: (PredictionContext?, Integer) -> void
+  end
+end

data/sig/antlr4ruby/atn/info/accept_state_info.rbs

@@ -0,0 +1,15 @@
+
+
+module Antlr4ruby
+  class AcceptStateInfo
+    attr_reader lexer_action_executor: LexerActionExecutor
+
+    private
+
+    attr_reader prediction: Integer
+
+    def get_lexer_action_executor: -> LexerActionExecutor
+
+    def get_prediction: -> Integer
+  end
+end

data/sig/antlr4ruby/atn/info/ambiguity_info.rbs

@@ -0,0 +1,8 @@
+module Antlr4ruby
+
+  class AmbiguityInfo < DecisionEventInfo
+    attr_accessor ambig_alts: BitSet
+
+    def initialize: (Integer, ATNConfigSet, BitSet, _TokenStream, Integer, Integer, bool) -> void
+  end
+end

data/sig/antlr4ruby/atn/info/conflict_info.rbs

@@ -0,0 +1,16 @@
+
+
+module Antlr4ruby
+  class ConflictInfo
+    attr_accessor exact: bool
+
+    def get_conflicted_alts: -> BitSet
+
+    def is_exact?: -> bool
+
+    private
+
+    attr_accessor conflicted_alts: BitSet
+  end
+end
+

data/sig/antlr4ruby/atn/info/context_sensitivity_info.rbs

@@ -0,0 +1,5 @@
+module Antlr4ruby
+
+  class ContextSensitivityInfo < DecisionEventInfo
+  end
+end

data/sig/antlr4ruby/atn/info/decision_event_info.rbs

@@ -0,0 +1,14 @@
+module Antlr4ruby
+
+  class DecisionEventInfo
+    attr_reader configs: ATNConfigSet
+    attr_reader decision: Integer
+    attr_reader full_ctx: bool
+    attr_reader input: _TokenStream
+    attr_reader start_index: Integer
+    attr_reader stop_index: Integer
+
+    def initialize: (Integer, ATNConfigSet, _TokenStream, Integer, Integer, bool) -> void
+
+  end
+end

data/sig/antlr4ruby/atn/info/decision_info.rbs

@@ -0,0 +1,29 @@
+module Antlr4ruby
+
+  class DecisionInfo
+    attr_reader ambiguities: Array[AmbiguityInfo]
+    attr_reader context_sensitivities: Array[ContextSensitivityInfo]
+    attr_reader decision: Integer
+
+    attr_reader errors: Array[ErrorInfo]
+    attr_accessor invocations: Integer
+
+    attr_accessor ll_atn_transitions: Integer
+    attr_accessor ll_dfa_transitions: Integer
+    attr_accessor ll_fallback: Integer
+    attr_accessor ll_max_look: Integer
+    attr_accessor ll_max_look_event: LookaheadEventInfo
+    attr_accessor ll_min_look: Integer
+    attr_accessor ll_total_look: Integer
+    attr_reader predicate_evals: Array[PredicateEvalInfo]
+    attr_accessor sll_atn_transitions: Integer
+    attr_accessor sll_dfa_transitions: Integer
+    attr_accessor sll_max_look: Integer
+    attr_accessor sll_max_look_event: LookaheadEventInfo
+    attr_accessor sll_min_look: Integer
+    attr_accessor sll_total_look: Integer
+    attr_accessor time_in_prediction: Integer
+
+    def initialize: (Integer, ATNConfigSet, _TokenStream, Integer, Integer, bool) -> void
+  end
+end

data/sig/antlr4ruby/atn/info/error_info.rbs

@@ -0,0 +1,5 @@
+module Antlr4ruby
+
+  class ErrorInfo < DecisionEventInfo
+  end
+end

data/sig/antlr4ruby/atn/info/lookahead_event_info.rbs

@@ -0,0 +1,8 @@
+module Antlr4ruby
+  class LookaheadEventInfo < DecisionEventInfo
+    attr_accessor predicted_alt: Integer
+
+    def initialize: (Integer, ATNConfigSet, Integer, _TokenStream, Integer, Integer, bool) -> void
+  end
+
+end

data/sig/antlr4ruby/atn/info/parse_info.rbs

@@ -0,0 +1,8 @@
+module Antlr4ruby
+  class ParseInfo
+    attr_reader atn_simulator: ProfilingATNSimulator
+    def initialize: (ProfilingATNSimulator) -> void
+
+    def get_decision_info: -> Array[DecisionInfo]
+  end
+end

data/sig/antlr4ruby/atn/info/predicate_eval_info.rbs

@@ -0,0 +1,6 @@
+module Antlr4ruby
+
+  class PredicateEvalInfo < DecisionEventInfo
+  end
+
+end

data/sig/antlr4ruby/atn/lexer_atn_simulator.rbs

@@ -0,0 +1,83 @@
+module Antlr4ruby
+
+  class LexerATNSimulator < ATNSimulator
+    MAX_DFA_EDGE: Integer
+    MIN_DFA_EDGE: Integer
+
+
+
+
+
+    class SimState
+
+      attr_accessor char_pos: Integer
+      attr_accessor dfa_state: DFAState?
+      attr_accessor index: Integer
+      attr_accessor line: Integer
+      def reset: -> void
+    end
+
+    @@debug: bool
+
+    @@dfa_debug: bool
+
+    def self.debug: -> bool
+
+    attr_accessor char_position_in_line: Integer
+    attr_accessor decision_to_dfa: Array[DFA]
+    attr_accessor line: Integer
+    attr_accessor mode: Integer
+    attr_accessor prev_accept: SimState
+    attr_reader recognizer: Lexer
+    attr_accessor start_index: Integer
+
+    def accept: (_CharStream, LexerActionExecutor, Integer, Integer, Integer, Integer) -> void
+
+    def add_dfa_edge: (DFAState, Integer, ATNConfigSet | DFAState) -> DFAState?
+
+    def add_dfa_state: (ATNConfigSet) -> DFAState
+
+    def capture_sim_state: (SimState, _CharStream, DFAState) -> void
+
+    def closure: (_CharStream, LexerATNConfig, ATNConfigSet, bool, bool, bool) -> bool
+
+    def compute_start_state: (_CharStream, ATNState) -> ATNConfigSet
+
+    def compute_target_state: (_CharStream, DFAState, Integer) -> DFAState
+
+    def consume: (_CharStream) -> void
+
+    def evaluate_predicate: (_CharStream, Integer, Integer, bool) -> bool
+
+    def exec_atn: (_CharStream) -> Integer
+
+    def fail_or_accept: (SimState, _CharStream, ATNConfigSet, Integer) -> Integer
+
+    def get_char_position_in_line: -> Integer
+
+    def get_dfa: (Integer) -> DFA
+
+    def get_epsilon_target: (_CharStream, LexerATNConfig, Transition, ATNConfigSet, bool, bool) -> LexerATNConfig
+
+    def get_existing_target_state: (DFAState, Integer) -> DFAState
+
+    def get_line: -> Integer
+
+    def get_reachable_config_set: (_CharStream, ATNConfigSet, ATNConfigSet, Integer) -> void
+
+    def get_reachable_target: (Transition, Integer) -> ATNState
+
+    def get_text: (_CharStream) -> String
+
+    def get_token_name: (Integer) -> String
+
+    def match: (_CharStream, Integer) -> Integer
+
+    def match_atn: (_CharStream) -> Integer
+
+    def set_char_position_in_line: (Integer) -> void
+
+    def set_line: (Integer) -> void
+
+  end
+end

data/sig/antlr4ruby/atn/ll1_analyzer.rbs

@@ -0,0 +1,5 @@
+module Antlr4ruby
+
+  class LL1Analyzer
+  end
+end

data/sig/antlr4ruby/atn/parser_atn_simulator.rbs

@@ -0,0 +1,5 @@
+module Antlr4ruby
+
+  class ParserATNSimulator < ATNSimulator
+  end
+end

data/sig/antlr4ruby/atn/prediction_mode.rbs

@@ -0,0 +1,6 @@
+module Antlr4ruby
+
+  class PredictionMode
+  end
+
+end

data/sig/antlr4ruby/atn/profiling_atn_simulator.rbs

@@ -0,0 +1,6 @@
+module Antlr4ruby
+
+  class ProfilingATNSimulator < ParserATNSimulator
+  end
+
+end

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

@@ -0,0 +1,50 @@
+module Antlr4ruby
+
+  # @abstract
+  class ATNState
+    BASIC: Integer
+    BLOCK_END: Integer
+    BLOCK_START: Integer
+    INITIAL_NUM_TRANSITIONS: Integer
+
+    INVALID_STATE_NUMBER: 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
+
+    @@serialization_names: Array[String]
+
+    attr_accessor atn: ATN?
+    attr_accessor epsilon_only_transitions: bool
+    attr_accessor next_token_within_rule: RangeSet[Integer]
+    attr_accessor rule_index: Integer
+    attr_accessor state_number: Integer
+    attr_reader transitions: Array[Transition]
+
+    def add_transition: (Transition, Integer) -> void
+
+    def get_number_of_transitions: -> Integer
+
+    def get_state_type: -> Integer
+
+    def get_transition: (Integer) -> Transition?
+
+    def only_has_epsilon_transitions?: -> bool
+
+    def remove_transition: (Integer) -> Transition
+
+    def set_rule_index: (Integer) -> void
+
+    def set_transition: (Integer, Transition) -> void
+  end
+end

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

@@ -0,0 +1,6 @@
+module Antlr4ruby
+
+  # @final
+  class BasicBlockStartState < BlockStartState
+  end
+end

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

@@ -0,0 +1,7 @@
+module Antlr4ruby
+
+  # @final
+  class BasicState < ATNState
+  end
+
+end

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

@@ -0,0 +1,7 @@
+module Antlr4ruby
+
+  # @final
+  class BlockEndState < ATNState
+    attr_accessor start_state: BlockStartState
+  end
+end

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

@@ -0,0 +1,8 @@
+module Antlr4ruby
+
+  # @abstract
+  class BlockStartState < DecisionState
+    attr_accessor end_state: BlockEndState
+  end
+
+end

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

@@ -0,0 +1,14 @@
+module Antlr4ruby
+
+  # @abstract
+  class DecisionState < ATNState
+    @decision: Integer
+
+    @non_greedy: bool
+
+    attr_accessor decision: Integer
+    attr_accessor non_greedy: bool
+
+    def get_state_type: -> Integer
+  end
+end