muina 0.2.7 → 0.3.0

data/sorbet/rbi/gems/rubocop-ast@1.8.0.rbi

@@ -1,2194 +0,0 @@
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rubocop-ast` gem.
-# Please instead update this file by running `bin/tapioca sync`.
-
-# typed: true
-
-class AST::Node
-  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
-
-  def +(array); end
-  def <<(element); end
-  def ==(other); end
-  def append(element); end
-  def children; end
-  def clone; end
-  def concat(array); end
-  def deconstruct; end
-  def dup; end
-  def eql?(other); end
-  def hash; end
-  def inspect(indent = T.unsafe(nil)); end
-  def to_a; end
-  def to_ast; end
-  def to_s(indent = T.unsafe(nil)); end
-  def to_sexp(indent = T.unsafe(nil)); end
-  def to_sexp_array; end
-  def type; end
-  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
-
-  protected
-
-  def assign_properties(properties); end
-  def fancy_type; end
-
-  private
-
-  def original_dup; end
-end
-
-class Parser::AST::Node < ::AST::Node
-  def assign_properties(properties); end
-  def loc; end
-  def location; end
-end
-
-class Parser::Builders::Default
-  def initialize; end
-
-  def __ENCODING__(__ENCODING__t); end
-  def __FILE__(__FILE__t); end
-  def __LINE__(__LINE__t); end
-  def accessible(node); end
-  def alias(alias_t, to, from); end
-  def arg(name_t); end
-  def arg_expr(expr); end
-  def args(begin_t, args, end_t, check_args = T.unsafe(nil)); end
-  def array(begin_t, elements, end_t); end
-  def array_pattern(lbrack_t, elements, rbrack_t); end
-  def assign(lhs, eql_t, rhs); end
-  def assignable(node); end
-  def associate(begin_t, pairs, end_t); end
-  def attr_asgn(receiver, dot_t, selector_t); end
-  def back_ref(token); end
-  def begin(begin_t, body, end_t); end
-  def begin_body(compound_stmt, rescue_bodies = T.unsafe(nil), else_t = T.unsafe(nil), else_ = T.unsafe(nil), ensure_t = T.unsafe(nil), ensure_ = T.unsafe(nil)); end
-  def begin_keyword(begin_t, body, end_t); end
-  def binary_op(receiver, operator_t, arg); end
-  def block(method_call, begin_t, args, body, end_t); end
-  def block_pass(amper_t, arg); end
-  def blockarg(amper_t, name_t); end
-  def blockarg_expr(amper_t, expr); end
-  def call_lambda(lambda_t); end
-  def call_method(receiver, dot_t, selector_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
-  def call_type_for_dot(dot_t); end
-  def case(case_t, expr, when_bodies, else_t, else_body, end_t); end
-  def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end
-  def character(char_t); end
-  def complex(complex_t); end
-  def compstmt(statements); end
-  def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end
-  def condition_mod(if_true, if_false, cond_t, cond); end
-  def const(name_t); end
-  def const_fetch(scope, t_colon2, name_t); end
-  def const_global(t_colon3, name_t); end
-  def const_op_assignable(node); end
-  def const_pattern(const, ldelim_t, pattern, rdelim_t); end
-  def cvar(token); end
-  def dedent_string(node, dedent_level); end
-  def def_class(class_t, name, lt_t, superclass, body, end_t); end
-  def def_endless_method(def_t, name_t, args, assignment_t, body); end
-  def def_endless_singleton(def_t, definee, dot_t, name_t, args, assignment_t, body); end
-  def def_method(def_t, name_t, args, body, end_t); end
-  def def_module(module_t, name, body, end_t); end
-  def def_sclass(class_t, lshft_t, expr, body, end_t); end
-  def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end
-  def emit_file_line_as_literals; end
-  def emit_file_line_as_literals=(_arg0); end
-  def false(false_t); end
-  def find_pattern(lbrack_t, elements, rbrack_t); end
-  def float(float_t); end
-  def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end
-  def forward_arg(dots_t); end
-  def forward_only_args(begin_t, dots_t, end_t); end
-  def forwarded_args(dots_t); end
-  def gvar(token); end
-  def hash_pattern(lbrace_t, kwargs, rbrace_t); end
-  def ident(token); end
-  def if_guard(if_t, if_body); end
-  def in_match(lhs, in_t, rhs); end
-  def in_pattern(in_t, pattern, guard, then_t, body); end
-  def index(receiver, lbrack_t, indexes, rbrack_t); end
-  def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end
-  def integer(integer_t); end
-  def ivar(token); end
-  def keyword_cmd(type, keyword_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
-  def kwarg(name_t); end
-  def kwnilarg(dstar_t, nil_t); end
-  def kwoptarg(name_t, value); end
-  def kwrestarg(dstar_t, name_t = T.unsafe(nil)); end
-  def kwsplat(dstar_t, arg); end
-  def logical_op(type, lhs, op_t, rhs); end
-  def loop(type, keyword_t, cond, do_t, body, end_t); end
-  def loop_mod(type, body, keyword_t, cond); end
-  def match_alt(left, pipe_t, right); end
-  def match_as(value, assoc_t, as); end
-  def match_hash_var(name_t); end
-  def match_hash_var_from_str(begin_t, strings, end_t); end
-  def match_label(label_type, label); end
-  def match_nil_pattern(dstar_t, nil_t); end
-  def match_op(receiver, match_t, arg); end
-  def match_pair(label_type, label, value); end
-  def match_pattern(lhs, match_t, rhs); end
-  def match_pattern_p(lhs, match_t, rhs); end
-  def match_rest(star_t, name_t = T.unsafe(nil)); end
-  def match_var(name_t); end
-  def match_with_trailing_comma(match, comma_t); end
-  def multi_assign(lhs, eql_t, rhs); end
-  def multi_lhs(begin_t, items, end_t); end
-  def nil(nil_t); end
-  def not_op(not_t, begin_t = T.unsafe(nil), receiver = T.unsafe(nil), end_t = T.unsafe(nil)); end
-  def nth_ref(token); end
-  def numargs(max_numparam); end
-  def objc_kwarg(kwname_t, assoc_t, name_t); end
-  def objc_restarg(star_t, name = T.unsafe(nil)); end
-  def objc_varargs(pair, rest_of_varargs); end
-  def op_assign(lhs, op_t, rhs); end
-  def optarg(name_t, eql_t, value); end
-  def pair(key, assoc_t, value); end
-  def pair_keyword(key_t, value); end
-  def pair_list_18(list); end
-  def pair_quoted(begin_t, parts, end_t, value); end
-  def parser; end
-  def parser=(_arg0); end
-  def pin(pin_t, var); end
-  def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end
-  def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end
-  def procarg0(arg); end
-  def range_exclusive(lhs, dot3_t, rhs); end
-  def range_inclusive(lhs, dot2_t, rhs); end
-  def rational(rational_t); end
-  def regexp_compose(begin_t, parts, end_t, options); end
-  def regexp_options(regopt_t); end
-  def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end
-  def restarg(star_t, name_t = T.unsafe(nil)); end
-  def restarg_expr(star_t, expr = T.unsafe(nil)); end
-  def self(token); end
-  def shadowarg(name_t); end
-  def splat(star_t, arg = T.unsafe(nil)); end
-  def string(string_t); end
-  def string_compose(begin_t, parts, end_t); end
-  def string_internal(string_t); end
-  def symbol(symbol_t); end
-  def symbol_compose(begin_t, parts, end_t); end
-  def symbol_internal(symbol_t); end
-  def symbols_compose(begin_t, parts, end_t); end
-  def ternary(cond, question_t, if_true, colon_t, if_false); end
-  def true(true_t); end
-  def unary_num(unary_t, numeric); end
-  def unary_op(op_t, receiver); end
-  def undef_method(undef_t, names); end
-  def unless_guard(unless_t, unless_body); end
-  def when(when_t, patterns, then_t, body); end
-  def word(parts); end
-  def words_compose(begin_t, parts, end_t); end
-  def xstring_compose(begin_t, parts, end_t); end
-
-  private
-
-  def arg_name_collides?(this_name, that_name); end
-  def arg_prefix_map(op_t, name_t = T.unsafe(nil)); end
-  def binary_op_map(left_e, op_t, right_e); end
-  def block_map(receiver_l, begin_t, end_t); end
-  def check_assignment_to_numparam(name, loc); end
-  def check_condition(cond); end
-  def check_duplicate_arg(this_arg, map = T.unsafe(nil)); end
-  def check_duplicate_args(args, map = T.unsafe(nil)); end
-  def check_duplicate_pattern_key(name, loc); end
-  def check_duplicate_pattern_variable(name, loc); end
-  def check_lvar_name(name, loc); end
-  def check_reserved_for_numparam(name, loc); end
-  def collapse_string_parts?(parts); end
-  def collection_map(begin_t, parts, end_t); end
-  def condition_map(keyword_t, cond_e, begin_t, body_e, else_t, else_e, end_t); end
-  def constant_map(scope, colon2_t, name_t); end
-  def definition_map(keyword_t, operator_t, name_t, end_t); end
-  def delimited_string_map(string_t); end
-  def diagnostic(type, reason, arguments, location, highlights = T.unsafe(nil)); end
-  def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end
-  def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e); end
-  def expr_map(loc); end
-  def for_map(keyword_t, in_t, begin_t, end_t); end
-  def guard_map(keyword_t, guard_body_e); end
-  def index_map(receiver_e, lbrack_t, rbrack_t); end
-  def join_exprs(left_expr, right_expr); end
-  def keyword_map(keyword_t, begin_t, args, end_t); end
-  def keyword_mod_map(pre_e, keyword_t, post_e); end
-  def kwarg_map(name_t, value_e = T.unsafe(nil)); end
-  def kwargs?(node); end
-  def loc(token); end
-  def module_definition_map(keyword_t, name_e, operator_t, end_t); end
-  def n(type, children, source_map); end
-  def n0(type, source_map); end
-  def numeric(kind, token); end
-  def pair_keyword_map(key_t, value_e); end
-  def pair_quoted_map(begin_t, end_t, value_e); end
-  def prefix_string_map(symbol); end
-  def range_map(start_e, op_t, end_e); end
-  def regexp_map(begin_t, end_t, options_e); end
-  def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end
-  def rewrite_hash_args_to_kwargs(args); end
-  def send_binary_op_map(lhs_e, selector_t, rhs_e); end
-  def send_index_map(receiver_e, lbrack_t, rbrack_t); end
-  def send_map(receiver_e, dot_t, selector_t, begin_t = T.unsafe(nil), args = T.unsafe(nil), end_t = T.unsafe(nil)); end
-  def send_unary_op_map(selector_t, arg_e); end
-  def static_regexp(parts, options); end
-  def static_regexp_node(node); end
-  def static_string(nodes); end
-  def string_map(begin_t, parts, end_t); end
-  def string_value(token); end
-  def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end
-  def token_map(token); end
-  def unary_op_map(op_t, arg_e = T.unsafe(nil)); end
-  def unquoted_map(token); end
-  def validate_definee(definee); end
-  def value(token); end
-  def var_send_map(variable_e); end
-  def variable_map(name_t); end
-
-  class << self
-    def emit_arg_inside_procarg0; end
-    def emit_arg_inside_procarg0=(_arg0); end
-    def emit_encoding; end
-    def emit_encoding=(_arg0); end
-    def emit_forward_arg; end
-    def emit_forward_arg=(_arg0); end
-    def emit_index; end
-    def emit_index=(_arg0); end
-    def emit_kwargs; end
-    def emit_kwargs=(_arg0); end
-    def emit_lambda; end
-    def emit_lambda=(_arg0); end
-    def emit_match_pattern; end
-    def emit_match_pattern=(_arg0); end
-    def emit_procarg0; end
-    def emit_procarg0=(_arg0); end
-    def modernize; end
-  end
-end
-
-module RuboCop; end
-
-module RuboCop::AST
-  extend ::RuboCop::AST::RuboCopCompatibility
-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::ArgNode < ::RuboCop::AST::Node
-  def default?; end
-  def default_value; end
-  def name; end
-end
-
-class RuboCop::AST::ArgsNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::CollectionNode
-
-  def argument_list; end
-  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 argument_list; end
-  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
-
-  private
-
-  def numbered_arguments; 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 branches; end
-  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_eql(*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 extract_options!(*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::ConstNode < ::RuboCop::AST::Node
-  def absolute?; end
-  def class_name?; end
-  def each_path(&block); end
-  def module_name?; end
-  def namespace; end
-  def relative?; end
-  def short_name; 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 endless?; 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
-
-module RuboCop::AST::Descendence
-  def child_nodes; end
-  def descendants; end
-  def each_child_node(*types); end
-  def each_descendant(*types, &block); end
-  def each_node(*types, &block); end
-
-  protected
-
-  def visit_descendants(types, &block); end
-end
-
-class RuboCop::AST::DstrNode < ::RuboCop::AST::StrNode
-  def value; 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
-
-module RuboCop::AST::Ext::RangeMinMax; 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::HashElementNode::HashElementDelta
-  def initialize(first, second); end
-
-  def delimiter_delta; end
-  def key_delta(alignment = T.unsafe(nil)); end
-  def value_delta; end
-
-  private
-
-  def delta(first, second, alignment = T.unsafe(nil)); end
-  def first; end
-  def keyword_splat?; end
-  def second; end
-  def valid_argument_types?; 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::InPatternNode < ::RuboCop::AST::Node
-  def body; end
-  def branch_index; end
-  def pattern; end
-  def then?; 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?(param0 = T.unsafe(nil)); end
-  def arithmetic_operation?; end
-  def assignment?; end
-  def bare_access_modifier?; end
-  def bare_access_modifier_declaration?(param0 = 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(node = T.unsafe(nil)); end
-  def def_modifier?(node = T.unsafe(nil)); end
-  def dot?; end
-  def double_colon?; end
-  def implicit_call?; end
-  def in_macro_scope?(param0 = T.unsafe(nil)); end
-  def lambda?; end
-  def lambda_literal?; end
-  def macro?; end
-  def method_name; end
-  def non_bare_access_modifier?; end
-  def non_bare_access_modifier_declaration?(param0 = 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
-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::AST::Descendence
-  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?(param0 = 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 class_constructor?(param0 = T.unsafe(nil)); end
-  def class_definition?(param0 = 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_type?; end
-  def defined_module; end
-  def defined_module_name; end
-  def defined_type?; end
-  def defs_type?; end
-  def dstr_type?; end
-  def dsym_type?; end
-  def each_ancestor(*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?(param0 = 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 kwargs_type?; end
-  def kwbegin_type?; end
-  def kwnilarg_type?; end
-  def kwoptarg_type?; end
-  def kwrestarg_type?; end
-  def kwsplat_type?; end
-  def lambda?(param0 = T.unsafe(nil)); end
-  def lambda_or_proc?(param0 = T.unsafe(nil)); end
-  def lambda_type?; end
-  def last_line; end
-  def left_sibling; end
-  def left_siblings; 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?(param0 = T.unsafe(nil)); end
-  def match_nil_pattern_type?; end
-  def match_pattern_p_type?; end
-  def match_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?(param0 = T.unsafe(nil)); end
-  def module_type?; end
-  def multiline?; end
-  def mutable_literal?; end
-  def new_class_or_module_block?(param0 = 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?; 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?(param0 = T.unsafe(nil)); end
-  def procarg0_type?; end
-  def pure?; end
-  def range_type?; end
-  def rational_type?; end
-  def receiver(param0 = 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 right_sibling; end
-  def right_siblings; end
-  def root?; 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(param0 = T.unsafe(nil)); end
-  def str_type?; end
-  def struct_constructor?(param0 = 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
-
-  private
-
-  def begin_value_used?; end
-  def case_if_value_used?; end
-  def defined_module0(param0 = 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), Set)
-RuboCop::AST::Node::ASSIGNMENTS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::BASIC_CONDITIONALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::BASIC_LITERALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::COMPARISON_OPERATORS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::COMPOSITE_LITERALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::CONDITIONALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::EQUALS_ASSIGNMENTS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::FALSEY_LITERALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::IMMUTABLE_LITERALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::KEYWORDS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::LITERALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::LITERAL_RECURSIVE_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::LITERAL_RECURSIVE_TYPES = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::LOOP_TYPES = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::MUTABLE_LITERALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::OPERATOR_KEYWORDS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::REFERENCES = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::SPECIAL_KEYWORDS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::TRUTHY_LITERALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::VARIABLES = T.let(T.unsafe(nil), Set)
-
-class RuboCop::AST::NodePattern
-  include ::RuboCop::AST::NodePattern::MethodDefiner
-  extend ::Forwardable
-
-  def initialize(str, compiler: T.unsafe(nil)); end
-
-  def ==(other); end
-  def as_json(_options = T.unsafe(nil)); end
-  def ast; end
-  def captures(*args, &block); end
-  def encode_with(coder); end
-  def eql?(other); end
-  def freeze; end
-  def init_with(coder); end
-  def marshal_dump; end
-  def marshal_load(pattern); end
-  def match(*args, **rest, &block); end
-  def match_code; end
-  def named_parameters(*args, &block); end
-  def pattern; end
-  def positional_parameters(*args, &block); end
-  def to_s; end
-
-  class << self
-    def descend(element, &block); end
-  end
-end
-
-class RuboCop::AST::NodePattern::Builder
-  def emit_atom(type, value); end
-  def emit_call(type, selector, args = T.unsafe(nil)); end
-  def emit_capture(capture_token, node); end
-  def emit_list(type, _begin, children, _end); end
-  def emit_subsequence(node_list); end
-  def emit_unary_op(type, _operator = T.unsafe(nil), *children); end
-  def emit_union(begin_t, pattern_lists, end_t); end
-
-  private
-
-  def n(type, *args); end
-  def optimizable_as_set?(children); end
-  def union_children(pattern_lists); end
-end
-
-class RuboCop::AST::NodePattern::Comment
-  def initialize(range); end
-
-  def ==(other); end
-  def inspect; end
-  def loc; end
-  def location; end
-  def text; end
-end
-
-class RuboCop::AST::NodePattern::Compiler
-  extend ::Forwardable
-
-  def initialize; end
-
-  def bind(*args, &block); end
-  def binding; end
-  def captures; end
-  def compile_as_atom(node); end
-  def compile_as_node_pattern(node, **options); end
-  def compile_sequence(sequence, var:); end
-  def each_union(enum, &block); end
-  def freeze; end
-  def named_parameter(name); end
-  def named_parameters; end
-  def next_capture; end
-  def parser; end
-  def positional_parameter(number); end
-  def positional_parameters; end
-  def with_temp_variables(*names, &block); end
-
-  private
-
-  def enforce_same_captures(enum); end
-  def new_capture; end
-end
-
-class RuboCop::AST::NodePattern::Compiler::AtomSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
-  private
-
-  def visit_const; end
-  def visit_named_parameter; end
-  def visit_number; end
-  def visit_other_type; end
-  def visit_positional_parameter; end
-  def visit_regexp; end
-  def visit_set; end
-  def visit_string; end
-  def visit_symbol; end
-  def visit_unify; end
-end
-
-class RuboCop::AST::NodePattern::Compiler::Binding
-  def initialize; end
-
-  def bind(name); end
-  def union_bind(enum); end
-
-  private
-
-  def forbid(names); end
-end
-
-class RuboCop::AST::NodePattern::Compiler::Debug < ::RuboCop::AST::NodePattern::Compiler
-  def initialize; end
-
-  def comments(*args, &block); end
-  def named_parameters; end
-  def node_ids; end
-  def parser; end
-  def tokens(*args, &block); end
-end
-
-class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer
-  def initialize(pattern, compiler: T.unsafe(nil)); end
-
-  def compiler; end
-  def node_pattern; end
-  def pattern; end
-  def test(ruby, trace: T.unsafe(nil)); end
-
-  private
-
-  def ruby_ast(ruby); end
-  def ruby_parser; end
-end
-
-RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::COLOR_SCHEME = T.let(T.unsafe(nil), Hash)
-RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Compiler = RuboCop::AST::NodePattern::Compiler::Debug
-
-class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Result < ::Struct
-  def color_map(color_scheme = T.unsafe(nil)); end
-  def colorize(color_scheme = T.unsafe(nil)); end
-  def colorizer; end
-  def colorizer=(_); end
-  def match_map; end
-  def matched?(node); end
-  def returned; end
-  def returned=(_); end
-  def ruby_ast; end
-  def ruby_ast=(_); end
-  def trace; end
-  def trace=(_); end
-
-  private
-
-  def ast; end
-  def color_map_for(node, color); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-module RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
-  def do_compile; end
-
-  private
-
-  def node_id; end
-  def tracer(kind); end
-end
-
-class RuboCop::AST::NodePattern::Compiler::Debug::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler
-  include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
-end
-
-class RuboCop::AST::NodePattern::Compiler::Debug::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler
-  include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
-end
-
-class RuboCop::AST::NodePattern::Compiler::Debug::Trace
-  def initialize; end
-
-  def enter(node_id); end
-  def matched?(node_id); end
-  def success(node_id); end
-end
-
-class RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
-  def initialize(compiler, var: T.unsafe(nil), access: T.unsafe(nil), seq_head: T.unsafe(nil)); end
-
-  def access; end
-  def seq_head; end
-
-  private
-
-  def access_element; end
-  def access_node; end
-  def compile_args(arg_list, first: T.unsafe(nil)); end
-  def compile_guard_clause; end
-  def compile_value_match(value); end
-  def multiple_access(kind); end
-  def visit_ascend; end
-  def visit_capture; end
-  def visit_descend; end
-  def visit_function_call; end
-  def visit_intersection; end
-  def visit_negation; end
-  def visit_node_type; end
-  def visit_other_type; end
-  def visit_predicate; end
-  def visit_sequence; end
-  def visit_unify; end
-  def visit_union; end
-  def visit_wildcard; end
-end
-
-class RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
-  def initialize(compiler, sequence:, var:); end
-
-  def compile_sequence; end
-  def in_sync; end
-
-  protected
-
-  def compile_terms(children = T.unsafe(nil), last_arity = T.unsafe(nil)); end
-  def cur_index; end
-  def sync; end
-
-  private
-
-  def compile_and_advance(term); end
-  def compile_any_order_branches(matched_var); end
-  def compile_any_order_else; end
-  def compile_captured_repetition(child_code, child_captures); end
-  def compile_case(when_branches, else_code); end
-  def compile_child_nb_guard(arity_range); end
-  def compile_cur_index; end
-  def compile_index(cur = T.unsafe(nil)); end
-  def compile_loop(term); end
-  def compile_loop_advance(to = T.unsafe(nil)); end
-  def compile_matched(kind); end
-  def compile_max_matched; end
-  def compile_min_check; end
-  def compile_remaining; end
-  def compile_union_forks; end
-  def empty_loop; end
-  def handle_prev; end
-  def merge_forks!(forks); end
-  def preserve_union_start(forks); end
-  def remaining_arities(children, last_arity); end
-  def use_index_from_end; end
-  def visit_any_order; end
-  def visit_capture; end
-  def visit_other_type; end
-  def visit_repetition; end
-  def visit_rest; end
-  def visit_union; end
-  def within_loop; end
-end
-
-RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::DELTA = T.let(T.unsafe(nil), Integer)
-RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::POSITIVE = T.let(T.unsafe(nil), Proc)
-
-class RuboCop::AST::NodePattern::Compiler::Subcompiler
-  def initialize(compiler); end
-
-  def compile(node); end
-  def compiler; end
-
-  private
-
-  def do_compile; end
-  def node; end
-
-  class << self
-    def inherited(base); end
-    def method_added(method); end
-    def registry; end
-  end
-end
-
-class RuboCop::AST::NodePattern::Invalid < ::StandardError; end
-
-class RuboCop::AST::NodePattern::Lexer < ::RuboCop::AST::NodePattern::LexerRex
-  def initialize(source); end
-
-  def comments; end
-  def source_buffer; end
-  def tokens; end
-
-  private
-
-  def do_parse; end
-  def emit(type); end
-  def emit_comment; end
-  def emit_regexp; end
-  def token(type, value); end
-end
-
-RuboCop::AST::NodePattern::Lexer::Error = RuboCop::AST::NodePattern::LexerRex::ScanError
-RuboCop::AST::NodePattern::Lexer::REGEXP_OPTIONS = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::AST::NodePattern::LexerRex
-  def action; end
-  def filename; end
-  def filename=(_arg0); end
-  def location; end
-  def match; end
-  def matches; end
-  def next_token; end
-  def parse(str); end
-  def parse_file(path); end
-  def scanner_class; end
-  def ss; end
-  def ss=(_arg0); end
-  def state; end
-  def state=(_arg0); end
-end
-
-RuboCop::AST::NodePattern::LexerRex::CALL = T.let(T.unsafe(nil), Regexp)
-RuboCop::AST::NodePattern::LexerRex::CONST_NAME = T.let(T.unsafe(nil), Regexp)
-RuboCop::AST::NodePattern::LexerRex::IDENTIFIER = T.let(T.unsafe(nil), Regexp)
-class RuboCop::AST::NodePattern::LexerRex::LexerError < ::StandardError; end
-RuboCop::AST::NodePattern::LexerRex::NODE_TYPE = T.let(T.unsafe(nil), Regexp)
-RuboCop::AST::NodePattern::LexerRex::REGEXP = T.let(T.unsafe(nil), Regexp)
-RuboCop::AST::NodePattern::LexerRex::REGEXP_BODY = T.let(T.unsafe(nil), Regexp)
-RuboCop::AST::NodePattern::LexerRex::SYMBOL_NAME = T.let(T.unsafe(nil), Regexp)
-class RuboCop::AST::NodePattern::LexerRex::ScanError < ::RuboCop::AST::NodePattern::LexerRex::LexerError; 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
-
-module RuboCop::AST::NodePattern::MethodDefiner
-  def as_lambda; end
-  def compile_as_lambda; end
-  def def_node_matcher(base, method_name, **defaults); end
-  def def_node_search(base, method_name, **defaults); end
-
-  private
-
-  def compile_init; end
-  def def_helper(base, method_name, **defaults); end
-  def emit_keyword_list(forwarding: T.unsafe(nil)); end
-  def emit_lambda_code; end
-  def emit_method_code; end
-  def emit_node_search(method_name); end
-  def emit_node_search_body(method_name, prelude:, on_match:); end
-  def emit_param_list; end
-  def emit_params(*first, forwarding: T.unsafe(nil)); end
-  def emit_retval; end
-  def emit_yield_capture(when_no_capture = T.unsafe(nil), yield_with: T.unsafe(nil)); end
-  def wrapping_block(method_name, **defaults); end
-end
-
-class RuboCop::AST::NodePattern::Node < ::Parser::AST::Node
-  include ::RuboCop::AST::Descendence
-  extend ::Forwardable
-
-  def arity; end
-  def arity_range; end
-  def capture?; end
-  def child; end
-  def children_nodes; end
-  def in_sequence_head; end
-  def matches_within_set?; end
-  def nb_captures; end
-  def rest?; end
-  def variadic?; end
-  def with(type: T.unsafe(nil), children: T.unsafe(nil), location: T.unsafe(nil)); end
-end
-
-class RuboCop::AST::NodePattern::Node::AnyOrder < ::RuboCop::AST::NodePattern::Node
-  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
-
-  def arity; end
-  def ends_with_rest?; end
-  def rest_node; end
-  def term_nodes; end
-end
-
-RuboCop::AST::NodePattern::Node::AnyOrder::ARITIES = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::AST::NodePattern::Node::Capture < ::RuboCop::AST::NodePattern::Node
-  def arity(*args, &block); end
-  def capture?; end
-  def in_sequence_head; end
-  def nb_captures; end
-  def rest?(*args, &block); end
-end
-
-module RuboCop::AST::NodePattern::Node::ForbidInSeqHead
-  def in_sequence_head; end
-end
-
-RuboCop::AST::NodePattern::Node::FunctionCall = RuboCop::AST::NodePattern::Node::Predicate
-RuboCop::AST::NodePattern::Node::INT_TO_RANGE = T.let(T.unsafe(nil), Hash)
-RuboCop::AST::NodePattern::Node::MAP = T.let(T.unsafe(nil), Hash)
-RuboCop::AST::NodePattern::Node::MATCHES_WITHIN_SET = T.let(T.unsafe(nil), Set)
-
-class RuboCop::AST::NodePattern::Node::Predicate < ::RuboCop::AST::NodePattern::Node
-  def arg_list; end
-  def method_name; end
-end
-
-class RuboCop::AST::NodePattern::Node::Repetition < ::RuboCop::AST::NodePattern::Node
-  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
-
-  def arity; end
-  def operator; end
-end
-
-RuboCop::AST::NodePattern::Node::Repetition::ARITIES = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::AST::NodePattern::Node::Rest < ::RuboCop::AST::NodePattern::Node
-  def arity; end
-  def in_sequence_head; end
-  def rest?; end
-end
-
-RuboCop::AST::NodePattern::Node::Rest::ARITY = T.let(T.unsafe(nil), Range)
-
-class RuboCop::AST::NodePattern::Node::Sequence < ::RuboCop::AST::NodePattern::Node
-  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
-
-  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
-end
-
-class RuboCop::AST::NodePattern::Node::Subsequence < ::RuboCop::AST::NodePattern::Node
-  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
-
-  def arity; end
-  def in_sequence_head; end
-end
-
-class RuboCop::AST::NodePattern::Node::Union < ::RuboCop::AST::NodePattern::Node
-  def arity; end
-  def in_sequence_head; end
-end
-
-class RuboCop::AST::NodePattern::Parser < ::Racc::Parser
-  extend ::Forwardable
-
-  def initialize(builder = T.unsafe(nil)); end
-
-  def _reduce_10(val, _values); end
-  def _reduce_11(val, _values); end
-  def _reduce_13(val, _values); end
-  def _reduce_14(val, _values); end
-  def _reduce_15(val, _values); end
-  def _reduce_16(val, _values); end
-  def _reduce_17(val, _values); end
-  def _reduce_18(val, _values); end
-  def _reduce_19(val, _values); end
-  def _reduce_2(val, _values); end
-  def _reduce_20(val, _values); end
-  def _reduce_21(val, _values); end
-  def _reduce_22(val, _values); end
-  def _reduce_25(val, _values); end
-  def _reduce_26(val, _values); end
-  def _reduce_3(val, _values); end
-  def _reduce_33(val, _values); end
-  def _reduce_37(val, _values); end
-  def _reduce_38(val, _values); end
-  def _reduce_39(val, _values); end
-  def _reduce_4(val, _values); end
-  def _reduce_40(val, _values); end
-  def _reduce_41(val, _values); end
-  def _reduce_42(val, _values); end
-  def _reduce_43(val, _values); end
-  def _reduce_44(val, _values); end
-  def _reduce_45(val, _values); end
-  def _reduce_46(val, _values); end
-  def _reduce_5(val, _values); end
-  def _reduce_6(val, _values); end
-  def _reduce_7(val, _values); end
-  def _reduce_8(val, _values); end
-  def _reduce_9(val, _values); end
-  def _reduce_none(val, _values); end
-  def emit_atom(*args, &block); end
-  def emit_call(*args, &block); end
-  def emit_capture(*args, &block); end
-  def emit_list(*args, &block); end
-  def emit_unary_op(*args, &block); end
-  def emit_union(*args, &block); end
-  def inspect; end
-  def next_token(*args, &block); end
-  def parse(source); end
-
-  private
-
-  def enforce_unary(node); end
-  def on_error(token, val, _vstack); end
-end
-
-RuboCop::AST::NodePattern::Parser::Builder = RuboCop::AST::NodePattern::Builder
-RuboCop::AST::NodePattern::Parser::Lexer = RuboCop::AST::NodePattern::Lexer
-RuboCop::AST::NodePattern::Parser::Racc_arg = T.let(T.unsafe(nil), Array)
-RuboCop::AST::NodePattern::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
-
-class RuboCop::AST::NodePattern::Parser::WithMeta < ::RuboCop::AST::NodePattern::Parser
-  def comments; end
-  def do_parse; end
-  def tokens; end
-end
-
-class RuboCop::AST::NodePattern::Parser::WithMeta::Builder < ::RuboCop::AST::NodePattern::Builder
-  def emit_atom(type, token); end
-  def emit_call(type, selector_t, args = T.unsafe(nil)); end
-  def emit_list(type, begin_t, children, end_t); end
-  def emit_unary_op(type, operator_t = T.unsafe(nil), *children); end
-
-  private
-
-  def join_exprs(left_expr, right_expr); end
-  def loc(token_or_range); end
-  def n(type, children, source_map); end
-  def source_map(token_or_range, begin_t: T.unsafe(nil), end_t: T.unsafe(nil), operator_t: T.unsafe(nil), selector_t: T.unsafe(nil)); end
-end
-
-class RuboCop::AST::NodePattern::Parser::WithMeta::Lexer < ::RuboCop::AST::NodePattern::Lexer
-  def initialize(str_or_buffer); end
-
-  def emit_comment; end
-  def pos; end
-  def source_buffer; end
-  def token(type, value); end
-end
-
-module RuboCop::AST::NodePattern::Sets
-  class << self
-    def [](set); end
-    def name(set); end
-    def uniq(name); end
-  end
-end
-
-RuboCop::AST::NodePattern::Sets::MAX = T.let(T.unsafe(nil), Integer)
-RuboCop::AST::NodePattern::Sets::REGISTRY = T.let(T.unsafe(nil), Hash)
-RuboCop::AST::NodePattern::Sets::SET_0_1 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_0_1_2 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_10_10 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_1_1 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_1_2 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ABSTRACT_OVERRIDE_OVERRIDABLE_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ADD_DEPENDENCY_ADD_RUNTIME_DEPENDENCY_ADD_DEVELOPMENT_DEPENDENCY = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ALL_CONTEXT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_AND_RETURN_AND_RAISE_AND_THROW_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ANY_ALL_NORETURN_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR_ATTR = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_BACKGROUND_SCENARIO_XSCENARIO_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_BEFORE_AFTER = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_BE_EQ_EQL_EQUAL = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_BE_TRUTHY_BE_FALSEY_BE_FALSY_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_BRANCH_REF_TAG = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CALLER_CALLER_LOCATIONS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CALL_RUN = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CAPTURE2_CAPTURE2E_CAPTURE3_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CIPHER_DIGEST = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_INSTANCE_EVAL = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE_STRUCT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CONSTANTIZE_CONSTANTS_CONST_GET = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CONTEXT_SHARED_CONTEXT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_COUNT_LENGTH_SIZE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_DEFINE_METHOD = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_DEFINE_METHOD_DEFINE_SINGLETON_METHOD = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_DESCRIBE_FEATURE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_DOUBLE_SPY = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_DOWNCASE_UPCASE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_EACH_EXAMPLE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_INDEX_WITH_INDEX = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_OBJECT_WITH_OBJECT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ENUMERATOR_RATIONAL_COMPLEX_THREAD = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_EQL_EQ_BE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ESCAPE_ENCODE_UNESCAPE_DECODE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_EXACTLY_AT_LEAST_AT_MOST = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_EXPECT_ALLOW = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_FACTORYGIRL_FACTORYBOT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_FIRST_LAST__ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_FIXNUM_BIGNUM = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_FLATTEN_FLATTEN = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_FORMAT_SPRINTF_PRINTF = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_GEMCUTTER_RUBYGEMS_RUBYFORGE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_GSUB_GSUB = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_GSUB_GSUB_SUB_SUB = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_INCLUDE_EXTEND_PREPEND = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_INCLUDE_MEMBER = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EVAL_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EXEC_CLASS_EXEC_MODULE_EXEC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_IO_FILE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_IS_EXPECTED_SHOULD_SHOULD_NOT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_KEYS_VALUES = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_KEY_HAS_KEY_FETCH_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_LAST_FIRST = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_LENGTH_SIZE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_LOAD_RESTORE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_MAP_COLLECT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_MATCH_MATCH = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_MATCH__MATCH = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_NEW_COMPILE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_NEW_OPEN = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_NIL_ = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_PIPELINE_PIPELINE_R_PIPELINE_RW_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED_PUBLIC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_PROC_LAMBDA = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_PROP_CONST = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_PUBLIC_CONSTANT_PRIVATE_CONSTANT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_PUBLIC_PROTECTED_PRIVATE_MODULE_FUNCTION = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RAISE_ERROR_RAISE_EXCEPTION = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL_THROW_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RECEIVE_HAVE_RECEIVED = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RECEIVE_MESSAGE_CHAIN_STUB_CHAIN = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RECEIVE_RECEIVE_MESSAGES_RECEIVE_MESSAGE_CHAIN_HAVE_RECEIVED = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RECEIVE_RECEIVE_MESSAGE_CHAIN = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_REDUCE_INJECT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_REJECT_REJECT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_REQUIRE_REQUIRE_RELATIVE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SELECT_FILTER_FIND_ALL_REJECT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SELECT_SELECT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SEND_PUBLIC_SEND___SEND__ = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SHOULD_SHOULD_NOT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SKIP_PENDING = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SORT_BY_SORT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SORT_MIN_MAX = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SPAWN_SYSTEM = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SPRINTF_FORMAT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_START_WITH_END_WITH = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_START_WITH_STARTS_WITH_END_WITH_ENDS_WITH = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_STRUCT_CLASS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SUCC_PRED_NEXT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_TASK_NAMESPACE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_TEMPFILE_STRINGIO = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_TO_ENUM_ENUM_FOR = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_TO_I_TO_F_TO_C = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_TRUE_FALSE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_TYPE_TEMPLATE_TYPE_MEMBER = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ZERO_POSITIVE_NEGATIVE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET__ = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET__AT_SLICE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET__EQUAL_EQL = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET__GLOB = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___ = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___2 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___3 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___4 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___5 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___6 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___7 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___8 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___EQL = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___METHOD_____CALLEE__ = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET____ = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET____ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET____ETC_2 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET____ETC_3 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::VAR = T.let(T.unsafe(nil), String)
-
-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::Procarg0Node < ::RuboCop::AST::ArgNode
-  def name; end
-end
-
-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 first_token_of(range_or_node); end
-  def following_line(token); end
-  def last_token_of(range_or_node); 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 tokens_within(range_or_node); end
-  def valid_syntax?; end
-
-  private
-
-  def comment_index; end
-  def create_parser(ruby_version); end
-  def first_token_index(range_or_node); end
-  def last_token_index(range_or_node); end
-  def parse(source, ruby_version); end
-  def parser_class(ruby_version); end
-  def sorted_tokens; end
-  def source_range(range_or_node); end
-  def tokenize(parser); end
-
-  class << self
-    def from_file(path, ruby_version); end
-  end
-end
-
-RuboCop::AST::ProcessedSource::INVALID_LEVELS = T.let(T.unsafe(nil), Array)
-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
-  include ::RuboCop::Ext::RegexpNode
-
-  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 options; 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 branch_index; end
-  def exception_variable; end
-  def exceptions; end
-end
-
-class RuboCop::AST::RescueNode < ::RuboCop::AST::Node
-  def body; end
-  def branches; end
-  def else?; end
-  def else_branch; end
-  def resbody_branches; end
-end
-
-class RuboCop::AST::ReturnNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ParameterizedNode
-  include ::RuboCop::AST::ParameterizedNode::WrappedArguments
-end
-
-module RuboCop::AST::RuboCopCompatibility
-  def rubocop_loaded; end
-end
-
-RuboCop::AST::RuboCopCompatibility::INCOMPATIBLE_COPS = T.let(T.unsafe(nil), Hash)
-
-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?(param0 = 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
-  extend ::RuboCop::AST::Traversal::CallbackCompiler
-
-  def on_(node); end
-  def on___ENCODING__(node); end
-  def on___FILE__(node); end
-  def on___LINE__(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_kwargs(node); end
-  def on_kwbegin(node); end
-  def on_kwnilarg(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_pattern(node); end
-  def on_match_pattern_p(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_mrasgn(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_rasgn(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
-
-module RuboCop::AST::Traversal::CallbackCompiler
-  def arity_check(range); end
-  def body(signature, prelude); end
-  def def_callback(type, *signature, arity: T.unsafe(nil), arity_check: T.unsafe(nil), body: T.unsafe(nil)); end
-end
-
-RuboCop::AST::Traversal::CallbackCompiler::SEND = T.let(T.unsafe(nil), String)
-RuboCop::AST::Traversal::CallbackCompiler::TEMPLATE = T.let(T.unsafe(nil), Hash)
-class RuboCop::AST::Traversal::DebugError < ::RuntimeError; end
-RuboCop::AST::Traversal::NO_CHILD_NODES = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Traversal::TYPE_TO_METHOD = T.let(T.unsafe(nil), Hash)
-
-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