# DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `rubocop-ast` gem. # Please instead update this file by running `tapioca generate --exclude json`. # typed: true module RuboCop end module RuboCop::AST end class RuboCop::AST::AliasNode < ::RuboCop::AST::Node def new_identifier; end def old_identifier; end end class RuboCop::AST::AndNode < ::RuboCop::AST::Node include(::RuboCop::AST::BinaryOperatorNode) include(::RuboCop::AST::PredicateOperatorNode) def alternate_operator; end def inverse_operator; end end class RuboCop::AST::ArgsNode < ::RuboCop::AST::Node include(::RuboCop::AST::CollectionNode) def empty_and_without_delimiters?; end end class RuboCop::AST::ArrayNode < ::RuboCop::AST::Node def bracketed?; end def each_value(&block); end def percent_literal?(type = T.unsafe(nil)); end def square_brackets?; end def values; end end RuboCop::AST::ArrayNode::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Hash) module RuboCop::AST::BasicLiteralNode def value; end end module RuboCop::AST::BinaryOperatorNode def conditions; end def lhs; end def rhs; end end class RuboCop::AST::BlockNode < ::RuboCop::AST::Node include(::RuboCop::AST::MethodIdentifierPredicates) def arguments; end def arguments?; end def body; end def braces?; end def closing_delimiter; end def delimiters; end def keywords?; end def lambda?; end def method_name; end def multiline?; end def opening_delimiter; end def send_node; end def single_line?; end def void_context?; end end RuboCop::AST::BlockNode::VOID_CONTEXT_METHODS = T.let(T.unsafe(nil), Array) class RuboCop::AST::BreakNode < ::RuboCop::AST::Node include(::RuboCop::AST::ParameterizedNode) include(::RuboCop::AST::ParameterizedNode::WrappedArguments) end class RuboCop::AST::Builder < ::Parser::Builders::Default def n(type, children, source_map); end def string_value(token); end private def node_klass(type); end end RuboCop::AST::Builder::NODE_MAP = T.let(T.unsafe(nil), Hash) class RuboCop::AST::CaseMatchNode < ::RuboCop::AST::Node include(::RuboCop::AST::ConditionalNode) def each_in_pattern(&block); end def else?; end def else_branch; end def in_pattern_branches; end def keyword; end end class RuboCop::AST::CaseNode < ::RuboCop::AST::Node include(::RuboCop::AST::ConditionalNode) def branches; end def each_when(&block); end def else?; end def else_branch; end def keyword; end def when_branches; end end class RuboCop::AST::ClassNode < ::RuboCop::AST::Node def body; end def identifier; end def parent_class; end end module RuboCop::AST::CollectionNode extend(::Forwardable) def &(*args, &block); end def *(*args, &block); end def +(*args, &block); end def -(*args, &block); end def <<(*args, &block); end def [](*args, &block); end def []=(*args, &block); end def all?(*args, &block); end def any?(*args, &block); end def append(*args, &block); end def assoc(*args, &block); end def at(*args, &block); end def bsearch(*args, &block); end def bsearch_index(*args, &block); end def chain(*args, &block); end def chunk(*args, &block); end def chunk_while(*args, &block); end def clear(*args, &block); end def collect(*args, &block); end def collect!(*args, &block); end def collect_concat(*args, &block); end def combination(*args, &block); end def compact(*args, &block); end def compact!(*args, &block); end def concat(*args, &block); end def count(*args, &block); end def cycle(*args, &block); end def delete(*args, &block); end def delete_at(*args, &block); end def delete_if(*args, &block); end def detect(*args, &block); end def difference(*args, &block); end def dig(*args, &block); end def drop(*args, &block); end def drop_while(*args, &block); end def each(*args, &block); end def each_cons(*args, &block); end def each_entry(*args, &block); end def each_index(*args, &block); end def each_slice(*args, &block); end def each_with_index(*args, &block); end def each_with_object(*args, &block); end def empty?(*args, &block); end def entries(*args, &block); end def fetch(*args, &block); end def fill(*args, &block); end def filter(*args, &block); end def filter!(*args, &block); end def find(*args, &block); end def find_all(*args, &block); end def find_index(*args, &block); end def first(*args, &block); end def flat_map(*args, &block); end def flatten(*args, &block); end def flatten!(*args, &block); end def grep(*args, &block); end def grep_v(*args, &block); end def group_by(*args, &block); end def include?(*args, &block); end def index(*args, &block); end def inject(*args, &block); end def insert(*args, &block); end def join(*args, &block); end def keep_if(*args, &block); end def last(*args, &block); end def lazy(*args, &block); end def length(*args, &block); end def map(*args, &block); end def map!(*args, &block); end def max(*args, &block); end def max_by(*args, &block); end def member?(*args, &block); end def min(*args, &block); end def min_by(*args, &block); end def minmax(*args, &block); end def minmax_by(*args, &block); end def none?(*args, &block); end def one?(*args, &block); end def pack(*args, &block); end def partition(*args, &block); end def permutation(*args, &block); end def pop(*args, &block); end def prepend(*args, &block); end def product(*args, &block); end def push(*args, &block); end def rassoc(*args, &block); end def reduce(*args, &block); end def reject(*args, &block); end def reject!(*args, &block); end def repeated_combination(*args, &block); end def repeated_permutation(*args, &block); end def replace(*args, &block); end def reverse(*args, &block); end def reverse!(*args, &block); end def reverse_each(*args, &block); end def rindex(*args, &block); end def rotate(*args, &block); end def rotate!(*args, &block); end def sample(*args, &block); end def select(*args, &block); end def select!(*args, &block); end def shelljoin(*args, &block); end def shift(*args, &block); end def shuffle(*args, &block); end def shuffle!(*args, &block); end def size(*args, &block); end def slice(*args, &block); end def slice!(*args, &block); end def slice_after(*args, &block); end def slice_before(*args, &block); end def slice_when(*args, &block); end def sort(*args, &block); end def sort!(*args, &block); end def sort_by(*args, &block); end def sort_by!(*args, &block); end def sum(*args, &block); end def take(*args, &block); end def take_while(*args, &block); end def to_ary(*args, &block); end def to_h(*args, &block); end def to_set(*args, &block); end def transpose(*args, &block); end def union(*args, &block); end def uniq(*args, &block); end def uniq!(*args, &block); end def unshift(*args, &block); end def values_at(*args, &block); end def zip(*args, &block); end def |(*args, &block); end end RuboCop::AST::CollectionNode::ARRAY_METHODS = T.let(T.unsafe(nil), Array) module RuboCop::AST::ConditionalNode def body; end def condition; end def multiline_condition?; end def single_line_condition?; end end class RuboCop::AST::DefNode < ::RuboCop::AST::Node include(::RuboCop::AST::ParameterizedNode) include(::RuboCop::AST::MethodIdentifierPredicates) def argument_forwarding?; end def arguments; end def body; end def method_name; end def receiver; end def void_context?; end end class RuboCop::AST::DefinedNode < ::RuboCop::AST::Node include(::RuboCop::AST::ParameterizedNode) include(::RuboCop::AST::MethodIdentifierPredicates) include(::RuboCop::AST::MethodDispatchNode) def arguments; end def node_parts; end end class RuboCop::AST::EnsureNode < ::RuboCop::AST::Node def body; end end module RuboCop::AST::Ext end module RuboCop::AST::Ext::Range def line_span(exclude_end: T.unsafe(nil)); end end class RuboCop::AST::FloatNode < ::RuboCop::AST::Node include(::RuboCop::AST::BasicLiteralNode) include(::RuboCop::AST::NumericNode) end class RuboCop::AST::ForNode < ::RuboCop::AST::Node def body; end def collection; end def do?; end def keyword; end def variable; end def void_context?; end end class RuboCop::AST::ForwardArgsNode < ::RuboCop::AST::Node include(::RuboCop::AST::CollectionNode) def to_a; end end module RuboCop::AST::HashElementNode def delimiter_delta(other); end def key; end def key_delta(other, alignment = T.unsafe(nil)); end def same_line?(other); end def value; end def value_delta(other); end end class RuboCop::AST::HashNode < ::RuboCop::AST::Node def braces?; end def each_key(&block); end def each_pair; end def each_value(&block); end def empty?; end def keys; end def mixed_delimiters?; end def pairs; end def pairs_on_same_line?; end def values; end end class RuboCop::AST::IfNode < ::RuboCop::AST::Node include(::RuboCop::AST::ConditionalNode) include(::RuboCop::AST::ModifierNode) def branches; end def each_branch(&block); end def else?; end def else_branch; end def elsif?; end def elsif_conditional?; end def if?; end def if_branch; end def inverse_keyword; end def keyword; end def modifier_form?; end def nested_conditional?; end def node_parts; end def ternary?; end def unless?; end end class RuboCop::AST::IndexNode < ::RuboCop::AST::Node include(::RuboCop::AST::ParameterizedNode) include(::RuboCop::AST::ParameterizedNode::RestArguments) include(::RuboCop::AST::MethodIdentifierPredicates) include(::RuboCop::AST::MethodDispatchNode) def assignment_method?; end def attribute_accessor?; end def method_name; end private def first_argument_index; end end class RuboCop::AST::IndexasgnNode < ::RuboCop::AST::Node include(::RuboCop::AST::ParameterizedNode) include(::RuboCop::AST::ParameterizedNode::RestArguments) include(::RuboCop::AST::MethodIdentifierPredicates) include(::RuboCop::AST::MethodDispatchNode) def assignment_method?; end def attribute_accessor?; end def method_name; end private def first_argument_index; end end class RuboCop::AST::IntNode < ::RuboCop::AST::Node include(::RuboCop::AST::BasicLiteralNode) include(::RuboCop::AST::NumericNode) end class RuboCop::AST::KeywordSplatNode < ::RuboCop::AST::Node include(::RuboCop::AST::HashElementNode) def colon?; end def hash_rocket?; end def node_parts; end def operator; end end RuboCop::AST::KeywordSplatNode::DOUBLE_SPLAT = T.let(T.unsafe(nil), String) class RuboCop::AST::LambdaNode < ::RuboCop::AST::Node include(::RuboCop::AST::ParameterizedNode) include(::RuboCop::AST::ParameterizedNode::RestArguments) include(::RuboCop::AST::MethodIdentifierPredicates) include(::RuboCop::AST::MethodDispatchNode) def assignment_method?; end def attribute_accessor?; end def lambda?; end def lambda_literal?; end def method_name; end def receiver; end private def first_argument_index; end end module RuboCop::AST::MethodDispatchNode include(::RuboCop::AST::MethodIdentifierPredicates) extend(::RuboCop::AST::NodePattern::Macros) def access_modifier?; end def adjacent_def_modifier?(node = T.unsafe(nil)); end def arithmetic_operation?; end def assignment?; end def bare_access_modifier?; end def bare_access_modifier_declaration?(node = T.unsafe(nil)); end def binary_operation?; end def block_literal?; end def block_node; end def command?(name); end def const_receiver?; end def def_modifier?; end def dot?; end def double_colon?; end def implicit_call?; end def lambda?; end def lambda_literal?; end def macro?; end def macro_scope?(node = T.unsafe(nil)); end def method_name; end def non_bare_access_modifier?; end def non_bare_access_modifier_declaration?(node = T.unsafe(nil)); end def receiver; end def safe_navigation?; end def self_receiver?; end def setter_method?; end def special_modifier?; end def unary_operation?; end private def macro_kwbegin_wrapper?(parent); end def root_node?(node); end end RuboCop::AST::MethodDispatchNode::ARITHMETIC_OPERATORS = T.let(T.unsafe(nil), Array) RuboCop::AST::MethodDispatchNode::SPECIAL_MODIFIERS = T.let(T.unsafe(nil), Array) module RuboCop::AST::MethodIdentifierPredicates def assignment_method?; end def bang_method?; end def camel_case_method?; end def comparison_method?; end def const_receiver?; end def enumerable_method?; end def enumerator_method?; end def method?(name); end def negation_method?; end def nonmutating_array_method?; end def nonmutating_binary_operator_method?; end def nonmutating_hash_method?; end def nonmutating_operator_method?; end def nonmutating_string_method?; end def nonmutating_unary_operator_method?; end def operator_method?; end def predicate_method?; end def prefix_bang?; end def prefix_not?; end def self_receiver?; end end RuboCop::AST::MethodIdentifierPredicates::ENUMERABLE_METHODS = T.let(T.unsafe(nil), Set) RuboCop::AST::MethodIdentifierPredicates::ENUMERATOR_METHODS = T.let(T.unsafe(nil), Set) RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_ARRAY_METHODS = T.let(T.unsafe(nil), Set) RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_BINARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set) RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_HASH_METHODS = T.let(T.unsafe(nil), Set) RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_OPERATOR_METHODS = T.let(T.unsafe(nil), Set) RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_STRING_METHODS = T.let(T.unsafe(nil), Set) RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_UNARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set) RuboCop::AST::MethodIdentifierPredicates::OPERATOR_METHODS = T.let(T.unsafe(nil), Set) module RuboCop::AST::ModifierNode def modifier_form?; end end class RuboCop::AST::ModuleNode < ::RuboCop::AST::Node def body; end def identifier; end end class RuboCop::AST::NextNode < ::RuboCop::AST::Node include(::RuboCop::AST::ParameterizedNode) include(::RuboCop::AST::ParameterizedNode::WrappedArguments) end class RuboCop::AST::Node < ::Parser::AST::Node include(::RuboCop::AST::Sexp) include(::RuboCop::RSpec::Node) extend(::RuboCop::AST::NodePattern::Macros) def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end def __ENCODING___type?; end def __FILE___type?; end def __LINE___type?; end def alias_type?; end def ancestors; end def and_asgn_type?; end def and_type?; end def arg_expr_type?; end def arg_type?; end def args_type?; end def argument?; end def argument_type?; end def array_pattern_type?; end def array_pattern_with_tail_type?; end def array_type?; end def assignment?; end def assignment_or_similar?(node = T.unsafe(nil)); end def back_ref_type?; end def basic_conditional?; end def basic_literal?; end def begin_type?; end def block_pass_type?; end def block_type?; end def blockarg_expr_type?; end def blockarg_type?; end def boolean_type?; end def break_type?; end def call_type?; end def case_match_type?; end def case_type?; end def casgn_type?; end def cbase_type?; end def chained?; end def child_nodes; end def class_constructor?(node = T.unsafe(nil)); end def class_definition?(node = T.unsafe(nil)); end def class_type?; end def complete!; end def complete?; end def complex_type?; end def conditional?; end def const_name; end def const_pattern_type?; end def const_type?; end def csend_type?; end def cvar_type?; end def cvasgn_type?; end def def_e_type?; end def def_type?; end def defined_module; end def defined_module_name; end def defined_type?; end def defs_e_type?; end def defs_type?; end def descendants; end def dstr_type?; end def dsym_type?; end def each_ancestor(*types, &block); end def each_child_node(*types); end def each_descendant(*types, &block); end def each_node(*types, &block); end def eflipflop_type?; end def empty_else_type?; end def empty_source?; end def ensure_type?; end def equals_asgn?; end def erange_type?; end def false_type?; end def falsey_literal?; end def find_pattern_type?; end def first_line; end def float_type?; end def for_type?; end def forward_arg_type?; end def forward_args_type?; end def forwarded_args_type?; end def global_const?(node = T.unsafe(nil), param1); end def guard_clause?; end def gvar_type?; end def gvasgn_type?; end def hash_pattern_type?; end def hash_type?; end def ident_type?; end def if_guard_type?; end def if_type?; end def iflipflop_type?; end def immutable_literal?; end def in_match_type?; end def in_pattern_type?; end def index_type?; end def indexasgn_type?; end def int_type?; end def irange_type?; end def ivar_type?; end def ivasgn_type?; end def keyword?; end def kwarg_type?; end def kwbegin_type?; end def kwnilarg_type?; end def kwoptarg_type?; end def kwrestarg_type?; end def kwsplat_type?; end def lambda?(node = T.unsafe(nil)); end def lambda_or_proc?(node = T.unsafe(nil)); end def lambda_type?; end def last_line; end def line_count; end def literal?; end def loop_keyword?; end def lvar_type?; end def lvasgn_type?; end def masgn_type?; end def match_alt_type?; end def match_as_type?; end def match_current_line_type?; end def match_guard_clause?(node = T.unsafe(nil)); end def match_nil_pattern_type?; end def match_rest_type?; end def match_var_type?; end def match_with_lvasgn_type?; end def match_with_trailing_comma_type?; end def mlhs_type?; end def module_definition?(node = T.unsafe(nil)); end def module_type?; end def mrasgn_type?; end def multiline?; end def mutable_literal?; end def new_class_or_module_block?(node = T.unsafe(nil)); end def next_type?; end def nil_type?; end def node_parts; end def nonempty_line_count; end def not_type?; end def nth_ref_type?; end def numargs_type?; end def numblock_type?; end def numeric_type?; end def objc_kwarg_type?; end def objc_restarg_type?; end def objc_varargs_type?; end def op_asgn_type?; end def operator_keyword?; end def optarg_type?; end def or_asgn_type?; end def or_type?; end def pair_type?; end def parent; end def parent_module_name; end def parenthesized_call?; end def pin_type?; end def post_condition_loop?; end def postexe_type?; end def preexe_type?; end def proc?(node = T.unsafe(nil)); end def procarg0_type?; end def pure?; end def range_type?; end def rasgn_type?; end def rational_type?; end def receiver(node = T.unsafe(nil)); end def recursive_basic_literal?; end def recursive_literal?; end def redo_type?; end def reference?; end def regexp_type?; end def regopt_type?; end def resbody_type?; end def rescue_type?; end def restarg_expr_type?; end def restarg_type?; end def retry_type?; end def return_type?; end def root_type?; end def sclass_type?; end def self_type?; end def send_type?; end def shadowarg_type?; end def shorthand_asgn?; end def sibling_index; end def single_line?; end def source; end def source_length; end def source_range; end def special_keyword?; end def splat_type?; end def str_content(node = T.unsafe(nil)); end def str_type?; end def struct_constructor?(node = T.unsafe(nil)); end def super_type?; end def sym_type?; end def true_type?; end def truthy_literal?; end def undef_type?; end def unless_guard_type?; end def until_post_type?; end def until_type?; end def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end def value_used?; end def variable?; end def when_type?; end def while_post_type?; end def while_type?; end def xstr_type?; end def yield_type?; end def zsuper_type?; end protected def parent=(node); end def visit_descendants(types, &block); end private def begin_value_used?; end def case_if_value_used?; end def defined_module0(node = T.unsafe(nil)); end def for_value_used?; end def parent_module_name_for_block(ancestor); end def parent_module_name_for_sclass(sclass_node); end def parent_module_name_part(node); end def visit_ancestors(types); end def while_until_value_used?; end end RuboCop::AST::Node::ARGUMENT_TYPES = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::ASSIGNMENTS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::BASIC_CONDITIONALS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::BASIC_LITERALS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::COMPARISON_OPERATORS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::COMPOSITE_LITERALS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::CONDITIONALS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::EQUALS_ASSIGNMENTS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::FALSEY_LITERALS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::IMMUTABLE_LITERALS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::KEYWORDS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::LITERALS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::LOOP_TYPES = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::MUTABLE_LITERALS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::OPERATOR_KEYWORDS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::REFERENCES = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::SPECIAL_KEYWORDS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::TRUTHY_LITERALS = T.let(T.unsafe(nil), Array) RuboCop::AST::Node::VARIABLES = T.let(T.unsafe(nil), Array) class RuboCop::AST::NodePattern def initialize(str); end def ==(other); end def eql?(other); end def marshal_dump; end def marshal_load(pattern); end def match(*args, **rest); end def pattern; end def to_s; end class << self def descend(element, &block); end end end class RuboCop::AST::NodePattern::Invalid < ::StandardError end module RuboCop::AST::NodePattern::Macros def def_node_matcher(method_name, pattern_str, **keyword_defaults); end def def_node_search(method_name, pattern_str, **keyword_defaults); end end class RuboCop::AST::NodePattern::Matcher def initialize(&block); end def ===(compare); end end module RuboCop::AST::NumericNode def sign?; end end RuboCop::AST::NumericNode::SIGN_REGEX = T.let(T.unsafe(nil), Regexp) class RuboCop::AST::OrNode < ::RuboCop::AST::Node include(::RuboCop::AST::BinaryOperatorNode) include(::RuboCop::AST::PredicateOperatorNode) def alternate_operator; end def inverse_operator; end end class RuboCop::AST::PairNode < ::RuboCop::AST::Node include(::RuboCop::AST::HashElementNode) def colon?; end def delimiter(*deprecated, with_spacing: T.unsafe(nil)); end def hash_rocket?; end def inverse_delimiter(*deprecated, with_spacing: T.unsafe(nil)); end def value_on_new_line?; end end RuboCop::AST::PairNode::COLON = T.let(T.unsafe(nil), String) RuboCop::AST::PairNode::HASH_ROCKET = T.let(T.unsafe(nil), String) RuboCop::AST::PairNode::SPACED_COLON = T.let(T.unsafe(nil), String) RuboCop::AST::PairNode::SPACED_HASH_ROCKET = T.let(T.unsafe(nil), String) module RuboCop::AST::ParameterizedNode def arguments?; end def block_argument?; end def first_argument; end def last_argument; end def parenthesized?; end def rest_argument?; end def splat_argument?; end end module RuboCop::AST::ParameterizedNode::RestArguments include(::RuboCop::AST::ParameterizedNode) def arguments; end def arguments?; end def first_argument; end def last_argument; end end module RuboCop::AST::ParameterizedNode::WrappedArguments include(::RuboCop::AST::ParameterizedNode) def arguments; end end module RuboCop::AST::PredicateOperatorNode def logical_operator?; end def operator; end def semantic_operator?; end end RuboCop::AST::PredicateOperatorNode::LOGICAL_AND = T.let(T.unsafe(nil), String) RuboCop::AST::PredicateOperatorNode::LOGICAL_OR = T.let(T.unsafe(nil), String) RuboCop::AST::PredicateOperatorNode::SEMANTIC_AND = T.let(T.unsafe(nil), String) RuboCop::AST::PredicateOperatorNode::SEMANTIC_OR = T.let(T.unsafe(nil), String) class RuboCop::AST::ProcessedSource include(::RuboCop::Ext::ProcessedSource) def initialize(source, ruby_version, path = T.unsafe(nil)); end def [](*args); end def ast; end def ast_with_comments; end def blank?; end def buffer; end def checksum; end def comment_at_line(line); end def commented?(source_range); end def comments; end def comments_before_line(line); end def contains_comment?(source_range); end def current_line(token); end def diagnostics; end def each_comment(&block); end def each_comment_in_lines(line_range); end def each_token(&block); end def file_path; end def find_comment(&block); end def find_token(&block); end def following_line(token); end def line_indentation(line_number); end def line_with_comment?(line); end def lines; end def parser_error; end def path; end def preceding_line(token); end def raw_source; end def ruby_version; end def start_with?(string); end def tokens; end def valid_syntax?; end private def comment_index; end def create_parser(ruby_version); end def parse(source, ruby_version); end def parser_class(ruby_version); end def tokenize(parser); end class << self def from_file(path, ruby_version); end end end RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME = T.let(T.unsafe(nil), String) class RuboCop::AST::RangeNode < ::RuboCop::AST::Node def begin; end def end; end end class RuboCop::AST::RegexpNode < ::RuboCop::AST::Node def content; end def delimiter?(char); end def delimiters; end def extended?; end def ignore_case?; end def interpolation?; end def multiline_mode?; end def no_encoding?; end def percent_r_literal?; end def regopt; end def single_interpolation?; end def slash_literal?; end def to_regexp; end private def regopt_include?(option); end end RuboCop::AST::RegexpNode::OPTIONS = T.let(T.unsafe(nil), Hash) class RuboCop::AST::ResbodyNode < ::RuboCop::AST::Node def body; end def exception_variable; end end class RuboCop::AST::ReturnNode < ::RuboCop::AST::Node include(::RuboCop::AST::ParameterizedNode) include(::RuboCop::AST::ParameterizedNode::WrappedArguments) end class RuboCop::AST::SelfClassNode < ::RuboCop::AST::Node def body; end def identifier; end end class RuboCop::AST::SendNode < ::RuboCop::AST::Node include(::RuboCop::AST::ParameterizedNode) include(::RuboCop::AST::ParameterizedNode::RestArguments) include(::RuboCop::AST::MethodIdentifierPredicates) include(::RuboCop::AST::MethodDispatchNode) def attribute_accessor?(node = T.unsafe(nil)); end private def first_argument_index; end end module RuboCop::AST::Sexp def s(type, *children); end end class RuboCop::AST::StrNode < ::RuboCop::AST::Node include(::RuboCop::AST::BasicLiteralNode) def heredoc?; end end class RuboCop::AST::SuperNode < ::RuboCop::AST::Node include(::RuboCop::AST::ParameterizedNode) include(::RuboCop::AST::MethodIdentifierPredicates) include(::RuboCop::AST::MethodDispatchNode) def arguments; end def node_parts; end end class RuboCop::AST::SymbolNode < ::RuboCop::AST::Node include(::RuboCop::AST::BasicLiteralNode) end class RuboCop::AST::Token def initialize(pos, type, text); end def begin_pos; end def column; end def comma?; end def comment?; end def end?; end def end_pos; end def equal_sign?; end def left_array_bracket?; end def left_brace?; end def left_bracket?; end def left_curly_brace?; end def left_parens?; end def left_ref_bracket?; end def line; end def pos; end def rescue_modifier?; end def right_bracket?; end def right_curly_brace?; end def right_parens?; end def semicolon?; end def space_after?; end def space_before?; end def text; end def to_s; end def type; end class << self def from_parser_token(parser_token); end end end module RuboCop::AST::Traversal def on___ENCODING__(node); end def on_alias(node); end def on_and(node); end def on_and_asgn(node); end def on_arg(node); end def on_arg_expr(node); end def on_args(node); end def on_array(node); end def on_array_pattern(node); end def on_array_pattern_with_tail(node); end def on_back_ref(node); end def on_begin(node); end def on_block(node); end def on_block_pass(node); end def on_blockarg(node); end def on_break(node); end def on_case(node); end def on_case_match(node); end def on_casgn(node); end def on_cbase(node); end def on_class(node); end def on_complex(node); end def on_const(node); end def on_const_pattern(node); end def on_csend(node); end def on_cvar(node); end def on_cvasgn(node); end def on_def(node); end def on_defined?(node); end def on_defs(node); end def on_dstr(node); end def on_dsym(node); end def on_eflipflop(node); end def on_empty_else(node); end def on_ensure(node); end def on_erange(node); end def on_false(node); end def on_find_pattern(node); end def on_float(node); end def on_for(node); end def on_forward_arg(node); end def on_forward_args(node); end def on_forwarded_args(node); end def on_gvar(node); end def on_gvasgn(node); end def on_hash(node); end def on_hash_pattern(node); end def on_if(node); end def on_if_guard(node); end def on_iflipflop(node); end def on_in_match(node); end def on_in_pattern(node); end def on_index(node); end def on_indexasgn(node); end def on_int(node); end def on_irange(node); end def on_ivar(node); end def on_ivasgn(node); end def on_kwarg(node); end def on_kwbegin(node); end def on_kwoptarg(node); end def on_kwrestarg(node); end def on_kwsplat(node); end def on_lambda(node); end def on_lvar(node); end def on_lvasgn(node); end def on_masgn(node); end def on_match_alt(node); end def on_match_as(node); end def on_match_current_line(node); end def on_match_nil_pattern(node); end def on_match_rest(node); end def on_match_var(node); end def on_match_with_lvasgn(node); end def on_match_with_trailing_comma(node); end def on_mlhs(node); end def on_module(node); end def on_next(node); end def on_nil(node); end def on_not(node); end def on_nth_ref(node); end def on_numblock(node); end def on_op_asgn(node); end def on_optarg(node); end def on_or(node); end def on_or_asgn(node); end def on_pair(node); end def on_pin(node); end def on_postexe(node); end def on_preexe(node); end def on_procarg0(node); end def on_rational(node); end def on_redo(node); end def on_regexp(node); end def on_regopt(node); end def on_resbody(node); end def on_rescue(node); end def on_restarg(node); end def on_retry(node); end def on_return(node); end def on_sclass(node); end def on_self(node); end def on_send(node); end def on_shadowarg(node); end def on_splat(node); end def on_str(node); end def on_super(node); end def on_sym(node); end def on_true(node); end def on_undef(node); end def on_unless_guard(node); end def on_until(node); end def on_until_post(node); end def on_when(node); end def on_while(node); end def on_while_post(node); end def on_xstr(node); end def on_yield(node); end def on_zsuper(node); end def walk(node); end end RuboCop::AST::Traversal::MANY_CHILD_NODES = T.let(T.unsafe(nil), Array) RuboCop::AST::Traversal::NO_CHILD_NODES = T.let(T.unsafe(nil), Array) RuboCop::AST::Traversal::ONE_CHILD_NODE = T.let(T.unsafe(nil), Array) RuboCop::AST::Traversal::SECOND_CHILD_ONLY = T.let(T.unsafe(nil), Array) class RuboCop::AST::UntilNode < ::RuboCop::AST::Node include(::RuboCop::AST::ConditionalNode) include(::RuboCop::AST::ModifierNode) def do?; end def inverse_keyword; end def keyword; end end module RuboCop::AST::Version end RuboCop::AST::Version::STRING = T.let(T.unsafe(nil), String) class RuboCop::AST::WhenNode < ::RuboCop::AST::Node def body; end def branch_index; end def conditions; end def each_condition(&block); end def then?; end end class RuboCop::AST::WhileNode < ::RuboCop::AST::Node include(::RuboCop::AST::ConditionalNode) include(::RuboCop::AST::ModifierNode) def do?; end def inverse_keyword; end def keyword; end end class RuboCop::AST::YieldNode < ::RuboCop::AST::Node include(::RuboCop::AST::ParameterizedNode) include(::RuboCop::AST::MethodIdentifierPredicates) include(::RuboCop::AST::MethodDispatchNode) def arguments; end def node_parts; end end RuboCop::NodePattern = RuboCop::AST::NodePattern RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource RuboCop::Token = RuboCop::AST::Token RuboCop::AST::NodePattern::Compiler::ANY_ORDER_TEMPLATE = T.let(T.unsafe(nil), ERB) RuboCop::AST::NodePattern::Compiler::CAPTURED_REST = T.let(T.unsafe(nil), String) RuboCop::AST::NodePattern::Compiler::CLOSING = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::COMMENT = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::CONST = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::CUR_ELEMENT = T.let(T.unsafe(nil), String) RuboCop::AST::NodePattern::Compiler::CUR_NODE = T.let(T.unsafe(nil), String) RuboCop::AST::NodePattern::Compiler::CUR_PLACEHOLDER = T.let(T.unsafe(nil), String) RuboCop::AST::NodePattern::Compiler::FUNCALL = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::IDENTIFIER = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::KEYWORD = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::KEYWORD_NAME = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::LITERAL = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::META = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::METHOD_NAME = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::MULTIPLE_CUR_PLACEHOLDER = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::NODE = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::NUMBER = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::ONLY_SEPARATOR = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::PARAM = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::PARAM_CONST = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::PARAM_NUMBER = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::PREDICATE = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::REPEATED_TEMPLATE = T.let(T.unsafe(nil), ERB) RuboCop::AST::NodePattern::Compiler::REST = T.let(T.unsafe(nil), String) RuboCop::AST::NodePattern::Compiler::SEPARATORS = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::SEQ_HEAD_GUARD = T.let(T.unsafe(nil), String) RuboCop::AST::NodePattern::Compiler::SEQ_HEAD_INDEX = T.let(T.unsafe(nil), Integer) RuboCop::AST::NodePattern::Compiler::STRING = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::SYMBOL = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::TOKEN = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::TOKENS = T.let(T.unsafe(nil), Regexp) RuboCop::AST::NodePattern::Compiler::WILDCARD = T.let(T.unsafe(nil), Regexp)