diff --git a/Library/Homebrew/sorbet/rbi/gems/parser@2.7.2.0.rbi b/Library/Homebrew/sorbet/rbi/gems/parser@3.0.0.0.rbi similarity index 94% rename from Library/Homebrew/sorbet/rbi/gems/parser@2.7.2.0.rbi rename to Library/Homebrew/sorbet/rbi/gems/parser@3.0.0.0.rbi index c0728e8800..b8fd4e54b9 100644 --- a/Library/Homebrew/sorbet/rbi/gems/parser@2.7.2.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/parser@3.0.0.0.rbi @@ -76,6 +76,7 @@ class Parser::AST::Processor < ::AST::Processor 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_kwoptarg(node); end def on_kwrestarg(node); end @@ -87,6 +88,8 @@ class Parser::AST::Processor < ::AST::Processor def on_match_alt(node); end def on_match_as(node); end def on_match_current_line(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 @@ -142,6 +145,7 @@ class Parser::Base < ::Racc::Parser def context; end def current_arg_stack; end def diagnostics; end + def lexer; end def max_numparam_stack; end def parse(source_buffer); end def parse_with_comments(source_buffer); end @@ -226,7 +230,7 @@ class Parser::Builders::Default 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=(_); 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 @@ -261,12 +265,13 @@ class Parser::Builders::Default 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 multi_rassign(lhs, assoc_t, rhs); 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 @@ -281,14 +286,13 @@ class Parser::Builders::Default def pair_list_18(list); end def pair_quoted(begin_t, parts, end_t, value); end def parser; 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 rassign(lhs, assoc_t, rhs); end def rational(rational_t); end def regexp_compose(begin_t, parts, end_t, options); end def regexp_options(regopt_t); end @@ -347,6 +351,7 @@ class Parser::Builders::Default 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 @@ -358,6 +363,7 @@ class Parser::Builders::Default 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 @@ -378,17 +384,21 @@ class Parser::Builders::Default class << self def emit_arg_inside_procarg0; end - def emit_arg_inside_procarg0=(_); end + def emit_arg_inside_procarg0=(_arg0); end def emit_encoding; end - def emit_encoding=(_); end + def emit_encoding=(_arg0); end def emit_forward_arg; end - def emit_forward_arg=(_); end + def emit_forward_arg=(_arg0); end def emit_index; 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=(_); end + def emit_lambda=(_arg0); end + def emit_match_pattern; end + def emit_match_pattern=(_arg0); end def emit_procarg0; end - def emit_procarg0=(_); end + def emit_procarg0=(_arg0); end def modernize; end end end @@ -401,6 +411,7 @@ class Parser::Context def class_definition_allowed?; end def dynamic_const_definition_allowed?; end + def empty?; end def in_block?; end def in_class?; end def in_dynamic_block?; end @@ -416,6 +427,7 @@ end class Parser::CurrentArgStack def initialize; end + def empty?; end def pop; end def push(value); end def reset; end @@ -428,7 +440,7 @@ Parser::CurrentRuby = Parser::Ruby26 module Parser::Deprecation def warn_of_deprecation; end - def warned_of_deprecation=(_); end + def warned_of_deprecation=(_arg0); end end class Parser::Diagnostic @@ -453,11 +465,11 @@ class Parser::Diagnostic::Engine def initialize(consumer = T.unsafe(nil)); end def all_errors_are_fatal; end - def all_errors_are_fatal=(_); end + def all_errors_are_fatal=(_arg0); end def consumer; end - def consumer=(_); end + def consumer=(_arg0); end def ignore_warnings; end - def ignore_warnings=(_); end + def ignore_warnings=(_arg0); end def process(diagnostic); end protected @@ -473,23 +485,27 @@ class Parser::Lexer def advance; end def cmdarg; end - def cmdarg=(_); end + def cmdarg=(_arg0); end + def cmdarg_stack; end def command_start; end - def command_start=(_); end + def command_start=(_arg0); end def comments; end - def comments=(_); end + def comments=(_arg0); end def cond; end - def cond=(_); end + def cond=(_arg0); end + def cond_stack; end def context; end - def context=(_); end + def context=(_arg0); end def dedent_level; end def diagnostics; end - def diagnostics=(_); end + def diagnostics=(_arg0); end def encoding; end def force_utf32; end - def force_utf32=(_); end + def force_utf32=(_arg0); end def in_kwarg; end - def in_kwarg=(_); end + def in_kwarg=(_arg0); end + def lambda_stack; end + def paren_nest; end def pop_cmdarg; end def pop_cond; end def push_cmdarg; end @@ -500,9 +516,9 @@ class Parser::Lexer def state; end def state=(state); end def static_env; end - def static_env=(_); end + def static_env=(_arg0); end def tokens; end - def tokens=(_); end + def tokens=(_arg0); end protected @@ -525,78 +541,78 @@ class Parser::Lexer class << self def lex_en_expr_arg; end - def lex_en_expr_arg=(_); end + def lex_en_expr_arg=(_arg0); end def lex_en_expr_beg; end - def lex_en_expr_beg=(_); end + def lex_en_expr_beg=(_arg0); end def lex_en_expr_cmdarg; end - def lex_en_expr_cmdarg=(_); end + def lex_en_expr_cmdarg=(_arg0); end def lex_en_expr_dot; end - def lex_en_expr_dot=(_); end + def lex_en_expr_dot=(_arg0); end def lex_en_expr_end; end - def lex_en_expr_end=(_); end + def lex_en_expr_end=(_arg0); end def lex_en_expr_endarg; end - def lex_en_expr_endarg=(_); end + def lex_en_expr_endarg=(_arg0); end def lex_en_expr_endfn; end - def lex_en_expr_endfn=(_); end + def lex_en_expr_endfn=(_arg0); end def lex_en_expr_fname; end - def lex_en_expr_fname=(_); end + def lex_en_expr_fname=(_arg0); end def lex_en_expr_labelarg; end - def lex_en_expr_labelarg=(_); end + def lex_en_expr_labelarg=(_arg0); end def lex_en_expr_mid; end - def lex_en_expr_mid=(_); end + def lex_en_expr_mid=(_arg0); end def lex_en_expr_value; end - def lex_en_expr_value=(_); end + def lex_en_expr_value=(_arg0); end def lex_en_expr_variable; end - def lex_en_expr_variable=(_); end + def lex_en_expr_variable=(_arg0); end def lex_en_interp_backslash_delimited; end - def lex_en_interp_backslash_delimited=(_); end + def lex_en_interp_backslash_delimited=(_arg0); end def lex_en_interp_backslash_delimited_words; end - def lex_en_interp_backslash_delimited_words=(_); end + def lex_en_interp_backslash_delimited_words=(_arg0); end def lex_en_interp_string; end - def lex_en_interp_string=(_); end + def lex_en_interp_string=(_arg0); end def lex_en_interp_words; end - def lex_en_interp_words=(_); end + def lex_en_interp_words=(_arg0); end def lex_en_leading_dot; end - def lex_en_leading_dot=(_); end + def lex_en_leading_dot=(_arg0); end def lex_en_line_begin; end - def lex_en_line_begin=(_); end + def lex_en_line_begin=(_arg0); end def lex_en_line_comment; end - def lex_en_line_comment=(_); end + def lex_en_line_comment=(_arg0); end def lex_en_plain_backslash_delimited; end - def lex_en_plain_backslash_delimited=(_); end + def lex_en_plain_backslash_delimited=(_arg0); end def lex_en_plain_backslash_delimited_words; end - def lex_en_plain_backslash_delimited_words=(_); end + def lex_en_plain_backslash_delimited_words=(_arg0); end def lex_en_plain_string; end - def lex_en_plain_string=(_); end + def lex_en_plain_string=(_arg0); end def lex_en_plain_words; end - def lex_en_plain_words=(_); end + def lex_en_plain_words=(_arg0); end def lex_en_regexp_modifiers; end - def lex_en_regexp_modifiers=(_); end + def lex_en_regexp_modifiers=(_arg0); end def lex_error; end - def lex_error=(_); end + def lex_error=(_arg0); end def lex_start; end - def lex_start=(_); end + def lex_start=(_arg0); end private def _lex_eof_trans; end - def _lex_eof_trans=(_); end + def _lex_eof_trans=(_arg0); end def _lex_from_state_actions; end - def _lex_from_state_actions=(_); end + def _lex_from_state_actions=(_arg0); end def _lex_index_offsets; end - def _lex_index_offsets=(_); end + def _lex_index_offsets=(_arg0); end def _lex_indicies; end - def _lex_indicies=(_); end + def _lex_indicies=(_arg0); end def _lex_key_spans; end - def _lex_key_spans=(_); end + def _lex_key_spans=(_arg0); end def _lex_to_state_actions; end - def _lex_to_state_actions=(_); end + def _lex_to_state_actions=(_arg0); end def _lex_trans_actions; end - def _lex_trans_actions=(_); end + def _lex_trans_actions=(_arg0); end def _lex_trans_keys; end - def _lex_trans_keys=(_); end + def _lex_trans_keys=(_arg0); end def _lex_trans_targs; end - def _lex_trans_targs=(_); end + def _lex_trans_targs=(_arg0); end end end @@ -636,7 +652,7 @@ class Parser::Lexer::Literal def plain_heredoc?; end def regexp?; end def saved_herebody_s; end - def saved_herebody_s=(_); end + def saved_herebody_s=(_arg0); end def squiggly_heredoc?; end def start_interp_brace; end def str_s; end @@ -681,6 +697,7 @@ Parser::MESSAGES = T.let(T.unsafe(nil), Hash) class Parser::MaxNumparamStack def initialize; end + def empty?; end def has_numparams?; end def has_ordinary_params!; end def has_ordinary_params?; end @@ -695,6 +712,8 @@ class Parser::MaxNumparamStack def set(value); end end +Parser::MaxNumparamStack::ORDINARY_PARAMS = T.let(T.unsafe(nil), Integer) + module Parser::Messages class << self def compile(reason, arguments); end @@ -709,7 +728,7 @@ Parser::Meta::NODE_TYPES = T.let(T.unsafe(nil), Set) class Parser::Rewriter < ::Parser::AST::Processor extend(::Parser::Deprecation) - def initialize(*_); end + def initialize(*_arg0); end def assignment?(node); end def insert_after(range, content); end @@ -1174,6 +1193,7 @@ class Parser::Source::Buffer def column_for_position(position); end def decompose_position(position); end def first_line; end + def freeze; end def last_line; end def line_for_position(position); end def line_range(lineno); end @@ -1189,8 +1209,9 @@ class Parser::Source::Buffer private + def bsearch(line_begins, position); end def line_begins; end - def line_for(position); end + def line_index_for_position(position); end class << self def recognize_encoding(string); end @@ -1224,7 +1245,7 @@ class Parser::Source::Comment::Associator def associate; end def associate_locations; end def skip_directives; end - def skip_directives=(_); end + def skip_directives=(_arg0); end private @@ -1430,7 +1451,7 @@ class Parser::Source::Range def empty?; end def end; end def end_pos; end - def eql?(_); end + def eql?(_arg0); end def first_line; end def hash; end def inspect; end @@ -1594,6 +1615,7 @@ class Parser::StaticEnvironment def declare_forward_args; end def declared?(name); end def declared_forward_args?; end + def empty?; end def extend_dynamic; end def extend_static; end def reset; end @@ -1625,6 +1647,7 @@ class Parser::VariablesStack def declare(name); end def declared?(name); end + def empty?; end def pop; end def push; end def reset; end diff --git a/Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.0.3.rbi similarity index 98% rename from Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.0.0.rbi rename to Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.0.3.rbi index 44981bd6de..bb6f3dbb0f 100644 --- a/Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.0.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.0.3.rbi @@ -390,7 +390,7 @@ end class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base def match_length; end - def quantify(token, text, min = T.unsafe(nil), max = T.unsafe(nil), mode = T.unsafe(nil)); end + def quantify(_token, _text, _min = T.unsafe(nil), _max = T.unsafe(nil), _mode = T.unsafe(nil)); end end module Regexp::Expression::Group @@ -440,6 +440,8 @@ class Regexp::Expression::Group::Options < ::Regexp::Expression::Group::Base end class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base + def initialize(*_arg0); end + def implicit=(_arg0); end def implicit?; end def to_s(format = T.unsafe(nil)); end @@ -528,12 +530,12 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base def at(*args, &block); end def dig(*indices); end def each(*args, &block); end - def each_expression(include_self = T.unsafe(nil), &block); end + def each_expression(include_self = T.unsafe(nil)); end def empty?(*args, &block); end def expressions; end def expressions=(_arg0); end def fetch(*args, &block); end - def flat_map(include_self = T.unsafe(nil), &block); end + def flat_map(include_self = T.unsafe(nil)); end def index(*args, &block); end def inner_match_length; end def join(*args, &block); end @@ -833,7 +835,7 @@ class Regexp::MatchLength def initialize(exp, opts = T.unsafe(nil)); end def each(opts = T.unsafe(nil)); end - def endless_each(&block); end + def endless_each; end def fixed?; end def include?(length); end def inspect; end @@ -1052,8 +1054,8 @@ end class Regexp::Syntax::Any < ::Regexp::Syntax::Base def initialize; end - def implements!(type, token); end - def implements?(type, token); end + def implements!(_type, _token); end + def implements?(_type, _token); end end class Regexp::Syntax::Base @@ -1078,11 +1080,11 @@ class Regexp::Syntax::Base end end -class Regexp::Syntax::InvalidVersionNameError < ::SyntaxError +class Regexp::Syntax::InvalidVersionNameError < ::Regexp::Syntax::SyntaxError def initialize(name); end end -class Regexp::Syntax::NotImplementedError < ::SyntaxError +class Regexp::Syntax::NotImplementedError < ::Regexp::Syntax::SyntaxError def initialize(syntax, type, token); end end @@ -1423,7 +1425,7 @@ Regexp::Syntax::Token::UnicodeProperty::V2_6_2 = T.let(T.unsafe(nil), Array) Regexp::Syntax::Token::UnicodeProperty::V2_6_3 = T.let(T.unsafe(nil), Array) -class Regexp::Syntax::UnknownSyntaxNameError < ::SyntaxError +class Regexp::Syntax::UnknownSyntaxNameError < ::Regexp::Syntax::SyntaxError def initialize(name); end end diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop@1.5.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop@1.7.0.rbi similarity index 97% rename from Library/Homebrew/sorbet/rbi/gems/rubocop@1.5.1.rbi rename to Library/Homebrew/sorbet/rbi/gems/rubocop@1.7.0.rbi index 34312a3705..a3fc7927b1 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rubocop@1.5.1.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rubocop@1.7.0.rbi @@ -126,12 +126,10 @@ class RuboCop::CLI::Command::SuggestExtensions < ::RuboCop::CLI::Command::Base def current_formatter; end def dependent_gems; end def extensions; end + def installed_gems; end + def lockfile; end def puts(*args); end def skip?; end - - class << self - def dependent_gems; end - end end RuboCop::CLI::Command::SuggestExtensions::INCLUDED_FORMATTERS = T.let(T.unsafe(nil), Array) @@ -243,6 +241,7 @@ class RuboCop::Config def check; end def delete(*args, &block); end def deprecation_check; end + def dig(*args, &block); end def disabled_new_cops?; end def each(*args, &block); end def each_key(*args, &block); end @@ -267,6 +266,7 @@ class RuboCop::Config def patterns_to_include; end def pending_cops; end def possibly_include_hidden?; end + def replace(*args, &block); end def signature; end def smart_loaded_path; end def target_rails_version; end @@ -310,6 +310,7 @@ class RuboCop::ConfigLoader class << self def add_excludes_from_files(config, config_file); end + def add_loaded_features(loaded_features); end def add_missing_namespaces(path, hash); end def clear_options; end def configuration_file_for(target_dir); end @@ -339,7 +340,6 @@ class RuboCop::ConfigLoader private - def add_loaded_features(loaded_features); end def check_duplication(yaml_code, absolute_path); end def expand_path(path); end def file_path(file); end @@ -366,6 +366,7 @@ class RuboCop::ConfigLoaderResolver def merge(base_hash, derived_hash, **opts); end def merge_with_default(config, config_file, unset_nil:); end def override_department_setting_for_cops(base_hash, derived_hash); end + def override_enabled_for_disabled_departments(base_hash, derived_hash); end def resolve_inheritance(path, hash, file, debug); end def resolve_inheritance_from_gems(hash); end def resolve_requires(path, hash); end @@ -392,34 +393,139 @@ end class RuboCop::ConfigObsoletion def initialize(config); end - def reject_obsolete_cops_and_parameters; end + def reject_obsolete!; end + def rules; end def warnings; end private - def obsolete_cops; end - def obsolete_enforced_style; end - def obsolete_enforced_style_message(cop, param, enforced_style, alternative); end - def obsolete_parameter_message(cops, parameters, alternative); end - def obsolete_parameters; end - def smart_loaded_path; end + def load_cop_rules(rules); end + def load_parameter_rules(rules); end + def load_rules; end + def obsoletions; end + + class << self + def files; end + def files=(_arg0); end + def legacy_cop_names; end + end end -RuboCop::ConfigObsoletion::MOVED_COPS = T.let(T.unsafe(nil), Array) +RuboCop::ConfigObsoletion::COP_RULE_CLASSES = T.let(T.unsafe(nil), Hash) -RuboCop::ConfigObsoletion::OBSOLETE_COPS = T.let(T.unsafe(nil), Hash) +class RuboCop::ConfigObsoletion::ChangedEnforcedStyles < ::RuboCop::ConfigObsoletion::ParameterRule + def message; end + def violated?; end -RuboCop::ConfigObsoletion::OBSOLETE_ENFORCED_STYLES = T.let(T.unsafe(nil), Array) + private -RuboCop::ConfigObsoletion::OBSOLETE_PARAMETERS = T.let(T.unsafe(nil), Array) + def value; end +end -RuboCop::ConfigObsoletion::REMOVED_COPS = T.let(T.unsafe(nil), Array) +RuboCop::ConfigObsoletion::ChangedEnforcedStyles::BASE_MESSAGE = T.let(T.unsafe(nil), String) -RuboCop::ConfigObsoletion::REMOVED_COPS_WITH_REASON = T.let(T.unsafe(nil), Array) +class RuboCop::ConfigObsoletion::ChangedParameter < ::RuboCop::ConfigObsoletion::ParameterRule + def message; end +end -RuboCop::ConfigObsoletion::RENAMED_COPS = T.let(T.unsafe(nil), Array) +RuboCop::ConfigObsoletion::ChangedParameter::BASE_MESSAGE = T.let(T.unsafe(nil), String) -RuboCop::ConfigObsoletion::SPLIT_COPS = T.let(T.unsafe(nil), Array) +class RuboCop::ConfigObsoletion::CopRule < ::RuboCop::ConfigObsoletion::Rule + def initialize(config, old_name); end + + def cop_rule?; end + def message; end + def old_name; end + def violated?; end + def warning?; end +end + +RuboCop::ConfigObsoletion::DEFAULT_RULES_FILE = T.let(T.unsafe(nil), String) + +class RuboCop::ConfigObsoletion::ExtractedCop < ::RuboCop::ConfigObsoletion::CopRule + def initialize(config, old_name, gem); end + + def department; end + def gem; end + def rule_message; end + def violated?; end + + private + + def affected_cops; end + def feature_loaded?; end +end + +RuboCop::ConfigObsoletion::PARAMETER_RULE_CLASSES = T.let(T.unsafe(nil), Hash) + +class RuboCop::ConfigObsoletion::ParameterRule < ::RuboCop::ConfigObsoletion::Rule + def initialize(config, cop, parameter, metadata); end + + def cop; end + def metadata; end + def parameter; end + def parameter_rule?; end + def violated?; end + def warning?; end + + private + + def alternative; end + def reason; end + def severity; end +end + +class RuboCop::ConfigObsoletion::RemovedCop < ::RuboCop::ConfigObsoletion::CopRule + def initialize(config, old_name, metadata); end + + def metadata; end + def old_name; end + def rule_message; end + + private + + def alternatives; end + def reason; end +end + +RuboCop::ConfigObsoletion::RemovedCop::BASE_MESSAGE = T.let(T.unsafe(nil), String) + +class RuboCop::ConfigObsoletion::RenamedCop < ::RuboCop::ConfigObsoletion::CopRule + def initialize(config, old_name, new_name); end + + def new_name; end + def rule_message; end + + private + + def moved?; end + def verb; end +end + +class RuboCop::ConfigObsoletion::Rule + def initialize(config); end + + def cop_rule?; end + def parameter_rule?; end + def violated?; end + + private + + def config; end + def smart_loaded_path; end + def to_sentence(collection, connector: T.unsafe(nil)); end +end + +class RuboCop::ConfigObsoletion::SplitCop < ::RuboCop::ConfigObsoletion::CopRule + def initialize(config, old_name, metadata); end + + def metadata; end + def rule_message; end + + private + + def alternatives; end +end class RuboCop::ConfigRegeneration def options; end @@ -642,7 +748,6 @@ class RuboCop::Cop::Base def callback_argument(range); end def complete_investigation; end def correct(range); end - def correction_strategy; end def current_offense_locations; end def currently_disabled_lines; end def custom_severity; end @@ -654,6 +759,7 @@ class RuboCop::Cop::Base def find_severity(_range, severity); end def range_from_node_or_range(node_or_range); end def reset_investigation; end + def use_corrector(range, corrector); end class << self def autocorrect_incompatible_with; end @@ -908,6 +1014,7 @@ class RuboCop::Cop::Commissioner 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 @@ -921,6 +1028,8 @@ class RuboCop::Cop::Commissioner 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 @@ -1246,6 +1355,10 @@ module RuboCop::Cop::EnforceSuperclass def on_class(node); end def on_send(node); end + private + + def register_offense(offense_node); end + class << self def included(base); end end @@ -2112,6 +2225,7 @@ class RuboCop::Cop::Layout::EmptyLineBetweenDefs < ::RuboCop::Cop::Base def class_candidate?(node); end def def_end(node); end def def_start(node); end + def end_loc(node); end def lines_between_defs(first_def_node, second_def_node); end def maximum_empty_lines; end def message(node); end @@ -2595,10 +2709,12 @@ class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis < ::RuboCop::Cop:: def add_correct_closing_paren(node, corrector); end def add_correct_external_trailing_comma(node, corrector); end def autocorrect(corrector, node); end + def exist_argument_between_heredoc_end_and_closing_parentheses?(node); end def external_trailing_comma?(node); end def external_trailing_comma_offset_from_loc_end(node); end def extract_heredoc(node); end def extract_heredoc_argument(node); end + def find_most_bottom_of_heredoc_end(arguments); end def fix_closing_parenthesis(node, corrector); end def fix_external_trailing_comma(node, corrector); end def heredoc_node?(node); end @@ -2614,6 +2730,7 @@ class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis < ::RuboCop::Cop:: def send_missing_closing_parens?(parent, child, heredoc); end def single_line_send_with_heredoc_receiver?(node); end def space?(pos); end + def subsequent_closing_parentheses_in_same_line?(outermost_send); end class << self def autocorrect_incompatible_with; end @@ -2793,20 +2910,19 @@ end RuboCop::Cop::Layout::LeadingEmptyLines::MSG = T.let(T.unsafe(nil), String) -class RuboCop::Cop::Layout::LineLength < ::RuboCop::Cop::Cop +class RuboCop::Cop::Layout::LineLength < ::RuboCop::Cop::Base include(::RuboCop::Cop::CheckLineBreakable) include(::RuboCop::Cop::ConfigurableMax) include(::RuboCop::Cop::IgnoredPattern) include(::RuboCop::Cop::RangeHelp) include(::RuboCop::Cop::LineLengthHelp) + extend(::RuboCop::Cop::AutoCorrector) - def autocorrect(range); end - def correctable?; end - def investigate(processed_source); end - def investigate_post_walk(processed_source); end def on_array(node); end def on_block(node); end def on_hash(node); end + def on_investigation_end; end + def on_new_investigation; end def on_potential_breakable_node(node); end def on_send(node); end @@ -2983,7 +3099,7 @@ class RuboCop::Cop::Layout::MultilineMethodCallIndentation < ::RuboCop::Cop::Cop def align_with_base_message(rhs); end def alignment_base(node, rhs, given_style); end def base_source; end - def extra_indentation(given_style); end + def extra_indentation(given_style, parent); end def message(node, lhs, rhs); end def no_base_message(lhs, rhs, node); end def offending_range(node, lhs, rhs, given_style); end @@ -3350,6 +3466,21 @@ RuboCop::Cop::Layout::SpaceBeforeBlockBraces::DETECTED_MSG = T.let(T.unsafe(nil) RuboCop::Cop::Layout::SpaceBeforeBlockBraces::MISSING_MSG = T.let(T.unsafe(nil), String) +class RuboCop::Cop::Layout::SpaceBeforeBrackets < ::RuboCop::Cop::Base + include(::RuboCop::Cop::RangeHelp) + extend(::RuboCop::Cop::AutoCorrector) + + def on_send(node); end + + private + + def offense_range(node, first_argument, begin_pos); end + def register_offense(range); end + def space_before_brackets?(node, first_argument); end +end + +RuboCop::Cop::Layout::SpaceBeforeBrackets::MSG = T.let(T.unsafe(nil), String) + class RuboCop::Cop::Layout::SpaceBeforeComma < ::RuboCop::Cop::Base include(::RuboCop::Cop::RangeHelp) include(::RuboCop::Cop::SpaceBeforePunctuation) @@ -3481,7 +3612,7 @@ class RuboCop::Cop::Layout::SpaceInsideBlockBraces < ::RuboCop::Cop::Base def multiline_block?(left_brace, right_brace); end def no_space(begin_pos, end_pos, msg); end def no_space_inside_left_brace(left_brace, args_delimiter); end - def offense(begin_pos, end_pos, msg); end + def offense(begin_pos, end_pos, msg, style_param = T.unsafe(nil)); end def pipe?(args_delimiter); end def space(begin_pos, end_pos, msg); end def space_inside_left_brace(left_brace, args_delimiter); end @@ -3705,6 +3836,27 @@ end module RuboCop::Cop::Lint end +class RuboCop::Cop::Lint::AmbiguousAssignment < ::RuboCop::Cop::Base + include(::RuboCop::Cop::RangeHelp) + + def on_asgn(node); end + def on_casgn(node); end + def on_cvasgn(node); end + def on_gvasgn(node); end + def on_ivasgn(node); end + def on_lvasgn(node); end + + private + + def rhs(node); end +end + +RuboCop::Cop::Lint::AmbiguousAssignment::MISTAKES = T.let(T.unsafe(nil), Hash) + +RuboCop::Cop::Lint::AmbiguousAssignment::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::AmbiguousAssignment::SIMPLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + class RuboCop::Cop::Lint::AmbiguousBlockAssociation < ::RuboCop::Cop::Base def on_csend(node); end def on_send(node); end @@ -3789,7 +3941,7 @@ class RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands < ::RuboCop::Cop:: def on_send(node); end end -RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands::MATH_OPERATORS = T.let(T.unsafe(nil), Set) +RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands::ALLOWED_MATH_OPERATORS = T.let(T.unsafe(nil), Set) RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands::MSG = T.let(T.unsafe(nil), String) @@ -3936,6 +4088,12 @@ class RuboCop::Cop::Lint::DuplicateBranch < ::RuboCop::Cop::Base private + def branches(node); end + def consider_branch?(branch); end + def const_branch?(branch); end + def ignore_constant_branches?; end + def ignore_literal_branches?; end + def literal_branch?(branch); end def offense_range(duplicate_branch); end end @@ -4818,6 +4976,7 @@ class RuboCop::Cop::Lint::RedundantSplatExpansion < ::RuboCop::Cop::Base private + def allow_percent_literal_array_argument?; end def array_new_inside_array_literal?(array_new_node); end def array_splat?(node); end def autocorrect(corrector, node); end @@ -4827,6 +4986,7 @@ class RuboCop::Cop::Lint::RedundantSplatExpansion < ::RuboCop::Cop::Base def redundant_splat_expansion(node); end def remove_brackets(array); end def replacement_range_and_content(node); end + def use_percent_literal_array_argument?(node); end end RuboCop::Cop::Lint::RedundantSplatExpansion::ARRAY_PARAM_MSG = T.let(T.unsafe(nil), String) @@ -5083,7 +5243,6 @@ class RuboCop::Cop::Lint::ShadowedException < ::RuboCop::Cop::Base def offense_range(rescues); end def rescued_exceptions(rescue_group); end def rescued_groups_for(rescues); end - def silence_warnings; end def sorted?(rescued_groups); end def system_call_err?(error); end end @@ -5092,6 +5251,7 @@ RuboCop::Cop::Lint::ShadowedException::MSG = T.let(T.unsafe(nil), String) class RuboCop::Cop::Lint::ShadowingOuterLocalVariable < ::RuboCop::Cop::Base def before_declaring_variable(variable, variable_table); end + def ractor_block?(param0 = T.unsafe(nil)); end class << self def joining_forces; end @@ -5259,6 +5419,8 @@ end RuboCop::Cop::Lint::UnreachableCode::MSG = T.let(T.unsafe(nil), String) class RuboCop::Cop::Lint::UnreachableLoop < ::RuboCop::Cop::Base + include(::RuboCop::Cop::IgnoredPattern) + def break_command?(param0 = T.unsafe(nil)); end def on_block(node); end def on_for(node); end @@ -6120,11 +6282,13 @@ class RuboCop::Cop::Naming::MemoizedInstanceVariableName < ::RuboCop::Cop::Base include(::RuboCop::Cop::ConfigurableEnforcedStyle) def defined_memoized?(param0 = T.unsafe(nil), param1); end + def method_definition?(param0 = T.unsafe(nil)); end def on_defined?(node); end def on_or_asgn(node); end private + def find_definition(node); end def matches?(method_name, ivar_assign); end def message(variable); end def style_parameter_name; end @@ -6132,6 +6296,8 @@ class RuboCop::Cop::Naming::MemoizedInstanceVariableName < ::RuboCop::Cop::Base def variable_name_candidates(method_name); end end +RuboCop::Cop::Naming::MemoizedInstanceVariableName::DYNAMIC_DEFINE_METHODS = T.let(T.unsafe(nil), Set) + RuboCop::Cop::Naming::MemoizedInstanceVariableName::MSG = T.let(T.unsafe(nil), String) RuboCop::Cop::Naming::MemoizedInstanceVariableName::UNDERSCORE_REQUIRED = T.let(T.unsafe(nil), String) @@ -6499,6 +6665,7 @@ class RuboCop::Cop::Registry def enabled_pending_cop?(cop_cfg, config); end def enlist(cop); end def find_by_cop_name(cop_name); end + def freeze; end def length; end def names; end def options; end @@ -6524,6 +6691,7 @@ class RuboCop::Cop::Registry def all; end def global; end def qualified_cop_name(name, origin); end + def reset!; end def with_temporary_global(temp_global = T.unsafe(nil)); end end end @@ -6708,7 +6876,7 @@ class RuboCop::Cop::StringLiteralCorrector extend(::RuboCop::Cop::Util) class << self - def correct(node, style); end + def correct(corrector, node, style); end end end @@ -7116,10 +7284,11 @@ end RuboCop::Cop::Style::CaseLikeIf::MSG = T.let(T.unsafe(nil), String) -class RuboCop::Cop::Style::CharacterLiteral < ::RuboCop::Cop::Cop +class RuboCop::Cop::Style::CharacterLiteral < ::RuboCop::Cop::Base include(::RuboCop::Cop::StringHelp) + extend(::RuboCop::Cop::AutoCorrector) - def autocorrect(node); end + def autocorrect(corrector, node); end def correct_style_detected; end def offense?(node); end def opposite_style_detected; end @@ -7266,7 +7435,9 @@ class RuboCop::Cop::Style::CollectionMethods < ::RuboCop::Cop::Base private def check_method_node(node); end + def implicit_block?(node); end def message(node); end + def methods_accepting_symbol; end end RuboCop::Cop::Style::CollectionMethods::MSG = T.let(T.unsafe(nil), String) @@ -7354,12 +7525,16 @@ RuboCop::Cop::Style::CommentAnnotation::MISSING_NOTE = T.let(T.unsafe(nil), Stri RuboCop::Cop::Style::CommentAnnotation::MSG = T.let(T.unsafe(nil), String) class RuboCop::Cop::Style::CommentedKeyword < ::RuboCop::Cop::Base + include(::RuboCop::Cop::RangeHelp) + extend(::RuboCop::Cop::AutoCorrector) + def on_new_investigation; end private def line(comment); end def offensive?(comment); end + def register_offense(comment, matched_keyword); end end RuboCop::Cop::Style::CommentedKeyword::ALLOWED_COMMENTS = T.let(T.unsafe(nil), Array) @@ -7940,6 +8115,7 @@ RuboCop::Cop::Style::ExponentialNotation::MESSAGES = T.let(T.unsafe(nil), Hash) class RuboCop::Cop::Style::FloatDivision < ::RuboCop::Cop::Base include(::RuboCop::Cop::ConfigurableEnforcedStyle) + extend(::RuboCop::Cop::AutoCorrector) def any_coerce?(param0 = T.unsafe(nil)); end def both_coerce?(param0 = T.unsafe(nil)); end @@ -7949,8 +8125,12 @@ class RuboCop::Cop::Style::FloatDivision < ::RuboCop::Cop::Base private + def add_to_f_method(corrector, node); end + def correct_from_slash_to_fdiv(corrector, node, receiver, argument); end + def extract_receiver_source(node); end def message(_node); end def offense_condition?(node); end + def remove_to_f_method(corrector, send_node); end end RuboCop::Cop::Style::FloatDivision::MESSAGES = T.let(T.unsafe(nil), Hash) @@ -8140,6 +8320,26 @@ end RuboCop::Cop::Style::HashEachMethods::MSG = T.let(T.unsafe(nil), String) +class RuboCop::Cop::Style::HashExcept < ::RuboCop::Cop::Base + include(::RuboCop::Cop::RangeHelp) + extend(::RuboCop::Cop::TargetRubyVersion) + extend(::RuboCop::Cop::AutoCorrector) + + def bad_method?(param0 = T.unsafe(nil)); end + def on_send(node); end + + private + + def except_key(node); end + def offense_range(node); end + def safe_to_register_offense?(block, except_key); end + def semantically_except_method?(send, block); end +end + +RuboCop::Cop::Style::HashExcept::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::HashExcept::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + class RuboCop::Cop::Style::HashLikeCase < ::RuboCop::Cop::Base def hash_like_case?(param0 = T.unsafe(nil)); end def on_case(node); end @@ -8286,6 +8486,10 @@ class RuboCop::Cop::Style::IfUnlessModifier < ::RuboCop::Cop::Base def too_long_line_based_on_config?(range, line); end def too_long_line_based_on_ignore_cop_directives?(range, line); end def too_long_single_line?(node); end + + class << self + def autocorrect_incompatible_with; end + end end RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_MODIFIER = T.let(T.unsafe(nil), String) @@ -8405,7 +8609,7 @@ RuboCop::Cop::Style::InverseMethods::MSG = T.let(T.unsafe(nil), String) RuboCop::Cop::Style::InverseMethods::NEGATED_EQUALITY_METHODS = T.let(T.unsafe(nil), Array) -class RuboCop::Cop::Style::IpAddresses < ::RuboCop::Cop::Cop +class RuboCop::Cop::Style::IpAddresses < ::RuboCop::Cop::Base include(::RuboCop::Cop::StringHelp) def correct_style_detected; end @@ -8545,6 +8749,7 @@ module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses def allowed_multiline_call_with_parentheses?(node); end def ambigious_literal?(node); end def assigned_before?(node, target); end + def auto_correct(corrector, node); end def call_as_argument_or_chain?(node); end def call_in_literals?(node); end def call_in_logical_operators?(node); end @@ -8554,6 +8759,7 @@ module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses def call_with_braced_block?(node); end def hash_literal?(node); end def hash_literal_in_arguments?(node); end + def inside_endless_method_def?(node); end def legitimate_call_with_parentheses?(node); end def logical_operator?(node); end def offense_range(node); end @@ -8802,11 +9008,16 @@ RuboCop::Cop::Style::MultilineMemoization::BRACES_MSG = T.let(T.unsafe(nil), Str RuboCop::Cop::Style::MultilineMemoization::KEYWORD_MSG = T.let(T.unsafe(nil), String) class RuboCop::Cop::Style::MultilineMethodSignature < ::RuboCop::Cop::Base + include(::RuboCop::Cop::RangeHelp) + extend(::RuboCop::Cop::AutoCorrector) + def on_def(node); end def on_defs(node); end private + def arguments_range(node); end + def autocorrect(corrector, node); end def closing_line(node); end def correction_exceeds_max_line_length?(node); end def definition_width(node); end @@ -8882,6 +9093,7 @@ class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base def autocorrect(corrector, node); end def check(value); end def correct_splat_expansion(corrector, expr, splat_value); end + def frozen_regexp_or_range_literals?(node); end def frozen_string_literal?(node); end def immutable_literal?(node); end def mutable_literal?(value); end @@ -9437,10 +9649,20 @@ RuboCop::Cop::Style::PercentQLiterals::UPPER_CASE_Q_MSG = T.let(T.unsafe(nil), S class RuboCop::Cop::Style::PerlBackrefs < ::RuboCop::Cop::Base extend(::RuboCop::Cop::AutoCorrector) + def on_back_ref(node); end + def on_gvar(node); end def on_nth_ref(node); end + + private + + def derived_from_braceless_interpolation?(node); end + def format_message(node:, preferred_expression:); end + def on_back_ref_or_gvar_or_nth_ref(node); end + def original_expression_of(node); end + def preferred_expression_to(node); end end -RuboCop::Cop::Style::PerlBackrefs::MSG = T.let(T.unsafe(nil), String) +RuboCop::Cop::Style::PerlBackrefs::MESSAGE_FORMAT = T.let(T.unsafe(nil), String) class RuboCop::Cop::Style::PreferredHashMethods < ::RuboCop::Cop::Base include(::RuboCop::Cop::ConfigurableEnforcedStyle) @@ -9519,10 +9741,14 @@ RuboCop::Cop::Style::RandomWithOffset::MSG = T.let(T.unsafe(nil), String) RuboCop::Cop::Style::RandomWithOffset::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) class RuboCop::Cop::Style::RedundantArgument < ::RuboCop::Cop::Base + include(::RuboCop::Cop::RangeHelp) + extend(::RuboCop::Cop::AutoCorrector) + def on_send(node); end private + def argument_range(node); end def redundant_arg_for_method(method_name); end def redundant_argument?(node); end end @@ -10217,14 +10443,17 @@ RuboCop::Cop::Style::SingleArgumentDig::MSG = T.let(T.unsafe(nil), String) RuboCop::Cop::Style::SingleArgumentDig::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) class RuboCop::Cop::Style::SingleLineBlockParams < ::RuboCop::Cop::Base + extend(::RuboCop::Cop::AutoCorrector) + def on_block(node); end private def args_match?(method_name, args); end + def autocorrect(corrector, node, preferred_block_arguments, joined_block_arguments); end + def build_preferred_arguments_map(node, preferred_arguments); end def eligible_arguments?(node); end def eligible_method?(node); end - def message(node); end def method_name(method); end def method_names; end def methods; end @@ -10274,8 +10503,10 @@ class RuboCop::Cop::Style::SoleNestedConditional < ::RuboCop::Cop::Base def autocorrect(corrector, node, if_branch); end def correct_for_basic_condition_style(corrector, node, if_branch, and_operator); end def correct_for_comment(corrector, node, if_branch); end - def correct_for_gurad_condition_style(corrector, node, if_branch, and_operator); end + def correct_for_guard_condition_style(corrector, node, if_branch, and_operator); end def offending_branch?(branch); end + def replacement_condition(and_operator, condition); end + def wrap_condition?(node); end end RuboCop::Cop::Style::SoleNestedConditional::MSG = T.let(T.unsafe(nil), String) @@ -10376,6 +10607,8 @@ class RuboCop::Cop::Style::StringConcatenation < ::RuboCop::Cop::Base def collect_parts(node, parts); end def corrected_ancestor?(node); end def find_topmost_plus_node(node); end + def handle_quotes(parts); end + def line_end_concatenation?(node); end def plus_node?(node); end def replacement(parts); end def single_quoted?(str_node); end @@ -10396,35 +10629,38 @@ end RuboCop::Cop::Style::StringHashKeys::MSG = T.let(T.unsafe(nil), String) -class RuboCop::Cop::Style::StringLiterals < ::RuboCop::Cop::Cop +class RuboCop::Cop::Style::StringLiterals < ::RuboCop::Cop::Base include(::RuboCop::Cop::ConfigurableEnforcedStyle) include(::RuboCop::Cop::StringHelp) include(::RuboCop::Cop::StringLiteralsHelp) + extend(::RuboCop::Cop::AutoCorrector) - def autocorrect(node); end def on_dstr(node); end private def accept_child_double_quotes?(nodes); end def all_string_literals?(nodes); end + def autocorrect(corrector, node); end def check_multiline_quote_style(node, quote); end def consistent_multiline?; end def detect_quote_styles(node); end def message(_node); end def offense?(node); end + def register_offense(node, message: T.unsafe(nil)); end def unexpected_double_quotes?(quote); end def unexpected_single_quotes?(quote); end end RuboCop::Cop::Style::StringLiterals::MSG_INCONSISTENT = T.let(T.unsafe(nil), String) -class RuboCop::Cop::Style::StringLiteralsInInterpolation < ::RuboCop::Cop::Cop +class RuboCop::Cop::Style::StringLiteralsInInterpolation < ::RuboCop::Cop::Base include(::RuboCop::Cop::ConfigurableEnforcedStyle) include(::RuboCop::Cop::StringHelp) include(::RuboCop::Cop::StringLiteralsHelp) + extend(::RuboCop::Cop::AutoCorrector) - def autocorrect(node); end + def autocorrect(corrector, node); end private @@ -10540,6 +10776,7 @@ class RuboCop::Cop::Style::SymbolProc < ::RuboCop::Cop::Base def on_numblock(node); end def proc_node?(param0 = T.unsafe(nil)); end def symbol_proc?(param0 = T.unsafe(nil)); end + def symbol_proc_receiver?(param0 = T.unsafe(nil)); end private @@ -11978,6 +12215,16 @@ end class RuboCop::IncorrectCopNameError < ::StandardError end +class RuboCop::Lockfile + def dependencies; end + def gems; end + def includes_gem?(name); end + + private + + def parser; end +end + class RuboCop::MagicComment def initialize(comment); end @@ -12082,6 +12329,7 @@ class RuboCop::Options def define_options; end def long_opt_symbol(args); end def option(opts, *args); end + def require_feature(file); end end RuboCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS = T.let(T.unsafe(nil), Integer) @@ -12256,6 +12504,7 @@ class RuboCop::Runner def mobilize_team(processed_source); end def mobilized_cop_classes(config); end def process_file(file); end + def qualify_option_cop_names; end def redundant_cop_disable_directive(file); end def save_in_cache(cache, offenses); end def standby_team(config); end @@ -12397,6 +12646,12 @@ end RuboCop::Token = RuboCop::AST::Token +module RuboCop::Util + class << self + def silence_warnings; end + end +end + class RuboCop::ValidationError < ::RuboCop::Error end @@ -12427,13 +12682,3 @@ module RuboCop::YAMLDuplicationChecker def traverse(tree, &on_duplicated); end end end - -class String - include(::Comparable) - include(::JSON::Ext::Generator::GeneratorMethods::String) - include(::Colorize::InstanceMethods) - extend(::JSON::Ext::Generator::GeneratorMethods::String::Extend) - extend(::Colorize::ClassMethods) - - def blank?; end -end diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi index 8d6979cbbb..4871c20951 100644 --- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi +++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi @@ -5873,8 +5873,6 @@ module CopHelper def inspect_source(source, file=T.unsafe(nil)); end - def inspect_source_file(source); end - def parse_source(source, file=T.unsafe(nil)); end end @@ -27709,6 +27707,12 @@ class RuboCop::AST::Node def key_node(param0=T.unsafe(nil)); end + def kwargs_type?(); end + + def match_pattern_p_type?(); end + + def match_pattern_type?(); end + def method_node(param0=T.unsafe(nil)); end def val_node(param0=T.unsafe(nil)); end @@ -27724,6 +27728,15 @@ module RuboCop::AST::NodePattern::Sets SET_INCLUDE_WITH_WITHOUT = ::T.let(nil, ::T.untyped) SET_SYSTEM_SHELL_OUTPUT_PIPE_OUTPUT = ::T.let(nil, ::T.untyped) SET_WITH_WITHOUT = ::T.let(nil, ::T.untyped) + SET___EQL = ::T.let(nil, ::T.untyped) +end + +module RuboCop::AST::Traversal + def on_kwargs(node); end + + def on_match_pattern(node); end + + def on_match_pattern_p(node); end end class RuboCop::Cask::AST::CaskHeader @@ -27925,7 +27938,7 @@ class RuboCop::Cop::FormulaCop end module RuboCop::RSpec::ExpectOffense - def expect_correction(correction, loop: T.unsafe(nil)); end + def expect_correction(correction, loop: T.unsafe(nil), source: T.unsafe(nil)); end def expect_no_corrections(); end @@ -27934,6 +27947,12 @@ module RuboCop::RSpec::ExpectOffense def expect_offense(source, file=T.unsafe(nil), severity: T.unsafe(nil), **replacements); end def format_offense(source, **replacements); end + + def parse_annotations(source, raise_error: T.unsafe(nil), **replacements); end + + def parse_processed_source(source, file=T.unsafe(nil)); end + + def set_formatter_options(); end end class RuboCop::RSpec::ExpectOffense::AnnotatedSource