diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock index 7dfe17b2231ce..94bd83e54348d 100644 --- a/Library/Homebrew/Gemfile.lock +++ b/Library/Homebrew/Gemfile.lock @@ -118,7 +118,7 @@ GEM rubocop-rspec (2.20.0) rubocop (~> 1.33) rubocop-capybara (~> 2.17) - rubocop-sorbet (0.7.0) + rubocop-sorbet (0.7.3) rubocop (>= 0.90.0) ruby-macho (4.0.0) ruby-prof (1.4.3) diff --git a/Library/Homebrew/os/mac/xcode.rb b/Library/Homebrew/os/mac/xcode.rb index 3a575f491d344..9402bf5d6e11d 100755 --- a/Library/Homebrew/os/mac/xcode.rb +++ b/Library/Homebrew/os/mac/xcode.rb @@ -95,21 +95,17 @@ def self.without_clt? # directory or nil if Xcode.app is not installed. sig { returns(T.nilable(Pathname)) } def self.prefix - return @prefix if defined?(@prefix) - - @prefix = T.let(@prefix, T.nilable(Pathname)) - @prefix ||= - begin - dir = MacOS.active_developer_dir - - if dir.empty? || dir == CLT::PKG_PATH || !File.directory?(dir) - path = bundle_path - path/"Contents/Developer" if path - else - # Use cleanpath to avoid pathological trailing slash - Pathname.new(dir).cleanpath - end + @prefix ||= begin + dir = MacOS.active_developer_dir + + if dir.empty? || dir == CLT::PKG_PATH || !File.directory?(dir) + path = bundle_path + path/"Contents/Developer" if path + else + # Use cleanpath to avoid pathological trailing slash + Pathname.new(dir).cleanpath end + end end sig { returns(Pathname) } diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-sorbet@0.7.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-sorbet@0.7.3.rbi similarity index 72% rename from Library/Homebrew/sorbet/rbi/gems/rubocop-sorbet@0.7.0.rbi rename to Library/Homebrew/sorbet/rbi/gems/rubocop-sorbet@0.7.3.rbi index 6f215fc07db4f..43d4d74cde05a 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rubocop-sorbet@0.7.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rubocop-sorbet@0.7.3.rbi @@ -10,31 +10,34 @@ RuboCop::Cop::IgnoredMethods = RuboCop::Cop::AllowedMethods RuboCop::Cop::IgnoredPattern = RuboCop::Cop::AllowedPattern module RuboCop::Cop::Sorbet; end -class RuboCop::Cop::Sorbet::AllowIncompatibleOverride < ::RuboCop::Cop::Cop - def allow_incompatible?(param0); end - def allow_incompatible_override?(param0 = T.unsafe(nil)); end - def not_nil?(node); end +class RuboCop::Cop::Sorbet::AllowIncompatibleOverride < ::RuboCop::Cop::Base + def on_block(node); end + def on_numblock(node); end def on_send(node); end + def override?(param0 = T.unsafe(nil)); end def sig?(param0); end + def sig_dot_override?(param0 = T.unsafe(nil)); end end -class RuboCop::Cop::Sorbet::BindingConstantWithoutTypeAlias < ::RuboCop::Cop::Cop - def autocorrect(node); end - def binding_unaliased_type?(param0 = T.unsafe(nil)); end - def dynamic_type_creation_with_block?(param0 = T.unsafe(nil)); end - def generic_parameter_decl_block_call?(param0 = T.unsafe(nil)); end - def generic_parameter_decl_call?(param0 = T.unsafe(nil)); end - def method_needing_aliasing_on_t?(param0); end - def not_dynamic_type_creation_with_block?(node); end - def not_generic_parameter_decl?(node); end - def not_nil?(node); end - def not_t_let?(node); end +RuboCop::Cop::Sorbet::AllowIncompatibleOverride::MSG = T.let(T.unsafe(nil), String) +RuboCop::Cop::Sorbet::AllowIncompatibleOverride::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Sorbet::BindingConstantWithoutTypeAlias < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + def on_casgn(node); end - def t_let?(param0 = T.unsafe(nil)); end - def using_deprecated_type_alias_syntax?(param0 = T.unsafe(nil)); end - def using_type_alias?(param0 = T.unsafe(nil)); end + def requires_type_alias?(param0 = T.unsafe(nil)); end + def type_alias_with_block?(param0 = T.unsafe(nil)); end + def type_alias_without_block(param0 = T.unsafe(nil)); end + + private + + def send_leaf(node); end end +RuboCop::Cop::Sorbet::BindingConstantWithoutTypeAlias::MSG = T.let(T.unsafe(nil), String) +RuboCop::Cop::Sorbet::BindingConstantWithoutTypeAlias::WITHOUT_BLOCK_MSG = T.let(T.unsafe(nil), String) + class RuboCop::Cop::Sorbet::CallbackConditionalsBinding < ::RuboCop::Cop::Cop def autocorrect(node); end def on_send(node); end @@ -133,12 +136,11 @@ class RuboCop::Cop::Sorbet::FalseSigil < ::RuboCop::Cop::Sorbet::HasSigil def minimum_strictness; end end -class RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims < ::RuboCop::Cop::Cop +class RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector - def autocorrect(node); end - def extend_t_helpers?(param0 = T.unsafe(nil)); end - def extend_t_sig?(param0 = T.unsafe(nil)); end + def extend_t_sig_or_helpers?(param0 = T.unsafe(nil)); end def on_send(node); end end @@ -167,27 +169,32 @@ class RuboCop::Cop::Sorbet::ForbidRBIOutsideOfAllowedPaths < ::RuboCop::Cop::Cop def allowed_paths; end end -class RuboCop::Cop::Sorbet::ForbidSuperclassConstLiteral < ::RuboCop::Cop::Cop - def not_lit_const_superclass?(param0 = T.unsafe(nil)); end +class RuboCop::Cop::Sorbet::ForbidSuperclassConstLiteral < ::RuboCop::Cop::Base + def dynamic_superclass?(param0 = T.unsafe(nil)); end def on_class(node); end end RuboCop::Cop::Sorbet::ForbidSuperclassConstLiteral::MSG = T.let(T.unsafe(nil), String) -class RuboCop::Cop::Sorbet::ForbidTUnsafe < ::RuboCop::Cop::Cop +class RuboCop::Cop::Sorbet::ForbidTUnsafe < ::RuboCop::Cop::Base def on_send(node); end def t_unsafe?(param0 = T.unsafe(nil)); end end -class RuboCop::Cop::Sorbet::ForbidTUntyped < ::RuboCop::Cop::Cop +RuboCop::Cop::Sorbet::ForbidTUnsafe::MSG = T.let(T.unsafe(nil), String) +RuboCop::Cop::Sorbet::ForbidTUnsafe::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Sorbet::ForbidTUntyped < ::RuboCop::Cop::Base def on_send(node); end def t_untyped?(param0 = T.unsafe(nil)); end end -class RuboCop::Cop::Sorbet::ForbidUntypedStructProps < ::RuboCop::Cop::Cop +RuboCop::Cop::Sorbet::ForbidTUntyped::MSG = T.let(T.unsafe(nil), String) +RuboCop::Cop::Sorbet::ForbidTUntyped::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Sorbet::ForbidUntypedStructProps < ::RuboCop::Cop::Base def on_class(node); end def subclass_of_t_struct?(param0 = T.unsafe(nil)); end - def t_immutable_struct(param0 = T.unsafe(nil)); end def t_nilable_untyped(param0 = T.unsafe(nil)); end def t_struct(param0 = T.unsafe(nil)); end def t_untyped(param0 = T.unsafe(nil)); end @@ -204,6 +211,17 @@ class RuboCop::Cop::Sorbet::IgnoreSigil < ::RuboCop::Cop::Sorbet::HasSigil def minimum_strictness; end end +class RuboCop::Cop::Sorbet::ImplicitConversionMethod < ::RuboCop::Cop::Base + def on_alias(node); end + def on_def(node); end + def on_defs(node); end + def on_send(node); end +end + +RuboCop::Cop::Sorbet::ImplicitConversionMethod::IMPLICIT_CONVERSION_METHODS = T.let(T.unsafe(nil), Array) +RuboCop::Cop::Sorbet::ImplicitConversionMethod::MSG = T.let(T.unsafe(nil), String) +RuboCop::Cop::Sorbet::ImplicitConversionMethod::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + class RuboCop::Cop::Sorbet::KeywordArgumentOrdering < ::RuboCop::Cop::Sorbet::SignatureCop def on_signature(node); end @@ -220,6 +238,22 @@ module RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour end end +class RuboCop::Cop::Sorbet::ObsoleteStrictMemoization < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::MatchRange + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::Sorbet::TargetSorbetVersion + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::Sorbet::TargetSorbetVersion::ClassMethods + + def legacy_memoization_pattern?(param0 = T.unsafe(nil)); end + def on_begin(node); end + def relevant_file?(file); end +end + +RuboCop::Cop::Sorbet::ObsoleteStrictMemoization::MSG = T.let(T.unsafe(nil), String) + class RuboCop::Cop::Sorbet::OneAncestorPerLine < ::RuboCop::Cop::Cop def abstract?(param0); end def autocorrect(node); end @@ -236,8 +270,9 @@ end RuboCop::Cop::Sorbet::OneAncestorPerLine::MSG = T.let(T.unsafe(nil), String) -class RuboCop::Cop::Sorbet::RedundantExtendTSig < ::RuboCop::Cop::Cop - def autocorrect(node); end +class RuboCop::Cop::Sorbet::RedundantExtendTSig < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + def extend_t_sig?(param0 = T.unsafe(nil)); end def on_send(node); end end @@ -262,21 +297,22 @@ RuboCop::Cop::Sorbet::SignatureBuildOrder::ORDER = T.let(T.unsafe(nil), Hash) class RuboCop::Cop::Sorbet::SignatureCop < ::RuboCop::Cop::Cop def on_block(node); end + def on_numblock(node); end def on_signature(_); end def signature?(param0 = T.unsafe(nil)); end def with_runtime?(param0 = T.unsafe(nil)); end def without_runtime?(param0 = T.unsafe(nil)); end end -class RuboCop::Cop::Sorbet::SingleLineRbiClassModuleDefinitions < ::RuboCop::Cop::Cop - def autocorrect(node); end +class RuboCop::Cop::Sorbet::SingleLineRbiClassModuleDefinitions < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + def on_class(node); end def on_module(node); end - protected + private - def convert_newlines(source); end - def process_node(node); end + def convert_newlines_to_semicolons(source); end end RuboCop::Cop::Sorbet::SingleLineRbiClassModuleDefinitions::MSG = T.let(T.unsafe(nil), String) @@ -289,13 +325,30 @@ class RuboCop::Cop::Sorbet::StrongSigil < ::RuboCop::Cop::Sorbet::HasSigil def minimum_strictness; end end +module RuboCop::Cop::Sorbet::TargetSorbetVersion + mixes_in_class_methods ::RuboCop::Cop::Sorbet::TargetSorbetVersion::ClassMethods + + def enabled_for_sorbet_static_version?; end + def read_sorbet_static_version_from_bundler_lock_file; end + def target_sorbet_static_version_from_bundler_lock_file; end + + class << self + def included(target); end + end +end + +module RuboCop::Cop::Sorbet::TargetSorbetVersion::ClassMethods + def minimum_target_sorbet_static_version(version); end + def support_target_sorbet_static_version?(version); end +end + class RuboCop::Cop::Sorbet::TrueSigil < ::RuboCop::Cop::Sorbet::HasSigil def minimum_strictness; end end -class RuboCop::Cop::Sorbet::TypeAliasName < ::RuboCop::Cop::Cop - def casgn_type_alias?(param0 = T.unsafe(nil)); end +class RuboCop::Cop::Sorbet::TypeAliasName < ::RuboCop::Cop::Base def on_casgn(node); end + def underscored_type_alias?(param0 = T.unsafe(nil)); end end RuboCop::Cop::Sorbet::TypeAliasName::MSG = T.let(T.unsafe(nil), String) @@ -310,12 +363,13 @@ class RuboCop::Cop::Sorbet::ValidSigil < ::RuboCop::Cop::Cop def check_strictness_level(sigil, strictness); end def check_strictness_not_empty(sigil, strictness); end def check_strictness_valid(sigil, strictness); end + def exact_strictness; end def extract_sigil(processed_source); end def extract_strictness(sigil); end def minimum_strictness; end def require_sigil_on_all_files?; end def suggested_strictness; end - def suggested_strictness_level(minimum_strictness, suggested_strictness); end + def suggested_strictness_level; end end RuboCop::Cop::Sorbet::ValidSigil::SIGIL_REGEX = T.let(T.unsafe(nil), Regexp) diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi index 6e1c781be8740..c631f80259cad 100644 --- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi +++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi @@ -7102,6 +7102,7 @@ class RuboCop::AST::NodePattern::Parser end module RuboCop::AST::NodePattern::Sets + SET_ALL_ANY_CLASS_OF_ETC = ::T.let(nil, ::T.untyped) SET_ARM_INTEL = ::T.let(nil, ::T.untyped) SET_BASH_COMPLETION_ZSH_COMPLETION_FISH_COMPLETION = ::T.let(nil, ::T.untyped) SET_BUILD_RECOMMENDED_TEST_OPTIONAL = ::T.let(nil, ::T.untyped) @@ -7111,6 +7112,8 @@ module RuboCop::AST::NodePattern::Sets SET_ON_ARM_ON_INTEL_ON_SONOMA_ETC = ::T.let(nil, ::T.untyped) SET_ON_INTEL_ON_ARM = ::T.let(nil, ::T.untyped) SET_OR_NEWER_OR_OLDER = ::T.let(nil, ::T.untyped) + SET_SIG_HELPERS = ::T.let(nil, ::T.untyped) + SET_STRUCT_IMMUTABLESTRUCT = ::T.let(nil, ::T.untyped) SET_SYSTEM_SHELL_OUTPUT_PIPE_OUTPUT = ::T.let(nil, ::T.untyped) SET_WITH_WITHOUT = ::T.let(nil, ::T.untyped) SET____ETC_4 = ::T.let(nil, ::T.untyped) diff --git a/Library/Homebrew/standalone/load_path.rb b/Library/Homebrew/standalone/load_path.rb index 7dbe4936f1fa8..f567fc734ae40 100644 --- a/Library/Homebrew/standalone/load_path.rb +++ b/Library/Homebrew/standalone/load_path.rb @@ -14,4 +14,6 @@ $LOAD_PATH.push HOMEBREW_LIBRARY_PATH.to_s unless $LOAD_PATH.include?(HOMEBREW_LIBRARY_PATH.to_s) require_relative "../vendor/bundle/bundler/setup" +$LOAD_PATH.unshift "#{HOMEBREW_LIBRARY_PATH}/vendor/bundle/#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/" \ + "bundler-#{Homebrew::HOMEBREW_BUNDLER_VERSION}/lib" $LOAD_PATH.uniq! diff --git a/Library/Homebrew/vendor/bundle/bundler/setup.rb b/Library/Homebrew/vendor/bundle/bundler/setup.rb index 02ab94bacea8f..771d2275b54eb 100644 --- a/Library/Homebrew/vendor/bundle/bundler/setup.rb +++ b/Library/Homebrew/vendor/bundle/bundler/setup.rb @@ -99,7 +99,7 @@ def self.extension_api_version $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rubocop-performance-1.17.1/lib") $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rubocop-rails-2.19.1/lib") $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rubocop-rspec-2.20.0/lib") -$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rubocop-sorbet-0.7.0/lib") +$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rubocop-sorbet-0.7.3/lib") $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/ruby-macho-4.0.0/lib") $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/extensions/universal-darwin-22/#{Gem.extension_api_version}/ruby-prof-1.4.3") $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/ruby-prof-1.4.3/lib") diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb deleted file mode 100644 index cc584413d1385..0000000000000 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb +++ /dev/null @@ -1,127 +0,0 @@ -# frozen_string_literal: true - -require "rubocop" - -module RuboCop - module Cop - module Sorbet - # This cop disallows binding the return value of `T.any`, `T.all`, `T.enum` - # to a constant directly. To bind the value, one must use `T.type_alias`. - # - # @example - # - # # bad - # FooOrBar = T.any(Foo, Bar) - # - # # good - # FooOrBar = T.type_alias { T.any(Foo, Bar) } - class BindingConstantWithoutTypeAlias < RuboCop::Cop::Cop - def_node_matcher(:binding_unaliased_type?, <<-PATTERN) - (casgn _ _ [#not_nil? #not_t_let? #not_dynamic_type_creation_with_block? #not_generic_parameter_decl? #method_needing_aliasing_on_t?]) - PATTERN - - def_node_matcher(:using_type_alias?, <<-PATTERN) - (block - (send - (const nil? :T) :type_alias) - _ - _ - ) - PATTERN - - def_node_matcher(:using_deprecated_type_alias_syntax?, <<-PATTERN) - ( - send - (const nil? :T) - :type_alias - _ - ) - PATTERN - - def_node_matcher(:t_let?, <<-PATTERN) - ( - send - (const nil? :T) - :let - _ - _ - ) - PATTERN - - def_node_matcher(:dynamic_type_creation_with_block?, <<-PATTERN) - (block - (send - const :new ...) - _ - _ - ) - PATTERN - - def_node_matcher(:generic_parameter_decl_call?, <<-PATTERN) - ( - send nil? {:type_template :type_member} ... - ) - PATTERN - - def_node_matcher(:generic_parameter_decl_block_call?, <<-PATTERN) - (block - (send nil? {:type_template :type_member} ...) ... - ) - PATTERN - - def_node_search(:method_needing_aliasing_on_t?, <<-PATTERN) - ( - send - (const nil? :T) - {:any :all :noreturn :class_of :untyped :nilable :self_type :enum :proc} - ... - ) - PATTERN - - def not_t_let?(node) - !t_let?(node) - end - - def not_dynamic_type_creation_with_block?(node) - !dynamic_type_creation_with_block?(node) - end - - def not_generic_parameter_decl?(node) - !generic_parameter_decl_call?(node) && !generic_parameter_decl_block_call?(node) - end - - def not_nil?(node) - !node.nil? - end - - def on_casgn(node) - return unless binding_unaliased_type?(node) && !using_type_alias?(node.children[2]) - if using_deprecated_type_alias_syntax?(node.children[2]) - add_offense( - node.children[2], - message: "It looks like you're using the old `T.type_alias` syntax. " \ - "`T.type_alias` now expects a block." \ - 'Run Sorbet with the options "--autocorrect --error-white-list=5043" ' \ - "to automatically upgrade to the new syntax." - ) - return - end - add_offense( - node.children[2], - message: "It looks like you're trying to bind a type to a constant. " \ - "To do this, you must alias the type using `T.type_alias`." - ) - end - - def autocorrect(node) - lambda do |corrector| - corrector.replace( - node.source_range, - "T.type_alias { #{node.source} }" - ) - end - end - end - end - end -end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb deleted file mode 100644 index 97b6337c871d2..0000000000000 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb +++ /dev/null @@ -1,45 +0,0 @@ -# encoding: utf-8 -# frozen_string_literal: true - -require "rubocop" - -# Correct superclass `send` expressions by constant literals. -# -# Sorbet, the static checker, is not (yet) able to support constructs on the -# following form: -# -# ```ruby -# class Foo < send_expr; end -# ``` -# -# Multiple occurences of this can be found in Shopify's code base like: -# -# ```ruby -# class ShopScope < Component::TrustedIdScope[ShopIdentity::ShopId] -# ``` -# or -# ```ruby -# class ApiClientEligibility < Struct.new(:api_client, :match_results, :shop) -# ``` -module RuboCop - module Cop - module Sorbet - class ForbidSuperclassConstLiteral < RuboCop::Cop::Cop - MSG = "Superclasses must only contain constant literals" - - def_node_matcher :not_lit_const_superclass?, <<-PATTERN - (class - (const ...) - (send ...) - ... - ) - PATTERN - - def on_class(node) - return unless not_lit_const_superclass?(node) - add_offense(node.child_nodes[1]) - end - end - end - end -end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb deleted file mode 100644 index c7b897098f765..0000000000000 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb +++ /dev/null @@ -1,53 +0,0 @@ -# frozen_string_literal: true - -module RuboCop - module Cop - module Sorbet - # This cop ensures RBI shims do not include a call to extend T::Sig - # or to extend T::Helpers - # - # @example - # - # # bad - # module SomeModule - # extend T::Sig - # extend T::Helpers - # - # sig { returns(String) } - # def foo; end - # end - # - # # good - # module SomeModule - # sig { returns(String) } - # def foo; end - # end - class ForbidExtendTSigHelpersInShims < RuboCop::Cop::Cop - include RangeHelp - - MSG = "Extending T::Sig or T::Helpers in a shim is unnecessary" - RESTRICT_ON_SEND = [:extend] - - def_node_matcher :extend_t_sig?, <<~PATTERN - (send nil? :extend (const (const nil? :T) :Sig)) - PATTERN - - def_node_matcher :extend_t_helpers?, <<~PATTERN - (send nil? :extend (const (const nil? :T) :Helpers)) - PATTERN - - def autocorrect(node) - -> (corrector) do - corrector.remove( - range_by_whole_lines(node.source_range, include_final_newline: true) - ) - end - end - - def on_send(node) - add_offense(node) if extend_t_helpers?(node) || extend_t_sig?(node) - end - end - end - end -end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb deleted file mode 100644 index 73420ccf8d0d8..0000000000000 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb +++ /dev/null @@ -1,59 +0,0 @@ -# frozen_string_literal: true - -require "rubocop" - -module RuboCop - module Cop - module Sorbet - # This cop disallows using `.override(allow_incompatible: true)`. - # Using `allow_incompatible` suggests a violation of the Liskov - # Substitution Principle, meaning that a subclass is not a valid - # subtype of it's superclass. This Cop prevents these design smells - # from occurring. - # - # @example - # - # # bad - # sig.override(allow_incompatible: true) - # - # # good - # sig.override - class AllowIncompatibleOverride < RuboCop::Cop::Cop - def_node_search(:sig?, <<-PATTERN) - ( - send - nil? - :sig - ... - ) - PATTERN - - def not_nil?(node) - !node.nil? - end - - def_node_search(:allow_incompatible?, <<-PATTERN) - (pair (sym :allow_incompatible) (true)) - PATTERN - - def_node_matcher(:allow_incompatible_override?, <<-PATTERN) - ( - send - [#not_nil? #sig?] - :override - [#not_nil? #allow_incompatible?] - ) - PATTERN - - def on_send(node) - return unless allow_incompatible_override?(node) - add_offense( - node.children[2], - message: "Usage of `allow_incompatible` suggests a violation of the Liskov Substitution Principle. "\ - "Instead, strive to write interfaces which respect subtyping principles and remove `allow_incompatible`", - ) - end - end - end - end -end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/type_alias_name.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/type_alias_name.rb deleted file mode 100644 index c22b3d16e5345..0000000000000 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/type_alias_name.rb +++ /dev/null @@ -1,45 +0,0 @@ -# frozen_string_literal: true - -require "rubocop" - -module RuboCop - module Cop - module Sorbet - # This cop ensures all constants used as `T.type_alias` are using CamelCase. - # - # @example - # - # # bad - # FOO_OR_BAR = T.type_alias { T.any(Foo, Bar) } - # - # # good - # FooOrBar = T.type_alias { T.any(Foo, Bar) } - class TypeAliasName < RuboCop::Cop::Cop - MSG = "Type alias constant name should be in CamelCase" - - def_node_matcher(:casgn_type_alias?, <<-PATTERN) - (casgn - _ - _ - (block - (send - (const nil? :T) :type_alias) - _ - _ - )) - PATTERN - - def on_casgn(node) - return unless casgn_type_alias?(node) - - name = node.children[1] - - # From https://github.com/rubocop/rubocop/blob/master/lib/rubocop/cop/naming/class_and_module_camel_case.rb - return unless /_/.match?(name) - - add_offense(node) - end - end - end - end -end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/sorbet/inject.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/sorbet/inject.rb deleted file mode 100644 index f0440faac0f5f..0000000000000 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/sorbet/inject.rb +++ /dev/null @@ -1,20 +0,0 @@ -# frozen_string_literal: true - -# The original code is from https://github.com/rubocop-hq/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb -# See https://github.com/rubocop-hq/rubocop-rspec/blob/master/MIT-LICENSE.md -module RuboCop - module Sorbet - # Because RuboCop doesn't yet support plugins, we have to monkey patch in a - # bit of our configuration. - module Inject - def self.defaults! - path = CONFIG_DEFAULT.to_s - hash = ConfigLoader.send(:load_yaml_configuration, path) - config = Config.new(hash, path).tap(&:make_excludes_absolute) - puts "configuration from #{path}" if ConfigLoader.debug? - config = ConfigLoader.merge_with_default(config, path) - ConfigLoader.instance_variable_set(:@default_configuration, config) - end - end - end -end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/config/default.yml b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/config/default.yml similarity index 89% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/config/default.yml rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/config/default.yml index d94a62d6f4666..b69275eaaf626 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/config/default.yml +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/config/default.yml @@ -120,7 +120,8 @@ Sorbet/HasSigil: Description: 'Makes the Sorbet typed sigil mandatory in all files.' Enabled: false SuggestedStrictness: "false" - MinimumStrictness: "false" + MinimumStrictness: nil + ExactStrictness: nil VersionAdded: 0.3.3 Include: - "**/*.{rb,rbi,rake,ru}" @@ -141,6 +142,13 @@ Sorbet/IgnoreSigil: - db/**/*.rb - script/**/* +Sorbet/ImplicitConversionMethod: + Description: >- + This cop disallows declaring implicit conversion methods, as sorbet does + not support implicit conversion. + Enabled: false + VersionAdded: '<>' + Sorbet/KeywordArgumentOrdering: Description: >- Enforces a compatible keyword arguments with Sorbet. @@ -151,6 +159,18 @@ Sorbet/KeywordArgumentOrdering: Enabled: true VersionAdded: 0.2.0 +Sorbet/ObsoleteStrictMemoization: + Description: >- + This cop checks for the obsolete pattern for initializing instance variables that was required for older Sorbet + versions in `#typed: strict` files. + + It's no longer required, as of Sorbet 0.5.10210 + See https://sorbet.org/docs/type-assertions#put-type-assertions-behind-memoization + Enabled: true + VersionAdded: '0.7.1' + Safe: true + SafeAutoCorrect: true + Sorbet/OneAncestorPerLine: Description: 'Enforces one ancestor per call to requires_ancestor' Enabled: false @@ -235,7 +255,8 @@ Sorbet/ValidSigil: Enabled: true RequireSigilOnAllFiles: false SuggestedStrictness: "false" - MinimumStrictness: "false" + MinimumStrictness: nil + ExactStrictness: nil VersionAdded: 0.3.3 Include: - "**/*.{rb,rbi,rake,ru}" diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/config/rbi.yml b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/config/rbi.yml similarity index 100% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/config/rbi.yml rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/config/rbi.yml diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop-sorbet.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop-sorbet.rb similarity index 100% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop-sorbet.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop-sorbet.rb diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/binding_constant_without_type_alias.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/binding_constant_without_type_alias.rb new file mode 100644 index 0000000000000..73580450095f2 --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/binding_constant_without_type_alias.rb @@ -0,0 +1,105 @@ +# frozen_string_literal: true + +require "rubocop" + +module RuboCop + module Cop + module Sorbet + # Disallows binding the return value of `T.any`, `T.all`, `T.enum` + # to a constant directly. To bind the value, one must use `T.type_alias`. + # + # @example + # + # # bad + # FooOrBar = T.any(Foo, Bar) + # + # # good + # FooOrBar = T.type_alias { T.any(Foo, Bar) } + class BindingConstantWithoutTypeAlias < RuboCop::Cop::Base + extend AutoCorrector + + MSG = "It looks like you're trying to bind a type to a constant. " \ + "To do this, you must alias the type using `T.type_alias`." + WITHOUT_BLOCK_MSG = "It looks like you're using the old `T.type_alias` syntax. " \ + "`T.type_alias` now expects a block." \ + 'Run Sorbet with the options "--autocorrect --error-white-list=5043" ' \ + "to automatically upgrade to the new syntax." + + # @!method type_alias_without_block(node) + def_node_matcher :type_alias_without_block, <<~PATTERN + (send + (const {nil? cbase} :T) + :type_alias + $_ + ) + PATTERN + + # @!method type_alias_with_block?(node) + def_node_matcher :type_alias_with_block?, <<~PATTERN + (block + (send + (const {nil? cbase} :T) + :type_alias) + ... + ) + PATTERN + + # @!method requires_type_alias?(node) + def_node_matcher :requires_type_alias?, <<~PATTERN + (send + (const {nil? cbase} :T) + { + :all + :any + :class_of + :nilable + :noreturn + :proc + :self_type + :untyped + } + ... + ) + PATTERN + + def on_casgn(node) + expression = node.expression + return if expression.nil? # multiple assignment + + type_alias_without_block(expression) do |type| + return add_offense(expression, message: WITHOUT_BLOCK_MSG) do |corrector| + corrector.replace(expression, "T.type_alias { #{type.source} }") + end + end + + return if type_alias_with_block?(expression) + + requires_type_alias?(send_leaf(expression)) do + return add_offense(expression) do |corrector| + corrector.replace(expression, "T.type_alias { #{expression.source} }") + end + end + end + + private + + # Given nested send nodes, returns the leaf with explicit receiver. + # + # i.e. in Ruby + # + # a.b.c.d.e.f + # ^^^ + # + # i.e. in AST + # + # (send (send (send (send (send (send nil :a) :b) :c) :d) :e) :f) + # ^^^^^^^^^^^^^^^^^^^^^^^ + # + def send_leaf(node) + node = node.receiver while node&.receiver&.send_type? + node + end + end + end + end +end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/callback_conditionals_binding.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/callback_conditionals_binding.rb similarity index 77% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/callback_conditionals_binding.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/callback_conditionals_binding.rb index 1f7ecf10ae619..f0a42a66912f9 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/callback_conditionals_binding.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/callback_conditionals_binding.rb @@ -3,7 +3,7 @@ module RuboCop module Cop module Sorbet - # This cop ensures that callback conditionals are bound to the right type + # Ensures that callback conditionals are bound to the right type # so that they are type checked properly. # # Auto-correction is unsafe because other libraries define similar style callbacks as Rails, but don't always need @@ -32,16 +32,44 @@ module Sorbet # true # end # end - class CallbackConditionalsBinding < RuboCop::Cop::Cop + class CallbackConditionalsBinding < RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass CALLBACKS = [ - :validate, :validates, :validates_with, :before_validation, :around_validation, :before_create, - :before_save, :before_destroy, :before_update, :after_create, :after_save, :after_destroy, - :after_update, :after_touch, :after_initialize, :after_find, :around_create, :around_save, - :around_destroy, :around_update, :before_commit, :after_commit, :after_create_commit, - :after_destroy_commit, :after_rollback, :after_save_commit, :after_update_commit, - :before_action, :prepend_before_action, :append_before_action, :around_action, - :prepend_around_action, :append_around_action, :after_action, :prepend_after_action, - :append_after_action + :validate, + :validates, + :validates_with, + :before_validation, + :around_validation, + :before_create, + :before_save, + :before_destroy, + :before_update, + :after_create, + :after_save, + :after_destroy, + :after_update, + :after_touch, + :after_initialize, + :after_find, + :around_create, + :around_save, + :around_destroy, + :around_update, + :before_commit, + :after_commit, + :after_create_commit, + :after_destroy_commit, + :after_rollback, + :after_save_commit, + :after_update_commit, + :before_action, + :prepend_before_action, + :append_before_action, + :around_action, + :prepend_around_action, + :append_around_action, + :after_action, + :prepend_after_action, + :append_after_action, ].freeze def autocorrect(node) @@ -132,7 +160,7 @@ def on_send(node) unless block.source.include?("T.bind(self") add_offense( node, - message: "Callback conditionals should be bound to the right type. Use T.bind(self, #{expected_class})" + message: "Callback conditionals should be bound to the right type. Use T.bind(self, #{expected_class})", ) end end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/constants_from_strings.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/constants_from_strings.rb similarity index 83% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/constants_from_strings.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/constants_from_strings.rb index eccd55f402596..1a1fb0d48ffd8 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/constants_from_strings.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/constants_from_strings.rb @@ -5,7 +5,7 @@ module RuboCop module Cop module Sorbet - # This cop disallows the calls that are used to get constants fom Strings + # Disallows the calls that are used to get constants fom Strings # such as +constantize+, +const_get+, and +constants+. # # The goal of this cop is to make the code easier to statically analyze, @@ -33,18 +33,20 @@ module Sorbet # # # good # { "User" => User }.fetch(class_name) - class ConstantsFromStrings < ::RuboCop::Cop::Cop + class ConstantsFromStrings < ::RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass + # @!method constant_from_string?(node) def_node_matcher(:constant_from_string?, <<-PATTERN) (send _ {:constantize :constants :const_get} ...) PATTERN def on_send(node) return unless constant_from_string?(node) + add_offense( node, location: :selector, message: "Don't use `#{node.method_name}`, it makes the code harder to understand, less editor-friendly, " \ - "and impossible to analyze. Replace `#{node.method_name}` with a case/when or a hash." + "and impossible to analyze. Replace `#{node.method_name}` with a case/when or a hash.", ) end end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb similarity index 57% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb index 087e27d74b399..331f2395d7683 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb @@ -3,34 +3,35 @@ require "rubocop" -# Correct `send` expressions in include statements by constant literals. -# -# Sorbet, the static checker, is not (yet) able to support constructs on the -# following form: -# -# ```ruby -# class MyClass -# include send_expr -# end -# ``` -# -# Multiple occurences of this can be found in Shopify's code base like: -# -# ```ruby -# include Rails.application.routes.url_helpers -# ``` -# or -# ```ruby -# include Polaris::Engine.helpers -# ``` module RuboCop module Cop module Sorbet - class ForbidIncludeConstLiteral < RuboCop::Cop::Cop + # Correct `send` expressions in include statements by constant literals. + # + # Sorbet, the static checker, is not (yet) able to support constructs on the + # following form: + # + # ```ruby + # class MyClass + # include send_expr + # end + # ``` + # + # Multiple occurences of this can be found in Shopify's code base like: + # + # ```ruby + # include Rails.application.routes.url_helpers + # ``` + # or + # ```ruby + # include Polaris::Engine.helpers + # ``` + class ForbidIncludeConstLiteral < RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass MSG = "Includes must only contain constant literals" attr_accessor :used_names + # @!method not_lit_const_include?(node) def_node_matcher :not_lit_const_include?, <<-PATTERN (send nil? {:include :extend :prepend} $_ @@ -46,18 +47,21 @@ def on_send(node) return unless not_lit_const_include?(node) do |send_argument| ![:const, :self].include?(send_argument.type) end + parent = node.parent return unless parent + parent = parent.parent if [:begin, :block].include?(parent.type) return unless [:module, :class, :sclass].include?(parent.type) + add_offense(node) end def autocorrect(node) lambda do |corrector| corrector.replace( - node.source_range, - "T.unsafe(self).#{node.source}" + node, + "T.unsafe(self).#{node.source}", ) end end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb new file mode 100644 index 0000000000000..fb2e5bff68167 --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb @@ -0,0 +1,44 @@ +# encoding: utf-8 +# frozen_string_literal: true + +require "rubocop" + +module RuboCop + module Cop + module Sorbet + # Correct superclass `send` expressions by constant literals. + # + # Sorbet, the static checker, is not (yet) able to support constructs on the + # following form: + # + # ```ruby + # class Foo < send_expr; end + # ``` + # + # Multiple occurences of this can be found in Shopify's code base like: + # + # ```ruby + # class ShopScope < Component::TrustedIdScope[ShopIdentity::ShopId] + # ``` + # or + # ```ruby + # class ApiClientEligibility < Struct.new(:api_client, :match_results, :shop) + # ``` + + class ForbidSuperclassConstLiteral < RuboCop::Cop::Base + MSG = "Superclasses must only contain constant literals" + + # @!method dynamic_superclass?(node) + def_node_matcher :dynamic_superclass?, <<-PATTERN + (class (const ...) $(send ...) ...) + PATTERN + + def on_class(node) + dynamic_superclass?(node) do |superclass| + add_offense(superclass) + end + end + end + end + end +end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/forbid_t_unsafe.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/forbid_t_unsafe.rb similarity index 57% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/forbid_t_unsafe.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/forbid_t_unsafe.rb index 9f4280301c640..fe3abff34a6a0 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/forbid_t_unsafe.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/forbid_t_unsafe.rb @@ -5,7 +5,7 @@ module RuboCop module Cop module Sorbet - # This cop disallows using `T.unsafe` anywhere. + # Disallows using `T.unsafe` anywhere. # # @example # @@ -14,11 +14,15 @@ module Sorbet # # # good # foo - class ForbidTUnsafe < RuboCop::Cop::Cop + class ForbidTUnsafe < RuboCop::Cop::Base + MSG = "Do not use `T.unsafe`." + RESTRICT_ON_SEND = [:unsafe].freeze + + # @!method t_unsafe?(node) def_node_matcher(:t_unsafe?, "(send (const nil? :T) :unsafe _)") def on_send(node) - add_offense(node, message: "Do not use `T.unsafe`.") if t_unsafe?(node) + add_offense(node) if t_unsafe?(node) end end end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/forbid_t_untyped.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/forbid_t_untyped.rb similarity index 65% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/forbid_t_untyped.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/forbid_t_untyped.rb index b6d4923e08631..a545fdc3a9ec6 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/forbid_t_untyped.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/forbid_t_untyped.rb @@ -5,7 +5,7 @@ module RuboCop module Cop module Sorbet - # This cop disallows using `T.untyped` anywhere. + # Disallows using `T.untyped` anywhere. # # @example # @@ -17,11 +17,15 @@ module Sorbet # sig { params(my_argument: String).void } # def foo(my_argument); end # - class ForbidTUntyped < RuboCop::Cop::Cop + class ForbidTUntyped < RuboCop::Cop::Base + MSG = "Do not use `T.untyped`." + RESTRICT_ON_SEND = [:untyped].freeze + + # @!method t_untyped?(node) def_node_matcher(:t_untyped?, "(send (const nil? :T) :untyped)") def on_send(node) - add_offense(node, message: "Do not use `T.untyped`.") if t_untyped?(node) + add_offense(node) if t_untyped?(node) end end end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb similarity index 63% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb index f755cd6faa2e1..935dd3a5b26c0 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb @@ -6,7 +6,7 @@ module RuboCop module Cop module Sorbet - # This cop disallows use of `T.untyped` or `T.nilable(T.untyped)` + # Disallows use of `T.untyped` or `T.nilable(T.untyped)` # as a prop type for `T::Struct` or `T::ImmutableStruct`. # # @example @@ -22,38 +22,40 @@ module Sorbet # const :foo, Integer # prop :bar, T.nilable(String) # end - class ForbidUntypedStructProps < RuboCop::Cop::Cop + class ForbidUntypedStructProps < RuboCop::Cop::Base MSG = "Struct props cannot be T.untyped" + # @!method t_struct(node) def_node_matcher :t_struct, <<~PATTERN - (const (const nil? :T) :Struct) - PATTERN - - def_node_matcher :t_immutable_struct, <<~PATTERN - (const (const nil? :T) :ImmutableStruct) + (const (const nil? :T) {:Struct :ImmutableStruct}) PATTERN + # @!method t_untyped(node) def_node_matcher :t_untyped, <<~PATTERN (send (const nil? :T) :untyped) PATTERN + # @!method t_nilable_untyped(node) def_node_matcher :t_nilable_untyped, <<~PATTERN (send (const nil? :T) :nilable {#t_untyped #t_nilable_untyped}) PATTERN + # @!method subclass_of_t_struct?(node) def_node_matcher :subclass_of_t_struct?, <<~PATTERN - (class (const ...) {#t_struct #t_immutable_struct} ...) + (class (const ...) #t_struct ...) PATTERN + # @!method untyped_props(node) + # Search for untyped prop/const declarations and capture their types def_node_search :untyped_props, <<~PATTERN - (send nil? {:prop :const} _ {#t_untyped #t_nilable_untyped} ...) + (send nil? {:prop :const} _ ${#t_untyped #t_nilable_untyped} ...) PATTERN def on_class(node) return unless subclass_of_t_struct?(node) - untyped_props(node).each do |untyped_prop| - add_offense(untyped_prop.child_nodes[1]) + untyped_props(node).each do |prop_type| + add_offense(prop_type) end end end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/implicit_conversion_method.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/implicit_conversion_method.rb new file mode 100644 index 0000000000000..89da704f633b8 --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/implicit_conversion_method.rb @@ -0,0 +1,56 @@ +# frozen_string_literal: true + +require "rubocop" + +module RuboCop + module Cop + module Sorbet + # Disallows declaring implicit conversion methods. + # Since Sorbet is a nominal (not structural) type system, + # implicit conversion is currently unsupported. + # + # @example + # + # # bad + # def to_str; end + # + # # good + # def to_str(x); end + # + # # bad + # def self.to_str; end + # + # # good + # def self.to_str(x); end + # + # # bad + # alias to_str to_s + # + # @see https://docs.ruby-lang.org/en/master/implicit_conversion_rdoc.html + # @note Since the arity of aliased methods is not checked, false positives may result. + class ImplicitConversionMethod < RuboCop::Cop::Base + IMPLICIT_CONVERSION_METHODS = [:to_ary, :to_int, :to_hash, :to_str].freeze + MSG = "Avoid implicit conversion methods, as Sorbet does not support them. " \ + "Explicity convert to the desired type instead." + RESTRICT_ON_SEND = [:alias_method].freeze + + def on_alias(node) + new_id = node.new_identifier + add_offense(new_id) if IMPLICIT_CONVERSION_METHODS.include?(new_id.value) + end + + def on_def(node) + return unless IMPLICIT_CONVERSION_METHODS.include?(node.method_name) + return unless node.arguments.empty? + + add_offense(node) + end + alias_method :on_defs, :on_def + + def on_send(node) + add_offense(node.first_argument) if IMPLICIT_CONVERSION_METHODS.include?(node.first_argument.value) + end + end + end + end +end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/mixin/target_sorbet_version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/mixin/target_sorbet_version.rb new file mode 100644 index 0000000000000..9da570d3117b2 --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/mixin/target_sorbet_version.rb @@ -0,0 +1,49 @@ +# frozen_string_literal: true + +module RuboCop + module Cop + module Sorbet + module TargetSorbetVersion + class << self + def included(target) + target.extend(ClassMethods) + end + end + + module ClassMethods + # The version of the Sorbet static type checker required by this cop + def minimum_target_sorbet_static_version(version) + @minimum_target_sorbet_static_version = Gem::Version.new(version) + end + + def support_target_sorbet_static_version?(version) + @minimum_target_sorbet_static_version <= Gem::Version.new(version) + end + end + + def enabled_for_sorbet_static_version? + sorbet_static_version = target_sorbet_static_version_from_bundler_lock_file + return false unless sorbet_static_version + + self.class.support_target_sorbet_static_version?(sorbet_static_version) + end + + def target_sorbet_static_version_from_bundler_lock_file + # Do memoization with the `defined?` pattern since sorbet-static version might be `nil` + if defined?(@target_sorbet_static_version_from_bundler_lock_file) + @target_sorbet_static_version_from_bundler_lock_file + else + @target_sorbet_static_version_from_bundler_lock_file = read_sorbet_static_version_from_bundler_lock_file + end + end + + def read_sorbet_static_version_from_bundler_lock_file + require "bundler" + ::Bundler.locked_gems.specs.find { |spec| spec.name == "sorbet-static" }&.version + rescue LoadError, Bundler::GemfileNotFound + nil + end + end + end + end +end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb similarity index 58% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb index 3d96a41803c01..735b3a7d3995e 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb @@ -6,10 +6,13 @@ module RuboCop module Cop module Sorbet module MutableConstantSorbetAwareBehaviour - def self.prepended(base) - base.def_node_matcher(:t_let, <<~PATTERN) - (send (const nil? :T) :let $_constant _type) - PATTERN + class << self + def prepended(base) + # @!method t_let(node) + base.def_node_matcher(:t_let, <<~PATTERN) + (send (const nil? :T) :let $_constant _type) + PATTERN + end end def on_assignment(value) @@ -25,5 +28,5 @@ def on_assignment(value) end RuboCop::Cop::Style::MutableConstant.prepend( - RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour + RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour, ) diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/obsolete_strict_memoization.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/obsolete_strict_memoization.rb new file mode 100644 index 0000000000000..018a6817a2c8c --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/obsolete_strict_memoization.rb @@ -0,0 +1,92 @@ +# frozen_string_literal: true + +require "rubocop" + +module RuboCop + module Cop + module Sorbet + # Checks for the obsolete pattern for initializing instance variables that was required for older Sorbet + # versions in `#typed: strict` files. + # + # It's no longer required, as of Sorbet 0.5.10210 + # See https://sorbet.org/docs/type-assertions#put-type-assertions-behind-memoization + # + # @example + # + # # bad + # sig { returns(Foo) } + # def foo + # @foo = T.let(@foo, T.nilable(Foo)) + # @foo ||= Foo.new + # end + # + # # bad + # sig { returns(Foo) } + # def foo + # # This would have been a mistake, causing the memoized value to be discarded and recomputed on every call. + # @foo = T.let(nil, T.nilable(Foo)) + # @foo ||= Foo.new + # end + # + # # good + # sig { returns(Foo) } + # def foo + # @foo ||= T.let(Foo.new, T.nilable(Foo)) + # end + # + class ObsoleteStrictMemoization < RuboCop::Cop::Base + include RuboCop::Cop::MatchRange + include RuboCop::Cop::Alignment + include RuboCop::Cop::LineLengthHelp + include RuboCop::Cop::RangeHelp + extend AutoCorrector + + include TargetSorbetVersion + minimum_target_sorbet_static_version "0.5.10210" + + MSG = "This two-stage workaround for memoization in `#typed: strict` files is no longer necessary. " \ + "See https://sorbet.org/docs/type-assertions#put-type-assertions-behind-memoization." + + # @!method legacy_memoization_pattern?(node) + def_node_matcher :legacy_memoization_pattern?, <<~PATTERN + (begin + ... # Ignore any other lines that come first. + $(ivasgn $_ivar # First line: @_ivar = ... + (send # T.let(_ivar, T.nilable(_ivar_type)) + $(const {nil? cbase} :T) :let + {(ivar _ivar) nil} + (send (const {nil? cbase} :T) :nilable $_ivar_type))) # T.nilable(_ivar_type) + $(or-asgn (ivasgn _ivar) $_initialization_expr)) # Second line: @_ivar ||= _initialization_expr + PATTERN + + def on_begin(node) + legacy_memoization_pattern?(node) do |first_asgn_node, ivar, t, ivar_type, second_or_asgn_node, init_expr| # rubocop:disable Metrics/ParameterLists + add_offense(first_asgn_node) do |corrector| + indent = offset(node) + correction = "#{ivar} ||= #{t.source}.let(#{init_expr.source}, #{t.source}.nilable(#{ivar_type.source}))" + + # We know good places to put line breaks, if required. + if line_length(indent + correction) > max_line_length || correction.include?("\n") + correction = <<~RUBY.chomp + #{ivar} ||= #{t.source}.let( + #{indent} #{init_expr.source.gsub("\n", "\n#{indent}")}, + #{indent} #{t.source}.nilable(#{ivar_type.source.gsub("\n", "\n#{indent}")}), + #{indent}) + RUBY + end + + corrector.replace( + range_between(first_asgn_node.source_range.begin_pos, second_or_asgn_node.source_range.end_pos), + correction, + ) + end + end + end + + def relevant_file?(file) + super && enabled_for_sorbet_static_version? + end + end + end + end +end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb similarity index 85% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb index 66b778a3e6716..b01d04b9cb30b 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb @@ -6,7 +6,7 @@ module RuboCop module Cop module Sorbet - # This cop ensures one ancestor per requires_ancestor line + # Ensures one ancestor per requires_ancestor line # rather than chaining them as a comma-separated list. # # @example @@ -21,17 +21,20 @@ module Sorbet # requires_ancestor Kernel # requires_ancestor Minitest::Assertions # end - class OneAncestorPerLine < RuboCop::Cop::Cop + class OneAncestorPerLine < RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass MSG = "Cannot require more than one ancestor per line" + # @!method requires_ancestors(node) def_node_search :requires_ancestors, <<~PATTERN (send nil? :requires_ancestor ...) PATTERN + # @!method more_than_one_ancestor(node) def_node_matcher :more_than_one_ancestor, <<~PATTERN (send nil? :requires_ancestor const const+) PATTERN + # @!method abstract?(node) def_node_search :abstract?, <<~PATTERN (send nil? :abstract!) PATTERN @@ -39,17 +42,19 @@ class OneAncestorPerLine < RuboCop::Cop::Cop def on_module(node) return unless node.body return unless requires_ancestors(node) + process_node(node) end def on_class(node) return unless abstract?(node) return unless requires_ancestors(node) + process_node(node) end def autocorrect(node) - -> (corrector) do + ->(corrector) do ra_call = node.parent split_ra_calls = ra_call.source.gsub(/,\s+/, new_ra_line(ra_call.loc.column)) corrector.replace(ra_call, split_ra_calls) diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb new file mode 100644 index 0000000000000..5b0943fed5ad3 --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb @@ -0,0 +1,47 @@ +# frozen_string_literal: true + +module RuboCop + module Cop + module Sorbet + # Ensures RBI shims do not include a call to extend T::Sig + # or to extend T::Helpers + # + # @example + # + # # bad + # module SomeModule + # extend T::Sig + # extend T::Helpers + # + # sig { returns(String) } + # def foo; end + # end + # + # # good + # module SomeModule + # sig { returns(String) } + # def foo; end + # end + class ForbidExtendTSigHelpersInShims < RuboCop::Cop::Base + extend AutoCorrector + include RangeHelp + + MSG = "Extending T::Sig or T::Helpers in a shim is unnecessary" + RESTRICT_ON_SEND = [:extend].freeze + + # @!method extend_t_sig_or_helpers?(node) + def_node_matcher :extend_t_sig_or_helpers?, <<~PATTERN + (send nil? :extend (const (const nil? :T) {:Sig :Helpers})) + PATTERN + + def on_send(node) + extend_t_sig_or_helpers?(node) do + add_offense(node) do |corrector| + corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true)) + end + end + end + end + end + end +end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb similarity index 77% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb index 241c76f9ab898..ebd4984da75e1 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb @@ -5,7 +5,7 @@ module RuboCop module Cop module Sorbet - # This cop makes sure that RBI files are always located under the defined allowed paths. + # Makes sure that RBI files are always located under the defined allowed paths. # # Options: # @@ -20,7 +20,7 @@ module Sorbet # # rbi/external_interface.rbi # # sorbet/rbi/some_file.rbi # # sorbet/rbi/any/path/for/file.rbi - class ForbidRBIOutsideOfAllowedPaths < RuboCop::Cop::Cop + class ForbidRBIOutsideOfAllowedPaths < RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass include RangeHelp def investigate(processed_source) @@ -30,14 +30,14 @@ def investigate(processed_source) add_offense( nil, location: source_range(processed_source.buffer, 1, 0), - message: "AllowedPaths expects an array" + message: "AllowedPaths expects an array", ) return elsif paths.empty? add_offense( nil, location: source_range(processed_source.buffer, 1, 0), - message: "AllowedPaths cannot be empty" + message: "AllowedPaths cannot be empty", ) return end @@ -49,15 +49,16 @@ def investigate(processed_source) add_offense( nil, location: source_range(processed_source.buffer, 1, 0), - message: "RBI file path should match one of: #{paths.join(", ")}" + message: "RBI file path should match one of: #{paths.join(", ")}", ) if paths.none? { |pattern| File.fnmatch(pattern, rel_path) } end private def allowed_paths - paths = cop_config["AllowedPaths"] - return nil unless paths.is_a?(Array) + paths = cop_config["AllowedPaths"] # rubocop:todo InternalAffairs/UndefinedConfig + return unless paths.is_a?(Array) + paths.compact end end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb similarity index 60% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb index cef6d6033669f..1e7abbd22d513 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb @@ -3,7 +3,7 @@ module RuboCop module Cop module Sorbet - # This cop ensures empty class/module definitions in RBI files are + # Ensures empty class/module definitions in RBI files are # done on a single line rather than being split across multiple lines. # # @example @@ -14,32 +14,26 @@ module Sorbet # # # good # module SomeModule; end - class SingleLineRbiClassModuleDefinitions < RuboCop::Cop::Cop + class SingleLineRbiClassModuleDefinitions < RuboCop::Cop::Base + extend AutoCorrector + MSG = "Empty class/module definitions in RBI files should be on a single line." def on_module(node) - process_node(node) - end - - def on_class(node) - process_node(node) - end + return if node.body + return if node.single_line? - def autocorrect(node) - -> (corrector) { corrector.replace(node, convert_newlines(node.source)) } + add_offense(node) do |corrector| + corrector.replace(node, convert_newlines_to_semicolons(node.source)) + end end + alias_method :on_class, :on_module - protected + private - def convert_newlines(source) + def convert_newlines_to_semicolons(source) source.sub(/[\r\n]+\s*[\r\n]*/, "; ") end - - def process_node(node) - return if node.body - return if node.single_line? - add_offense(node) - end end end end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/redundant_extend_t_sig.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/redundant_extend_t_sig.rb similarity index 87% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/redundant_extend_t_sig.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/redundant_extend_t_sig.rb index 5f6f492861899..88076822965d5 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/redundant_extend_t_sig.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/redundant_extend_t_sig.rb @@ -25,10 +25,13 @@ module Sorbet # def no_op; end # end # - class RedundantExtendTSig < RuboCop::Cop::Cop + class RedundantExtendTSig < RuboCop::Cop::Base + extend AutoCorrector + MSG = "Do not redundantly `extend T::Sig` when it is already included in all modules." RESTRICT_ON_SEND = [:extend].freeze + # @!method extend_t_sig?(node) def_node_matcher :extend_t_sig?, <<~PATTERN (send _ :extend (const (const {nil? | cbase} :T) :Sig)) PATTERN @@ -36,11 +39,7 @@ class RedundantExtendTSig < RuboCop::Cop::Cop def on_send(node) return unless extend_t_sig?(node) - add_offense(node) - end - - def autocorrect(node) - lambda do |corrector| + add_offense(node) do |corrector| corrector.remove(node) end end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb similarity index 96% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb index 988195d859e24..7cf246d10710d 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb @@ -5,7 +5,7 @@ module RuboCop module Cop module Sorbet - # This cop checks that the Sorbet sigil comes as the first magic comment in the file. + # Checks that the Sorbet sigil comes as the first magic comment in the file. # # The expected order for magic comments is: (en)?coding, typed, warn_indent then frozen_string_literal. # @@ -57,6 +57,7 @@ def autocorrect(_node) (lines.min...lines.max).each do |line| next if lines.include?(line) next unless processed_source[line - 1].empty? + corrector.remove(source_range(processed_source.buffer, line, 0)) end end @@ -104,7 +105,7 @@ def check_magic_comments_order(tokens) add_offense( token, location: token.pos, - message: "Magic comments should be in the following order: #{PREFERRED_ORDER.values.join(", ")}." + message: "Magic comments should be in the following order: #{PREFERRED_ORDER.values.join(", ")}.", ) end end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb similarity index 87% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb index ee2de41a4bd45..11027f723101a 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb @@ -3,7 +3,7 @@ module RuboCop module Cop module Sorbet - # This cop checks that there is only one Sorbet sigil in a given file + # Checks that there is only one Sorbet sigil in a given file # # For example, the following class with two sigils # @@ -28,8 +28,9 @@ class EnforceSingleSigil < ValidSigil def investigate(processed_source) return if processed_source.tokens.empty? + sigils = extract_all_sigils(processed_source) - return unless sigils.size > 1 + return if sigils.empty? sigils[1..sigils.size].each do |token| add_offense(token, location: token.pos, message: "Files must only contain one sigil") @@ -37,14 +38,14 @@ def investigate(processed_source) end def autocorrect(_node) - -> (corrector) do + ->(corrector) do sigils = extract_all_sigils(processed_source) - return unless sigils.size > 1 + return if sigils.empty? # The first sigil encountered represents the "real" strictness so remove any below sigils[1..sigils.size].each do |token| corrector.remove( - source_range(processed_source.buffer, token.line, (0..token.pos.last_column)) + source_range(processed_source.buffer, token.line, (0..token.pos.last_column)), ) end end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/false_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/false_sigil.rb similarity index 77% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/false_sigil.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/false_sigil.rb index 1f7d9e4ff13db..286d532963697 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/false_sigil.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/false_sigil.rb @@ -6,7 +6,7 @@ module RuboCop module Cop module Sorbet - # This cop makes the Sorbet `false` sigil mandatory in all files. + # Makes the Sorbet `false` sigil mandatory in all files. class FalseSigil < HasSigil def minimum_strictness "false" diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/has_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/has_sigil.rb similarity index 90% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/has_sigil.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/has_sigil.rb index 4143b0aa5ef84..e31c210820b58 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/has_sigil.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/has_sigil.rb @@ -6,7 +6,7 @@ module RuboCop module Cop module Sorbet - # This cop makes the Sorbet typed sigil mandatory in all files. + # Makes the Sorbet typed sigil mandatory in all files. # # Options: # diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/ignore_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/ignore_sigil.rb similarity index 77% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/ignore_sigil.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/ignore_sigil.rb index 0e1130310a71d..71cd205993764 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/ignore_sigil.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/ignore_sigil.rb @@ -6,7 +6,7 @@ module RuboCop module Cop module Sorbet - # This cop makes the Sorbet `ignore` sigil mandatory in all files. + # Makes the Sorbet `ignore` sigil mandatory in all files. class IgnoreSigil < HasSigil def minimum_strictness "ignore" diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/strict_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/strict_sigil.rb similarity index 77% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/strict_sigil.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/strict_sigil.rb index 6c415ea04e1f5..9dd7b805eca64 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/strict_sigil.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/strict_sigil.rb @@ -6,7 +6,7 @@ module RuboCop module Cop module Sorbet - # This cop makes the Sorbet `strict` sigil mandatory in all files. + # Makes the Sorbet `strict` sigil mandatory in all files. class StrictSigil < HasSigil def minimum_strictness "strict" diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/strong_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/strong_sigil.rb similarity index 77% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/strong_sigil.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/strong_sigil.rb index 567c46c790624..36cc3cc4e8d09 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/strong_sigil.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/strong_sigil.rb @@ -6,7 +6,7 @@ module RuboCop module Cop module Sorbet - # This cop makes the Sorbet `strong` sigil mandatory in all files. + # Makes the Sorbet `strong` sigil mandatory in all files. class StrongSigil < HasSigil def minimum_strictness "strong" diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/true_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/true_sigil.rb similarity index 77% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/true_sigil.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/true_sigil.rb index 415e69155447c..cae63fc99768d 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/true_sigil.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/true_sigil.rb @@ -6,7 +6,7 @@ module RuboCop module Cop module Sorbet - # This cop makes the Sorbet `true` sigil mandatory in all files. + # Makes the Sorbet `true` sigil mandatory in all files. class TrueSigil < HasSigil def minimum_strictness "true" diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb similarity index 62% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb index 7c35e693ff176..c62a5732a648f 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb @@ -5,7 +5,7 @@ module RuboCop module Cop module Sorbet - # This cop checks that every Ruby file contains a valid Sorbet sigil. + # Checks that every Ruby file contains a valid Sorbet sigil. # Adapted from: https://gist.github.com/clarkdave/85aca4e16f33fd52aceb6a0a29936e52 # # Options: @@ -13,9 +13,11 @@ module Sorbet # * `RequireSigilOnAllFiles`: make offense if the Sorbet typed is not found in the file (default: false) # * `SuggestedStrictness`: Sorbet strictness level suggested in offense messages (default: 'false') # * `MinimumStrictness`: If set, make offense if the strictness level in the file is below this one + # * `ExactStrictness`: If set, make offense if the strictness level in the file is different than this one # - # If a `MinimumStrictness` level is specified, it will be used in offense messages and autocorrect. - class ValidSigil < RuboCop::Cop::Cop + # If an `ExactStrictness` level is specified, it will be used in offense messages and autocorrect. + # Otherwise, if a `MinimumStrictness` level is specified, it will be used in offense messages and autocorrect. + class ValidSigil < RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass @registry = Cop.registry # So we can properly subclass this cop def investigate(processed_source) @@ -36,7 +38,7 @@ def autocorrect(_node) return unless extract_sigil(processed_source).nil? token = processed_source.tokens.first - replace_with = suggested_strictness_level(minimum_strictness, suggested_strictness) + replace_with = suggested_strictness_level sigil = "# typed: #{replace_with}" if token.text.start_with?("#!") # shebang line corrector.insert_after(token.pos, "\n#{sigil}") @@ -49,7 +51,7 @@ def autocorrect(_node) protected STRICTNESS_LEVELS = ["ignore", "false", "true", "strict", "strong"] - SIGIL_REGEX = /^\s*#\s+typed:(?:\s+([\w]+))?/ + SIGIL_REGEX = /^[[:blank:]]*#[[:blank:]]+typed:(?:[[:blank:]]+([\S]+))?/ # extraction @@ -70,34 +72,37 @@ def check_sigil_present(sigil) token = processed_source.tokens.first if require_sigil_on_all_files? - strictness = suggested_strictness_level(minimum_strictness, suggested_strictness) + strictness = suggested_strictness_level add_offense( token, location: token.pos, message: "No Sorbet sigil found in file. " \ - "Try a `typed: #{strictness}` to start (you can also use `rubocop -a` to automatically add this)." + "Try a `typed: #{strictness}` to start (you can also use `rubocop -a` to automatically add this).", ) end false end - def suggested_strictness_level(minimum_strictness, suggested_strictness) + def suggested_strictness_level + return exact_strictness if exact_strictness # if no minimum strictness is set (eg. using Sorbet/HasSigil without config) then # we always use the suggested strictness which defaults to `false` return suggested_strictness unless minimum_strictness # special case: if you're using Sorbet/IgnoreSigil without config, we should recommend `ignore` - return "ignore" if minimum_strictness == "ignore" && cop_config["SuggestedStrictness"].nil? + return "ignore" if minimum_strictness == "ignore" && cop_config["SuggestedStrictness"].nil? # rubocop:todo InternalAffairs/UndefinedConfig # if a minimum strictness is set (eg. you're using Sorbet/FalseSigil) # we want to compare the minimum strictness and suggested strictness. this is because # the suggested strictness might be higher than the minimum (eg. if you want all new files # at a higher strictness level, without having to migrate existing files at lower levels). - suggested_level = STRICTNESS_LEVELS.index(suggested_strictness) - minimum_level = STRICTNESS_LEVELS.index(minimum_strictness) + levels = [ + STRICTNESS_LEVELS.index(suggested_strictness), + STRICTNESS_LEVELS.index(minimum_strictness), + ] - suggested_level > minimum_level ? suggested_strictness : minimum_strictness + STRICTNESS_LEVELS[levels.compact.max] end def check_strictness_not_empty(sigil, strictness) @@ -106,7 +111,7 @@ def check_strictness_not_empty(sigil, strictness) add_offense( sigil, location: sigil.pos, - message: "Sorbet sigil should not be empty." + message: "Sorbet sigil should not be empty.", ) false end @@ -117,24 +122,38 @@ def check_strictness_valid(sigil, strictness) add_offense( sigil, location: sigil.pos, - message: "Invalid Sorbet sigil `#{strictness}`." + message: "Invalid Sorbet sigil `#{strictness}`.", ) false end def check_strictness_level(sigil, strictness) - return true unless minimum_strictness + return true if !minimum_strictness && !exact_strictness - minimum_level = STRICTNESS_LEVELS.index(minimum_strictness) current_level = STRICTNESS_LEVELS.index(strictness) - if current_level < minimum_level - add_offense( - sigil, - location: sigil.pos, - message: "Sorbet sigil should be at least `#{minimum_strictness}` got `#{strictness}`." - ) - return false + + if exact_strictness + exact_level = STRICTNESS_LEVELS.index(exact_strictness) + if current_level != exact_level + add_offense( + sigil, + location: sigil.pos, + message: "Sorbet sigil should be `#{exact_strictness}` got `#{strictness}`.", + ) + return false + end + else + minimum_level = STRICTNESS_LEVELS.index(minimum_strictness) + if current_level < minimum_level + add_offense( + sigil, + location: sigil.pos, + message: "Sorbet sigil should be at least `#{minimum_strictness}` got `#{strictness}`.", + ) + return false + end end + true end @@ -142,18 +161,24 @@ def check_strictness_level(sigil, strictness) # Default is `false` def require_sigil_on_all_files? - !!cop_config["RequireSigilOnAllFiles"] + !!cop_config["RequireSigilOnAllFiles"] # rubocop:todo InternalAffairs/UndefinedConfig end # Default is `'false'` def suggested_strictness - config = cop_config["SuggestedStrictness"].to_s + config = cop_config["SuggestedStrictness"].to_s # rubocop:todo InternalAffairs/UndefinedConfig STRICTNESS_LEVELS.include?(config) ? config : "false" end # Default is `nil` def minimum_strictness - config = cop_config["MinimumStrictness"].to_s + config = cop_config["MinimumStrictness"].to_s # rubocop:todo InternalAffairs/UndefinedConfig + config if STRICTNESS_LEVELS.include?(config) + end + + # Default is `nil` + def exact_strictness + config = cop_config["ExactStrictness"].to_s # rubocop:todo InternalAffairs/UndefinedConfig config if STRICTNESS_LEVELS.include?(config) end end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb new file mode 100644 index 0000000000000..570ca8bb6aadb --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb @@ -0,0 +1,76 @@ +# frozen_string_literal: true + +require "rubocop" + +module RuboCop + module Cop + module Sorbet + # Disallows using `.override(allow_incompatible: true)`. + # Using `allow_incompatible` suggests a violation of the Liskov + # Substitution Principle, meaning that a subclass is not a valid + # subtype of its superclass. This Cop prevents these design smells + # from occurring. + # + # @example + # + # # bad + # sig.override(allow_incompatible: true) + # + # # good + # sig.override + class AllowIncompatibleOverride < RuboCop::Cop::Base + MSG = "Usage of `allow_incompatible` suggests a violation of the Liskov Substitution Principle. " \ + "Instead, strive to write interfaces which respect subtyping principles and remove `allow_incompatible`" + RESTRICT_ON_SEND = [:override].freeze + + # @!method sig_dot_override?(node) + def_node_matcher(:sig_dot_override?, <<~PATTERN) + (send + [!nil? #sig?] + :override + (hash <$(pair (sym :allow_incompatible) true) ...>) + ) + PATTERN + + # @!method sig?(node) + def_node_search(:sig?, <<~PATTERN) + (send _ :sig ...) + PATTERN + + # @!method override?(node) + def_node_matcher(:override?, <<~PATTERN) + (send + _ + :override + (hash <$(pair (sym :allow_incompatible) true) ...>) + ) + PATTERN + + def on_send(node) + sig_dot_override?(node) do |allow_incompatible_pair| + add_offense(allow_incompatible_pair) + end + end + + def on_block(node) + return unless sig?(node.send_node) + + block = node.children.last + return unless block.send_type? + + receiver = block.receiver + while receiver + allow_incompatible_pair = override?(receiver) + if allow_incompatible_pair + add_offense(allow_incompatible_pair) + break + end + receiver = receiver.receiver + end + end + + alias_method :on_numblock, :on_block + end + end + end +end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb similarity index 92% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb index 4166214a9bf6b..b8ead9371eec0 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb @@ -6,7 +6,7 @@ module RuboCop module Cop module Sorbet - # This cop disallows the usage of `checked(true)`. This usage could cause + # Disallows the usage of `checked(true)`. This usage could cause # confusion; it could lead some people to believe that a method would be checked # even if runtime checks have not been enabled on the class or globally. # Additionally, in the event where checks are enabled, `checked(true)` would @@ -22,6 +22,7 @@ module Sorbet class CheckedTrueInSignature < SignatureCop include(RuboCop::Cop::RangeHelp) + # @!method offending_node(node) def_node_search(:offending_node, <<~PATTERN) (send _ :checked (true)) PATTERN @@ -44,7 +45,7 @@ def on_signature(node) error.location.line, (error.location.selector.begin_pos)..(error.location.end.begin_pos), ), - message: MESSAGE + message: MESSAGE, ) end end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/empty_line_after_sig.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/empty_line_after_sig.rb similarity index 93% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/empty_line_after_sig.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/empty_line_after_sig.rb index 358c3bf48d27b..5f1306a2cebf7 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/empty_line_after_sig.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/empty_line_after_sig.rb @@ -5,7 +5,7 @@ module RuboCop module Cop module Sorbet - # This cop checks for blank lines after signatures. + # Checks for blank lines after signatures. # # It also suggests an autocorrect # @@ -31,10 +31,10 @@ def on_signature(node) end def autocorrect(node) - -> (corrector) do + ->(corrector) do offending_range = node.source_range.with( begin_pos: node.source_range.end_pos + 1, - end_pos: processed_source.buffer.line_range(next_method(node).line).begin_pos + end_pos: processed_source.buffer.line_range(next_method(node).line).begin_pos, ) corrector.remove(offending_range) clean_range = offending_range.source.split("\n").reject(&:empty?).join("\n") diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb similarity index 94% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb index a6fd572970d63..ee0f10433e28c 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb @@ -7,7 +7,7 @@ module RuboCop module Cop module Sorbet - # This cop checks that every method definition and attribute accessor has a Sorbet signature. + # Checks that every method definition and attribute accessor has a Sorbet signature. # # It also suggest an autocorrect with placeholders so the following code: # @@ -32,6 +32,7 @@ def initialize(config = nil, options = nil) @last_sig_for_scope = {} end + # @!method accessor?(node) def_node_matcher(:accessor?, <<-PATTERN) (send nil? {:attr_reader :attr_writer :attr_accessor} ...) PATTERN @@ -67,13 +68,14 @@ def autocorrect(node) suggest.returns = "void" if method == :attr_writer end - corrector.insert_before(node.loc.expression, suggest.to_autocorrect) + corrector.insert_before(node, suggest.to_autocorrect) end end def scope(node) - return nil unless node.parent + return unless node.parent return node.parent if [:begin, :block, :class, :module].include?(node.parent.type) + scope(node.parent) end @@ -84,7 +86,7 @@ def check_node(node) unless @last_sig_for_scope[scope] add_offense( node, - message: "Each method is required to have a signature." + message: "Each method is required to have a signature.", ) end @last_sig_for_scope[scope] = nil @@ -123,6 +125,7 @@ def to_autocorrect def generate_params return if @params.empty? + out = StringIO.new out << "params(" out << @params.map do |param| @@ -135,6 +138,7 @@ def generate_params def generate_return return "returns(#{@return_placeholder})" if @returns.nil? return @returns if @returns == "void" + "returns(#{@returns})" end end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/keyword_argument_ordering.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/keyword_argument_ordering.rb similarity index 80% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/keyword_argument_ordering.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/keyword_argument_ordering.rb index d98d9032aa710..a5dc52323debf 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/keyword_argument_ordering.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/keyword_argument_ordering.rb @@ -6,7 +6,7 @@ module RuboCop module Cop module Sorbet - # This cop checks for the ordering of keyword arguments required by + # Checks for the ordering of keyword arguments required by # sorbet-runtime. The ordering requires that all keyword arguments # are at the end of the parameters list, and all keyword arguments # with a default value must be after those without default values. @@ -24,6 +24,7 @@ class KeywordArgumentOrdering < SignatureCop def on_signature(node) method_node = node.parent.children[node.sibling_index + 1] return if method_node.nil? + method_parameters = method_node.arguments check_order_for_kwoptargs(method_parameters) @@ -35,13 +36,13 @@ def check_order_for_kwoptargs(parameters) out_of_kwoptarg = false parameters.reverse.each do |param| - out_of_kwoptarg = true unless param.type == :kwoptarg || param.type == :blockarg || param.type == :kwrestarg + out_of_kwoptarg = true unless param.kwoptarg_type? || param.blockarg_type? || param.kwrestarg_type? - next unless param.type == :kwoptarg && out_of_kwoptarg + next unless param.kwoptarg_type? && out_of_kwoptarg add_offense( param, - message: "Optional keyword arguments must be at the end of the parameter list." + message: "Optional keyword arguments must be at the end of the parameter list.", ) end end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb similarity index 89% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb index a09ea877d565d..836b45225b559 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb @@ -27,13 +27,18 @@ class SignatureBuildOrder < SignatureCop :on_failure, ].each_with_index.to_h.freeze + # @!method root_call(node) def_node_search(:root_call, <<~PATTERN) (send nil? {#{ORDER.keys.map(&:inspect).join(" ")}} ...) PATTERN def on_signature(node) calls = call_chain(node.children[2]).map(&:method_name) - return unless calls.any? + return if calls.empty? + + # While the developer is typing, we may have an incomplete call statement, which means `ORDER[call]` will + # return `nil`. In that case, invoking `sort_by` will raise + return if calls.any? { |call| ORDER[call].nil? } expected_order = calls.sort_by { |call| ORDER[call] } return if expected_order == calls @@ -52,7 +57,7 @@ def on_signature(node) end def autocorrect(node) - return nil unless can_autocorrect? + return unless can_autocorrect? lambda do |corrector| tree = call_chain(node_reparsed_with_modern_features(node)) @@ -62,7 +67,7 @@ def autocorrect(node) end corrector.replace( - node.source_range, + node, Unparser.unparse(tree), ) end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/signature_cop.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/signature_cop.rb similarity index 78% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/signature_cop.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/signature_cop.rb index 99bef18302c49..bf865e59d87df 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet/signatures/signature_cop.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/signatures/signature_cop.rb @@ -8,9 +8,10 @@ module Sorbet # Abstract cop specific to Sorbet signatures # # You can subclass it to use the `on_signature` trigger and the `signature?` node matcher. - class SignatureCop < RuboCop::Cop::Cop + class SignatureCop < RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass @registry = Cop.registry # So we can properly subclass this cop + # @!method signature?(node) def_node_matcher(:signature?, <<~PATTERN) (block (send {nil? #with_runtime? #without_runtime?} @@ -19,10 +20,12 @@ class SignatureCop < RuboCop::Cop::Cop ) (args) ...) PATTERN + # @!method with_runtime?(node) def_node_matcher(:with_runtime?, <<~PATTERN) (const (const nil? :T) :Sig) PATTERN + # @!method without_runtime?(node) def_node_matcher(:without_runtime?, <<~PATTERN) (const (const (const nil? :T) :Sig) :WithoutRuntime) PATTERN @@ -31,6 +34,8 @@ def on_block(node) on_signature(node) if signature?(node) end + alias_method :on_numblock, :on_block + def on_signature(_) # To be defined in subclasses end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/type_alias_name.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/type_alias_name.rb new file mode 100644 index 0000000000000..78259323393f6 --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet/type_alias_name.rb @@ -0,0 +1,38 @@ +# frozen_string_literal: true + +require "rubocop" + +module RuboCop + module Cop + module Sorbet + # Ensures all constants used as `T.type_alias` are using CamelCase. + # + # @example + # + # # bad + # FOO_OR_BAR = T.type_alias { T.any(Foo, Bar) } + # + # # good + # FooOrBar = T.type_alias { T.any(Foo, Bar) } + class TypeAliasName < RuboCop::Cop::Base + MSG = "Type alias constant name should be in CamelCase" + + # @!method underscored_type_alias?(node) + def_node_matcher(:underscored_type_alias?, <<-PATTERN) + (casgn + _ + /_/ # Name matches underscore + (block + (send (const nil? :T) :type_alias) + ... + ) + ) + PATTERN + + def on_casgn(node) + add_offense(node) if underscored_type_alias?(node) + end + end + end + end +end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet_cops.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet_cops.rb similarity index 87% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet_cops.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet_cops.rb index cfc8f93a23a07..c9556dcd55ab2 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/cop/sorbet_cops.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/cop/sorbet_cops.rb @@ -1,15 +1,20 @@ # frozen_string_literal: true -require_relative "sorbet/binding_constants_without_type_alias" + +require_relative "sorbet/mixin/target_sorbet_version.rb" + +require_relative "sorbet/binding_constant_without_type_alias" require_relative "sorbet/constants_from_strings" require_relative "sorbet/forbid_superclass_const_literal" require_relative "sorbet/forbid_include_const_literal" require_relative "sorbet/forbid_untyped_struct_props" +require_relative "sorbet/implicit_conversion_method" require_relative "sorbet/one_ancestor_per_line" require_relative "sorbet/callback_conditionals_binding" require_relative "sorbet/forbid_t_unsafe" require_relative "sorbet/forbid_t_untyped" require_relative "sorbet/redundant_extend_t_sig" require_relative "sorbet/type_alias_name" +require_relative "sorbet/obsolete_strict_memoization" require_relative "sorbet/rbi/forbid_extend_t_sig_helpers_in_shims" require_relative "sorbet/rbi/forbid_rbi_outside_of_allowed_paths" diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/sorbet.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/sorbet.rb similarity index 99% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/sorbet.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/sorbet.rb index 23e6647ed5ee6..cd618ee18dcbc 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/sorbet.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/sorbet.rb @@ -1,4 +1,5 @@ # frozen_string_literal: true + require "rubocop/sorbet/version" require "yaml" diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/sorbet/inject.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/sorbet/inject.rb new file mode 100644 index 0000000000000..b3a31508b5d2d --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/sorbet/inject.rb @@ -0,0 +1,22 @@ +# frozen_string_literal: true + +# The original code is from https://github.com/rubocop-hq/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb +# See https://github.com/rubocop-hq/rubocop-rspec/blob/master/MIT-LICENSE.md +module RuboCop + module Sorbet + # Because RuboCop doesn't yet support plugins, we have to monkey patch in a + # bit of our configuration. + module Inject + class << self + def defaults! + path = CONFIG_DEFAULT.to_s + hash = ConfigLoader.send(:load_yaml_configuration, path) + config = Config.new(hash, path).tap(&:make_excludes_absolute) + puts "configuration from #{path}" if ConfigLoader.debug? + config = ConfigLoader.merge_with_default(config, path) + ConfigLoader.instance_variable_set(:@default_configuration, config) + end + end + end + end +end diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/sorbet/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/sorbet/version.rb similarity index 75% rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/sorbet/version.rb rename to Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/sorbet/version.rb index cb4e0a3956d27..7b84c846f7012 100644 --- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.0/lib/rubocop/sorbet/version.rb +++ b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.7.3/lib/rubocop/sorbet/version.rb @@ -1,6 +1,7 @@ # frozen_string_literal: true + module RuboCop module Sorbet - VERSION = "0.7.0" + VERSION = "0.7.3" end end