diff --git a/Library/Homebrew/sorbet/rbi/gems/parser@2.7.1.4.rbi b/Library/Homebrew/sorbet/rbi/gems/parser@2.7.1.5.rbi
similarity index 62%
rename from Library/Homebrew/sorbet/rbi/gems/parser@2.7.1.4.rbi
rename to Library/Homebrew/sorbet/rbi/gems/parser@2.7.1.5.rbi
index dcec51aa9bed4030e457c2f5678b137360f77392..c0728e88005a97364ebd59154ce14b649ffd717d 100644
--- a/Library/Homebrew/sorbet/rbi/gems/parser@2.7.1.4.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/parser@2.7.1.5.rbi
@@ -1,10 +1,16 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `parser` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `tapioca sync`.
 
 # typed: true
 
 module Parser
+  class << self
+
+    private
+
+    def warn_syntax_deviation(feature, version); end
+  end
 end
 
 module Parser::AST
@@ -44,10 +50,8 @@ class Parser::AST::Processor < ::AST::Processor
   def on_cvar(node); end
   def on_cvasgn(node); end
   def on_def(node); end
-  def on_def_e(node); end
   def on_defined?(node); end
   def on_defs(node); end
-  def on_defs_e(node); end
   def on_dstr(node); end
   def on_dsym(node); end
   def on_eflipflop(node); end
@@ -88,7 +92,6 @@ class Parser::AST::Processor < ::AST::Processor
   def on_match_with_lvasgn(node); end
   def on_mlhs(node); end
   def on_module(node); end
-  def on_mrasgn(node); end
   def on_next(node); end
   def on_not(node); end
   def on_nth_ref(node); end
@@ -102,7 +105,6 @@ class Parser::AST::Processor < ::AST::Processor
   def on_postexe(node); end
   def on_preexe(node); end
   def on_procarg0(node); end
-  def on_rasgn(node); end
   def on_redo(node); end
   def on_regexp(node); end
   def on_resbody(node); end
@@ -320,13 +322,14 @@ class Parser::Builders::Default
   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(node); 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
@@ -421,6 +424,8 @@ class Parser::CurrentArgStack
   def top; end
 end
 
+Parser::CurrentRuby = Parser::Ruby26
+
 module Parser::Deprecation
   def warn_of_deprecation; end
   def warned_of_deprecation=(_); end
@@ -717,6 +722,449 @@ end
 
 Parser::Rewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
 
+class Parser::Ruby26 < ::Parser::Base
+  def _reduce_10(val, _values, result); end
+  def _reduce_100(val, _values, result); end
+  def _reduce_101(val, _values, result); end
+  def _reduce_102(val, _values, result); end
+  def _reduce_103(val, _values, result); end
+  def _reduce_104(val, _values, result); end
+  def _reduce_105(val, _values, result); end
+  def _reduce_106(val, _values, result); end
+  def _reduce_107(val, _values, result); end
+  def _reduce_108(val, _values, result); end
+  def _reduce_109(val, _values, result); end
+  def _reduce_11(val, _values, result); end
+  def _reduce_110(val, _values, result); end
+  def _reduce_111(val, _values, result); end
+  def _reduce_113(val, _values, result); end
+  def _reduce_114(val, _values, result); end
+  def _reduce_115(val, _values, result); end
+  def _reduce_12(val, _values, result); end
+  def _reduce_121(val, _values, result); end
+  def _reduce_125(val, _values, result); end
+  def _reduce_126(val, _values, result); end
+  def _reduce_127(val, _values, result); end
+  def _reduce_13(val, _values, result); end
+  def _reduce_14(val, _values, result); end
+  def _reduce_15(val, _values, result); end
+  def _reduce_17(val, _values, result); end
+  def _reduce_18(val, _values, result); end
+  def _reduce_19(val, _values, result); end
+  def _reduce_199(val, _values, result); end
+  def _reduce_2(val, _values, result); end
+  def _reduce_20(val, _values, result); end
+  def _reduce_200(val, _values, result); end
+  def _reduce_201(val, _values, result); end
+  def _reduce_202(val, _values, result); end
+  def _reduce_203(val, _values, result); end
+  def _reduce_204(val, _values, result); end
+  def _reduce_205(val, _values, result); end
+  def _reduce_206(val, _values, result); end
+  def _reduce_207(val, _values, result); end
+  def _reduce_208(val, _values, result); end
+  def _reduce_209(val, _values, result); end
+  def _reduce_21(val, _values, result); end
+  def _reduce_210(val, _values, result); end
+  def _reduce_211(val, _values, result); end
+  def _reduce_212(val, _values, result); end
+  def _reduce_213(val, _values, result); end
+  def _reduce_214(val, _values, result); end
+  def _reduce_215(val, _values, result); end
+  def _reduce_216(val, _values, result); end
+  def _reduce_217(val, _values, result); end
+  def _reduce_218(val, _values, result); end
+  def _reduce_219(val, _values, result); end
+  def _reduce_22(val, _values, result); end
+  def _reduce_220(val, _values, result); end
+  def _reduce_221(val, _values, result); end
+  def _reduce_222(val, _values, result); end
+  def _reduce_223(val, _values, result); end
+  def _reduce_224(val, _values, result); end
+  def _reduce_226(val, _values, result); end
+  def _reduce_227(val, _values, result); end
+  def _reduce_228(val, _values, result); end
+  def _reduce_229(val, _values, result); end
+  def _reduce_23(val, _values, result); end
+  def _reduce_230(val, _values, result); end
+  def _reduce_231(val, _values, result); end
+  def _reduce_232(val, _values, result); end
+  def _reduce_233(val, _values, result); end
+  def _reduce_234(val, _values, result); end
+  def _reduce_235(val, _values, result); end
+  def _reduce_236(val, _values, result); end
+  def _reduce_237(val, _values, result); end
+  def _reduce_238(val, _values, result); end
+  def _reduce_24(val, _values, result); end
+  def _reduce_244(val, _values, result); end
+  def _reduce_245(val, _values, result); end
+  def _reduce_249(val, _values, result); end
+  def _reduce_25(val, _values, result); end
+  def _reduce_250(val, _values, result); end
+  def _reduce_252(val, _values, result); end
+  def _reduce_253(val, _values, result); end
+  def _reduce_254(val, _values, result); end
+  def _reduce_256(val, _values, result); end
+  def _reduce_259(val, _values, result); end
+  def _reduce_26(val, _values, result); end
+  def _reduce_260(val, _values, result); end
+  def _reduce_261(val, _values, result); end
+  def _reduce_262(val, _values, result); end
+  def _reduce_263(val, _values, result); end
+  def _reduce_264(val, _values, result); end
+  def _reduce_265(val, _values, result); end
+  def _reduce_266(val, _values, result); end
+  def _reduce_267(val, _values, result); end
+  def _reduce_268(val, _values, result); end
+  def _reduce_269(val, _values, result); end
+  def _reduce_27(val, _values, result); end
+  def _reduce_270(val, _values, result); end
+  def _reduce_271(val, _values, result); end
+  def _reduce_272(val, _values, result); end
+  def _reduce_273(val, _values, result); end
+  def _reduce_274(val, _values, result); end
+  def _reduce_275(val, _values, result); end
+  def _reduce_277(val, _values, result); end
+  def _reduce_278(val, _values, result); end
+  def _reduce_279(val, _values, result); end
+  def _reduce_28(val, _values, result); end
+  def _reduce_29(val, _values, result); end
+  def _reduce_290(val, _values, result); end
+  def _reduce_291(val, _values, result); end
+  def _reduce_292(val, _values, result); end
+  def _reduce_293(val, _values, result); end
+  def _reduce_294(val, _values, result); end
+  def _reduce_295(val, _values, result); end
+  def _reduce_296(val, _values, result); end
+  def _reduce_297(val, _values, result); end
+  def _reduce_298(val, _values, result); end
+  def _reduce_299(val, _values, result); end
+  def _reduce_3(val, _values, result); end
+  def _reduce_300(val, _values, result); end
+  def _reduce_301(val, _values, result); end
+  def _reduce_302(val, _values, result); end
+  def _reduce_303(val, _values, result); end
+  def _reduce_304(val, _values, result); end
+  def _reduce_305(val, _values, result); end
+  def _reduce_306(val, _values, result); end
+  def _reduce_307(val, _values, result); end
+  def _reduce_308(val, _values, result); end
+  def _reduce_309(val, _values, result); end
+  def _reduce_31(val, _values, result); end
+  def _reduce_311(val, _values, result); end
+  def _reduce_312(val, _values, result); end
+  def _reduce_313(val, _values, result); end
+  def _reduce_314(val, _values, result); end
+  def _reduce_315(val, _values, result); end
+  def _reduce_316(val, _values, result); end
+  def _reduce_317(val, _values, result); end
+  def _reduce_318(val, _values, result); end
+  def _reduce_319(val, _values, result); end
+  def _reduce_32(val, _values, result); end
+  def _reduce_320(val, _values, result); end
+  def _reduce_321(val, _values, result); end
+  def _reduce_322(val, _values, result); end
+  def _reduce_323(val, _values, result); end
+  def _reduce_324(val, _values, result); end
+  def _reduce_325(val, _values, result); end
+  def _reduce_326(val, _values, result); end
+  def _reduce_327(val, _values, result); end
+  def _reduce_328(val, _values, result); end
+  def _reduce_329(val, _values, result); end
+  def _reduce_33(val, _values, result); end
+  def _reduce_330(val, _values, result); end
+  def _reduce_331(val, _values, result); end
+  def _reduce_332(val, _values, result); end
+  def _reduce_333(val, _values, result); end
+  def _reduce_334(val, _values, result); end
+  def _reduce_335(val, _values, result); end
+  def _reduce_337(val, _values, result); end
+  def _reduce_340(val, _values, result); end
+  def _reduce_344(val, _values, result); end
+  def _reduce_346(val, _values, result); end
+  def _reduce_349(val, _values, result); end
+  def _reduce_35(val, _values, result); end
+  def _reduce_350(val, _values, result); end
+  def _reduce_351(val, _values, result); end
+  def _reduce_352(val, _values, result); end
+  def _reduce_354(val, _values, result); end
+  def _reduce_355(val, _values, result); end
+  def _reduce_356(val, _values, result); end
+  def _reduce_357(val, _values, result); end
+  def _reduce_358(val, _values, result); end
+  def _reduce_359(val, _values, result); end
+  def _reduce_36(val, _values, result); end
+  def _reduce_360(val, _values, result); end
+  def _reduce_361(val, _values, result); end
+  def _reduce_362(val, _values, result); end
+  def _reduce_363(val, _values, result); end
+  def _reduce_364(val, _values, result); end
+  def _reduce_365(val, _values, result); end
+  def _reduce_366(val, _values, result); end
+  def _reduce_367(val, _values, result); end
+  def _reduce_368(val, _values, result); end
+  def _reduce_369(val, _values, result); end
+  def _reduce_37(val, _values, result); end
+  def _reduce_370(val, _values, result); end
+  def _reduce_371(val, _values, result); end
+  def _reduce_372(val, _values, result); end
+  def _reduce_374(val, _values, result); end
+  def _reduce_375(val, _values, result); end
+  def _reduce_376(val, _values, result); end
+  def _reduce_377(val, _values, result); end
+  def _reduce_378(val, _values, result); end
+  def _reduce_379(val, _values, result); end
+  def _reduce_38(val, _values, result); end
+  def _reduce_380(val, _values, result); end
+  def _reduce_381(val, _values, result); end
+  def _reduce_383(val, _values, result); end
+  def _reduce_384(val, _values, result); end
+  def _reduce_385(val, _values, result); end
+  def _reduce_386(val, _values, result); end
+  def _reduce_387(val, _values, result); end
+  def _reduce_388(val, _values, result); end
+  def _reduce_389(val, _values, result); end
+  def _reduce_39(val, _values, result); end
+  def _reduce_390(val, _values, result); end
+  def _reduce_391(val, _values, result); end
+  def _reduce_392(val, _values, result); end
+  def _reduce_394(val, _values, result); end
+  def _reduce_395(val, _values, result); end
+  def _reduce_396(val, _values, result); end
+  def _reduce_397(val, _values, result); end
+  def _reduce_398(val, _values, result); end
+  def _reduce_399(val, _values, result); end
+  def _reduce_4(val, _values, result); end
+  def _reduce_40(val, _values, result); end
+  def _reduce_400(val, _values, result); end
+  def _reduce_401(val, _values, result); end
+  def _reduce_402(val, _values, result); end
+  def _reduce_403(val, _values, result); end
+  def _reduce_404(val, _values, result); end
+  def _reduce_405(val, _values, result); end
+  def _reduce_406(val, _values, result); end
+  def _reduce_407(val, _values, result); end
+  def _reduce_408(val, _values, result); end
+  def _reduce_409(val, _values, result); end
+  def _reduce_41(val, _values, result); end
+  def _reduce_410(val, _values, result); end
+  def _reduce_411(val, _values, result); end
+  def _reduce_412(val, _values, result); end
+  def _reduce_413(val, _values, result); end
+  def _reduce_414(val, _values, result); end
+  def _reduce_415(val, _values, result); end
+  def _reduce_416(val, _values, result); end
+  def _reduce_417(val, _values, result); end
+  def _reduce_418(val, _values, result); end
+  def _reduce_419(val, _values, result); end
+  def _reduce_42(val, _values, result); end
+  def _reduce_420(val, _values, result); end
+  def _reduce_421(val, _values, result); end
+  def _reduce_422(val, _values, result); end
+  def _reduce_423(val, _values, result); end
+  def _reduce_424(val, _values, result); end
+  def _reduce_425(val, _values, result); end
+  def _reduce_426(val, _values, result); end
+  def _reduce_427(val, _values, result); end
+  def _reduce_428(val, _values, result); end
+  def _reduce_430(val, _values, result); end
+  def _reduce_431(val, _values, result); end
+  def _reduce_432(val, _values, result); end
+  def _reduce_435(val, _values, result); end
+  def _reduce_437(val, _values, result); end
+  def _reduce_44(val, _values, result); end
+  def _reduce_442(val, _values, result); end
+  def _reduce_443(val, _values, result); end
+  def _reduce_444(val, _values, result); end
+  def _reduce_445(val, _values, result); end
+  def _reduce_446(val, _values, result); end
+  def _reduce_447(val, _values, result); end
+  def _reduce_448(val, _values, result); end
+  def _reduce_449(val, _values, result); end
+  def _reduce_450(val, _values, result); end
+  def _reduce_451(val, _values, result); end
+  def _reduce_452(val, _values, result); end
+  def _reduce_453(val, _values, result); end
+  def _reduce_454(val, _values, result); end
+  def _reduce_455(val, _values, result); end
+  def _reduce_456(val, _values, result); end
+  def _reduce_457(val, _values, result); end
+  def _reduce_458(val, _values, result); end
+  def _reduce_459(val, _values, result); end
+  def _reduce_460(val, _values, result); end
+  def _reduce_461(val, _values, result); end
+  def _reduce_462(val, _values, result); end
+  def _reduce_463(val, _values, result); end
+  def _reduce_464(val, _values, result); end
+  def _reduce_465(val, _values, result); end
+  def _reduce_466(val, _values, result); end
+  def _reduce_467(val, _values, result); end
+  def _reduce_468(val, _values, result); end
+  def _reduce_469(val, _values, result); end
+  def _reduce_47(val, _values, result); end
+  def _reduce_470(val, _values, result); end
+  def _reduce_471(val, _values, result); end
+  def _reduce_472(val, _values, result); end
+  def _reduce_473(val, _values, result); end
+  def _reduce_474(val, _values, result); end
+  def _reduce_475(val, _values, result); end
+  def _reduce_476(val, _values, result); end
+  def _reduce_478(val, _values, result); end
+  def _reduce_479(val, _values, result); end
+  def _reduce_48(val, _values, result); end
+  def _reduce_480(val, _values, result); end
+  def _reduce_481(val, _values, result); end
+  def _reduce_482(val, _values, result); end
+  def _reduce_483(val, _values, result); end
+  def _reduce_484(val, _values, result); end
+  def _reduce_485(val, _values, result); end
+  def _reduce_486(val, _values, result); end
+  def _reduce_487(val, _values, result); end
+  def _reduce_488(val, _values, result); end
+  def _reduce_489(val, _values, result); end
+  def _reduce_49(val, _values, result); end
+  def _reduce_490(val, _values, result); end
+  def _reduce_491(val, _values, result); end
+  def _reduce_492(val, _values, result); end
+  def _reduce_493(val, _values, result); end
+  def _reduce_494(val, _values, result); end
+  def _reduce_495(val, _values, result); end
+  def _reduce_496(val, _values, result); end
+  def _reduce_497(val, _values, result); end
+  def _reduce_498(val, _values, result); end
+  def _reduce_499(val, _values, result); end
+  def _reduce_5(val, _values, result); end
+  def _reduce_50(val, _values, result); end
+  def _reduce_500(val, _values, result); end
+  def _reduce_501(val, _values, result); end
+  def _reduce_502(val, _values, result); end
+  def _reduce_503(val, _values, result); end
+  def _reduce_504(val, _values, result); end
+  def _reduce_505(val, _values, result); end
+  def _reduce_506(val, _values, result); end
+  def _reduce_507(val, _values, result); end
+  def _reduce_508(val, _values, result); end
+  def _reduce_509(val, _values, result); end
+  def _reduce_510(val, _values, result); end
+  def _reduce_511(val, _values, result); end
+  def _reduce_512(val, _values, result); end
+  def _reduce_513(val, _values, result); end
+  def _reduce_514(val, _values, result); end
+  def _reduce_515(val, _values, result); end
+  def _reduce_516(val, _values, result); end
+  def _reduce_517(val, _values, result); end
+  def _reduce_518(val, _values, result); end
+  def _reduce_519(val, _values, result); end
+  def _reduce_520(val, _values, result); end
+  def _reduce_521(val, _values, result); end
+  def _reduce_522(val, _values, result); end
+  def _reduce_523(val, _values, result); end
+  def _reduce_524(val, _values, result); end
+  def _reduce_525(val, _values, result); end
+  def _reduce_526(val, _values, result); end
+  def _reduce_527(val, _values, result); end
+  def _reduce_528(val, _values, result); end
+  def _reduce_529(val, _values, result); end
+  def _reduce_53(val, _values, result); end
+  def _reduce_530(val, _values, result); end
+  def _reduce_531(val, _values, result); end
+  def _reduce_532(val, _values, result); end
+  def _reduce_533(val, _values, result); end
+  def _reduce_534(val, _values, result); end
+  def _reduce_536(val, _values, result); end
+  def _reduce_537(val, _values, result); end
+  def _reduce_538(val, _values, result); end
+  def _reduce_539(val, _values, result); end
+  def _reduce_54(val, _values, result); end
+  def _reduce_540(val, _values, result); end
+  def _reduce_541(val, _values, result); end
+  def _reduce_542(val, _values, result); end
+  def _reduce_543(val, _values, result); end
+  def _reduce_544(val, _values, result); end
+  def _reduce_545(val, _values, result); end
+  def _reduce_546(val, _values, result); end
+  def _reduce_547(val, _values, result); end
+  def _reduce_548(val, _values, result); end
+  def _reduce_549(val, _values, result); end
+  def _reduce_550(val, _values, result); end
+  def _reduce_553(val, _values, result); end
+  def _reduce_554(val, _values, result); end
+  def _reduce_555(val, _values, result); end
+  def _reduce_556(val, _values, result); end
+  def _reduce_557(val, _values, result); end
+  def _reduce_558(val, _values, result); end
+  def _reduce_559(val, _values, result); end
+  def _reduce_560(val, _values, result); end
+  def _reduce_563(val, _values, result); end
+  def _reduce_564(val, _values, result); end
+  def _reduce_567(val, _values, result); end
+  def _reduce_568(val, _values, result); end
+  def _reduce_569(val, _values, result); end
+  def _reduce_571(val, _values, result); end
+  def _reduce_572(val, _values, result); end
+  def _reduce_574(val, _values, result); end
+  def _reduce_575(val, _values, result); end
+  def _reduce_576(val, _values, result); end
+  def _reduce_577(val, _values, result); end
+  def _reduce_578(val, _values, result); end
+  def _reduce_579(val, _values, result); end
+  def _reduce_58(val, _values, result); end
+  def _reduce_59(val, _values, result); end
+  def _reduce_592(val, _values, result); end
+  def _reduce_593(val, _values, result); end
+  def _reduce_598(val, _values, result); end
+  def _reduce_599(val, _values, result); end
+  def _reduce_6(val, _values, result); end
+  def _reduce_60(val, _values, result); end
+  def _reduce_603(val, _values, result); end
+  def _reduce_607(val, _values, result); end
+  def _reduce_62(val, _values, result); end
+  def _reduce_63(val, _values, result); end
+  def _reduce_64(val, _values, result); end
+  def _reduce_65(val, _values, result); end
+  def _reduce_66(val, _values, result); end
+  def _reduce_67(val, _values, result); end
+  def _reduce_68(val, _values, result); end
+  def _reduce_69(val, _values, result); end
+  def _reduce_70(val, _values, result); end
+  def _reduce_71(val, _values, result); end
+  def _reduce_72(val, _values, result); end
+  def _reduce_73(val, _values, result); end
+  def _reduce_74(val, _values, result); end
+  def _reduce_75(val, _values, result); end
+  def _reduce_76(val, _values, result); end
+  def _reduce_78(val, _values, result); end
+  def _reduce_79(val, _values, result); end
+  def _reduce_8(val, _values, result); end
+  def _reduce_80(val, _values, result); end
+  def _reduce_81(val, _values, result); end
+  def _reduce_82(val, _values, result); end
+  def _reduce_83(val, _values, result); end
+  def _reduce_84(val, _values, result); end
+  def _reduce_85(val, _values, result); end
+  def _reduce_86(val, _values, result); end
+  def _reduce_88(val, _values, result); end
+  def _reduce_89(val, _values, result); end
+  def _reduce_9(val, _values, result); end
+  def _reduce_90(val, _values, result); end
+  def _reduce_91(val, _values, result); end
+  def _reduce_92(val, _values, result); end
+  def _reduce_93(val, _values, result); end
+  def _reduce_94(val, _values, result); end
+  def _reduce_95(val, _values, result); end
+  def _reduce_96(val, _values, result); end
+  def _reduce_97(val, _values, result); end
+  def _reduce_98(val, _values, result); end
+  def _reduce_99(val, _values, result); end
+  def _reduce_none(val, _values, result); end
+  def default_encoding; end
+  def version; end
+end
+
+Parser::Ruby26::Racc_arg = T.let(T.unsafe(nil), Array)
+
+Parser::Ruby26::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
+
 module Parser::Source
 end
 
@@ -860,15 +1308,6 @@ class Parser::Source::Map::Definition < ::Parser::Source::Map
   def operator; end
 end
 
-class Parser::Source::Map::EndlessDefinition < ::Parser::Source::Map
-  def initialize(keyword_l, operator_l, name_l, assignment_l, body_l); end
-
-  def assignment; end
-  def keyword; end
-  def name; end
-  def operator; end
-end
-
 class Parser::Source::Map::For < ::Parser::Source::Map
   def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end
 
@@ -906,6 +1345,16 @@ class Parser::Source::Map::Keyword < ::Parser::Source::Map
   def keyword; end
 end
 
+class Parser::Source::Map::MethodDefinition < ::Parser::Source::Map
+  def initialize(keyword_l, operator_l, name_l, end_l, assignment_l, body_l); end
+
+  def assignment; end
+  def end; end
+  def keyword; end
+  def name; end
+  def operator; end
+end
+
 class Parser::Source::Map::ObjcKwarg < ::Parser::Source::Map
   def initialize(keyword_l, operator_l, argument_l, expression_l); end
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.4.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.7.0.rbi
similarity index 50%
rename from Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.4.2.rbi
rename to Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.7.0.rbi
index d5a98da9c2b2fd2bcb2d6e5a007e013728a357e2..e4f71c1624056fa5c2dc7ad183909709718f8e74 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.4.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.7.0.rbi
@@ -8,6 +8,7 @@ module RuboCop
 end
 
 module RuboCop::AST
+  extend(::RuboCop::AST::RuboCopCompatibility)
 end
 
 class RuboCop::AST::AliasNode < ::RuboCop::AST::Node
@@ -37,8 +38,6 @@ class RuboCop::AST::ArrayNode < ::RuboCop::AST::Node
   def values; end
 end
 
-RuboCop::AST::ArrayNode::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Hash)
-
 module RuboCop::AST::BasicLiteralNode
   def value; end
 end
@@ -68,8 +67,6 @@ class RuboCop::AST::BlockNode < ::RuboCop::AST::Node
   def void_context?; end
 end
 
-RuboCop::AST::BlockNode::VOID_CONTEXT_METHODS = T.let(T.unsafe(nil), Array)
-
 class RuboCop::AST::BreakNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ParameterizedNode)
   include(::RuboCop::AST::ParameterizedNode::WrappedArguments)
@@ -249,8 +246,6 @@ module RuboCop::AST::CollectionNode
   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
@@ -289,6 +284,18 @@ class RuboCop::AST::DefinedNode < ::RuboCop::AST::Node
   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::EnsureNode < ::RuboCop::AST::Node
   def body; end
 end
@@ -407,8 +414,6 @@ class RuboCop::AST::KeywordSplatNode < ::RuboCop::AST::Node
   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)
@@ -432,11 +437,11 @@ module RuboCop::AST::MethodDispatchNode
   extend(::RuboCop::AST::NodePattern::Macros)
 
   def access_modifier?; end
-  def adjacent_def_modifier?(node = T.unsafe(nil)); 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?(node = T.unsafe(nil)); end
+  def bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end
   def binary_operation?; end
   def block_literal?; end
   def block_node; end
@@ -446,30 +451,21 @@ module RuboCop::AST::MethodDispatchNode
   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 macro_scope?(node = T.unsafe(nil)); end
   def method_name; end
   def non_bare_access_modifier?; end
-  def non_bare_access_modifier_declaration?(node = T.unsafe(nil)); end
+  def 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
-
-  private
-
-  def macro_kwbegin_wrapper?(parent); end
-  def root_node?(node); end
 end
 
-RuboCop::AST::MethodDispatchNode::ARITHMETIC_OPERATORS = T.let(T.unsafe(nil), Array)
-
-RuboCop::AST::MethodDispatchNode::SPECIAL_MODIFIERS = T.let(T.unsafe(nil), Array)
-
 module RuboCop::AST::MethodIdentifierPredicates
   def assignment_method?; end
   def bang_method?; end
@@ -493,24 +489,6 @@ module RuboCop::AST::MethodIdentifierPredicates
   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
@@ -527,6 +505,7 @@ 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)
 
@@ -548,7 +527,7 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def array_pattern_with_tail_type?; end
   def array_type?; end
   def assignment?; end
-  def assignment_or_similar?(node = T.unsafe(nil)); end
+  def assignment_or_similar?(param0 = T.unsafe(nil)); end
   def back_ref_type?; end
   def basic_conditional?; end
   def basic_literal?; end
@@ -565,9 +544,8 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def casgn_type?; end
   def cbase_type?; end
   def chained?; end
-  def child_nodes; end
-  def class_constructor?(node = T.unsafe(nil)); end
-  def class_definition?(node = T.unsafe(nil)); end
+  def class_constructor?(param0 = T.unsafe(nil)); end
+  def class_definition?(param0 = T.unsafe(nil)); end
   def class_type?; end
   def complete!; end
   def complete?; end
@@ -579,20 +557,14 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def csend_type?; end
   def cvar_type?; end
   def cvasgn_type?; end
-  def def_e_type?; end
   def def_type?; end
   def defined_module; end
   def defined_module_name; end
   def defined_type?; end
-  def defs_e_type?; end
   def defs_type?; end
-  def descendants; end
   def dstr_type?; end
   def dsym_type?; end
   def each_ancestor(*types, &block); end
-  def each_child_node(*types); end
-  def each_descendant(*types, &block); end
-  def each_node(*types, &block); end
   def eflipflop_type?; end
   def empty_else_type?; end
   def empty_source?; end
@@ -608,7 +580,7 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def forward_arg_type?; end
   def forward_args_type?; end
   def forwarded_args_type?; end
-  def global_const?(node = T.unsafe(nil), param1); end
+  def global_const?(param0 = T.unsafe(nil), param1); end
   def guard_clause?; end
   def gvar_type?; end
   def gvasgn_type?; end
@@ -634,8 +606,8 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def kwoptarg_type?; end
   def kwrestarg_type?; end
   def kwsplat_type?; end
-  def lambda?(node = T.unsafe(nil)); end
-  def lambda_or_proc?(node = T.unsafe(nil)); end
+  def lambda?(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
@@ -649,19 +621,18 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def match_alt_type?; end
   def match_as_type?; end
   def match_current_line_type?; end
-  def match_guard_clause?(node = T.unsafe(nil)); end
+  def match_guard_clause?(param0 = T.unsafe(nil)); end
   def match_nil_pattern_type?; end
   def match_rest_type?; end
   def match_var_type?; end
   def match_with_lvasgn_type?; end
   def match_with_trailing_comma_type?; end
   def mlhs_type?; end
-  def module_definition?(node = T.unsafe(nil)); end
+  def module_definition?(param0 = T.unsafe(nil)); end
   def module_type?; end
-  def mrasgn_type?; end
   def multiline?; end
   def mutable_literal?; end
-  def new_class_or_module_block?(node = T.unsafe(nil)); end
+  def new_class_or_module_block?(param0 = T.unsafe(nil)); end
   def next_type?; end
   def nil_type?; end
   def node_parts; end
@@ -681,19 +652,19 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   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?(node = T.unsafe(nil)); end
+  def proc?(param0 = T.unsafe(nil)); end
   def procarg0_type?; end
   def pure?; end
   def range_type?; end
-  def rasgn_type?; end
   def rational_type?; end
-  def receiver(node = T.unsafe(nil)); end
+  def receiver(param0 = T.unsafe(nil)); end
   def recursive_basic_literal?; end
   def recursive_literal?; end
   def redo_type?; end
@@ -708,7 +679,7 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def return_type?; end
   def right_sibling; end
   def right_siblings; end
-  def root_type?; end
+  def root?; end
   def sclass_type?; end
   def self_type?; end
   def send_type?; end
@@ -721,9 +692,9 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def source_range; end
   def special_keyword?; end
   def splat_type?; end
-  def str_content(node = T.unsafe(nil)); end
+  def str_content(param0 = T.unsafe(nil)); end
   def str_type?; end
-  def struct_constructor?(node = T.unsafe(nil)); end
+  def struct_constructor?(param0 = T.unsafe(nil)); end
   def super_type?; end
   def sym_type?; end
   def true_type?; end
@@ -745,13 +716,12 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   protected
 
   def parent=(node); end
-  def visit_descendants(types, &block); end
 
   private
 
   def begin_value_used?; end
   def case_if_value_used?; end
-  def defined_module0(node = T.unsafe(nil)); end
+  def 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
@@ -760,57 +730,69 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def while_until_value_used?; end
 end
 
-RuboCop::AST::Node::ARGUMENT_TYPES = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::ARGUMENT_TYPES = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::ASSIGNMENTS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::ASSIGNMENTS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::BASIC_CONDITIONALS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::BASIC_CONDITIONALS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::BASIC_LITERALS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::BASIC_LITERALS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::COMPARISON_OPERATORS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::COMPARISON_OPERATORS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::COMPOSITE_LITERALS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::COMPOSITE_LITERALS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::CONDITIONALS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::CONDITIONALS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::EQUALS_ASSIGNMENTS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::EQUALS_ASSIGNMENTS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::FALSEY_LITERALS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::FALSEY_LITERALS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::IMMUTABLE_LITERALS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::IMMUTABLE_LITERALS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::KEYWORDS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::KEYWORDS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::LITERALS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::LITERALS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::LOOP_TYPES = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::LOOP_TYPES = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::MUTABLE_LITERALS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::MUTABLE_LITERALS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::OPERATOR_KEYWORDS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::OPERATOR_KEYWORDS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::REFERENCES = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::REFERENCES = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::SPECIAL_KEYWORDS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::SPECIAL_KEYWORDS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::TRUTHY_LITERALS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::TRUTHY_LITERALS = T.let(T.unsafe(nil), Set)
 
-RuboCop::AST::Node::VARIABLES = T.let(T.unsafe(nil), Array)
+RuboCop::AST::Node::VARIABLES = T.let(T.unsafe(nil), Set)
 
 class RuboCop::AST::NodePattern
-  def initialize(str); end
+  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); 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
@@ -818,26 +800,805 @@ class RuboCop::AST::NodePattern
   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 [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); 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)
+
+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
+
+class RuboCop::AST::NodePattern::LexerRex
+  def action; end
+  def filename; end
+  def filename=(_); 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=(_); end
+  def state; end
+  def state=(_); end
+end
+
+RuboCop::AST::NodePattern::LexerRex::IDENTIFIER = T.let(T.unsafe(nil), Regexp)
+
+class RuboCop::AST::NodePattern::LexerRex::LexerError < ::StandardError
+end
+
+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
 
-class RuboCop::AST::NodePattern::Matcher
-  def initialize(&block); 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
+
+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::MAP = T.let(T.unsafe(nil), Hash)
+
+module RuboCop::AST::NodePattern::Node::MapMinMax
+  def map_min_max(enum); end
+end
+
+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
+
+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)
+  include(::RuboCop::AST::NodePattern::Node::MapMinMax)
+
+  def arity; end
+  def in_sequence_head; end
+end
+
+class RuboCop::AST::NodePattern::Node::Union < ::RuboCop::AST::NodePattern::Node
+  include(::RuboCop::AST::NodePattern::Node::MapMinMax)
+
+  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 ===(compare); 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_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_ANY_INSTANCE_ALLOW_ANY_INSTANCE_OF_EXPECT_ANY_INSTANCE_OF = 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_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_CHANNEL_CONTROLLER_HELPER_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_COLLECT_COMPACT_FLATTEN_ETC = 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_DEBUGGER_BYEBUG_REMOTE_BYEBUG = 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_CONTEXT_FEATURE_ETC = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_DESCRIBE_CONTEXT_FEATURE_ETC_2 = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_DESCRIBE_CONTEXT_FEATURE_ETC_3 = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_DESCRIBE_CONTEXT_FEATURE_ETC_4 = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_DESCRIBE_CONTEXT_FEATURE_ETC_5 = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_DESCRIBE_CONTEXT_FEATURE_ETC_6 = 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_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_EXPECT_IS_EXPECTED_EXPECT_ANY_INSTANCE_OF = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_FACTORYGIRL_FACTORYBOT = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_FDESCRIBE_FCONTEXT_FFEATURE_ETC = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_FIRST_LAST_POP_ETC = 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_IT_BEHAVES_LIKE_IT_SHOULD_BEHAVE_LIKE_INCLUDE_EXAMPLES = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_IT_BEHAVES_LIKE_IT_SHOULD_BEHAVE_LIKE_INCLUDE_EXAMPLES_INCLUDE_CONTEXT = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_IT_SPECIFY_EXAMPLE_ETC = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_IT_SPECIFY_EXAMPLE_ETC_2 = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_IT_SPECIFY_EXAMPLE_ETC_3 = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_KEYS_VALUES = 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_LET_LET = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_LET_LET_SUBJECT_SUBJECT = 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_PENDING_XIT_XSPECIFY_ETC = 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_PREPEND_BEFORE_BEFORE_APPEND_BEFORE_ETC = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_PREPEND_BEFORE_BEFORE_APPEND_BEFORE_ETC_2 = 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_PRY_REMOTE_PRY_PRY_REMOTE_CONSOLE = 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_REDUCE_INJECT = 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_SAVE_AND_OPEN_PAGE_SAVE_AND_OPEN_SCREENSHOT_SAVE_SCREENSHOT = 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_SEND_PUBLIC_SEND___SEND__ = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_SHARED_CONTEXT = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_SHARED_EXAMPLES_SHARED_EXAMPLES_FOR = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_SHARED_EXAMPLES_SHARED_EXAMPLES_FOR_SHARED_CONTEXT = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_SHARED_EXAMPLES_SHARED_EXAMPLES_FOR_SHARED_CONTEXT_ETC = 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_SUBJECT_SUBJECT = 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_TEMPFILE_STRINGIO = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_TIME_DATETIME = 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_TO_TO_NOT_NOT_TO = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET_TRUE_FALSE = 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__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____ = 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::Sets::SET____ETC_4 = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::NodePattern::Sets::SET____ETC_5 = 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)
@@ -856,14 +1617,6 @@ class RuboCop::AST::PairNode < ::RuboCop::AST::Node
   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
@@ -895,14 +1648,6 @@ module RuboCop::AST::PredicateOperatorNode
   def semantic_operator?; end
 end
 
-RuboCop::AST::PredicateOperatorNode::LOGICAL_AND = T.let(T.unsafe(nil), String)
-
-RuboCop::AST::PredicateOperatorNode::LOGICAL_OR = T.let(T.unsafe(nil), String)
-
-RuboCop::AST::PredicateOperatorNode::SEMANTIC_AND = T.let(T.unsafe(nil), String)
-
-RuboCop::AST::PredicateOperatorNode::SEMANTIC_OR = T.let(T.unsafe(nil), String)
-
 class RuboCop::AST::ProcessedSource
   include(::RuboCop::Ext::ProcessedSource)
 
@@ -978,6 +1723,7 @@ class RuboCop::AST::RegexpNode < ::RuboCop::AST::Node
   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
@@ -989,8 +1735,6 @@ class RuboCop::AST::RegexpNode < ::RuboCop::AST::Node
   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
@@ -1011,6 +1755,12 @@ class RuboCop::AST::ReturnNode < ::RuboCop::AST::Node
   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
@@ -1022,7 +1772,7 @@ class RuboCop::AST::SendNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::MethodIdentifierPredicates)
   include(::RuboCop::AST::MethodDispatchNode)
 
-  def attribute_accessor?(node = T.unsafe(nil)); end
+  def attribute_accessor?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -1211,14 +1961,6 @@ module RuboCop::AST::Traversal
   def walk(node); end
 end
 
-RuboCop::AST::Traversal::MANY_CHILD_NODES = T.let(T.unsafe(nil), Array)
-
-RuboCop::AST::Traversal::NO_CHILD_NODES = T.let(T.unsafe(nil), Array)
-
-RuboCop::AST::Traversal::ONE_CHILD_NODE = T.let(T.unsafe(nil), Array)
-
-RuboCop::AST::Traversal::SECOND_CHILD_ONLY = T.let(T.unsafe(nil), Array)
-
 class RuboCop::AST::UntilNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ConditionalNode)
   include(::RuboCop::AST::ModifierNode)
@@ -1264,69 +2006,3 @@ RuboCop::NodePattern = RuboCop::AST::NodePattern
 RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource
 
 RuboCop::Token = RuboCop::AST::Token
-
-RuboCop::AST::NodePattern::Compiler::ANY_ORDER_TEMPLATE = T.let(T.unsafe(nil), ERB)
-
-RuboCop::AST::NodePattern::Compiler::CAPTURED_REST = T.let(T.unsafe(nil), String)
-
-RuboCop::AST::NodePattern::Compiler::CLOSING = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::COMMENT = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::CONST = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::CUR_ELEMENT = T.let(T.unsafe(nil), String)
-
-RuboCop::AST::NodePattern::Compiler::CUR_NODE = T.let(T.unsafe(nil), String)
-
-RuboCop::AST::NodePattern::Compiler::CUR_PLACEHOLDER = T.let(T.unsafe(nil), String)
-
-RuboCop::AST::NodePattern::Compiler::FUNCALL = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::IDENTIFIER = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::KEYWORD = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::KEYWORD_NAME = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::LITERAL = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::META = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::METHOD_NAME = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::MULTIPLE_CUR_PLACEHOLDER = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::NODE = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::NUMBER = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::ONLY_SEPARATOR = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::PARAM = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::PARAM_CONST = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::PARAM_NUMBER = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::PREDICATE = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::REPEATED_TEMPLATE = T.let(T.unsafe(nil), ERB)
-
-RuboCop::AST::NodePattern::Compiler::REST = T.let(T.unsafe(nil), String)
-
-RuboCop::AST::NodePattern::Compiler::SEPARATORS = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::SEQ_HEAD_GUARD = T.let(T.unsafe(nil), String)
-
-RuboCop::AST::NodePattern::Compiler::SEQ_HEAD_INDEX = T.let(T.unsafe(nil), Integer)
-
-RuboCop::AST::NodePattern::Compiler::STRING = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::SYMBOL = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::TOKEN = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::TOKENS = T.let(T.unsafe(nil), Regexp)
-
-RuboCop::AST::NodePattern::Compiler::WILDCARD = T.let(T.unsafe(nil), Regexp)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop@0.91.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop@0.92.0.rbi
similarity index 95%
rename from Library/Homebrew/sorbet/rbi/gems/rubocop@0.91.0.rbi
rename to Library/Homebrew/sorbet/rbi/gems/rubocop@0.92.0.rbi
index d303decbfb4eb1f4d91ea053b963f8c4adf15611..3af2a33d3a64da8abdf496dfe8319c722e130c86 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rubocop@0.91.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rubocop@0.92.0.rbi
@@ -175,7 +175,7 @@ class RuboCop::CommentConfig
   def each_directive; end
   def each_mentioned_cop; end
   def enable_all?(comment); end
-  def extra_enabled_comments_with_names(extras, names); end
+  def extra_enabled_comments_with_names(extras:, names:); end
   def handle_enable_all(names, extras, comment); end
   def handle_switch(cop_names, names, disabled, extras, comment); end
   def non_comment_token_line_numbers; end
@@ -393,6 +393,21 @@ RuboCop::ConfigObsoletion::RENAMED_COPS = T.let(T.unsafe(nil), Array)
 
 RuboCop::ConfigObsoletion::SPLIT_COPS = T.let(T.unsafe(nil), Array)
 
+class RuboCop::ConfigRegeneration
+  def options; end
+
+  private
+
+  def generation_command; end
+  def todo_exists?; end
+end
+
+RuboCop::ConfigRegeneration::AUTO_GENERATED_FILE = T.let(T.unsafe(nil), String)
+
+RuboCop::ConfigRegeneration::COMMAND_REGEX = T.let(T.unsafe(nil), Regexp)
+
+RuboCop::ConfigRegeneration::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+
 class RuboCop::ConfigStore
   def initialize; end
 
@@ -564,7 +579,6 @@ RuboCop::Cop::Badge::InvalidBadge::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Base
   include(::RuboCop::AST::Sexp)
   include(::RuboCop::PathUtil)
-  include(::RuboCop::TokensUtil)
   include(::RuboCop::Cop::Util)
   include(::RuboCop::Cop::IgnoredNode)
   include(::RuboCop::Cop::AutocorrectLogic)
@@ -663,7 +677,7 @@ end
 class RuboCop::Cop::Bundler::DuplicatedGem < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
-  def gem_declarations(node0); end
+  def gem_declarations(param0); end
   def investigate(processed_source); end
 
   private
@@ -678,7 +692,7 @@ RuboCop::Cop::Bundler::DuplicatedGem::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Bundler::GemComment < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::DefNode)
 
-  def gem_declaration?(node = T.unsafe(nil)); end
+  def gem_declaration?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -707,7 +721,7 @@ class RuboCop::Cop::Bundler::InsecureProtocolSource < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def insecure_protocol_source?(node = T.unsafe(nil)); end
+  def insecure_protocol_source?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -720,7 +734,7 @@ class RuboCop::Cop::Bundler::OrderedGems < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::OrderedGemNode)
 
   def autocorrect(node); end
-  def gem_declarations(node0); end
+  def gem_declarations(param0); end
   def investigate(processed_source); end
 
   private
@@ -883,7 +897,6 @@ class RuboCop::Cop::Commissioner
   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
@@ -898,7 +911,6 @@ class RuboCop::Cop::Commissioner
   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
@@ -1089,7 +1101,7 @@ end
 module RuboCop::Cop::DefNode
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def non_public_modifier?(node = T.unsafe(nil)); end
+  def non_public_modifier?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -1169,7 +1181,7 @@ end
 module RuboCop::Cop::EmptyParameter
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def empty_arguments?(node = T.unsafe(nil)); end
+  def empty_arguments?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -1281,8 +1293,8 @@ end
 class RuboCop::Cop::Gemspec::DuplicatedAssignment < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
-  def assignment_method_declarations(node0); end
-  def gem_specification(node0); end
+  def assignment_method_declarations(param0); end
+  def gem_specification(param0); end
   def investigate(processed_source); end
 
   private
@@ -1300,7 +1312,7 @@ class RuboCop::Cop::Gemspec::OrderedDependencies < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::OrderedGemNode)
 
   def autocorrect(node); end
-  def dependency_declarations(node0); end
+  def dependency_declarations(param0); end
   def investigate(processed_source); end
 
   private
@@ -1315,8 +1327,8 @@ class RuboCop::Cop::Gemspec::RequiredRubyVersion < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def investigate(processed_source); end
-  def required_ruby_version(node0); end
-  def string_version?(node = T.unsafe(nil)); end
+  def required_ruby_version(param0); end
+  def string_version?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -1329,9 +1341,9 @@ RuboCop::Cop::Gemspec::RequiredRubyVersion::MISSING_MSG = T.let(T.unsafe(nil), S
 RuboCop::Cop::Gemspec::RequiredRubyVersion::NOT_EQUAL_MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage < ::RuboCop::Cop::Cop
-  def gem_specification?(node0); end
+  def gem_specification?(param0); end
   def on_const(node); end
-  def ruby_version?(node = T.unsafe(nil)); end
+  def ruby_version?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -1464,7 +1476,7 @@ end
 module RuboCop::Cop::HashTransformMethod
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def array_receiver?(node = T.unsafe(nil)); end
+  def array_receiver?(param0 = T.unsafe(nil)); end
   def on_block(node); end
   def on_csend(node); end
   def on_send(node); end
@@ -1708,7 +1720,7 @@ class RuboCop::Cop::Layout::BlockAlignment < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def block_end_align_target?(node = T.unsafe(nil), param1); end
+  def block_end_align_target?(param0 = T.unsafe(nil), param1); end
   def on_block(node); end
   def style_parameter_name; end
 
@@ -1760,7 +1772,6 @@ class RuboCop::Cop::Layout::CaseIndentation < ::RuboCop::Cop::Base
   def base_column(case_node, base); end
   def check_when(when_node); end
   def detect_incorrect_style(when_node); end
-  def find_message(*_); end
   def incorrect_style(when_node); end
   def indent_one_step?; end
   def indentation_width; end
@@ -2012,7 +2023,6 @@ RuboCop::Cop::Layout::EmptyLineAfterMagicComment::MSG = T.let(T.unsafe(nil), Str
 
 class RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
-  include(::RuboCop::Cop::RescueNode)
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_case(node); end
@@ -2030,7 +2040,6 @@ class RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition < ::RuboCop::Cop::B
   def multiline_rescue_exceptions?(exception_nodes); end
   def multiline_when_condition?(when_node); end
   def next_line_empty?(line); end
-  def right_sibling(node); end
 end
 
 RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition::MSG = T.let(T.unsafe(nil), String)
@@ -2109,6 +2118,7 @@ class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier < ::RuboCop::Cop::Bas
   def next_line_empty?(last_send_line); end
   def previous_line_empty?(send_line); end
   def previous_line_ignoring_comments(processed_source, send_line); end
+  def register_offense?(node); end
 end
 
 RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_AFTER = T.let(T.unsafe(nil), String)
@@ -2188,8 +2198,8 @@ module RuboCop::Cop::Layout::EmptyLinesAroundBody
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def constant_definition?(node = T.unsafe(nil)); end
-  def empty_line_required?(node = T.unsafe(nil)); end
+  def constant_definition?(param0 = T.unsafe(nil)); end
+  def empty_line_required?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -2359,7 +2369,7 @@ class RuboCop::Cop::Layout::FirstArgumentIndentation < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def autocorrect(node); end
-  def eligible_method_call?(node = T.unsafe(nil)); end
+  def eligible_method_call?(param0 = T.unsafe(nil)); end
   def on_csend(node); end
   def on_send(node); end
 
@@ -2636,7 +2646,7 @@ class RuboCop::Cop::Layout::IndentationWidth < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::CheckAssignment)
   include(::RuboCop::Cop::IgnoredPattern)
 
-  def access_modifier?(node = T.unsafe(nil)); end
+  def access_modifier?(param0 = T.unsafe(nil)); end
   def autocorrect(node); end
   def on_block(node); end
   def on_case(case_node); end
@@ -3435,7 +3445,6 @@ class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces < ::RuboCop::Cop::Base
   def autocorrect(corrector, range); end
   def check(token1, token2); end
   def expect_space?(token1, token2); end
-  def hash_literal_with_braces(node); end
   def incorrect_style_detected(token1, token2, expect_space, is_empty_braces); end
   def message(brace, is_empty_braces, expect_space); end
   def offense?(token1, expect_space); end
@@ -3598,7 +3607,6 @@ class RuboCop::Cop::LineBreakCorrector
   extend(::RuboCop::Cop::Alignment)
   extend(::RuboCop::Cop::TrailingBody)
   extend(::RuboCop::PathUtil)
-  extend(::RuboCop::TokensUtil)
   extend(::RuboCop::Cop::Util)
 
   class << self
@@ -3703,7 +3711,7 @@ RuboCop::Cop::Lint::AssignmentInCondition::MSG_WITH_SAFE_ASSIGNMENT_ALLOWED = T.
 class RuboCop::Cop::Lint::BigDecimalNew < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def big_decimal_new(node = T.unsafe(nil)); end
+  def big_decimal_new(param0 = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -3724,7 +3732,7 @@ RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands::MSG = T.let(T.unsafe(ni
 class RuboCop::Cop::Lint::BooleanSymbol < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def boolean_symbol?(node = T.unsafe(nil)); end
+  def boolean_symbol?(param0 = T.unsafe(nil)); end
   def on_sym(node); end
 
   private
@@ -3746,8 +3754,8 @@ end
 RuboCop::Cop::Lint::CircularArgumentReference::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::ConstantDefinitionInBlock < ::RuboCop::Cop::Base
-  def constant_assigned_in_block?(node = T.unsafe(nil)); end
-  def module_defined_in_block?(node = T.unsafe(nil)); end
+  def constant_assigned_in_block?(param0 = T.unsafe(nil)); end
+  def module_defined_in_block?(param0 = T.unsafe(nil)); end
   def on_casgn(node); end
   def on_class(node); end
   def on_module(node); end
@@ -3757,7 +3765,7 @@ RuboCop::Cop::Lint::ConstantDefinitionInBlock::MSG = T.let(T.unsafe(nil), String
 
 class RuboCop::Cop::Lint::ConstantResolution < ::RuboCop::Cop::Base
   def on_const(node); end
-  def unqualified_const?(node = T.unsafe(nil)); end
+  def unqualified_const?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -3769,9 +3777,9 @@ end
 RuboCop::Cop::Lint::ConstantResolution::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::Debugger < ::RuboCop::Cop::Base
-  def binding_irb_call?(node = T.unsafe(nil)); end
-  def debugger_call?(node = T.unsafe(nil)); end
-  def kernel?(node = T.unsafe(nil)); end
+  def binding_irb_call?(param0 = T.unsafe(nil)); end
+  def debugger_call?(param0 = T.unsafe(nil)); end
+  def kernel?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -3818,7 +3826,7 @@ class RuboCop::Cop::Lint::DeprecatedOpenSSLConstant < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def algorithm_const(node = T.unsafe(nil)); end
+  def algorithm_const(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -3877,13 +3885,13 @@ RuboCop::Cop::Lint::DuplicateHashKey::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Lint::DuplicateMethods < ::RuboCop::Cop::Base
   def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
 
-  def alias_method?(node = T.unsafe(nil)); end
-  def method_alias?(node = T.unsafe(nil)); end
+  def alias_method?(param0 = T.unsafe(nil)); end
+  def method_alias?(param0 = T.unsafe(nil)); end
   def on_alias(node); end
   def on_def(node); end
   def on_defs(node); end
   def on_send(node); end
-  def sym_name(node = T.unsafe(nil)); end
+  def sym_name(param0 = T.unsafe(nil)); end
 
   private
 
@@ -3907,7 +3915,7 @@ RuboCop::Cop::Lint::DuplicateMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Ar
 class RuboCop::Cop::Lint::DuplicateRequire < ::RuboCop::Cop::Base
   def on_new_investigation; end
   def on_send(node); end
-  def require_call?(node = T.unsafe(nil)); end
+  def require_call?(param0 = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Lint::DuplicateRequire::MSG = T.let(T.unsafe(nil), String)
@@ -3925,7 +3933,7 @@ end
 RuboCop::Cop::Lint::DuplicateRescueException::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::EachWithObjectArgument < ::RuboCop::Cop::Base
-  def each_with_object?(node = T.unsafe(nil)); end
+  def each_with_object?(param0 = T.unsafe(nil)); end
   def on_csend(node); end
   def on_send(node); end
 end
@@ -4012,7 +4020,7 @@ class RuboCop::Cop::Lint::ErbNewArguments < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::TargetRubyVersion)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def erb_new_with_non_keyword_arguments(node = T.unsafe(nil)); end
+  def erb_new_with_non_keyword_arguments(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -4062,7 +4070,7 @@ end
 RuboCop::Cop::Lint::FloatOutOfRange::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::FormatParameterMismatch < ::RuboCop::Cop::Base
-  def called_on_string?(node = T.unsafe(nil)); end
+  def called_on_string?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -4163,7 +4171,7 @@ RuboCop::Cop::Lint::ImplicitStringConcatenation::MSG = T.let(T.unsafe(nil), Stri
 class RuboCop::Cop::Lint::IneffectiveAccessModifier < ::RuboCop::Cop::Base
   def on_class(node); end
   def on_module(node); end
-  def private_class_methods(node0); end
+  def private_class_methods(param0); end
 
   private
 
@@ -4185,7 +4193,7 @@ class RuboCop::Cop::Lint::InheritException < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def class_new_call?(node = T.unsafe(nil)); end
+  def class_new_call?(param0 = T.unsafe(nil)); end
   def on_class(node); end
   def on_send(node); end
 
@@ -4331,7 +4339,7 @@ RuboCop::Cop::Lint::MixedRegexpCaptureTypes::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Lint::MultipleComparison < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def multiple_compare?(node = T.unsafe(nil)); end
+  def multiple_compare?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -4342,9 +4350,9 @@ RuboCop::Cop::Lint::MultipleComparison::MSG = T.let(T.unsafe(nil), String)
 RuboCop::Cop::Lint::MultipleComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
 
 class RuboCop::Cop::Lint::NestedMethodDefinition < ::RuboCop::Cop::Base
-  def class_or_module_or_struct_new_call?(node = T.unsafe(nil)); end
-  def eval_call?(node = T.unsafe(nil)); end
-  def exec_call?(node = T.unsafe(nil)); end
+  def class_or_module_or_struct_new_call?(param0 = T.unsafe(nil)); end
+  def eval_call?(param0 = T.unsafe(nil)); end
+  def exec_call?(param0 = T.unsafe(nil)); end
   def on_def(node); end
   def on_defs(node); end
 
@@ -4375,7 +4383,7 @@ RuboCop::Cop::Lint::NestedPercentLiteral::REGEXES = T.let(T.unsafe(nil), Array)
 
 class RuboCop::Cop::Lint::NextWithoutAccumulator < ::RuboCop::Cop::Base
   def on_block(node); end
-  def on_body_of_reduce(node = T.unsafe(nil)); end
+  def on_body_of_reduce(param0 = T.unsafe(nil)); end
 
   private
 
@@ -4387,15 +4395,15 @@ RuboCop::Cop::Lint::NextWithoutAccumulator::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Lint::NonDeterministicRequireOrder < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def loop_variable(node = T.unsafe(nil)); end
-  def method_require?(node = T.unsafe(nil)); end
+  def loop_variable(param0 = T.unsafe(nil)); end
+  def method_require?(param0 = T.unsafe(nil)); end
   def on_block(node); end
   def on_block_pass(node); end
-  def unsorted_dir_block?(node = T.unsafe(nil)); end
-  def unsorted_dir_each?(node = T.unsafe(nil)); end
-  def unsorted_dir_each_pass?(node = T.unsafe(nil)); end
-  def unsorted_dir_glob_pass?(node = T.unsafe(nil)); end
-  def var_is_required?(node0, param1); end
+  def unsorted_dir_block?(param0 = T.unsafe(nil)); end
+  def unsorted_dir_each?(param0 = T.unsafe(nil)); end
+  def unsorted_dir_each_pass?(param0 = T.unsafe(nil)); end
+  def unsorted_dir_glob_pass?(param0 = T.unsafe(nil)); end
+  def var_is_required?(param0, param1); end
 
   private
 
@@ -4409,8 +4417,8 @@ end
 RuboCop::Cop::Lint::NonDeterministicRequireOrder::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::NonLocalExitFromIterator < ::RuboCop::Cop::Base
-  def chained_send?(node = T.unsafe(nil)); end
-  def define_method?(node = T.unsafe(nil)); end
+  def chained_send?(param0 = T.unsafe(nil)); end
+  def define_method?(param0 = T.unsafe(nil)); end
   def on_return(return_node); end
 
   private
@@ -4424,9 +4432,9 @@ RuboCop::Cop::Lint::NonLocalExitFromIterator::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Lint::NumberConversion < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def datetime?(node = T.unsafe(nil)); end
+  def datetime?(param0 = T.unsafe(nil)); end
   def on_send(node); end
-  def to_method(node = T.unsafe(nil)); end
+  def to_method(param0 = T.unsafe(nil)); end
 
   private
 
@@ -4537,8 +4545,8 @@ RuboCop::Cop::Lint::PercentSymbolArray::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Lint::RaiseException < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def exception?(node = T.unsafe(nil)); end
-  def exception_new_with_message?(node = T.unsafe(nil)); end
+  def exception?(param0 = T.unsafe(nil)); end
+  def exception_new_with_message?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -4554,7 +4562,7 @@ RuboCop::Cop::Lint::RaiseException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Arra
 
 class RuboCop::Cop::Lint::RandOne < ::RuboCop::Cop::Base
   def on_send(node); end
-  def rand_one?(node = T.unsafe(nil)); end
+  def rand_one?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -4594,6 +4602,7 @@ class RuboCop::Cop::Lint::RedundantCopDisableDirective < ::RuboCop::Cop::Base
   def find_redundant(comment, offenses, cop, line_range, next_line_range); end
   def ignore_offense?(disabled_ranges, line_range); end
   def matching_range(haystack, needle); end
+  def previous_line_blank?(range); end
   def trailing_range?(ranges, range); end
 end
 
@@ -4614,6 +4623,7 @@ class RuboCop::Cop::Lint::RedundantCopEnableDirective < ::RuboCop::Cop::Base
   def range_of_offense(comment, name); end
   def range_to_remove(begin_pos, end_pos, comma_pos, comment); end
   def range_with_comma(comment, name); end
+  def register_offense(comment, cop_names); end
 end
 
 RuboCop::Cop::Lint::RedundantCopEnableDirective::MSG = T.let(T.unsafe(nil), String)
@@ -4623,7 +4633,7 @@ class RuboCop::Cop::Lint::RedundantRequireStatement < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def unnecessary_require_statement?(node = T.unsafe(nil)); end
+  def unnecessary_require_statement?(param0 = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Lint::RedundantRequireStatement::MSG = T.let(T.unsafe(nil), String)
@@ -4633,8 +4643,8 @@ RuboCop::Cop::Lint::RedundantRequireStatement::RESTRICT_ON_SEND = T.let(T.unsafe
 class RuboCop::Cop::Lint::RedundantSplatExpansion < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def array_new?(node = T.unsafe(nil)); end
-  def literal_expansion(node = T.unsafe(nil)); end
+  def array_new?(param0 = T.unsafe(nil)); end
+  def literal_expansion(param0 = T.unsafe(nil)); end
   def on_splat(node); end
 
   private
@@ -4669,7 +4679,7 @@ class RuboCop::Cop::Lint::RedundantStringCoercion < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_interpolation(begin_node); end
-  def to_s_without_args?(node = T.unsafe(nil)); end
+  def to_s_without_args?(param0 = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Lint::RedundantStringCoercion::MSG_DEFAULT = T.let(T.unsafe(nil), String)
@@ -4681,7 +4691,7 @@ class RuboCop::Cop::Lint::RedundantWithIndex < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_block(node); end
-  def redundant_with_index?(node = T.unsafe(nil)); end
+  def redundant_with_index?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -4698,7 +4708,7 @@ class RuboCop::Cop::Lint::RedundantWithObject < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_block(node); end
-  def redundant_with_object?(node = T.unsafe(nil)); end
+  def redundant_with_object?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -4740,7 +4750,6 @@ end
 RuboCop::Cop::Lint::RescueException::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::RescueType < ::RuboCop::Cop::Base
-  include(::RuboCop::Cop::RescueNode)
   extend(::RuboCop::Cop::AutoCorrector)
 
   def autocorrect(corrector, node); end
@@ -4774,7 +4783,7 @@ class RuboCop::Cop::Lint::SafeNavigationChain < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::AllowedMethods)
   include(::RuboCop::Cop::NilMethods)
 
-  def bad_method?(node = T.unsafe(nil)); end
+  def bad_method?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -4806,7 +4815,7 @@ class RuboCop::Cop::Lint::SafeNavigationWithEmpty < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_if(node); end
-  def safe_navigation_empty_in_conditional?(node = T.unsafe(nil)); end
+  def safe_navigation_empty_in_conditional?(param0 = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Lint::SafeNavigationWithEmpty::MSG = T.let(T.unsafe(nil), String)
@@ -4852,7 +4861,7 @@ class RuboCop::Cop::Lint::SendWithMixinArgument < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def send_with_mixin_argument?(node = T.unsafe(nil)); end
+  def send_with_mixin_argument?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -4871,7 +4880,7 @@ RuboCop::Cop::Lint::SendWithMixinArgument::SEND_METHODS = T.let(T.unsafe(nil), A
 
 class RuboCop::Cop::Lint::ShadowedArgument < ::RuboCop::Cop::Base
   def after_leaving_scope(scope, _variable_table); end
-  def uses_var?(node0, param1); end
+  def uses_var?(param0, param1); end
 
   private
 
@@ -4900,7 +4909,7 @@ class RuboCop::Cop::Lint::ShadowedException < ::RuboCop::Cop::Base
 
   def compare_exceptions(exception, other_exception); end
   def contains_multiple_levels_of_exceptions?(group); end
-  def evaluate_exceptions(rescue_group); end
+  def evaluate_exceptions(group); end
   def find_shadowing_rescue(rescues); end
   def offense_range(rescues); end
   def rescued_exceptions(rescue_group); end
@@ -4924,7 +4933,7 @@ RuboCop::Cop::Lint::ShadowingOuterLocalVariable::MSG = T.let(T.unsafe(nil), Stri
 
 class RuboCop::Cop::Lint::StructNewOverride < ::RuboCop::Cop::Base
   def on_send(node); end
-  def struct_new(node = T.unsafe(nil)); end
+  def struct_new(param0 = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Lint::StructNewOverride::MSG = T.let(T.unsafe(nil), String)
@@ -5004,14 +5013,14 @@ RuboCop::Cop::Lint::UnderscorePrefixedVariableName::MSG = T.let(T.unsafe(nil), S
 class RuboCop::Cop::Lint::UnifiedInteger < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def fixnum_or_bignum_const(node = T.unsafe(nil)); end
+  def fixnum_or_bignum_const(param0 = T.unsafe(nil)); end
   def on_const(node); end
 end
 
 RuboCop::Cop::Lint::UnifiedInteger::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::UnreachableCode < ::RuboCop::Cop::Base
-  def flow_command?(node = T.unsafe(nil)); end
+  def flow_command?(param0 = T.unsafe(nil)); end
   def on_begin(node); end
   def on_kwbegin(node); end
 
@@ -5025,7 +5034,7 @@ end
 RuboCop::Cop::Lint::UnreachableCode::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::UnreachableLoop < ::RuboCop::Cop::Base
-  def break_command?(node = T.unsafe(nil)); end
+  def break_command?(param0 = T.unsafe(nil)); end
   def on_block(node); end
   def on_for(node); end
   def on_until(node); end
@@ -5039,7 +5048,6 @@ class RuboCop::Cop::Lint::UnreachableLoop < ::RuboCop::Cop::Base
   def check(node); end
   def check_case(node); end
   def check_if(node); end
-  def left_siblings_of(node); end
   def loop_method?(node); end
   def preceded_by_continue_statement?(break_statement); end
   def statements(node); end
@@ -5088,7 +5096,7 @@ class RuboCop::Cop::Lint::UnusedMethodArgument < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::Lint::UnusedArgument)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def not_implemented?(node = T.unsafe(nil)); end
+  def not_implemented?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -5104,7 +5112,7 @@ end
 
 class RuboCop::Cop::Lint::UriEscapeUnescape < ::RuboCop::Cop::Base
   def on_send(node); end
-  def uri_escape_unescape?(node = T.unsafe(nil)); end
+  def uri_escape_unescape?(param0 = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Lint::UriEscapeUnescape::ALTERNATE_METHODS_OF_URI_ESCAPE = T.let(T.unsafe(nil), Array)
@@ -5133,14 +5141,14 @@ class RuboCop::Cop::Lint::UselessAccessModifier < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def class_or_instance_eval?(node = T.unsafe(nil)); end
-  def class_or_module_or_struct_new_call?(node = T.unsafe(nil)); end
-  def dynamic_method_definition?(node = T.unsafe(nil)); end
+  def class_or_instance_eval?(param0 = T.unsafe(nil)); end
+  def class_or_module_or_struct_new_call?(param0 = T.unsafe(nil)); end
+  def dynamic_method_definition?(param0 = T.unsafe(nil)); end
   def on_block(node); end
   def on_class(node); end
   def on_module(node); end
   def on_sclass(node); end
-  def static_method_definition?(node = T.unsafe(nil)); end
+  def static_method_definition?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -5202,7 +5210,7 @@ RuboCop::Cop::Lint::UselessMethodDefinition::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Lint::UselessSetterCall < ::RuboCop::Cop::Base
   def on_def(node); end
   def on_defs(node); end
-  def setter_call_to_local_variable?(node = T.unsafe(nil)); end
+  def setter_call_to_local_variable?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -5230,16 +5238,17 @@ class RuboCop::Cop::Lint::UselessTimes < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def block_arg(node = T.unsafe(nil)); end
-  def block_reassigns_arg?(node0, param1); end
+  def block_arg(param0 = T.unsafe(nil)); end
+  def block_reassigns_arg?(param0, param1); end
   def on_send(node); end
-  def times_call?(node = T.unsafe(nil)); end
+  def times_call?(param0 = T.unsafe(nil)); end
 
   private
 
   def autocorrect_block(corrector, node); end
   def autocorrect_block_pass(corrector, node, proc_name); end
   def fix_indentation(source, range); end
+  def never_process?(count, node); end
   def own_line?(node); end
   def remove_node(corrector, node); end
 end
@@ -5330,7 +5339,7 @@ module RuboCop::Cop::MethodComplexity
   include(::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def define_method?(node = T.unsafe(nil)); end
+  def define_method?(param0 = T.unsafe(nil)); end
   def on_block(node); end
   def on_def(node); end
   def on_defs(node); end
@@ -5401,7 +5410,7 @@ class RuboCop::Cop::Metrics::ClassLength < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableMax)
   include(::RuboCop::Cop::CodeLength)
 
-  def class_definition?(node = T.unsafe(nil)); end
+  def class_definition?(param0 = T.unsafe(nil)); end
   def on_casgn(node); end
   def on_class(node); end
 
@@ -5448,7 +5457,7 @@ class RuboCop::Cop::Metrics::ModuleLength < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableMax)
   include(::RuboCop::Cop::CodeLength)
 
-  def module_definition?(node = T.unsafe(nil)); end
+  def module_definition?(param0 = T.unsafe(nil)); end
   def on_casgn(node); end
   def on_module(node); end
 
@@ -5460,7 +5469,7 @@ end
 class RuboCop::Cop::Metrics::ParameterLists < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableMax)
 
-  def argument_to_lambda_or_proc?(node = T.unsafe(nil)); end
+  def argument_to_lambda_or_proc?(param0 = T.unsafe(nil)); end
   def on_args(node); end
 
   private
@@ -5501,9 +5510,9 @@ class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator
 
   def argument?(node); end
   def assignment?(node); end
-  def assignment_doubled_in_ast?(node); end
   def branch?(node); end
   def capturing_variable?(name); end
+  def compound_assignment(node); end
   def condition?(node); end
   def simple_assignment?(node); end
 
@@ -5514,7 +5523,6 @@ end
 
 class RuboCop::Cop::Metrics::Utils::CodeLengthCalculator
   include(::RuboCop::PathUtil)
-  include(::RuboCop::TokensUtil)
   include(::RuboCop::Cop::Util)
   extend(::RuboCop::AST::NodePattern::Macros)
 
@@ -5732,7 +5740,7 @@ RuboCop::Cop::Naming::AsciiIdentifiers::IDENTIFIER_MSG = T.let(T.unsafe(nil), St
 
 class RuboCop::Cop::Naming::BinaryOperatorParameterName < ::RuboCop::Cop::Base
   def on_def(node); end
-  def op_method_candidate?(node = T.unsafe(nil)); end
+  def op_method_candidate?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -5759,8 +5767,8 @@ end
 RuboCop::Cop::Naming::ClassAndModuleCamelCase::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Naming::ConstantName < ::RuboCop::Cop::Base
-  def class_or_struct_return_method?(node = T.unsafe(nil)); end
-  def literal_receiver?(node = T.unsafe(nil)); end
+  def class_or_struct_return_method?(param0 = T.unsafe(nil)); end
+  def literal_receiver?(param0 = T.unsafe(nil)); end
   def on_casgn(node); end
 
   private
@@ -5843,7 +5851,7 @@ RuboCop::Cop::Naming::HeredocDelimiterNaming::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Naming::MemoizedInstanceVariableName < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def memoized?(node = T.unsafe(nil)); end
+  def memoized?(param0 = T.unsafe(nil)); end
   def on_def(node); end
   def on_defs(node); end
 
@@ -5877,8 +5885,8 @@ class RuboCop::Cop::Naming::MethodName < ::RuboCop::Cop::Base
   def on_def(node); end
   def on_defs(node); end
   def on_send(node); end
-  def str_name(node = T.unsafe(nil)); end
-  def sym_name(node = T.unsafe(nil)); end
+  def str_name(param0 = T.unsafe(nil)); end
+  def sym_name(param0 = T.unsafe(nil)); end
 
   private
 
@@ -5899,7 +5907,7 @@ end
 class RuboCop::Cop::Naming::PredicateName < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::AllowedMethods)
 
-  def dynamic_method_define(node = T.unsafe(nil)); end
+  def dynamic_method_define(param0 = T.unsafe(nil)); end
   def on_def(node); end
   def on_defs(node); end
   def on_send(node); end
@@ -5973,8 +5981,8 @@ RuboCop::Cop::Naming::VariableNumber::MSG = T.let(T.unsafe(nil), String)
 module RuboCop::Cop::NegativeConditional
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def empty_condition?(node = T.unsafe(nil)); end
-  def single_negative?(node = T.unsafe(nil)); end
+  def empty_condition?(param0 = T.unsafe(nil)); end
+  def single_negative?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -6107,7 +6115,6 @@ end
 
 class RuboCop::Cop::PercentLiteralCorrector
   include(::RuboCop::PathUtil)
-  include(::RuboCop::TokensUtil)
   include(::RuboCop::Cop::Util)
 
   def initialize(config, preferred_delimiters); end
@@ -6206,7 +6213,7 @@ RuboCop::Cop::RangeHelp::BYTE_ORDER_MARK = T.let(T.unsafe(nil), Integer)
 module RuboCop::Cop::RationalLiteral
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def rational_literal?(node = T.unsafe(nil)); end
+  def rational_literal?(param0 = T.unsafe(nil)); end
 end
 
 module RuboCop::Cop::RegexpLiteralHelp
@@ -6277,9 +6284,9 @@ end
 module RuboCop::Cop::SafeAssignment
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def empty_condition?(node = T.unsafe(nil)); end
-  def safe_assignment?(node = T.unsafe(nil)); end
-  def setter_method?(node = T.unsafe(nil)); end
+  def empty_condition?(param0 = T.unsafe(nil)); end
+  def safe_assignment?(param0 = T.unsafe(nil)); end
+  def setter_method?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -6290,7 +6297,7 @@ module RuboCop::Cop::Security
 end
 
 class RuboCop::Cop::Security::Eval < ::RuboCop::Cop::Base
-  def eval?(node = T.unsafe(nil)); end
+  def eval?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -6301,7 +6308,7 @@ RuboCop::Cop::Security::Eval::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
 class RuboCop::Cop::Security::JSONLoad < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def json_load(node = T.unsafe(nil)); end
+  def json_load(param0 = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -6310,7 +6317,7 @@ RuboCop::Cop::Security::JSONLoad::MSG = T.let(T.unsafe(nil), String)
 RuboCop::Cop::Security::JSONLoad::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
 
 class RuboCop::Cop::Security::MarshalLoad < ::RuboCop::Cop::Base
-  def marshal_load(node = T.unsafe(nil)); end
+  def marshal_load(param0 = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -6320,7 +6327,7 @@ RuboCop::Cop::Security::MarshalLoad::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Arr
 
 class RuboCop::Cop::Security::Open < ::RuboCop::Cop::Base
   def on_send(node); end
-  def open?(node = T.unsafe(nil)); end
+  def open?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -6340,7 +6347,7 @@ class RuboCop::Cop::Security::YAMLLoad < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def yaml_load(node = T.unsafe(nil)); end
+  def yaml_load(param0 = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Security::YAMLLoad::MSG = T.let(T.unsafe(nil), String)
@@ -6417,6 +6424,7 @@ module RuboCop::Cop::StatementModifier
 
   private
 
+  def comment_disables_cop?(comment); end
   def first_line_comment(node); end
   def length_in_modifier_form(node); end
   def max_line_length; end
@@ -6440,7 +6448,6 @@ end
 
 class RuboCop::Cop::StringLiteralCorrector
   extend(::RuboCop::PathUtil)
-  extend(::RuboCop::TokensUtil)
   extend(::RuboCop::Cop::Util)
 
   class << self
@@ -6463,7 +6470,7 @@ end
 class RuboCop::Cop::Style::AccessModifierDeclarations < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def access_modifier_with_symbol?(node = T.unsafe(nil)); end
+  def access_modifier_with_symbol?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -6518,7 +6525,7 @@ class RuboCop::Cop::Style::Alias < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def identifier(node = T.unsafe(nil)); end
+  def identifier(param0 = T.unsafe(nil)); end
   def on_alias(node); end
   def on_send(node); end
 
@@ -6586,10 +6593,10 @@ end
 class RuboCop::Cop::Style::ArrayCoercion < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def array_splat?(node = T.unsafe(nil)); end
+  def array_splat?(param0 = T.unsafe(nil)); end
   def on_array(node); end
   def on_if(node); end
-  def unless_array?(node = T.unsafe(nil)); end
+  def unless_array?(param0 = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Style::ArrayCoercion::CHECK_MSG = T.let(T.unsafe(nil), String)
@@ -6599,7 +6606,7 @@ RuboCop::Cop::Style::ArrayCoercion::SPLAT_MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Style::ArrayJoin < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def join_candidate?(node = T.unsafe(nil)); end
+  def join_candidate?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -6626,7 +6633,7 @@ class RuboCop::Cop::Style::Attr < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def class_eval?(node = T.unsafe(nil)); end
+  def class_eval?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -6783,7 +6790,7 @@ end
 class RuboCop::Cop::Style::CaseEquality < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def case_equality?(node = T.unsafe(nil)); end
+  def case_equality?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -6946,7 +6953,7 @@ RuboCop::Cop::Style::CollectionMethods::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Style::ColonMethodCall < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def java_type_node?(node = T.unsafe(nil)); end
+  def java_type_node?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   class << self
@@ -6971,7 +6978,6 @@ class RuboCop::Cop::Style::CombinableLoops < ::RuboCop::Cop::Base
   private
 
   def collection_looping_method?(node); end
-  def left_sibling_of(node); end
   def same_collection_looping?(node, sibling); end
 end
 
@@ -7026,13 +7032,12 @@ 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::Cop
-  def investigate(processed_source); end
+class RuboCop::Cop::Style::CommentedKeyword < ::RuboCop::Cop::Base
+  def on_new_investigation; end
 
   private
 
   def line(comment); end
-  def message(comment); end
   def offensive?(comment); end
 end
 
@@ -7051,8 +7056,8 @@ class RuboCop::Cop::Style::ConditionalAssignment < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def assignment_type?(node = T.unsafe(nil)); end
-  def candidate_condition?(node = T.unsafe(nil)); end
+  def assignment_type?(param0 = T.unsafe(nil)); end
+  def candidate_condition?(param0 = T.unsafe(nil)); end
   def on_and_asgn(node); end
   def on_case(node); end
   def on_casgn(node); end
@@ -7149,7 +7154,7 @@ end
 
 class RuboCop::Cop::Style::ConstantVisibility < ::RuboCop::Cop::Base
   def on_casgn(node); end
-  def visibility_declaration_for?(node = T.unsafe(nil), param1); end
+  def visibility_declaration_for?(param0 = T.unsafe(nil), param1); end
 
   private
 
@@ -7184,13 +7189,16 @@ RuboCop::Cop::Style::Copyright::AUTOCORRECT_EMPTY_WARNING = T.let(T.unsafe(nil),
 RuboCop::Cop::Style::Copyright::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::DateTime < ::RuboCop::Cop::Base
-  def date_time?(node = T.unsafe(nil)); end
-  def historic_date?(node = T.unsafe(nil)); end
+  extend(::RuboCop::Cop::AutoCorrector)
+
+  def date_time?(param0 = T.unsafe(nil)); end
+  def historic_date?(param0 = T.unsafe(nil)); end
   def on_send(node); end
-  def to_datetime?(node = T.unsafe(nil)); end
+  def to_datetime?(param0 = T.unsafe(nil)); end
 
   private
 
+  def autocorrect(corrector, node); end
   def disallow_coercion?; end
 end
 
@@ -7210,7 +7218,7 @@ RuboCop::Cop::Style::DefWithParentheses::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Style::Dir < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def dir_replacement?(node = T.unsafe(nil)); end
+  def dir_replacement?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -7238,11 +7246,11 @@ class RuboCop::Cop::Style::Documentation < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::Style::AnnotationComment)
   include(::RuboCop::Cop::DocumentationComment)
 
-  def constant_definition?(node = T.unsafe(nil)); end
-  def constant_visibility_declaration?(node = T.unsafe(nil)); end
+  def constant_definition?(param0 = T.unsafe(nil)); end
+  def constant_visibility_declaration?(param0 = T.unsafe(nil)); end
   def on_class(node); end
   def on_module(node); end
-  def outer_module(node0); end
+  def outer_module(param0); end
 
   private
 
@@ -7262,7 +7270,7 @@ class RuboCop::Cop::Style::DocumentationMethod < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::DocumentationComment)
   include(::RuboCop::Cop::DefNode)
 
-  def module_function_node?(node = T.unsafe(nil)); end
+  def module_function_node?(param0 = T.unsafe(nil)); end
   def on_def(node); end
   def on_defs(node); end
 
@@ -7285,7 +7293,7 @@ RuboCop::Cop::Style::DoubleCopDisableDirective::MSG = T.let(T.unsafe(nil), Strin
 class RuboCop::Cop::Style::DoubleNegation < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def double_negative?(node = T.unsafe(nil)); end
+  def double_negative?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -7302,7 +7310,7 @@ RuboCop::Cop::Style::DoubleNegation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Arr
 class RuboCop::Cop::Style::EachForSimpleLoop < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def offending_each_range(node = T.unsafe(nil)); end
+  def offending_each_range(param0 = T.unsafe(nil)); end
   def on_block(node); end
 end
 
@@ -7312,7 +7320,7 @@ class RuboCop::Cop::Style::EachWithObject < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def each_with_object_candidate?(node = T.unsafe(nil)); end
+  def each_with_object_candidate?(param0 = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -7404,12 +7412,12 @@ class RuboCop::Cop::Style::EmptyLiteral < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def array_node(node = T.unsafe(nil)); end
-  def array_with_block(node = T.unsafe(nil)); end
-  def hash_node(node = T.unsafe(nil)); end
-  def hash_with_block(node = T.unsafe(nil)); end
+  def array_node(param0 = T.unsafe(nil)); end
+  def array_with_block(param0 = T.unsafe(nil)); end
+  def hash_node(param0 = T.unsafe(nil)); end
+  def hash_with_block(param0 = T.unsafe(nil)); end
   def on_send(node); end
-  def str_node(node = T.unsafe(nil)); end
+  def str_node(param0 = T.unsafe(nil)); end
 
   private
 
@@ -7483,8 +7491,8 @@ end
 RuboCop::Cop::Style::EndBlock::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::EvalWithLocation < ::RuboCop::Cop::Base
-  def eval_without_location?(node = T.unsafe(nil)); end
-  def line_with_offset?(node = T.unsafe(nil), param1, param2); end
+  def eval_without_location?(param0 = T.unsafe(nil)); end
+  def line_with_offset?(param0 = T.unsafe(nil), param1, param2); end
   def on_send(node); end
 
   private
@@ -7508,7 +7516,7 @@ RuboCop::Cop::Style::EvalWithLocation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), A
 class RuboCop::Cop::Style::EvenOdd < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def even_odd_candidate?(node = T.unsafe(nil)); end
+  def even_odd_candidate?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -7524,10 +7532,10 @@ class RuboCop::Cop::Style::ExpandPathArguments < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def file_expand_path(node = T.unsafe(nil)); end
+  def file_expand_path(param0 = T.unsafe(nil)); end
   def on_send(node); end
-  def pathname_new_parent_expand_path(node = T.unsafe(nil)); end
-  def pathname_parent_expand_path(node = T.unsafe(nil)); end
+  def pathname_new_parent_expand_path(param0 = T.unsafe(nil)); end
+  def pathname_parent_expand_path(param0 = T.unsafe(nil)); end
 
   private
 
@@ -7557,7 +7565,7 @@ class RuboCop::Cop::Style::ExplicitBlockArgument < ::RuboCop::Cop::Base
   def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
 
   def on_yield(node); end
-  def yielding_block?(node = T.unsafe(nil)); end
+  def yielding_block?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -7587,11 +7595,11 @@ RuboCop::Cop::Style::ExponentialNotation::MESSAGES = T.let(T.unsafe(nil), Hash)
 class RuboCop::Cop::Style::FloatDivision < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def any_coerce?(node = T.unsafe(nil)); end
-  def both_coerce?(node = T.unsafe(nil)); end
-  def left_coerce?(node = T.unsafe(nil)); end
+  def any_coerce?(param0 = T.unsafe(nil)); end
+  def both_coerce?(param0 = T.unsafe(nil)); end
+  def left_coerce?(param0 = T.unsafe(nil)); end
   def on_send(node); end
-  def right_coerce?(node = T.unsafe(nil)); end
+  def right_coerce?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -7626,9 +7634,9 @@ class RuboCop::Cop::Style::FormatString < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def formatter(node = T.unsafe(nil)); end
+  def formatter(param0 = T.unsafe(nil)); end
   def on_send(node); end
-  def variable_argument?(node = T.unsafe(nil)); end
+  def variable_argument?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -7646,7 +7654,7 @@ RuboCop::Cop::Style::FormatString::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array
 class RuboCop::Cop::Style::FormatStringToken < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def format_string_in_typical_context?(node = T.unsafe(nil)); end
+  def format_string_in_typical_context?(param0 = T.unsafe(nil)); end
   def on_str(node); end
 
   private
@@ -7699,7 +7707,7 @@ RuboCop::Cop::Style::FrozenStringLiteralComment::SHEBANG = T.let(T.unsafe(nil),
 class RuboCop::Cop::Style::GlobalStdStream < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def const_to_gvar_assignment?(node = T.unsafe(nil), param1); end
+  def const_to_gvar_assignment?(param0 = T.unsafe(nil), param1); end
   def on_const(node); end
 
   private
@@ -7757,14 +7765,16 @@ class RuboCop::Cop::Style::HashAsLastArrayItem < ::RuboCop::Cop::Base
   def braces_style?; end
   def check_braces(node); end
   def check_no_braces(node); end
-  def last_array_item?(node); end
+  def containing_array(hash_node); end
+  def explicit_array?(array); end
+  def last_array_item?(array, node); end
 end
 
 class RuboCop::Cop::Style::HashEachMethods < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::Lint::UnusedArgument)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def kv_each(node = T.unsafe(nil)); end
+  def kv_each(param0 = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -7781,7 +7791,7 @@ end
 RuboCop::Cop::Style::HashEachMethods::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::HashLikeCase < ::RuboCop::Cop::Base
-  def hash_like_case?(node = T.unsafe(nil)); end
+  def hash_like_case?(param0 = T.unsafe(nil)); end
   def on_case(node); end
 
   private
@@ -7829,10 +7839,10 @@ class RuboCop::Cop::Style::HashTransformKeys < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::TargetRubyVersion)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def on_bad_each_with_object(node = T.unsafe(nil)); end
-  def on_bad_hash_brackets_map(node = T.unsafe(nil)); end
-  def on_bad_map_to_h(node = T.unsafe(nil)); end
-  def on_bad_to_h(node = T.unsafe(nil)); end
+  def on_bad_each_with_object(param0 = T.unsafe(nil)); end
+  def on_bad_hash_brackets_map(param0 = T.unsafe(nil)); end
+  def on_bad_map_to_h(param0 = T.unsafe(nil)); end
+  def on_bad_to_h(param0 = T.unsafe(nil)); end
 
   private
 
@@ -7844,10 +7854,10 @@ class RuboCop::Cop::Style::HashTransformValues < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::HashTransformMethod)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def on_bad_each_with_object(node = T.unsafe(nil)); end
-  def on_bad_hash_brackets_map(node = T.unsafe(nil)); end
-  def on_bad_map_to_h(node = T.unsafe(nil)); end
-  def on_bad_to_h(node = T.unsafe(nil)); end
+  def on_bad_each_with_object(param0 = T.unsafe(nil)); end
+  def on_bad_hash_brackets_map(param0 = T.unsafe(nil)); end
+  def on_bad_map_to_h(param0 = T.unsafe(nil)); end
+  def on_bad_to_h(param0 = T.unsafe(nil)); end
 
   private
 
@@ -7909,7 +7919,6 @@ class RuboCop::Cop::Style::IfUnlessModifier < ::RuboCop::Cop::Base
 
   def another_statement_on_same_line?(node); end
   def autocorrect(corrector, node); end
-  def first_line_comment(node); end
   def ignored_patterns; end
   def line_length_enabled_at_line?(line); end
   def named_capture_in_condition?(node); end
@@ -7951,7 +7960,7 @@ end
 RuboCop::Cop::Style::IfWithSemicolon::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::ImplicitRuntimeError < ::RuboCop::Cop::Base
-  def implicit_runtime_error_raise_or_fail(node = T.unsafe(nil)); end
+  def implicit_runtime_error_raise_or_fail(param0 = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -8000,8 +8009,8 @@ class RuboCop::Cop::Style::InverseMethods < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def inverse_block?(node = T.unsafe(nil)); end
-  def inverse_candidate?(node = T.unsafe(nil)); end
+  def inverse_block?(param0 = T.unsafe(nil)); end
+  def inverse_candidate?(param0 = T.unsafe(nil)); end
   def on_block(node); end
   def on_send(node); end
 
@@ -8064,7 +8073,6 @@ class RuboCop::Cop::Style::KeywordParametersOrder < ::RuboCop::Cop::Base
   private
 
   def remove_kwargs(kwarg_nodes, corrector); end
-  def right_siblings_of(node); end
 end
 
 RuboCop::Cop::Style::KeywordParametersOrder::MSG = T.let(T.unsafe(nil), String)
@@ -8265,7 +8273,7 @@ RuboCop::Cop::Style::MethodDefParentheses::MSG_PRESENT = T.let(T.unsafe(nil), St
 class RuboCop::Cop::Style::MinMax < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def min_max_candidate(node = T.unsafe(nil)); end
+  def min_max_candidate(param0 = T.unsafe(nil)); end
   def on_array(node); end
   def on_return(node); end
 
@@ -8341,15 +8349,9 @@ RuboCop::Cop::Style::MixinGrouping::MIXIN_METHODS = T.let(T.unsafe(nil), Array)
 RuboCop::Cop::Style::MixinGrouping::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::MixinUsage < ::RuboCop::Cop::Base
-  def include_statement(node = T.unsafe(nil)); end
+  def in_top_level_scope?(param0 = T.unsafe(nil)); end
+  def include_statement(param0 = T.unsafe(nil)); end
   def on_send(node); end
-  def wrapped_macro_scope?(node = T.unsafe(nil)); end
-
-  private
-
-  def accepted_include?(node); end
-  def ascend_macro_scope?(ancestor); end
-  def belongs_to_class_or_module?(node); end
 end
 
 RuboCop::Cop::Style::MixinUsage::MSG = T.let(T.unsafe(nil), String)
@@ -8360,10 +8362,10 @@ class RuboCop::Cop::Style::ModuleFunction < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def extend_self_node?(node = T.unsafe(nil)); end
-  def module_function_node?(node = T.unsafe(nil)); end
+  def extend_self_node?(param0 = T.unsafe(nil)); end
+  def module_function_node?(param0 = T.unsafe(nil)); end
   def on_module(node); end
-  def private_directive?(node = T.unsafe(nil)); end
+  def private_directive?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -8380,7 +8382,7 @@ RuboCop::Cop::Style::ModuleFunction::FORBIDDEN_MSG = T.let(T.unsafe(nil), String
 
 RuboCop::Cop::Style::ModuleFunction::MODULE_FUNCTION_MSG = T.let(T.unsafe(nil), String)
 
-class RuboCop::Cop::Style::MultilineBlockChain < ::RuboCop::Cop::Cop
+class RuboCop::Cop::Style::MultilineBlockChain < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
 
   def on_block(node); end
@@ -8484,8 +8486,8 @@ RuboCop::Cop::Style::MultilineWhenThen::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::MultipleComparison < ::RuboCop::Cop::Base
   def on_or(node); end
-  def simple_comparison?(node = T.unsafe(nil)); end
-  def simple_double_comparison?(node = T.unsafe(nil)); end
+  def simple_comparison?(param0 = T.unsafe(nil)); end
+  def simple_double_comparison?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -8507,9 +8509,9 @@ class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base
 
   def on_casgn(node); end
   def on_or_asgn(node); end
-  def operation_produces_immutable_object?(node = T.unsafe(nil)); end
-  def range_enclosed_in_parentheses?(node = T.unsafe(nil)); end
-  def splat_value(node = T.unsafe(nil)); end
+  def operation_produces_immutable_object?(param0 = T.unsafe(nil)); end
+  def range_enclosed_in_parentheses?(param0 = T.unsafe(nil)); end
+  def splat_value(param0 = T.unsafe(nil)); end
 
   private
 
@@ -8660,8 +8662,8 @@ class RuboCop::Cop::Style::NilComparison < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def nil_check?(node = T.unsafe(nil)); end
-  def nil_comparison?(node = T.unsafe(nil)); end
+  def nil_check?(param0 = T.unsafe(nil)); end
+  def nil_comparison?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -8680,13 +8682,13 @@ RuboCop::Cop::Style::NilComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Arra
 class RuboCop::Cop::Style::NonNilCheck < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def nil_check?(node = T.unsafe(nil)); end
-  def not_and_nil_check?(node = T.unsafe(nil)); end
-  def not_equal_to_nil?(node = T.unsafe(nil)); end
+  def nil_check?(param0 = T.unsafe(nil)); end
+  def not_and_nil_check?(param0 = T.unsafe(nil)); end
+  def not_equal_to_nil?(param0 = T.unsafe(nil)); end
   def on_def(node); end
   def on_defs(node); end
   def on_send(node); end
-  def unless_check?(node = T.unsafe(nil)); end
+  def unless_check?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -8790,10 +8792,10 @@ class RuboCop::Cop::Style::NumericPredicate < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::IgnoredMethods)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def comparison(node = T.unsafe(nil)); end
-  def inverted_comparison(node = T.unsafe(nil)); end
+  def comparison(param0 = T.unsafe(nil)); end
+  def inverted_comparison(param0 = T.unsafe(nil)); end
   def on_send(node); end
-  def predicate(node = T.unsafe(nil)); end
+  def predicate(param0 = T.unsafe(nil)); end
 
   private
 
@@ -8837,7 +8839,7 @@ RuboCop::Cop::Style::OneLineConditional::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::OptionHash < ::RuboCop::Cop::Base
   def on_args(node); end
-  def option_hash(node = T.unsafe(nil)); end
+  def option_hash(param0 = T.unsafe(nil)); end
 
   private
 
@@ -8860,6 +8862,8 @@ end
 RuboCop::Cop::Style::OptionalArguments::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::OptionalBooleanParameter < ::RuboCop::Cop::Base
+  include(::RuboCop::Cop::AllowedMethods)
+
   def on_def(node); end
   def on_defs(node); end
 end
@@ -8876,8 +8880,8 @@ class RuboCop::Cop::Style::OrAssignment < ::RuboCop::Cop::Base
   def on_if(node); end
   def on_ivasgn(node); end
   def on_lvasgn(node); end
-  def ternary_assignment?(node = T.unsafe(nil)); end
-  def unless_assignment?(node = T.unsafe(nil)); end
+  def ternary_assignment?(param0 = T.unsafe(nil)); end
+  def unless_assignment?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -8892,7 +8896,7 @@ class RuboCop::Cop::Style::ParallelAssignment < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RescueNode)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def implicit_self_getter?(node = T.unsafe(nil)); end
+  def implicit_self_getter?(param0 = T.unsafe(nil)); end
   def on_masgn(node); end
 
   private
@@ -8916,11 +8920,11 @@ class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter
 
   def accesses?(rhs, lhs); end
   def dependency?(lhs, rhs); end
-  def matching_calls(node0, param1, param2); end
+  def matching_calls(param0, param1, param2); end
   def tsort_each_child(assignment); end
   def tsort_each_node(&block); end
-  def uses_var?(node0, param1); end
-  def var_name(node = T.unsafe(nil)); end
+  def uses_var?(param0, param1); end
+  def var_name(param0 = T.unsafe(nil)); end
 end
 
 class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector
@@ -8970,7 +8974,7 @@ class RuboCop::Cop::Style::ParenthesesAroundCondition < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::Parentheses)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def control_op_condition(node = T.unsafe(nil)); end
+  def control_op_condition(param0 = T.unsafe(nil)); end
   def on_if(node); end
   def on_until(node); end
   def on_while(node); end
@@ -9061,7 +9065,7 @@ class RuboCop::Cop::Style::Proc < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_block(node); end
-  def proc_new?(node = T.unsafe(nil)); end
+  def proc_new?(param0 = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Style::Proc::MSG = T.let(T.unsafe(nil), String)
@@ -9091,12 +9095,12 @@ RuboCop::Cop::Style::RaiseArgs::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
 class RuboCop::Cop::Style::RandomWithOffset < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def integer_op_rand?(node = T.unsafe(nil)); end
+  def integer_op_rand?(param0 = T.unsafe(nil)); end
   def on_send(node); end
-  def rand_modified?(node = T.unsafe(nil)); end
-  def rand_op_integer?(node = T.unsafe(nil)); end
-  def random_call(node = T.unsafe(nil)); end
-  def to_int(node = T.unsafe(nil)); end
+  def rand_modified?(param0 = T.unsafe(nil)); end
+  def rand_op_integer?(param0 = T.unsafe(nil)); end
+  def random_call(param0 = T.unsafe(nil)); end
+  def to_int(param0 = T.unsafe(nil)); end
 
   private
 
@@ -9117,7 +9121,7 @@ class RuboCop::Cop::Style::RedundantAssignment < ::RuboCop::Cop::Base
 
   def on_def(node); end
   def on_defs(node); end
-  def redundant_assignment?(node = T.unsafe(nil)); end
+  def redundant_assignment?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -9127,8 +9131,6 @@ class RuboCop::Cop::Style::RedundantAssignment < ::RuboCop::Cop::Base
   def check_ensure_node(node); end
   def check_if_node(node); end
   def check_rescue_node(node); end
-  def right_sibling_of(node); end
-  def siblings_of(node); end
 end
 
 RuboCop::Cop::Style::RedundantAssignment::MSG = T.let(T.unsafe(nil), String)
@@ -9185,13 +9187,13 @@ RuboCop::Cop::Style::RedundantCondition::MSG = T.let(T.unsafe(nil), String)
 
 RuboCop::Cop::Style::RedundantCondition::REDUNDANT_CONDITION = T.let(T.unsafe(nil), String)
 
-class RuboCop::Cop::Style::RedundantConditional < ::RuboCop::Cop::Cop
+class RuboCop::Cop::Style::RedundantConditional < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::Alignment)
+  extend(::RuboCop::Cop::AutoCorrector)
 
-  def autocorrect(node); end
   def on_if(node); end
-  def redundant_condition?(node = T.unsafe(nil)); end
-  def redundant_condition_inverted?(node = T.unsafe(nil)); end
+  def redundant_condition?(param0 = T.unsafe(nil)); end
+  def redundant_condition_inverted?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -9210,8 +9212,8 @@ RuboCop::Cop::Style::RedundantConditional::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Style::RedundantException < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def compact?(node = T.unsafe(nil)); end
-  def exploded?(node = T.unsafe(nil)); end
+  def compact?(param0 = T.unsafe(nil)); end
+  def exploded?(param0 = T.unsafe(nil)); end
   def fix_compact(node); end
   def fix_exploded(node); end
   def on_send(node); end
@@ -9229,8 +9231,8 @@ class RuboCop::Cop::Style::RedundantFetchBlock < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_block(node); end
-  def rails_cache?(node = T.unsafe(nil)); end
-  def redundant_fetch_block_candidate?(node = T.unsafe(nil)); end
+  def rails_cache?(param0 = T.unsafe(nil)); end
+  def redundant_fetch_block_candidate?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -9250,7 +9252,7 @@ class RuboCop::Cop::Style::RedundantFileExtensionInRequire < ::RuboCop::Cop::Bas
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def require_call?(node = T.unsafe(nil)); end
+  def require_call?(param0 = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Style::RedundantFileExtensionInRequire::MSG = T.let(T.unsafe(nil), String)
@@ -9262,7 +9264,7 @@ class RuboCop::Cop::Style::RedundantFreeze < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def operation_produces_immutable_object?(node = T.unsafe(nil)); end
+  def operation_produces_immutable_object?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -9304,15 +9306,15 @@ class RuboCop::Cop::Style::RedundantParentheses < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::Parentheses)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def arg_in_call_with_block?(node = T.unsafe(nil)); end
-  def first_send_argument?(node = T.unsafe(nil)); end
-  def first_super_argument?(node = T.unsafe(nil)); end
-  def first_yield_argument?(node = T.unsafe(nil)); end
-  def method_node_and_args(node = T.unsafe(nil)); end
+  def arg_in_call_with_block?(param0 = T.unsafe(nil)); end
+  def first_send_argument?(param0 = T.unsafe(nil)); end
+  def first_super_argument?(param0 = T.unsafe(nil)); end
+  def first_yield_argument?(param0 = T.unsafe(nil)); end
+  def method_node_and_args(param0 = T.unsafe(nil)); end
   def on_begin(node); end
-  def range_end?(node = T.unsafe(nil)); end
-  def rescue?(node = T.unsafe(nil)); end
-  def square_brackets?(node = T.unsafe(nil)); end
+  def range_end?(param0 = T.unsafe(nil)); end
+  def rescue?(param0 = T.unsafe(nil)); end
+  def square_brackets?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -9345,8 +9347,9 @@ class RuboCop::Cop::Style::RedundantParentheses < ::RuboCop::Cop::Base
   def suspect_unary?(node); end
 end
 
-class RuboCop::Cop::Style::RedundantPercentQ < ::RuboCop::Cop::Cop
-  def autocorrect(node); end
+class RuboCop::Cop::Style::RedundantPercentQ < ::RuboCop::Cop::Base
+  extend(::RuboCop::Cop::AutoCorrector)
+
   def on_dstr(node); end
   def on_str(node); end
 
@@ -9422,10 +9425,10 @@ RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_WITHIN_CHAR_CLASS_METACHAR_E
 
 RuboCop::Cop::Style::RedundantRegexpEscape::MSG_REDUNDANT_ESCAPE = T.let(T.unsafe(nil), String)
 
-class RuboCop::Cop::Style::RedundantReturn < ::RuboCop::Cop::Cop
+class RuboCop::Cop::Style::RedundantReturn < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
+  extend(::RuboCop::Cop::AutoCorrector)
 
-  def autocorrect(node); end
   def on_def(node); end
   def on_defs(node); end
 
@@ -9439,6 +9442,7 @@ class RuboCop::Cop::Style::RedundantReturn < ::RuboCop::Cop::Cop
   def check_case_node(node); end
   def check_ensure_node(node); end
   def check_if_node(node); end
+  def check_resbody_node(node); end
   def check_rescue_node(node); end
   def check_return_node(node); end
   def correct_with_arguments(return_node, corrector); end
@@ -9451,10 +9455,11 @@ RuboCop::Cop::Style::RedundantReturn::MSG = T.let(T.unsafe(nil), String)
 
 RuboCop::Cop::Style::RedundantReturn::MULTI_RETURN_MSG = T.let(T.unsafe(nil), String)
 
-class RuboCop::Cop::Style::RedundantSelf < ::RuboCop::Cop::Cop
+class RuboCop::Cop::Style::RedundantSelf < ::RuboCop::Cop::Base
+  extend(::RuboCop::Cop::AutoCorrector)
+
   def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
 
-  def autocorrect(node); end
   def on_and_asgn(node); end
   def on_args(node); end
   def on_block(node); end
@@ -9496,8 +9501,8 @@ class RuboCop::Cop::Style::RedundantSelfAssignment < ::RuboCop::Cop::Base
   def on_ivasgn(node); end
   def on_lvasgn(node); end
   def on_send(node); end
-  def redundant_nonself_assignment?(node = T.unsafe(nil), param1, param2); end
-  def redundant_self_assignment?(node = T.unsafe(nil), param1); end
+  def redundant_nonself_assignment?(param0 = T.unsafe(nil), param1, param2); end
+  def redundant_self_assignment?(param0 = T.unsafe(nil), param1); end
 
   private
 
@@ -9512,18 +9517,19 @@ RuboCop::Cop::Style::RedundantSelfAssignment::METHODS_RETURNING_SELF = T.let(T.u
 
 RuboCop::Cop::Style::RedundantSelfAssignment::MSG = T.let(T.unsafe(nil), String)
 
-class RuboCop::Cop::Style::RedundantSort < ::RuboCop::Cop::Cop
+class RuboCop::Cop::Style::RedundantSort < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
+  extend(::RuboCop::Cop::AutoCorrector)
 
-  def autocorrect(node); end
   def on_send(node); end
-  def redundant_sort?(node = T.unsafe(nil)); end
+  def redundant_sort?(param0 = T.unsafe(nil)); end
 
   private
 
   def accessor_start(node); end
   def arg_node(node); end
   def arg_value(node); end
+  def autocorrect(corrector, node, sort_node, sorter, accessor); end
   def base(accessor, arg); end
   def message(node, sorter, accessor); end
   def offense_range(sort_node, ancestor); end
@@ -9535,12 +9541,12 @@ RuboCop::Cop::Style::RedundantSort::MSG = T.let(T.unsafe(nil), String)
 
 RuboCop::Cop::Style::RedundantSort::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
 
-class RuboCop::Cop::Style::RedundantSortBy < ::RuboCop::Cop::Cop
+class RuboCop::Cop::Style::RedundantSortBy < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
+  extend(::RuboCop::Cop::AutoCorrector)
 
-  def autocorrect(node); end
   def on_block(node); end
-  def redundant_sort_by(node = T.unsafe(nil)); end
+  def redundant_sort_by(param0 = T.unsafe(nil)); end
 
   private
 
@@ -9597,15 +9603,20 @@ end
 
 RuboCop::Cop::Style::RescueModifier::MSG = T.let(T.unsafe(nil), String)
 
-class RuboCop::Cop::Style::RescueStandardError < ::RuboCop::Cop::Cop
+class RuboCop::Cop::Style::RescueStandardError < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RescueNode)
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   include(::RuboCop::Cop::RangeHelp)
+  extend(::RuboCop::Cop::AutoCorrector)
 
-  def autocorrect(node); end
   def on_resbody(node); end
-  def rescue_standard_error?(node = T.unsafe(nil)); end
-  def rescue_without_error_class?(node = T.unsafe(nil)); end
+  def rescue_standard_error?(param0 = T.unsafe(nil)); end
+  def rescue_without_error_class?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def offense_for_exlicit_enforced_style(node); end
+  def offense_for_implicit_enforced_style(node, error); end
 end
 
 RuboCop::Cop::Style::RescueStandardError::MSG_EXPLICIT = T.let(T.unsafe(nil), String)
@@ -9616,11 +9627,11 @@ class RuboCop::Cop::Style::ReturnNil < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def chained_send?(node = T.unsafe(nil)); end
-  def define_method?(node = T.unsafe(nil)); end
+  def chained_send?(param0 = T.unsafe(nil)); end
+  def define_method?(param0 = T.unsafe(nil)); end
   def on_return(node); end
-  def return_nil_node?(node = T.unsafe(nil)); end
-  def return_node?(node = T.unsafe(nil)); end
+  def return_nil_node?(param0 = T.unsafe(nil)); end
+  def return_node?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -9640,8 +9651,8 @@ class RuboCop::Cop::Style::SafeNavigation < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def check_node(node); end
-  def modifier_if_safe_navigation_candidate(node = T.unsafe(nil)); end
-  def not_nil_check?(node = T.unsafe(nil)); end
+  def modifier_if_safe_navigation_candidate(param0 = T.unsafe(nil)); end
+  def not_nil_check?(param0 = T.unsafe(nil)); end
   def on_and(node); end
   def on_if(node); end
   def use_var_only_in_unless_modifier?(node, variable); end
@@ -9676,7 +9687,7 @@ class RuboCop::Cop::Style::Sample < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def sample_candidate?(node = T.unsafe(nil)); end
+  def sample_candidate?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -9752,8 +9763,8 @@ class RuboCop::Cop::Style::SignalException < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def custom_fail_methods(node0); end
-  def kernel_call?(node = T.unsafe(nil), param1); end
+  def custom_fail_methods(param0); end
+  def kernel_call?(param0 = T.unsafe(nil), param1); end
   def on_new_investigation; end
   def on_rescue(node); end
   def on_send(node); end
@@ -9779,7 +9790,7 @@ class RuboCop::Cop::Style::SingleArgumentDig < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def single_argument_dig?(node = T.unsafe(nil)); end
+  def single_argument_dig?(param0 = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Style::SingleArgumentDig::MSG = T.let(T.unsafe(nil), String)
@@ -9825,7 +9836,7 @@ class RuboCop::Cop::Style::SlicingWithRange < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::TargetRubyVersion)
 
   def on_send(node); end
-  def range_till_minus_one?(node = T.unsafe(nil)); end
+  def range_till_minus_one?(param0 = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Style::SlicingWithRange::MSG = T.let(T.unsafe(nil), String)
@@ -9899,7 +9910,7 @@ class RuboCop::Cop::Style::StderrPuts < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def stderr_puts?(node = T.unsafe(nil)); end
+  def stderr_puts?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -9916,7 +9927,7 @@ class RuboCop::Cop::Style::StringConcatenation < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def string_concatenation?(node = T.unsafe(nil)); end
+  def string_concatenation?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -9936,8 +9947,8 @@ class RuboCop::Cop::Style::StringHashKeys < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_pair(node); end
-  def receive_environments_method?(node = T.unsafe(nil)); end
-  def string_hash_key?(node = T.unsafe(nil)); end
+  def receive_environments_method?(param0 = T.unsafe(nil)); end
+  def string_hash_key?(param0 = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Style::StringHashKeys::MSG = T.let(T.unsafe(nil), String)
@@ -9992,7 +10003,7 @@ class RuboCop::Cop::Style::Strip < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def lstrip_rstrip(node = T.unsafe(nil)); end
+  def lstrip_rstrip(param0 = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -10005,7 +10016,7 @@ class RuboCop::Cop::Style::StructInheritance < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_class(node); end
-  def struct_constructor?(node = T.unsafe(nil)); end
+  def struct_constructor?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -10055,8 +10066,8 @@ class RuboCop::Cop::Style::SymbolProc < ::RuboCop::Cop::Base
 
   def destructuring_block_argument?(argument_node); end
   def on_block(node); end
-  def proc_node?(node = T.unsafe(nil)); end
-  def symbol_proc?(node = T.unsafe(nil)); end
+  def proc_node?(param0 = T.unsafe(nil)); end
+  def symbol_proc?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -10102,7 +10113,7 @@ class RuboCop::Cop::Style::TernaryParentheses < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::SurroundingSpace)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def method_name(node = T.unsafe(nil)); end
+  def method_name(param0 = T.unsafe(nil)); end
   def on_if(node); end
   def only_closing_parenthesis_is_last_line?(condition); end
 
@@ -10133,7 +10144,7 @@ RuboCop::Cop::Style::TernaryParentheses::MSG_COMPLEX = T.let(T.unsafe(nil), Stri
 
 RuboCop::Cop::Style::TernaryParentheses::NON_COMPLEX_TYPES = T.let(T.unsafe(nil), Array)
 
-RuboCop::Cop::Style::TernaryParentheses::VARIABLE_TYPES = T.let(T.unsafe(nil), Array)
+RuboCop::Cop::Style::TernaryParentheses::VARIABLE_TYPES = T.let(T.unsafe(nil), Set)
 
 class RuboCop::Cop::Style::TrailingBodyOnClass < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::Alignment)
@@ -10257,7 +10268,7 @@ class RuboCop::Cop::Style::TrivialAccessors < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::AllowedMethods)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def looks_like_trivial_writer?(node = T.unsafe(nil)); end
+  def looks_like_trivial_writer?(param0 = T.unsafe(nil)); end
   def on_def(node); end
   def on_defs(node); end
 
@@ -10303,7 +10314,7 @@ class RuboCop::Cop::Style::UnpackFirst < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def unpack_and_first_element?(node = T.unsafe(nil)); end
+  def unpack_and_first_element?(param0 = T.unsafe(nil)); end
 
   private
 
@@ -10386,7 +10397,7 @@ class RuboCop::Cop::Style::YodaCondition < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def file_constant_equal_program_name?(node = T.unsafe(nil)); end
+  def file_constant_equal_program_name?(param0 = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -10419,12 +10430,12 @@ RuboCop::Cop::Style::YodaCondition::REVERSE_COMPARISON = T.let(T.unsafe(nil), Ha
 class RuboCop::Cop::Style::ZeroLengthPredicate < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def non_polymorphic_collection?(node = T.unsafe(nil)); end
-  def nonzero_length_predicate(node = T.unsafe(nil)); end
+  def non_polymorphic_collection?(param0 = T.unsafe(nil)); end
+  def nonzero_length_predicate(param0 = T.unsafe(nil)); end
   def on_send(node); end
-  def other_receiver(node = T.unsafe(nil)); end
-  def zero_length_predicate(node = T.unsafe(nil)); end
-  def zero_length_receiver(node = T.unsafe(nil)); end
+  def other_receiver(param0 = T.unsafe(nil)); end
+  def zero_length_predicate(param0 = T.unsafe(nil)); end
+  def zero_length_receiver(param0 = T.unsafe(nil)); end
 
   private
 
@@ -10593,7 +10604,6 @@ end
 
 module RuboCop::Cop::Util
   include(::RuboCop::PathUtil)
-  include(::RuboCop::TokensUtil)
 
 
   private
@@ -11045,20 +11055,26 @@ RuboCop::Cop::VariableForce::ZERO_ARITY_SUPER_TYPE = T.let(T.unsafe(nil), Symbol
 module RuboCop::Cop::VisibilityHelp
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def visibility_block?(node = T.unsafe(nil)); end
+  def visibility_block?(param0 = T.unsafe(nil)); end
 
   private
 
   def find_visibility_end(node); end
   def find_visibility_start(node); end
-  def left_siblings_of(node); end
   def node_visibility(node); end
-  def right_siblings_of(node); end
-  def siblings_of(node); end
 end
 
 RuboCop::Cop::VisibilityHelp::VISIBILITY_SCOPES = T.let(T.unsafe(nil), Array)
 
+class RuboCop::DirectiveComment
+  def initialize(comment); end
+
+  def comment; end
+  def cops; end
+  def match?(cop_names); end
+  def range; end
+end
+
 class RuboCop::Error < ::StandardError
 end
 
@@ -11169,6 +11185,8 @@ class RuboCop::Formatter::DisabledConfigFormatter < ::RuboCop::Formatter::BaseFo
   def output_offending_files(output_buffer, cfg, cop_name); end
   def output_offenses; end
   def set_max(cfg, cop_name); end
+  def show_offense_counts?; end
+  def show_timestamp?; end
   def timestamp; end
 
   class << self
@@ -11344,9 +11362,9 @@ RuboCop::Formatter::PacmanFormatter::FALLBACK_TERMINAL_WIDTH = T.let(T.unsafe(ni
 
 RuboCop::Formatter::PacmanFormatter::GHOST = T.let(T.unsafe(nil), String)
 
-RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::Presenter)
+RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::NullPresenter)
 
-RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::Presenter)
+RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::NullPresenter)
 
 class RuboCop::Formatter::ProgressFormatter < ::RuboCop::Formatter::ClangStyleFormatter
   include(::RuboCop::Formatter::TextUtil)
@@ -11775,6 +11793,8 @@ class RuboCop::TargetFinder
   def order; end
 end
 
+RuboCop::TargetFinder::HIDDEN_PATH_SUBSTRING = T.let(T.unsafe(nil), String)
+
 class RuboCop::TargetRuby
   def initialize(config); end
 
@@ -11836,30 +11856,12 @@ end
 
 RuboCop::Token = RuboCop::AST::Token
 
-module RuboCop::TokensUtil
-
-  private
-
-  def fast_index_of_first_token(node); end
-  def fast_index_of_last_token(node); end
-  def fast_tokens(node); end
-  def index_of_first_token(node); end
-  def index_of_last_token(node); end
-  def sorted_tokens?(tokens); end
-  def tokens(node); end
-
-  class << self
-    def index_of_first_token(node); end
-    def index_of_last_token(node); end
-    def tokens(node); end
-  end
-end
-
 class RuboCop::ValidationError < ::RuboCop::Error
 end
 
 module RuboCop::Version
   class << self
+    def document_version; end
     def version(debug: T.unsafe(nil)); end
   end
 end
diff --git a/Library/Homebrew/sorbet/rbi/gems/strscan@1.0.3.rbi b/Library/Homebrew/sorbet/rbi/gems/strscan@1.0.3.rbi
new file mode 100644
index 0000000000000000000000000000000000000000..b9728211d8907bde74f3b35397f2b6a1656447a2
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/strscan@1.0.3.rbi
@@ -0,0 +1,8 @@
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `strscan` gem.
+# Please instead update this file by running `tapioca sync`.
+
+# typed: true
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
index 514dca6811793f8d06ed17d3ad0ead5c3b6c8981..890eefd524c5f43536952204a6a5122f9b6d5fbb 100644
--- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
+++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
@@ -14200,893 +14200,7 @@ end
 
 ParseError = Racc::ParseError
 
-Parser::CurrentRuby = Parser::Ruby26
-
-class Parser::Ruby24
-  def _reduce_10(val, _values, result); end
-
-  def _reduce_100(val, _values, result); end
-
-  def _reduce_101(val, _values, result); end
-
-  def _reduce_102(val, _values, result); end
-
-  def _reduce_103(val, _values, result); end
-
-  def _reduce_104(val, _values, result); end
-
-  def _reduce_105(val, _values, result); end
-
-  def _reduce_106(val, _values, result); end
-
-  def _reduce_107(val, _values, result); end
-
-  def _reduce_108(val, _values, result); end
-
-  def _reduce_11(val, _values, result); end
-
-  def _reduce_110(val, _values, result); end
-
-  def _reduce_111(val, _values, result); end
-
-  def _reduce_112(val, _values, result); end
-
-  def _reduce_118(val, _values, result); end
-
-  def _reduce_12(val, _values, result); end
-
-  def _reduce_122(val, _values, result); end
-
-  def _reduce_123(val, _values, result); end
-
-  def _reduce_124(val, _values, result); end
-
-  def _reduce_13(val, _values, result); end
-
-  def _reduce_14(val, _values, result); end
-
-  def _reduce_16(val, _values, result); end
-
-  def _reduce_17(val, _values, result); end
-
-  def _reduce_18(val, _values, result); end
-
-  def _reduce_19(val, _values, result); end
-
-  def _reduce_196(val, _values, result); end
-
-  def _reduce_197(val, _values, result); end
-
-  def _reduce_198(val, _values, result); end
-
-  def _reduce_199(val, _values, result); end
-
-  def _reduce_2(val, _values, result); end
-
-  def _reduce_20(val, _values, result); end
-
-  def _reduce_200(val, _values, result); end
-
-  def _reduce_201(val, _values, result); end
-
-  def _reduce_202(val, _values, result); end
-
-  def _reduce_203(val, _values, result); end
-
-  def _reduce_204(val, _values, result); end
-
-  def _reduce_205(val, _values, result); end
-
-  def _reduce_206(val, _values, result); end
-
-  def _reduce_207(val, _values, result); end
-
-  def _reduce_208(val, _values, result); end
-
-  def _reduce_209(val, _values, result); end
-
-  def _reduce_21(val, _values, result); end
-
-  def _reduce_210(val, _values, result); end
-
-  def _reduce_211(val, _values, result); end
-
-  def _reduce_212(val, _values, result); end
-
-  def _reduce_213(val, _values, result); end
-
-  def _reduce_214(val, _values, result); end
-
-  def _reduce_215(val, _values, result); end
-
-  def _reduce_216(val, _values, result); end
-
-  def _reduce_217(val, _values, result); end
-
-  def _reduce_218(val, _values, result); end
-
-  def _reduce_219(val, _values, result); end
-
-  def _reduce_22(val, _values, result); end
-
-  def _reduce_220(val, _values, result); end
-
-  def _reduce_221(val, _values, result); end
-
-  def _reduce_222(val, _values, result); end
-
-  def _reduce_223(val, _values, result); end
-
-  def _reduce_224(val, _values, result); end
-
-  def _reduce_225(val, _values, result); end
-
-  def _reduce_226(val, _values, result); end
-
-  def _reduce_227(val, _values, result); end
-
-  def _reduce_228(val, _values, result); end
-
-  def _reduce_229(val, _values, result); end
-
-  def _reduce_23(val, _values, result); end
-
-  def _reduce_230(val, _values, result); end
-
-  def _reduce_231(val, _values, result); end
-
-  def _reduce_232(val, _values, result); end
-
-  def _reduce_233(val, _values, result); end
-
-  def _reduce_234(val, _values, result); end
-
-  def _reduce_235(val, _values, result); end
-
-  def _reduce_236(val, _values, result); end
-
-  def _reduce_24(val, _values, result); end
-
-  def _reduce_241(val, _values, result); end
-
-  def _reduce_242(val, _values, result); end
-
-  def _reduce_244(val, _values, result); end
-
-  def _reduce_245(val, _values, result); end
-
-  def _reduce_246(val, _values, result); end
-
-  def _reduce_248(val, _values, result); end
-
-  def _reduce_25(val, _values, result); end
-
-  def _reduce_251(val, _values, result); end
-
-  def _reduce_252(val, _values, result); end
-
-  def _reduce_253(val, _values, result); end
-
-  def _reduce_254(val, _values, result); end
-
-  def _reduce_255(val, _values, result); end
-
-  def _reduce_256(val, _values, result); end
-
-  def _reduce_257(val, _values, result); end
-
-  def _reduce_258(val, _values, result); end
-
-  def _reduce_259(val, _values, result); end
-
-  def _reduce_26(val, _values, result); end
-
-  def _reduce_260(val, _values, result); end
-
-  def _reduce_261(val, _values, result); end
-
-  def _reduce_262(val, _values, result); end
-
-  def _reduce_263(val, _values, result); end
-
-  def _reduce_264(val, _values, result); end
-
-  def _reduce_265(val, _values, result); end
-
-  def _reduce_266(val, _values, result); end
-
-  def _reduce_267(val, _values, result); end
-
-  def _reduce_269(val, _values, result); end
-
-  def _reduce_27(val, _values, result); end
-
-  def _reduce_270(val, _values, result); end
-
-  def _reduce_271(val, _values, result); end
-
-  def _reduce_28(val, _values, result); end
-
-  def _reduce_282(val, _values, result); end
-
-  def _reduce_283(val, _values, result); end
-
-  def _reduce_284(val, _values, result); end
-
-  def _reduce_285(val, _values, result); end
-
-  def _reduce_286(val, _values, result); end
-
-  def _reduce_287(val, _values, result); end
-
-  def _reduce_288(val, _values, result); end
-
-  def _reduce_289(val, _values, result); end
-
-  def _reduce_290(val, _values, result); end
-
-  def _reduce_291(val, _values, result); end
-
-  def _reduce_292(val, _values, result); end
-
-  def _reduce_293(val, _values, result); end
-
-  def _reduce_294(val, _values, result); end
-
-  def _reduce_295(val, _values, result); end
-
-  def _reduce_296(val, _values, result); end
-
-  def _reduce_297(val, _values, result); end
-
-  def _reduce_298(val, _values, result); end
-
-  def _reduce_299(val, _values, result); end
-
-  def _reduce_3(val, _values, result); end
-
-  def _reduce_30(val, _values, result); end
-
-  def _reduce_300(val, _values, result); end
-
-  def _reduce_301(val, _values, result); end
-
-  def _reduce_303(val, _values, result); end
-
-  def _reduce_304(val, _values, result); end
-
-  def _reduce_305(val, _values, result); end
-
-  def _reduce_306(val, _values, result); end
-
-  def _reduce_307(val, _values, result); end
-
-  def _reduce_308(val, _values, result); end
-
-  def _reduce_309(val, _values, result); end
-
-  def _reduce_31(val, _values, result); end
-
-  def _reduce_310(val, _values, result); end
-
-  def _reduce_311(val, _values, result); end
-
-  def _reduce_312(val, _values, result); end
-
-  def _reduce_313(val, _values, result); end
-
-  def _reduce_314(val, _values, result); end
-
-  def _reduce_315(val, _values, result); end
-
-  def _reduce_316(val, _values, result); end
-
-  def _reduce_317(val, _values, result); end
-
-  def _reduce_318(val, _values, result); end
-
-  def _reduce_319(val, _values, result); end
-
-  def _reduce_32(val, _values, result); end
-
-  def _reduce_320(val, _values, result); end
-
-  def _reduce_321(val, _values, result); end
-
-  def _reduce_322(val, _values, result); end
-
-  def _reduce_323(val, _values, result); end
-
-  def _reduce_324(val, _values, result); end
-
-  def _reduce_325(val, _values, result); end
-
-  def _reduce_326(val, _values, result); end
-
-  def _reduce_327(val, _values, result); end
-
-  def _reduce_328(val, _values, result); end
-
-  def _reduce_329(val, _values, result); end
-
-  def _reduce_330(val, _values, result); end
-
-  def _reduce_331(val, _values, result); end
-
-  def _reduce_332(val, _values, result); end
-
-  def _reduce_333(val, _values, result); end
-
-  def _reduce_337(val, _values, result); end
-
-  def _reduce_34(val, _values, result); end
-
-  def _reduce_341(val, _values, result); end
-
-  def _reduce_343(val, _values, result); end
-
-  def _reduce_346(val, _values, result); end
-
-  def _reduce_347(val, _values, result); end
-
-  def _reduce_348(val, _values, result); end
-
-  def _reduce_349(val, _values, result); end
-
-  def _reduce_35(val, _values, result); end
-
-  def _reduce_351(val, _values, result); end
-
-  def _reduce_352(val, _values, result); end
-
-  def _reduce_353(val, _values, result); end
-
-  def _reduce_354(val, _values, result); end
-
-  def _reduce_355(val, _values, result); end
-
-  def _reduce_356(val, _values, result); end
-
-  def _reduce_357(val, _values, result); end
-
-  def _reduce_358(val, _values, result); end
-
-  def _reduce_359(val, _values, result); end
-
-  def _reduce_36(val, _values, result); end
-
-  def _reduce_360(val, _values, result); end
-
-  def _reduce_361(val, _values, result); end
-
-  def _reduce_362(val, _values, result); end
-
-  def _reduce_363(val, _values, result); end
-
-  def _reduce_364(val, _values, result); end
-
-  def _reduce_365(val, _values, result); end
-
-  def _reduce_366(val, _values, result); end
-
-  def _reduce_367(val, _values, result); end
-
-  def _reduce_368(val, _values, result); end
-
-  def _reduce_369(val, _values, result); end
-
-  def _reduce_37(val, _values, result); end
-
-  def _reduce_371(val, _values, result); end
-
-  def _reduce_372(val, _values, result); end
-
-  def _reduce_373(val, _values, result); end
-
-  def _reduce_374(val, _values, result); end
-
-  def _reduce_375(val, _values, result); end
-
-  def _reduce_376(val, _values, result); end
-
-  def _reduce_377(val, _values, result); end
-
-  def _reduce_378(val, _values, result); end
-
-  def _reduce_38(val, _values, result); end
-
-  def _reduce_380(val, _values, result); end
-
-  def _reduce_381(val, _values, result); end
-
-  def _reduce_382(val, _values, result); end
-
-  def _reduce_383(val, _values, result); end
-
-  def _reduce_384(val, _values, result); end
-
-  def _reduce_385(val, _values, result); end
-
-  def _reduce_386(val, _values, result); end
-
-  def _reduce_387(val, _values, result); end
-
-  def _reduce_388(val, _values, result); end
-
-  def _reduce_389(val, _values, result); end
-
-  def _reduce_39(val, _values, result); end
-
-  def _reduce_391(val, _values, result); end
-
-  def _reduce_392(val, _values, result); end
-
-  def _reduce_393(val, _values, result); end
-
-  def _reduce_394(val, _values, result); end
-
-  def _reduce_395(val, _values, result); end
-
-  def _reduce_396(val, _values, result); end
-
-  def _reduce_397(val, _values, result); end
-
-  def _reduce_398(val, _values, result); end
-
-  def _reduce_399(val, _values, result); end
-
-  def _reduce_4(val, _values, result); end
-
-  def _reduce_40(val, _values, result); end
-
-  def _reduce_400(val, _values, result); end
-
-  def _reduce_401(val, _values, result); end
-
-  def _reduce_402(val, _values, result); end
-
-  def _reduce_403(val, _values, result); end
-
-  def _reduce_404(val, _values, result); end
-
-  def _reduce_405(val, _values, result); end
-
-  def _reduce_406(val, _values, result); end
-
-  def _reduce_407(val, _values, result); end
-
-  def _reduce_408(val, _values, result); end
-
-  def _reduce_409(val, _values, result); end
-
-  def _reduce_41(val, _values, result); end
-
-  def _reduce_410(val, _values, result); end
-
-  def _reduce_411(val, _values, result); end
-
-  def _reduce_412(val, _values, result); end
-
-  def _reduce_413(val, _values, result); end
-
-  def _reduce_414(val, _values, result); end
-
-  def _reduce_415(val, _values, result); end
-
-  def _reduce_416(val, _values, result); end
-
-  def _reduce_417(val, _values, result); end
-
-  def _reduce_418(val, _values, result); end
-
-  def _reduce_419(val, _values, result); end
-
-  def _reduce_420(val, _values, result); end
-
-  def _reduce_421(val, _values, result); end
-
-  def _reduce_422(val, _values, result); end
-
-  def _reduce_423(val, _values, result); end
-
-  def _reduce_424(val, _values, result); end
-
-  def _reduce_425(val, _values, result); end
-
-  def _reduce_427(val, _values, result); end
-
-  def _reduce_428(val, _values, result); end
-
-  def _reduce_429(val, _values, result); end
-
-  def _reduce_43(val, _values, result); end
-
-  def _reduce_432(val, _values, result); end
-
-  def _reduce_434(val, _values, result); end
-
-  def _reduce_439(val, _values, result); end
-
-  def _reduce_440(val, _values, result); end
-
-  def _reduce_441(val, _values, result); end
-
-  def _reduce_442(val, _values, result); end
-
-  def _reduce_443(val, _values, result); end
-
-  def _reduce_444(val, _values, result); end
-
-  def _reduce_445(val, _values, result); end
-
-  def _reduce_446(val, _values, result); end
-
-  def _reduce_447(val, _values, result); end
-
-  def _reduce_448(val, _values, result); end
-
-  def _reduce_449(val, _values, result); end
-
-  def _reduce_450(val, _values, result); end
-
-  def _reduce_451(val, _values, result); end
-
-  def _reduce_452(val, _values, result); end
-
-  def _reduce_453(val, _values, result); end
-
-  def _reduce_454(val, _values, result); end
-
-  def _reduce_455(val, _values, result); end
-
-  def _reduce_456(val, _values, result); end
-
-  def _reduce_457(val, _values, result); end
-
-  def _reduce_458(val, _values, result); end
-
-  def _reduce_459(val, _values, result); end
-
-  def _reduce_46(val, _values, result); end
-
-  def _reduce_460(val, _values, result); end
-
-  def _reduce_461(val, _values, result); end
-
-  def _reduce_462(val, _values, result); end
-
-  def _reduce_463(val, _values, result); end
-
-  def _reduce_464(val, _values, result); end
-
-  def _reduce_465(val, _values, result); end
-
-  def _reduce_466(val, _values, result); end
-
-  def _reduce_467(val, _values, result); end
-
-  def _reduce_468(val, _values, result); end
-
-  def _reduce_469(val, _values, result); end
-
-  def _reduce_47(val, _values, result); end
-
-  def _reduce_470(val, _values, result); end
-
-  def _reduce_471(val, _values, result); end
-
-  def _reduce_472(val, _values, result); end
-
-  def _reduce_473(val, _values, result); end
-
-  def _reduce_475(val, _values, result); end
-
-  def _reduce_476(val, _values, result); end
-
-  def _reduce_477(val, _values, result); end
-
-  def _reduce_478(val, _values, result); end
-
-  def _reduce_479(val, _values, result); end
-
-  def _reduce_48(val, _values, result); end
-
-  def _reduce_480(val, _values, result); end
-
-  def _reduce_481(val, _values, result); end
-
-  def _reduce_482(val, _values, result); end
-
-  def _reduce_483(val, _values, result); end
-
-  def _reduce_484(val, _values, result); end
-
-  def _reduce_485(val, _values, result); end
-
-  def _reduce_486(val, _values, result); end
-
-  def _reduce_487(val, _values, result); end
-
-  def _reduce_488(val, _values, result); end
-
-  def _reduce_489(val, _values, result); end
-
-  def _reduce_49(val, _values, result); end
-
-  def _reduce_490(val, _values, result); end
-
-  def _reduce_491(val, _values, result); end
-
-  def _reduce_492(val, _values, result); end
-
-  def _reduce_493(val, _values, result); end
-
-  def _reduce_494(val, _values, result); end
-
-  def _reduce_495(val, _values, result); end
-
-  def _reduce_496(val, _values, result); end
-
-  def _reduce_497(val, _values, result); end
-
-  def _reduce_498(val, _values, result); end
-
-  def _reduce_499(val, _values, result); end
-
-  def _reduce_5(val, _values, result); end
-
-  def _reduce_500(val, _values, result); end
-
-  def _reduce_501(val, _values, result); end
-
-  def _reduce_502(val, _values, result); end
-
-  def _reduce_503(val, _values, result); end
-
-  def _reduce_504(val, _values, result); end
-
-  def _reduce_505(val, _values, result); end
-
-  def _reduce_506(val, _values, result); end
-
-  def _reduce_507(val, _values, result); end
-
-  def _reduce_508(val, _values, result); end
-
-  def _reduce_509(val, _values, result); end
-
-  def _reduce_510(val, _values, result); end
-
-  def _reduce_511(val, _values, result); end
-
-  def _reduce_512(val, _values, result); end
-
-  def _reduce_513(val, _values, result); end
-
-  def _reduce_514(val, _values, result); end
-
-  def _reduce_515(val, _values, result); end
-
-  def _reduce_516(val, _values, result); end
-
-  def _reduce_517(val, _values, result); end
-
-  def _reduce_518(val, _values, result); end
-
-  def _reduce_519(val, _values, result); end
-
-  def _reduce_520(val, _values, result); end
-
-  def _reduce_521(val, _values, result); end
-
-  def _reduce_522(val, _values, result); end
-
-  def _reduce_523(val, _values, result); end
-
-  def _reduce_524(val, _values, result); end
-
-  def _reduce_525(val, _values, result); end
-
-  def _reduce_526(val, _values, result); end
-
-  def _reduce_527(val, _values, result); end
-
-  def _reduce_528(val, _values, result); end
-
-  def _reduce_529(val, _values, result); end
-
-  def _reduce_530(val, _values, result); end
-
-  def _reduce_531(val, _values, result); end
-
-  def _reduce_533(val, _values, result); end
-
-  def _reduce_534(val, _values, result); end
-
-  def _reduce_535(val, _values, result); end
-
-  def _reduce_536(val, _values, result); end
-
-  def _reduce_537(val, _values, result); end
-
-  def _reduce_538(val, _values, result); end
-
-  def _reduce_539(val, _values, result); end
-
-  def _reduce_540(val, _values, result); end
-
-  def _reduce_541(val, _values, result); end
-
-  def _reduce_542(val, _values, result); end
-
-  def _reduce_543(val, _values, result); end
-
-  def _reduce_544(val, _values, result); end
-
-  def _reduce_545(val, _values, result); end
-
-  def _reduce_546(val, _values, result); end
-
-  def _reduce_547(val, _values, result); end
-
-  def _reduce_55(val, _values, result); end
-
-  def _reduce_550(val, _values, result); end
-
-  def _reduce_551(val, _values, result); end
-
-  def _reduce_552(val, _values, result); end
-
-  def _reduce_553(val, _values, result); end
-
-  def _reduce_554(val, _values, result); end
-
-  def _reduce_555(val, _values, result); end
-
-  def _reduce_556(val, _values, result); end
-
-  def _reduce_557(val, _values, result); end
-
-  def _reduce_56(val, _values, result); end
-
-  def _reduce_560(val, _values, result); end
-
-  def _reduce_561(val, _values, result); end
-
-  def _reduce_564(val, _values, result); end
-
-  def _reduce_565(val, _values, result); end
-
-  def _reduce_566(val, _values, result); end
-
-  def _reduce_568(val, _values, result); end
-
-  def _reduce_569(val, _values, result); end
-
-  def _reduce_57(val, _values, result); end
-
-  def _reduce_571(val, _values, result); end
-
-  def _reduce_572(val, _values, result); end
-
-  def _reduce_573(val, _values, result); end
-
-  def _reduce_574(val, _values, result); end
-
-  def _reduce_575(val, _values, result); end
-
-  def _reduce_576(val, _values, result); end
-
-  def _reduce_589(val, _values, result); end
-
-  def _reduce_59(val, _values, result); end
-
-  def _reduce_590(val, _values, result); end
-
-  def _reduce_595(val, _values, result); end
-
-  def _reduce_596(val, _values, result); end
-
-  def _reduce_6(val, _values, result); end
-
-  def _reduce_60(val, _values, result); end
-
-  def _reduce_600(val, _values, result); end
-
-  def _reduce_604(val, _values, result); end
-
-  def _reduce_61(val, _values, result); end
-
-  def _reduce_62(val, _values, result); end
-
-  def _reduce_63(val, _values, result); end
-
-  def _reduce_64(val, _values, result); end
-
-  def _reduce_65(val, _values, result); end
-
-  def _reduce_66(val, _values, result); end
-
-  def _reduce_67(val, _values, result); end
-
-  def _reduce_68(val, _values, result); end
-
-  def _reduce_69(val, _values, result); end
-
-  def _reduce_70(val, _values, result); end
-
-  def _reduce_71(val, _values, result); end
-
-  def _reduce_72(val, _values, result); end
-
-  def _reduce_73(val, _values, result); end
-
-  def _reduce_75(val, _values, result); end
-
-  def _reduce_76(val, _values, result); end
-
-  def _reduce_77(val, _values, result); end
-
-  def _reduce_78(val, _values, result); end
-
-  def _reduce_79(val, _values, result); end
-
-  def _reduce_8(val, _values, result); end
-
-  def _reduce_80(val, _values, result); end
-
-  def _reduce_81(val, _values, result); end
-
-  def _reduce_82(val, _values, result); end
-
-  def _reduce_83(val, _values, result); end
-
-  def _reduce_85(val, _values, result); end
-
-  def _reduce_86(val, _values, result); end
-
-  def _reduce_87(val, _values, result); end
-
-  def _reduce_88(val, _values, result); end
-
-  def _reduce_89(val, _values, result); end
-
-  def _reduce_9(val, _values, result); end
-
-  def _reduce_90(val, _values, result); end
-
-  def _reduce_91(val, _values, result); end
-
-  def _reduce_92(val, _values, result); end
-
-  def _reduce_93(val, _values, result); end
-
-  def _reduce_94(val, _values, result); end
-
-  def _reduce_95(val, _values, result); end
-
-  def _reduce_96(val, _values, result); end
-
-  def _reduce_97(val, _values, result); end
-
-  def _reduce_98(val, _values, result); end
-
-  def _reduce_99(val, _values, result); end
-
-  def _reduce_none(val, _values, result); end
-
-  def default_encoding(); end
-
-  def version(); end
-  Racc_arg = ::T.let(nil, ::T.untyped)
-  Racc_debug_parser = ::T.let(nil, ::T.untyped)
-  Racc_token_to_s_table = ::T.let(nil, ::T.untyped)
-end
-
 class Parser::Ruby24
-end
-
-class Parser::Ruby26
   def _reduce_10(val, _values, result); end
 
   def _reduce_100(val, _values, result); end
@@ -15107,35 +14221,29 @@ class Parser::Ruby26
 
   def _reduce_108(val, _values, result); end
 
-  def _reduce_109(val, _values, result); end
-
   def _reduce_11(val, _values, result); end
 
   def _reduce_110(val, _values, result); end
 
   def _reduce_111(val, _values, result); end
 
-  def _reduce_113(val, _values, result); end
-
-  def _reduce_114(val, _values, result); end
+  def _reduce_112(val, _values, result); end
 
-  def _reduce_115(val, _values, result); end
+  def _reduce_118(val, _values, result); end
 
   def _reduce_12(val, _values, result); end
 
-  def _reduce_121(val, _values, result); end
-
-  def _reduce_125(val, _values, result); end
+  def _reduce_122(val, _values, result); end
 
-  def _reduce_126(val, _values, result); end
+  def _reduce_123(val, _values, result); end
 
-  def _reduce_127(val, _values, result); end
+  def _reduce_124(val, _values, result); end
 
   def _reduce_13(val, _values, result); end
 
   def _reduce_14(val, _values, result); end
 
-  def _reduce_15(val, _values, result); end
+  def _reduce_16(val, _values, result); end
 
   def _reduce_17(val, _values, result); end
 
@@ -15143,6 +14251,12 @@ class Parser::Ruby26
 
   def _reduce_19(val, _values, result); end
 
+  def _reduce_196(val, _values, result); end
+
+  def _reduce_197(val, _values, result); end
+
+  def _reduce_198(val, _values, result); end
+
   def _reduce_199(val, _values, result); end
 
   def _reduce_2(val, _values, result); end
@@ -15203,6 +14317,8 @@ class Parser::Ruby26
 
   def _reduce_224(val, _values, result); end
 
+  def _reduce_225(val, _values, result); end
+
   def _reduce_226(val, _values, result); end
 
   def _reduce_227(val, _values, result); end
@@ -15227,21 +14343,23 @@ class Parser::Ruby26
 
   def _reduce_236(val, _values, result); end
 
-  def _reduce_237(val, _values, result); end
+  def _reduce_24(val, _values, result); end
 
-  def _reduce_238(val, _values, result); end
+  def _reduce_241(val, _values, result); end
 
-  def _reduce_24(val, _values, result); end
+  def _reduce_242(val, _values, result); end
 
   def _reduce_244(val, _values, result); end
 
   def _reduce_245(val, _values, result); end
 
-  def _reduce_249(val, _values, result); end
+  def _reduce_246(val, _values, result); end
+
+  def _reduce_248(val, _values, result); end
 
   def _reduce_25(val, _values, result); end
 
-  def _reduce_250(val, _values, result); end
+  def _reduce_251(val, _values, result); end
 
   def _reduce_252(val, _values, result); end
 
@@ -15249,8 +14367,14 @@ class Parser::Ruby26
 
   def _reduce_254(val, _values, result); end
 
+  def _reduce_255(val, _values, result); end
+
   def _reduce_256(val, _values, result); end
 
+  def _reduce_257(val, _values, result); end
+
+  def _reduce_258(val, _values, result); end
+
   def _reduce_259(val, _values, result); end
 
   def _reduce_26(val, _values, result); end
@@ -15271,8 +14395,6 @@ class Parser::Ruby26
 
   def _reduce_267(val, _values, result); end
 
-  def _reduce_268(val, _values, result); end
-
   def _reduce_269(val, _values, result); end
 
   def _reduce_27(val, _values, result); end
@@ -15281,23 +14403,23 @@ class Parser::Ruby26
 
   def _reduce_271(val, _values, result); end
 
-  def _reduce_272(val, _values, result); end
+  def _reduce_28(val, _values, result); end
 
-  def _reduce_273(val, _values, result); end
+  def _reduce_282(val, _values, result); end
 
-  def _reduce_274(val, _values, result); end
+  def _reduce_283(val, _values, result); end
 
-  def _reduce_275(val, _values, result); end
+  def _reduce_284(val, _values, result); end
 
-  def _reduce_277(val, _values, result); end
+  def _reduce_285(val, _values, result); end
 
-  def _reduce_278(val, _values, result); end
+  def _reduce_286(val, _values, result); end
 
-  def _reduce_279(val, _values, result); end
+  def _reduce_287(val, _values, result); end
 
-  def _reduce_28(val, _values, result); end
+  def _reduce_288(val, _values, result); end
 
-  def _reduce_29(val, _values, result); end
+  def _reduce_289(val, _values, result); end
 
   def _reduce_290(val, _values, result); end
 
@@ -15321,12 +14443,12 @@ class Parser::Ruby26
 
   def _reduce_3(val, _values, result); end
 
+  def _reduce_30(val, _values, result); end
+
   def _reduce_300(val, _values, result); end
 
   def _reduce_301(val, _values, result); end
 
-  def _reduce_302(val, _values, result); end
-
   def _reduce_303(val, _values, result); end
 
   def _reduce_304(val, _values, result); end
@@ -15343,6 +14465,8 @@ class Parser::Ruby26
 
   def _reduce_31(val, _values, result); end
 
+  def _reduce_310(val, _values, result); end
+
   def _reduce_311(val, _values, result); end
 
   def _reduce_312(val, _values, result); end
@@ -15383,8 +14507,6 @@ class Parser::Ruby26
 
   def _reduce_329(val, _values, result); end
 
-  def _reduce_33(val, _values, result); end
-
   def _reduce_330(val, _values, result); end
 
   def _reduce_331(val, _values, result); end
@@ -15393,28 +14515,30 @@ class Parser::Ruby26
 
   def _reduce_333(val, _values, result); end
 
-  def _reduce_334(val, _values, result); end
-
-  def _reduce_335(val, _values, result); end
-
   def _reduce_337(val, _values, result); end
 
-  def _reduce_340(val, _values, result); end
+  def _reduce_34(val, _values, result); end
+
+  def _reduce_341(val, _values, result); end
 
-  def _reduce_344(val, _values, result); end
+  def _reduce_343(val, _values, result); end
 
   def _reduce_346(val, _values, result); end
 
+  def _reduce_347(val, _values, result); end
+
+  def _reduce_348(val, _values, result); end
+
   def _reduce_349(val, _values, result); end
 
   def _reduce_35(val, _values, result); end
 
-  def _reduce_350(val, _values, result); end
-
   def _reduce_351(val, _values, result); end
 
   def _reduce_352(val, _values, result); end
 
+  def _reduce_353(val, _values, result); end
+
   def _reduce_354(val, _values, result); end
 
   def _reduce_355(val, _values, result); end
@@ -15451,12 +14575,12 @@ class Parser::Ruby26
 
   def _reduce_37(val, _values, result); end
 
-  def _reduce_370(val, _values, result); end
-
   def _reduce_371(val, _values, result); end
 
   def _reduce_372(val, _values, result); end
 
+  def _reduce_373(val, _values, result); end
+
   def _reduce_374(val, _values, result); end
 
   def _reduce_375(val, _values, result); end
@@ -15467,14 +14591,14 @@ class Parser::Ruby26
 
   def _reduce_378(val, _values, result); end
 
-  def _reduce_379(val, _values, result); end
-
   def _reduce_38(val, _values, result); end
 
   def _reduce_380(val, _values, result); end
 
   def _reduce_381(val, _values, result); end
 
+  def _reduce_382(val, _values, result); end
+
   def _reduce_383(val, _values, result); end
 
   def _reduce_384(val, _values, result); end
@@ -15491,12 +14615,12 @@ class Parser::Ruby26
 
   def _reduce_39(val, _values, result); end
 
-  def _reduce_390(val, _values, result); end
-
   def _reduce_391(val, _values, result); end
 
   def _reduce_392(val, _values, result); end
 
+  def _reduce_393(val, _values, result); end
+
   def _reduce_394(val, _values, result); end
 
   def _reduce_395(val, _values, result); end
@@ -15555,8 +14679,6 @@ class Parser::Ruby26
 
   def _reduce_419(val, _values, result); end
 
-  def _reduce_42(val, _values, result); end
-
   def _reduce_420(val, _values, result); end
 
   def _reduce_421(val, _values, result); end
@@ -15569,23 +14691,23 @@ class Parser::Ruby26
 
   def _reduce_425(val, _values, result); end
 
-  def _reduce_426(val, _values, result); end
-
   def _reduce_427(val, _values, result); end
 
   def _reduce_428(val, _values, result); end
 
-  def _reduce_430(val, _values, result); end
+  def _reduce_429(val, _values, result); end
 
-  def _reduce_431(val, _values, result); end
+  def _reduce_43(val, _values, result); end
 
   def _reduce_432(val, _values, result); end
 
-  def _reduce_435(val, _values, result); end
+  def _reduce_434(val, _values, result); end
+
+  def _reduce_439(val, _values, result); end
 
-  def _reduce_437(val, _values, result); end
+  def _reduce_440(val, _values, result); end
 
-  def _reduce_44(val, _values, result); end
+  def _reduce_441(val, _values, result); end
 
   def _reduce_442(val, _values, result); end
 
@@ -15623,6 +14745,8 @@ class Parser::Ruby26
 
   def _reduce_459(val, _values, result); end
 
+  def _reduce_46(val, _values, result); end
+
   def _reduce_460(val, _values, result); end
 
   def _reduce_461(val, _values, result); end
@@ -15653,12 +14777,12 @@ class Parser::Ruby26
 
   def _reduce_473(val, _values, result); end
 
-  def _reduce_474(val, _values, result); end
-
   def _reduce_475(val, _values, result); end
 
   def _reduce_476(val, _values, result); end
 
+  def _reduce_477(val, _values, result); end
+
   def _reduce_478(val, _values, result); end
 
   def _reduce_479(val, _values, result); end
@@ -15709,8 +14833,6 @@ class Parser::Ruby26
 
   def _reduce_5(val, _values, result); end
 
-  def _reduce_50(val, _values, result); end
-
   def _reduce_500(val, _values, result); end
 
   def _reduce_501(val, _values, result); end
@@ -15771,18 +14893,16 @@ class Parser::Ruby26
 
   def _reduce_529(val, _values, result); end
 
-  def _reduce_53(val, _values, result); end
-
   def _reduce_530(val, _values, result); end
 
   def _reduce_531(val, _values, result); end
 
-  def _reduce_532(val, _values, result); end
-
   def _reduce_533(val, _values, result); end
 
   def _reduce_534(val, _values, result); end
 
+  def _reduce_535(val, _values, result); end
+
   def _reduce_536(val, _values, result); end
 
   def _reduce_537(val, _values, result); end
@@ -15791,8 +14911,6 @@ class Parser::Ruby26
 
   def _reduce_539(val, _values, result); end
 
-  def _reduce_54(val, _values, result); end
-
   def _reduce_540(val, _values, result); end
 
   def _reduce_541(val, _values, result); end
@@ -15809,12 +14927,14 @@ class Parser::Ruby26
 
   def _reduce_547(val, _values, result); end
 
-  def _reduce_548(val, _values, result); end
-
-  def _reduce_549(val, _values, result); end
+  def _reduce_55(val, _values, result); end
 
   def _reduce_550(val, _values, result); end
 
+  def _reduce_551(val, _values, result); end
+
+  def _reduce_552(val, _values, result); end
+
   def _reduce_553(val, _values, result); end
 
   def _reduce_554(val, _values, result); end
@@ -15825,57 +14945,55 @@ class Parser::Ruby26
 
   def _reduce_557(val, _values, result); end
 
-  def _reduce_558(val, _values, result); end
-
-  def _reduce_559(val, _values, result); end
+  def _reduce_56(val, _values, result); end
 
   def _reduce_560(val, _values, result); end
 
-  def _reduce_563(val, _values, result); end
+  def _reduce_561(val, _values, result); end
 
   def _reduce_564(val, _values, result); end
 
-  def _reduce_567(val, _values, result); end
+  def _reduce_565(val, _values, result); end
+
+  def _reduce_566(val, _values, result); end
 
   def _reduce_568(val, _values, result); end
 
   def _reduce_569(val, _values, result); end
 
+  def _reduce_57(val, _values, result); end
+
   def _reduce_571(val, _values, result); end
 
   def _reduce_572(val, _values, result); end
 
+  def _reduce_573(val, _values, result); end
+
   def _reduce_574(val, _values, result); end
 
   def _reduce_575(val, _values, result); end
 
   def _reduce_576(val, _values, result); end
 
-  def _reduce_577(val, _values, result); end
-
-  def _reduce_578(val, _values, result); end
-
-  def _reduce_579(val, _values, result); end
-
-  def _reduce_58(val, _values, result); end
+  def _reduce_589(val, _values, result); end
 
   def _reduce_59(val, _values, result); end
 
-  def _reduce_592(val, _values, result); end
-
-  def _reduce_593(val, _values, result); end
+  def _reduce_590(val, _values, result); end
 
-  def _reduce_598(val, _values, result); end
+  def _reduce_595(val, _values, result); end
 
-  def _reduce_599(val, _values, result); end
+  def _reduce_596(val, _values, result); end
 
   def _reduce_6(val, _values, result); end
 
   def _reduce_60(val, _values, result); end
 
-  def _reduce_603(val, _values, result); end
+  def _reduce_600(val, _values, result); end
+
+  def _reduce_604(val, _values, result); end
 
-  def _reduce_607(val, _values, result); end
+  def _reduce_61(val, _values, result); end
 
   def _reduce_62(val, _values, result); end
 
@@ -15901,12 +15019,12 @@ class Parser::Ruby26
 
   def _reduce_73(val, _values, result); end
 
-  def _reduce_74(val, _values, result); end
-
   def _reduce_75(val, _values, result); end
 
   def _reduce_76(val, _values, result); end
 
+  def _reduce_77(val, _values, result); end
+
   def _reduce_78(val, _values, result); end
 
   def _reduce_79(val, _values, result); end
@@ -15921,12 +15039,12 @@ class Parser::Ruby26
 
   def _reduce_83(val, _values, result); end
 
-  def _reduce_84(val, _values, result); end
-
   def _reduce_85(val, _values, result); end
 
   def _reduce_86(val, _values, result); end
 
+  def _reduce_87(val, _values, result); end
+
   def _reduce_88(val, _values, result); end
 
   def _reduce_89(val, _values, result); end
@@ -15963,7 +15081,11 @@ class Parser::Ruby26
   Racc_token_to_s_table = ::T.let(nil, ::T.untyped)
 end
 
+class Parser::Ruby24
+end
+
 class Parser::Ruby26
+  Racc_debug_parser = ::T.let(nil, ::T.untyped)
 end
 
 class Pathname
@@ -20092,17 +19214,29 @@ module RuboCop::AST::CollectionNode
 end
 
 class RuboCop::AST::Node
-  def block_args(node=T.unsafe(nil)); end
+  def block_args(param0=T.unsafe(nil)); end
+
+  def block_body(param0=T.unsafe(nil)); end
 
-  def block_body(node=T.unsafe(nil)); end
+  def cask_block?(param0=T.unsafe(nil)); end
 
-  def cask_block?(node=T.unsafe(nil)); end
+  def key_node(param0=T.unsafe(nil)); end
 
-  def key_node(node=T.unsafe(nil)); end
+  def method_node(param0=T.unsafe(nil)); end
 
-  def method_node(node=T.unsafe(nil)); end
+  def val_node(param0=T.unsafe(nil)); end
+end
+
+class RuboCop::AST::NodePattern::Parser
+  Racc_debug_parser = ::T.let(nil, ::T.untyped)
+end
 
-  def val_node(node=T.unsafe(nil)); end
+module RuboCop::AST::NodePattern::Sets
+  SET_BUILD_RECOMMENDED_TEST_OPTIONAL = ::T.let(nil, ::T.untyped)
+  SET_DEPENDS_ON_USES_FROM_MACOS = ::T.let(nil, ::T.untyped)
+  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)
 end
 
 class RuboCop::Cask::AST::CaskBlock
@@ -20244,79 +19378,79 @@ class RuboCop::Cop::Cop
 end
 
 class RuboCop::Cop::FormulaAudit::ComponentsOrder
-  def depends_on_node?(node=T.unsafe(nil)); end
+  def depends_on_node?(param0=T.unsafe(nil)); end
 end
 
 class RuboCop::Cop::FormulaAudit::DependencyOrder
-  def build_with_dependency_node(node0); end
+  def build_with_dependency_node(param0); end
 
-  def buildtime_dependency?(node0); end
+  def buildtime_dependency?(param0); end
 
-  def dependency_name_node(node0); end
+  def dependency_name_node(param0); end
 
-  def depends_on_node?(node=T.unsafe(nil)); end
+  def depends_on_node?(param0=T.unsafe(nil)); end
 
-  def negate_normal_dependency?(node0); end
+  def negate_normal_dependency?(param0); end
 
-  def optional_dependency?(node0); end
+  def optional_dependency?(param0); end
 
-  def recommended_dependency?(node0); end
+  def recommended_dependency?(param0); end
 
-  def test_dependency?(node0); end
+  def test_dependency?(param0); end
 
-  def uses_from_macos_node?(node=T.unsafe(nil)); end
+  def uses_from_macos_node?(param0=T.unsafe(nil)); end
 end
 
 class RuboCop::Cop::FormulaAudit::DeprecateDisableDate
-  def date(node0); end
+  def date(param0); end
 end
 
 class RuboCop::Cop::FormulaAudit::DeprecateDisableReason
-  def reason(node0); end
+  def reason(param0); end
 end
 
 class RuboCop::Cop::FormulaAudit::Miscellaneous
-  def conditional_dependencies(node0); end
+  def conditional_dependencies(param0); end
 
-  def destructure_hash(node=T.unsafe(nil)); end
+  def destructure_hash(param0=T.unsafe(nil)); end
 
-  def formula_path_strings(node0, param1); end
+  def formula_path_strings(param0, param1); end
 
-  def hash_dep(node=T.unsafe(nil)); end
+  def hash_dep(param0=T.unsafe(nil)); end
 
-  def languageNodeModule?(node0); end
+  def languageNodeModule?(param0); end
 end
 
 class RuboCop::Cop::FormulaAudit::OptionDeclarations
-  def depends_on_build_with(node0); end
+  def depends_on_build_with(param0); end
 end
 
 class RuboCop::Cop::FormulaAudit::Patches
-  def patch_data?(node0); end
+  def patch_data?(param0); end
 end
 
 class RuboCop::Cop::FormulaAudit::Test
-  def test_calls(node0); end
+  def test_calls(param0); end
 end
 
 class RuboCop::Cop::FormulaAudit::Text
-  def prefix_path(node0); end
+  def prefix_path(param0); end
 end
 
 class RuboCop::Cop::FormulaAuditStrict::Text
-  def interpolated_share_path_starts_with(node0, param1); end
+  def interpolated_share_path_starts_with(param0, param1); end
 
-  def share_path_starts_with(node0, param1); end
+  def share_path_starts_with(param0, param1); end
 end
 
 class RuboCop::Cop::FormulaCop
-  def dependency_name_hash_match?(node0, param1); end
+  def dependency_name_hash_match?(param0, param1); end
 
-  def dependency_type_hash_match?(node0, param1); end
+  def dependency_type_hash_match?(param0, param1); end
 
-  def required_dependency?(node0); end
+  def required_dependency?(param0); end
 
-  def required_dependency_name?(node0, param1); end
+  def required_dependency_name?(param0, param1); end
 end
 
 module RuboCop::RSpec::ExpectOffense