sorbet-runtime 0.4.4667 → 0.5.6189

data/lib/types/private/methods/decl_builder.rb

@@ -2,7 +2,7 @@
 # typed: true
 
 module T::Private::Methods
-  Declaration = Struct.new(:mod, :params, :returns, :bind, :mode, :checked, :finalized, :on_failure, :override_allow_incompatible, :type_parameters, :generated)
+  Declaration = Struct.new(:mod, :params, :returns, :bind, :mode, :checked, :finalized, :on_failure, :override_allow_incompatible, :type_parameters)
 
   class DeclBuilder
     attr_reader :decl
@@ -28,16 +28,18 @@ module T::Private::Methods
         ARG_NOT_PROVIDED, # on_failure
         nil, # override_allow_incompatible
         ARG_NOT_PROVIDED, # type_parameters
-        ARG_NOT_PROVIDED, # generated
       )
     end
 
-    def params(params)
+    def params(**params)
       check_live!
       if !decl.params.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .params twice")
       end
 
+      if params.empty?
+        raise BuilderError.new("params expects keyword arguments")
+      end
       decl.params = params
 
       self
@@ -88,9 +90,6 @@ module T::Private::Methods
       if level == :never && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't use .checked(:never) with .on_failure because .on_failure will have no effect.")
       end
-      if !decl.generated.equal?(ARG_NOT_PROVIDED)
-        raise BuilderError.new("You can't use .checked with .generated.")
-      end
       if !T::Private::RuntimeLevels::LEVELS.include?(level)
         raise BuilderError.new("Invalid `checked` level '#{level}'. Use one of: #{T::Private::RuntimeLevels::LEVELS}.")
       end
@@ -109,33 +108,12 @@ module T::Private::Methods
       if decl.checked == :never
         raise BuilderError.new("You can't use .on_failure with .checked(:never) because .on_failure will have no effect.")
       end
-      if !decl.generated.equal?(ARG_NOT_PROVIDED)
-        raise BuilderError.new("You can't use .on_failure with .generated.")
-      end
 
       decl.on_failure = args
 
       self
     end
 
-    def generated
-      check_live!
-
-      if !decl.generated.equal?(ARG_NOT_PROVIDED)
-        raise BuilderError.new("You can't call .generated multiple times in a signature.")
-      end
-      if !decl.checked.equal?(ARG_NOT_PROVIDED)
-        raise BuilderError.new("You can't use .generated with .checked.")
-      end
-      if !decl.on_failure.equal?(ARG_NOT_PROVIDED)
-        raise BuilderError.new("You can't use .generated with .on_failure.")
-      end
-
-      decl.generated = true
-
-      self
-    end
-
     def abstract
       check_live!
 
@@ -145,8 +123,7 @@ module T::Private::Methods
       when Modes.abstract
         raise BuilderError.new(".abstract cannot be repeated in a single signature")
       else
-        raise BuilderError.new("`.abstract` cannot be combined with any of `.override`, `.implementation`, or "\
-              "`.overridable`.")
+        raise BuilderError.new("`.abstract` cannot be combined with `.override` or `.overridable`.")
       end
 
       self
@@ -164,11 +141,12 @@ module T::Private::Methods
       when Modes.standard
         decl.mode = Modes.override
         decl.override_allow_incompatible = allow_incompatible
-      when Modes.override
+      when Modes.override, Modes.overridable_override
         raise BuilderError.new(".override cannot be repeated in a single signature")
+      when Modes.overridable
+        decl.mode = Modes.overridable_override
       else
-        raise BuilderError.new("`.override` cannot be combined with any of `.abstract`, `.implementation`, or "\
-              "`.overridable`.")
+        raise BuilderError.new("`.override` cannot be combined with `.abstract`.")
       end
 
       self
@@ -178,36 +156,19 @@ module T::Private::Methods
       check_live!
 
       case decl.mode
-      when Modes.abstract, Modes.override
+      when Modes.abstract
         raise BuilderError.new("`.overridable` cannot be combined with `.#{decl.mode}`")
+      when Modes.override
+        decl.mode = Modes.overridable_override
       when Modes.standard
         decl.mode = Modes.overridable
-      when Modes.implementation
-        decl.mode = Modes.overridable_implementation
-      when Modes.overridable, Modes.overridable_implementation
+      when Modes.overridable, Modes.overridable_override
         raise BuilderError.new(".overridable cannot be repeated in a single signature")
       end
 
       self
     end
 
-    def implementation
-      check_live!
-
-      case decl.mode
-      when Modes.abstract, Modes.override
-        raise BuilderError.new("`.implementation` cannot be combined with `.#{decl.mode}`")
-      when Modes.standard
-        decl.mode = Modes.implementation
-      when Modes.overridable
-        decl.mode = Modes.overridable_implementation
-      when Modes.implementation, Modes.overridable_implementation
-        raise BuilderError.new(".implementation cannot be repeated in a single signature")
-      end
-
-      self
-    end
-
     # Declares valid type paramaters which can be used with `T.type_parameter` in
     # this `sig`.
     #
@@ -255,9 +216,6 @@ module T::Private::Methods
       if decl.on_failure.equal?(ARG_NOT_PROVIDED)
         decl.on_failure = nil
       end
-      if decl.generated.equal?(ARG_NOT_PROVIDED)
-        decl.generated = false
-      end
       if decl.params.equal?(ARG_NOT_PROVIDED)
         decl.params = {}
       end

data/lib/types/private/methods/modes.rb

@@ -5,14 +5,12 @@ module T::Private::Methods::Modes
   def self.standard; 'standard'; end
   def self.abstract; 'abstract'; end
   def self.overridable; 'overridable'; end
-  def self.implementation; 'implementation'; end
   def self.override; 'override'; end
-  def self.overridable_implementation; 'overridable_implementation'; end
+  def self.overridable_override; 'overridable_override'; end
   def self.untyped; 'untyped'; end
-  MODES = [self.standard, self.abstract, self.overridable, self.implementation, self.override, self.overridable_implementation, self.untyped]
+  MODES = [self.standard, self.abstract, self.overridable, self.override, self.overridable_override, self.untyped].freeze
 
-  IMPLEMENT_MODES = [self.implementation, self.overridable_implementation]
-  OVERRIDABLE_MODES = [self.override, self.overridable, self.overridable_implementation, self.untyped]
-  OVERRIDE_MODES = [self.override]
-  NON_OVERRIDE_MODES = MODES - OVERRIDE_MODES - IMPLEMENT_MODES
+  OVERRIDABLE_MODES = [self.override, self.overridable, self.overridable_override, self.untyped, self.abstract].freeze
+  OVERRIDE_MODES = [self.override, self.overridable_override].freeze
+  NON_OVERRIDE_MODES = MODES - OVERRIDE_MODES
 end

data/lib/types/private/methods/signature.rb

@@ -5,7 +5,7 @@ class T::Private::Methods::Signature
   attr_reader :method, :method_name, :arg_types, :kwarg_types, :block_type, :block_name,
               :rest_type, :rest_name, :keyrest_type, :keyrest_name, :bind,
               :return_type, :mode, :req_arg_count, :req_kwarg_names, :has_rest, :has_keyrest,
-              :check_level, :generated, :parameters, :on_failure, :override_allow_incompatible, :ever_failed
+              :check_level, :parameters, :on_failure, :override_allow_incompatible
 
   def self.new_untyped(method:, mode: T::Private::Methods::Modes.untyped, parameters: method.parameters)
     # Using `Untyped` ensures we'll get an error if we ever try validation on these.
@@ -28,11 +28,7 @@ class T::Private::Methods::Signature
     )
   end
 
-  def mark_failed
-    @ever_failed = true
-  end
-
-  def initialize(method:, method_name:, raw_arg_types:, raw_return_type:, bind:, mode:, check_level:, parameters: method.parameters, on_failure:, generated: false, override_allow_incompatible: false)
+  def initialize(method:, method_name:, raw_arg_types:, raw_return_type:, bind:, mode:, check_level:, on_failure:, parameters: method.parameters, override_allow_incompatible: false)
     @method = method
     @method_name = method_name
     @arg_types = []
@@ -54,11 +50,15 @@ class T::Private::Methods::Signature
     @parameters = parameters
     @on_failure = on_failure
     @override_allow_incompatible = override_allow_incompatible
-    @generated = generated
-    @ever_failed = false
 
-    param_names = parameters.map {|_, name| name}
     declared_param_names = raw_arg_types.keys
+    # If sig params are declared but there is a single parameter with a missing name
+    # **and** the method ends with a "=", assume it is a writer method generated
+    # by attr_writer or attr_accessor
+    writer_method = declared_param_names != [nil] && parameters == [[:req]] && method_name[-1] == "="
+    # For writer methods, map the single parameter to the method name without the "=" at the end
+    parameters = [[:req, method_name[0...-1].to_sym]] if writer_method
+    param_names = parameters.map {|_, name| name}
     missing_names = param_names - declared_param_names
     extra_names = declared_param_names - param_names
     if !missing_names.empty?
@@ -68,6 +68,10 @@ class T::Private::Methods::Signature
       raise "The declaration for `#{method.name}` has extra parameter(s): #{extra_names.join(', ')}"
     end
 
+    if parameters.size != raw_arg_types.size
+      raise "The declaration for `#{method.name}` has arguments with duplicate names"
+    end
+
     parameters.zip(raw_arg_types) do |(param_kind, param_name), (type_name, raw_type)|
       if type_name != param_name
         hint = ""
@@ -121,6 +125,15 @@ class T::Private::Methods::Signature
     end
   end
 
+  attr_writer :method_name
+  protected :method_name=
+
+  def as_alias(alias_name)
+    new_sig = clone
+    new_sig.method_name = alias_name
+    new_sig
+  end
+
   def arg_count
     @arg_types.length
   end
@@ -146,9 +159,10 @@ class T::Private::Methods::Signature
     # can't) match the definition of the method we're validating. In addition, Ruby has a bug that
     # causes forwarding **kwargs to do the wrong thing: see https://bugs.ruby-lang.org/issues/10708
     # and https://bugs.ruby-lang.org/issues/11860.
-    if (args.length > @req_arg_count) && (!@kwarg_types.empty? || @has_keyrest) && args[-1].is_a?(Hash)
+    args_length = args.length
+    if (args_length > @req_arg_count) && (!@kwarg_types.empty? || @has_keyrest) && args[-1].is_a?(Hash)
       kwargs = args[-1]
-      args = args[0...-1]
+      args_length -= 1
     else
       kwargs = EMPTY_HASH
     end
@@ -156,19 +170,19 @@ class T::Private::Methods::Signature
     arg_types = @arg_types
 
     if @has_rest
-      arg_types += [[@rest_name, @rest_type]] * (args.length - @arg_types.length)
+      arg_types += [[@rest_name, @rest_type]] * (args_length - @arg_types.length)
 
-    elsif (args.length < @req_arg_count) || (args.length > @arg_types.length)
+    elsif (args_length < @req_arg_count) || (args_length > @arg_types.length)
       expected_str = @req_arg_count.to_s
       if @arg_types.length != @req_arg_count
         expected_str += "..#{@arg_types.length}"
       end
-      raise ArgumentError.new("wrong number of arguments (given #{args.length}, expected #{expected_str})")
+      raise ArgumentError.new("wrong number of arguments (given #{args_length}, expected #{expected_str})")
     end
 
     begin
       it = 0
-      while it < args.length
+      while it < args_length
         yield arg_types[it][0], args[it], arg_types[it][1]
         it += 1
       end
@@ -184,10 +198,10 @@ class T::Private::Methods::Signature
   end
 
   def method_desc
-    if @method.source_location
-      loc = @method.source_location.join(':')
+    loc = if @method.source_location
+      @method.source_location.join(':')
     else
-      loc = "<unknown location>"
+      "<unknown location>"
     end
     "#{@method} at #{loc}"
   end

data/lib/types/private/methods/signature_validation.rb

@@ -48,8 +48,8 @@ module T::Private::Methods::SignatureValidation
   end
 
   private_class_method def self.pretty_mode(signature)
-    if signature.mode == Modes.overridable_implementation
-      '.overridable.implementation'
+    if signature.mode == Modes.overridable_override
+      '.overridable.override'
     else
       ".#{signature.mode}"
     end
@@ -58,22 +58,12 @@ module T::Private::Methods::SignatureValidation
   def self.validate_override_mode(signature, super_signature)
     case signature.mode
     when *Modes::OVERRIDE_MODES
-      if !Modes::OVERRIDABLE_MODES.include?(super_signature.mode)
-        raise "You declared `#{signature.method_name}` as #{pretty_mode(signature)}, but the method it overrides is not declared as `overridable`.\n" \
-              "  Parent definition: #{method_loc_str(super_signature.method)}\n" \
-              "  Child definition:  #{method_loc_str(signature.method)}\n"
-      end
-    when *Modes::IMPLEMENT_MODES
-      if super_signature.mode != Modes.abstract
-        raise "You declared `#{signature.method_name}` as #{pretty_mode(signature)}, but the method it overrides is not declared as abstract.\n" \
-              "  Either mark #{super_signature.method_name} as `abstract.` in the parent: #{method_loc_str(super_signature.method)}\n" \
-              "  ... or mark #{signature.method_name} as `override.` in the child: #{method_loc_str(signature.method)}\n"
-      end
+      # Peaceful
     when *Modes::NON_OVERRIDE_MODES
       if super_signature.mode == Modes.standard
         # Peaceful
       elsif super_signature.mode == Modes.abstract
-        raise "You must use `.implementation` when overriding the abstract method `#{signature.method_name}`.\n" \
+        raise "You must use `.override` when overriding the abstract method `#{signature.method_name}`.\n" \
               "  Abstract definition: #{method_loc_str(super_signature.method)}\n" \
               "  Implementation definition: #{method_loc_str(signature.method)}\n"
       elsif super_signature.mode != Modes.untyped
@@ -89,33 +79,37 @@ module T::Private::Methods::SignatureValidation
   def self.validate_non_override_mode(signature)
     case signature.mode
     when Modes.override
-      raise "You marked `#{signature.method_name}` as #{pretty_mode(signature)}, but that method doesn't already exist in this class/module to be overriden.\n" \
-        "  Either check for typos and for missing includes or super classes to make the parent method shows up\n" \
-        "  ... or remove #{pretty_mode(signature)} here: #{method_loc_str(signature.method)}\n"
+      if signature.method_name == :each && signature.method.owner < Enumerable
+        # Enumerable#each is the only method in Sorbet's RBI payload that defines an abstract method.
+        # Enumerable#each does not actually exist at runtime, but it is required to be implemented by
+        # any class which includes Enumerable. We want to declare Enumerable#each as abstract so that
+        # people can call it anything which implements the Enumerable interface, and so that it's a
+        # static error to forget to implement it.
+        #
+        # This is a one-off hack, and we should think carefully before adding more methods here.
+        nil
+      else
+        raise "You marked `#{signature.method_name}` as #{pretty_mode(signature)}, but that method doesn't already exist in this class/module to be overriden.\n" \
+          "  Either check for typos and for missing includes or super classes to make the parent method shows up\n" \
+          "  ... or remove #{pretty_mode(signature)} here: #{method_loc_str(signature.method)}\n"
+      end
     when Modes.standard, *Modes::NON_OVERRIDE_MODES
       # Peaceful
       nil
-    when *Modes::IMPLEMENT_MODES
-      raise "You marked `#{signature.method_name}` as #{pretty_mode(signature)}, but it doesn't match up with a corresponding abstract method.\n" \
-        "  Either check for typos and for missing includes or super classes to make the parent method shows up\n" \
-        "  ... or remove #{pretty_mode(signature)} here: #{method_loc_str(signature.method)}\n"
     else
       raise "Unexpected mode: #{signature.mode}. Please report to #dev-productivity."
     end
 
+    # Given a singleton class, we can check if it belongs to a
+    # module by looking at its superclass; given `module M`,
+    # `M.singleton_class.superclass == Module`, which is not true
+    # for any class.
     owner = signature.method.owner
     if (signature.mode == Modes.abstract || Modes::OVERRIDABLE_MODES.include?(signature.mode)) &&
-        owner.singleton_class?
-      # Given a singleton class, we can check if it belongs to a
-      # module by looking at its superclass; given `module M`,
-      # `M.singleton_class.superclass == Module`, which is not true
-      # for any class.
-      if owner.superclass == Module
-        raise "Defining an overridable class method (via #{pretty_mode(signature)}) " \
-              "on a module is not allowed. Class methods on " \
-              "modules do not get inherited and thus cannot be overridden. For help, ask in " \
-              "#dev-productivity."
-      end
+        owner.singleton_class? && owner.superclass == Module
+      raise "Defining an overridable class method (via #{pretty_mode(signature)}) " \
+            "on a module is not allowed. Class methods on " \
+            "modules do not get inherited and thus cannot be overridden."
     end
   end
 
@@ -222,10 +216,10 @@ module T::Private::Methods::SignatureValidation
   end
 
   private_class_method def self.method_loc_str(method)
-    if method.source_location
-      loc = method.source_location.join(':')
+    loc = if method.source_location
+      method.source_location.join(':')
     else
-      loc = "<unknown location>"
+      "<unknown location>"
     end
     "#{method.owner} at #{loc}"
   end

data/lib/types/private/retry.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Private::Retry
+
+  # A special singleton used for static analysis of exceptions.
+  module RETRY
+    freeze
+  end
+end

data/lib/types/private/sealed.rb

@@ -7,6 +7,11 @@ module T::Private::Sealed
       super
       this_line = Kernel.caller.find {|line| !line.match(/in `inherited'$/)}
       T::Private::Sealed.validate_inheritance(this_line, self, 'inherited')
+      @sorbet_sealed_module_all_subclasses << other
+    end
+
+    def sealed_subclasses
+      @sorbet_sealed_module_all_subclasses
     end
   end
 
@@ -15,12 +20,21 @@ module T::Private::Sealed
       super
       this_line = Kernel.caller.find {|line| !line.match(/in `included'$/)}
       T::Private::Sealed.validate_inheritance(this_line, self, 'included')
+      @sorbet_sealed_module_all_subclasses << other
     end
 
     def extended(other)
       super
       this_line = Kernel.caller.find {|line| !line.match(/in `extended'$/)}
       T::Private::Sealed.validate_inheritance(this_line, self, 'extended')
+      @sorbet_sealed_module_all_subclasses << other
+    end
+
+    def sealed_subclasses
+      # this will freeze the set so that you can never get into a
+      # state where you use the subclasses list and then something
+      # else will add to it
+      @sorbet_sealed_module_all_subclasses.freeze
     end
   end
 
@@ -39,6 +53,7 @@ module T::Private::Sealed
       raise "Couldn't determine declaration file for sealed class."
     end
     mod.instance_variable_set(:@sorbet_sealed_module_decl_file, decl_file)
+    mod.instance_variable_set(:@sorbet_sealed_module_all_subclasses, Set.new)
   end
 
   def self.sealed_module?(mod)
@@ -46,7 +61,7 @@ module T::Private::Sealed
   end
 
   def self.validate_inheritance(this_line, parent, verb)
-    this_file = this_line&.split(':').first
+    this_file = this_line&.split(':')&.first
     decl_file = parent.instance_variable_get(:@sorbet_sealed_module_decl_file)
 
     if !this_file || !decl_file
@@ -54,6 +69,11 @@ module T::Private::Sealed
     end
 
     if !this_file.start_with?(decl_file)
+      whitelist = T::Configuration.sealed_violation_whitelist
+      if !whitelist.nil? && whitelist.any? {|pattern| this_file =~ pattern}
+        return
+      end
+
       raise "#{parent} was declared sealed and can only be #{verb} in #{decl_file}, not #{this_file}"
     end
   end