sorbet-runtime 0.4.4446 → 0.4.4788

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4a800d5e7728111e31a78225eaf32a47c00e3fed
-  data.tar.gz: e8546195bf3b79b86484089e66a78966d8cbc9ef
+SHA256:
+  metadata.gz: 31271303dfeb98e19ae3042f9c577f080415b592e005a407be7dab657cae0f77
+  data.tar.gz: 10ebdce3b1e460c9a95b6144e0b0662f98eb77574eb586a1d248c38c91e01b73
 SHA512:
-  metadata.gz: c2cc3a61f53c8073bcbc091bb5a244059714de8ef38d4f101f5d4d626ab928cfd546a504ce6ef77d1a972b824d0fbfaffdbf11f6fd7e85b6ad8f238131fee3d2
-  data.tar.gz: 8db326b0147134aabba33d5500065d5438ed2d362fc86f90ac36c8d53318c228439ace3c4ccb194ec35d8d42991a26a63d0c2ee433867ddbd98ad9710f8abcf6
+  metadata.gz: '0027993a7fa1be8694fd2eb2b0b3c64978430bb6d44b91a54ebd8922cbab1a9b40b4ecab04f8d3331acfded84873e49926b6930be53acbd565f418c34e817484'
+  data.tar.gz: 89c69d15484d2f69df868ab465dc8085c1123adae026b1678c28b268211c0b2eb80ef991af6b930572a2c0113fc8bc165e3aba1138d7af187c1487aa79aa2632

data/lib/sorbet-runtime.rb

@@ -29,6 +29,8 @@ require_relative 'types/private/runtime_levels'
 require_relative 'types/private/methods/_methods'
 require_relative 'types/sig'
 require_relative 'types/helpers'
+require_relative 'types/private/final'
+require_relative 'types/private/sealed'
 
 # The types themselves. First base classes
 require_relative 'types/types/base'
@@ -43,6 +45,7 @@ require_relative 'types/types/noreturn'
 require_relative 'types/types/proc'
 require_relative 'types/types/self_type'
 require_relative 'types/types/simple'
+require_relative 'types/types/opus_enum'
 require_relative 'types/types/type_parameter'
 require_relative 'types/types/typed_array'
 require_relative 'types/types/typed_enumerator'

data/lib/types/_types.rb

@@ -184,7 +184,7 @@ module T
     begin
       raise TypeError.new("Passed `nil` into T.must")
     rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
-      T::Private::ErrorHandler.handle_inline_type_error(e)
+      T::Configuration.inline_type_error_handler(e)
     end
   end
 
@@ -195,29 +195,63 @@ module T
     value
   end
 
+  # A way to ask Sorbet to prove that a certain branch of control flow never
+  # happens. Commonly used to assert that a case or if statement exhausts all
+  # possible cases.
+  def self.absurd(value)
+    msg = "Control flow reached T.absurd."
+
+    case value
+    when Kernel
+      msg += " Got value: #{value}"
+    end
+
+    begin
+      raise TypeError.new(msg)
+    rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
+      T::Configuration.inline_type_error_handler(e)
+    end
+  end
+
   ### Generic classes ###
 
   module Array
     def self.[](type)
-      T::Types::TypedArray.new(type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedArray::Untyped.new
+      else
+        T::Types::TypedArray.new(type)
+      end
     end
   end
 
   module Hash
     def self.[](keys, values)
-      T::Types::TypedHash.new(keys: keys, values: values)
+      if keys.is_a?(T::Types::Untyped) && values.is_a?(T::Types::Untyped)
+        T::Types::TypedHash::Untyped.new
+      else
+        T::Types::TypedHash.new(keys: keys, values: values)
+      end
     end
   end
 
   module Enumerable
     def self.[](type)
-      T::Types::TypedEnumerable.new(type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedEnumerable::Untyped.new
+      else
+        T::Types::TypedEnumerable.new(type)
+      end
     end
   end
 
   module Enumerator
     def self.[](type)
-      T::Types::TypedEnumerator.new(type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedEnumerator::Untyped.new
+      else
+        T::Types::TypedEnumerator.new(type)
+      end
     end
   end
 
@@ -229,7 +263,11 @@ module T
 
   module Set
     def self.[](type)
-      T::Types::TypedSet.new(type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedSet::Untyped.new
+      else
+        T::Types::TypedSet.new(type)
+      end
     end
   end
 

data/lib/types/configuration.rb

@@ -32,14 +32,14 @@ module T::Configuration
   #   def foo; end
   # end
   # ```
-  def self.enable_final_checks_for_include_extend
-    T::Private::Methods.set_final_checks_for_include_extend(true)
+  def self.enable_final_checks_on_hooks
+    T::Private::Methods.set_final_checks_on_hooks(true)
   end
 
   # Undo the effects of a previous call to
-  # `enable_final_checks_for_include_extend`.
-  def self.reset_final_checks_for_include_extend
-    T::Private::Methods.set_final_checks_for_include_extend(false)
+  # `enable_final_checks_on_hooks`.
+  def self.reset_final_checks_on_hooks
+    T::Private::Methods.set_final_checks_on_hooks(false)
   end
 
   # Configure the default checked level for a sig with no explicit `.checked`
@@ -89,6 +89,7 @@ module T::Configuration
     else
       inline_type_error_handler_default(error)
     end
+    nil
   end
 
   # Set a handler to handle errors that occur when the builder methods in the
@@ -119,7 +120,7 @@ module T::Configuration
   end
 
   private_class_method def self.sig_builder_error_handler_default(error, location)
-    T::Private::Methods.sig_error(location, error.message)
+    raise ArgumentError.new("#{location.path}:#{location.lineno}: Error interpreting `sig`:\n  #{error.message}\n\n")
   end
 
   def self.sig_builder_error_handler(error, location)
@@ -128,6 +129,7 @@ module T::Configuration
     else
       sig_builder_error_handler_default(error, location)
     end
+    nil
   end
 
   # Set a handler to handle sig validation errors.
@@ -171,12 +173,13 @@ module T::Configuration
     raise error
   end
 
-  def self.sig_validation_error_handler(error, opts)
+  def self.sig_validation_error_handler(error, opts={})
     if @sig_validation_error_handler
       @sig_validation_error_handler.call(error, opts)
     else
       sig_validation_error_handler_default(error, opts)
     end
+    nil
   end
 
   # Set a handler for type errors that result from calling a method.
@@ -216,12 +219,13 @@ module T::Configuration
     raise TypeError.new(opts[:pretty_message])
   end
 
-  def self.call_validation_error_handler(signature, opts)
+  def self.call_validation_error_handler(signature, opts={})
     if @call_validation_error_handler
       @call_validation_error_handler.call(signature, opts)
     else
       call_validation_error_handler_default(signature, opts)
     end
+    nil
   end
 
   # Set a handler for logging
@@ -315,7 +319,7 @@ module T::Configuration
     raise str
   end
 
-  def self.hard_assert_handler(str, extra)
+  def self.hard_assert_handler(str, extra={})
     if @hard_assert_handler
       @hard_assert_handler.call(str, extra)
     else

data/lib/types/helpers.rb

@@ -16,6 +16,14 @@ module T::Helpers
     Private::Abstract::Declare.declare_abstract(self, type: :interface)
   end
 
+  def final!
+    Private::Final.declare(self)
+  end
+
+  def sealed!
+    Private::Sealed.declare(self, Kernel.caller(1..1)&.first&.split(':')&.first)
+  end
+
   # Causes a mixin to also mix in class methods from the named module.
   #
   # Nearly equivalent to

data/lib/types/private/abstract/declare.rb

@@ -7,7 +7,10 @@ module T::Private::Abstract::Declare
 
   def self.declare_abstract(mod, type:)
     if AbstractUtils.abstract_module?(mod)
-      raise "#{mod.name} is already declared as abstract"
+      raise "#{mod} is already declared as abstract"
+    end
+    if T::Private::Final.final_module?(mod)
+      raise "#{mod} was already declared as final and cannot be declared as abstract"
     end
 
     Abstract::Data.set(mod, :can_have_abstract_methods, true)

data/lib/types/private/abstract/validate.rb

@@ -61,7 +61,7 @@ module T::Private::Abstract::Validate
       # In that case, get its untyped signature.
       implementation_signature ||= Methods::Signature.new_untyped(
         method: implementation_method,
-        mode: Methods::Modes.implementation
+        mode: Methods::Modes.override
       )
       SignatureValidation.validate_override_shape(implementation_signature, abstract_signature)
       SignatureValidation.validate_override_types(implementation_signature, abstract_signature)

data/lib/types/private/casts.rb

@@ -14,7 +14,7 @@ module T::Private
 
         raise TypeError.new("#{cast_method}: #{error}\n#{suffix}")
       rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
-        T::Private::ErrorHandler.handle_inline_type_error(e)
+        T::Configuration.inline_type_error_handler(e)
         value
       end
     end

data/lib/types/private/class_utils.rb

@@ -96,9 +96,11 @@ module T::Private::ClassUtils
 
     overwritten = original_owner == mod
     T::Configuration.without_ruby_warnings do
-      mod.send(:define_method, name, &blk) # rubocop:disable PrisonGuard/UsePublicSend
-      mod.send(original_visibility, name) # rubocop:disable PrisonGuard/UsePublicSend
+      T::Private::DeclState.current.without_on_method_added do
+        mod.send(:define_method, name, &blk) # rubocop:disable PrisonGuard/UsePublicSend
+      end
     end
+    mod.send(original_visibility, name) # rubocop:disable PrisonGuard/UsePublicSend
     new_method = mod.instance_method(name)
 
     ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)

data/lib/types/private/decl_state.rb

@@ -11,9 +11,20 @@ class T::Private::DeclState
   end
 
   attr_accessor :active_declaration
-  attr_accessor :skip_next_on_method_added
+  attr_accessor :skip_on_method_added
 
   def reset!
     self.active_declaration = nil
   end
+
+  def without_on_method_added
+    begin
+      # explicit 'self' is needed here
+      old_value = self.skip_on_method_added
+      self.skip_on_method_added = true
+      yield
+    ensure
+      self.skip_on_method_added = old_value
+    end
+  end
 end

data/lib/types/private/error_handler.rb

@@ -1,37 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module T::Private::ErrorHandler
-  # Handle a rescued TypeError. This will pass the TypeError to the
-  # T::Configuration.inline_type_error_handler so that the user can override
-  # error handling if they wish. If no inline_type_error_handler is set, this
-  # method will call handle_inline_type_error_default, which raises the error.
-  def self.handle_inline_type_error(type_error)
-    T::Configuration.inline_type_error_handler(type_error)
-    nil
-  end
-
-  # Handle a sig declaration failure. This allows users to override the behavior
-  # when a sig decl fails. If T::Configuration.sig_builder_error_handler
-  # is unset, this method will call handle_sig_builder_error_default.
-  def self.handle_sig_builder_error(error, location)
-    T::Configuration.sig_builder_error_handler(error, location)
-    nil
-  end
-
-  # Handle a sig build validation failure. This allows users to override the
-  # behavior when a sig build fails. If T::Configuration.sig_validation_error_handler
-  # is unset, this method will call handle_sig_validation_error_default.
-  def self.handle_sig_validation_error(error, opts={})
-    T::Configuration.sig_validation_error_handler(error, opts)
-    nil
-  end
-
-  # Handle a sig call validation failure. This allows users to override the
-  # behavior when a sig call fails. If T::Configuration.call_validation_error_handler
-  # is unset, this method will call handle_call_validation_error_default.
-  def self.handle_call_validation_error(signature, opts={})
-    T::Configuration.call_validation_error_handler(signature, opts)
-    nil
-  end
-end

data/lib/types/private/final.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Private::Final
+  module NoInherit
+    def inherited(arg)
+      super(arg)
+      raise "#{self} was declared as final and cannot be inherited"
+    end
+  end
+
+  module NoIncludeExtend
+    def included(arg)
+      super(arg)
+      raise "#{self} was declared as final and cannot be included"
+    end
+
+    def extended(arg)
+      super(arg)
+      raise "#{self} was declared as final and cannot be extended"
+    end
+  end
+
+  def self.declare(mod)
+    if !mod.is_a?(Module)
+      raise "#{mod} is not a class or module and cannot be declared as final with `final!`"
+    end
+    if final_module?(mod)
+      raise "#{mod} was already declared as final and cannot be re-declared as final"
+    end
+    if T::AbstractUtils.abstract_module?(mod)
+      raise "#{mod} was already declared as abstract and cannot be declared as final"
+    end
+    if T::Private::Sealed.sealed_module?(mod)
+      raise "#{mod} was already declared as sealed and cannot be declared as final"
+    end
+    mod.extend(mod.is_a?(Class) ? NoInherit : NoIncludeExtend)
+    mark_as_final_module(mod)
+    mark_as_final_module(mod.singleton_class)
+    T::Private::Methods.add_module_with_final(mod)
+    T::Private::Methods.install_hooks(mod)
+  end
+
+  def self.final_module?(mod)
+    mod.instance_variable_defined?(:@sorbet_final_module)
+  end
+
+  private_class_method def self.mark_as_final_module(mod)
+    mod.instance_variable_set(:@sorbet_final_module, true)
+  end
+end

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

@@ -11,10 +11,18 @@ module T::Private::Methods
   # - they are done possibly before any sig block has run.
   # - they are done even if the method being defined doesn't have a sig.
   @final_methods = Set.new
-  # if a module directly defines a final method, or includes, extends, or inherits from a module which does so, then it
-  # should be in this set.
+  # a non-singleton is a module for which at least one of the following is true:
+  # - is declared final
+  # - defines a method that is declared final
+  # - includes an non-singleton
+  # - extends an non-singleton
+  # a singleton is the singleton_class of a non-singleton.
+  # modules_with_final is the set of singletons and non-singletons.
   @modules_with_final = Set.new
-  @old_included_extended = nil
+  # this stores the old [included, extended] hooks for Module and inherited hook for Class that we override when
+  # enabling final checks for when those hooks are called. the 'hooks' here don't have anything to do with the 'hooks'
+  # in installed_hooks.
+  @old_hooks = nil
 
   ARG_NOT_PROVIDED = Object.new
   PROC_TYPE = Object.new
@@ -123,6 +131,9 @@ module T::Private::Methods
   # the final instance methods of target and source_method_names. so, for every m in source_method_names, check if there
   # is already a method defined on one of target_ancestors with the same name that is final.
   def self._check_final_ancestors(target, target_ancestors, source_method_names)
+    if !module_with_final?(target)
+      return
+    end
     # use reverse_each to check farther-up ancestors first, for better error messages. we could avoid this if we were on
     # the version of ruby that adds the optional argument to method_defined? that allows you to exclude ancestors.
     target_ancestors.reverse_each do |ancestor|
@@ -133,8 +144,8 @@ module T::Private::Methods
         # directly on ancestor but instead an ancestor of ancestor.
         if ancestor.method_defined?(method_name) && final_method?(method_owner_and_name_to_key(ancestor, method_name))
           raise(
-            "`#{ancestor.name}##{method_name}` was declared as final and cannot be " +
-            (target == ancestor ? "redefined" : "overridden in `#{target.name}`")
+            "The method `#{method_name}` on #{ancestor} was declared as final and cannot be " +
+            (target == ancestor ? "redefined" : "overridden in #{target}")
           )
         end
       end
@@ -151,6 +162,7 @@ module T::Private::Methods
 
   def self.add_module_with_final(mod)
     @modules_with_final.add(mod)
+    @modules_with_final.add(mod.singleton_class)
   end
 
   private_class_method def self.module_with_final?(mod)
@@ -159,20 +171,31 @@ module T::Private::Methods
 
   # Only public because it needs to get called below inside the replace_method blocks below.
   def self._on_method_added(hook_mod, method_name, is_singleton_method: false)
-    if T::Private::DeclState.current.skip_next_on_method_added
-      T::Private::DeclState.current.skip_next_on_method_added = false
+    if T::Private::DeclState.current.skip_on_method_added
       return
     end
 
     current_declaration = T::Private::DeclState.current.active_declaration
     mod = is_singleton_method ? hook_mod.singleton_class : hook_mod
-    original_method = mod.instance_method(method_name)
 
+    if T::Private::Final.final_module?(mod) && (current_declaration.nil? || !current_declaration.final)
+      raise "#{mod} was declared as final but its method `#{method_name}` was not declared as final"
+    end
     _check_final_ancestors(mod, mod.ancestors, [method_name])
 
-    return if current_declaration.nil?
+    if current_declaration.nil?
+      return
+    end
     T::Private::DeclState.current.reset!
 
+    if method_name == :method_added || method_name == :singleton_method_added
+      raise(
+        "Putting a `sig` on `#{method_name}` is not supported" +
+        " (sorbet-runtime uses this method internally to perform `sig` validation logic)"
+      )
+    end
+
+    original_method = mod.instance_method(method_name)
     sig_block = lambda do
       T::Private::Methods.run_sig(hook_mod, method_name, original_method, current_declaration)
     end
@@ -223,14 +246,12 @@ module T::Private::Methods
     @sig_wrappers[key] = sig_block
     if current_declaration.final
       add_final_method(key)
-      add_module_with_final(mod)
+      # use hook_mod, not mod, because for example, we want class C to be marked as having final if we def C.foo as
+      # final. change this to mod to see some final_method tests fail.
+      add_module_with_final(hook_mod)
     end
   end
 
-  def self.sig_error(loc, message)
-    raise(ArgumentError.new("#{loc.path}:#{loc.lineno}: Error interpreting `sig`:\n  #{message}\n\n"))
-  end
-
   # Executes the `sig` block, and converts the resulting Declaration
   # to a Signature.
   def self.run_sig(hook_mod, method_name, original_method, declaration_block)
@@ -238,7 +259,7 @@ module T::Private::Methods
       begin
         run_builder(declaration_block)
       rescue DeclBuilder::BuilderError => e
-        T::Private::ErrorHandler.handle_sig_builder_error(e, declaration_block.loc)
+        T::Configuration.sig_builder_error_handler(e, declaration_block.loc)
         nil
       end
 
@@ -271,10 +292,6 @@ module T::Private::Methods
               "class/module."
       end
 
-      if current_declaration.returns.equal?(ARG_NOT_PROVIDED)
-        sig_error(loc, "You must provide a return type; use the `.returns` or `.void` builder methods. Method: #{original_method}")
-      end
-
       signature = Signature.new(
         method: original_method,
         method_name: method_name,
@@ -294,7 +311,7 @@ module T::Private::Methods
       super_method = original_method&.super_method
       super_signature = signature_for_method(super_method) if super_method
 
-      T::Private::ErrorHandler.handle_sig_validation_error(
+      T::Configuration.sig_validation_error_handler(
         e,
         method: original_method,
         declaration: current_declaration,
@@ -334,7 +351,13 @@ module T::Private::Methods
   private_class_method def self.run_sig_block_for_key(key)
     blk = @sig_wrappers[key]
     if !blk
-      raise "No `sig` wrapper for #{key_to_method(key)}"
+      sig = @signatures_by_method[key]
+      if sig
+        # We already ran the sig block, perhaps in another thread.
+        return sig
+      else
+        raise "No `sig` wrapper for #{key_to_method(key)}"
+      end
     end
 
     begin
@@ -361,7 +384,7 @@ module T::Private::Methods
 
   # the module target is adding the methods from the module source to itself. we need to check that for all instance
   # methods M on source, M is not defined on any of target's ancestors.
-  def self._included_extended_impl(target, target_ancestors, source)
+  def self._hook_impl(target, target_ancestors, source)
     if !module_with_final?(target) && !module_with_final?(source)
       return
     end
@@ -370,24 +393,42 @@ module T::Private::Methods
     _check_final_ancestors(target, target_ancestors - source.ancestors, source.instance_methods)
   end
 
-  def self.set_final_checks_for_include_extend(enable)
-    is_enabled = @old_included_extended != nil
+  def self.set_final_checks_on_hooks(enable)
+    is_enabled = @old_hooks != nil
     if enable == is_enabled
       return
     end
     if is_enabled
-      @old_included_extended.each(&:restore)
-      @old_included_extended = nil
+      @old_hooks.each(&:restore)
+      @old_hooks = nil
     else
       old_included = T::Private::ClassUtils.replace_method(Module, :included) do |arg|
         old_included.bind(self).call(arg)
-        ::T::Private::Methods._included_extended_impl(arg, arg.ancestors, self)
+        ::T::Private::Methods._hook_impl(arg, arg.ancestors, self)
       end
       old_extended = T::Private::ClassUtils.replace_method(Module, :extended) do |arg|
         old_extended.bind(self).call(arg)
-        ::T::Private::Methods._included_extended_impl(arg, arg.singleton_class.ancestors, self)
+        ::T::Private::Methods._hook_impl(arg, arg.singleton_class.ancestors, self)
       end
-      @old_included_extended = [old_included, old_extended]
+      old_inherited = T::Private::ClassUtils.replace_method(Class, :inherited) do |arg|
+        old_inherited.bind(self).call(arg)
+        ::T::Private::Methods._hook_impl(arg, arg.ancestors, self)
+      end
+      @old_hooks = [old_included, old_extended, old_inherited]
+    end
+  end
+
+  module MethodHooks
+    def method_added(name)
+      super(name)
+      ::T::Private::Methods._on_method_added(self, name, is_singleton_method: false)
+    end
+  end
+
+  module SingletonMethodHooks
+    def singleton_method_added(name)
+      super(name)
+      ::T::Private::Methods._on_method_added(self, name, is_singleton_method: true)
     end
   end
 
@@ -396,29 +437,11 @@ module T::Private::Methods
     @installed_hooks << mod
 
     if mod.singleton_class?
-      install_singleton_method_added_hook(mod)
+      mod.include(SingletonMethodHooks)
     else
-      original_method = T::Private::ClassUtils.replace_method(mod.singleton_class, :method_added) do |name|
-        T::Private::Methods._on_method_added(self, name)
-        original_method.bind(self).call(name)
-      end
-    end
-    install_singleton_method_added_hook(mod.singleton_class)
-  end
-
-  private_class_method def self.install_singleton_method_added_hook(singleton_klass)
-    attached = nil
-    original_singleton_method = T::Private::ClassUtils.replace_method(singleton_klass, :singleton_method_added) do |name|
-      attached = self
-      T::Private::Methods._on_method_added(self, name, is_singleton_method: true)
-      # This will be nil when this gets called for the addition of this method itself. We
-      # call it below to compensate.
-      if original_singleton_method
-        original_singleton_method.bind(self).call(name)
-      end
+      mod.extend(MethodHooks)
     end
-    # See the comment above
-    original_singleton_method.bind(attached).call(:singleton_method_added)
+    mod.extend(SingletonMethodHooks)
   end
 
   # use this directly if you don't want/need to box up the method into an object to pass to method_to_key.

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

@@ -37,7 +37,9 @@ module T::Private::Methods::CallValidation
     else
       T::Configuration.without_ruby_warnings do
         # get all the shims out of the way and put back the original method
-        mod.send(:define_method, method_sig.method_name, original_method)
+        T::Private::DeclState.current.without_on_method_added do
+          mod.send(:define_method, method_sig.method_name, original_method)
+        end
         mod.send(original_visibility, method_sig.method_name)
       end
     end
@@ -163,7 +165,6 @@ module T::Private::Methods::CallValidation
   end
 
   def self.create_validator_method(mod, original_method, method_sig, original_visibility)
-    T::Private::DeclState.current.skip_next_on_method_added = true
     has_fixed_arity = method_sig.kwarg_types.empty? && !method_sig.has_rest && !method_sig.has_keyrest &&
       original_method.parameters.all? {|(kind, _name)| kind == :req}
     all_args_are_simple = method_sig.arg_types.all? {|_name, type| type.is_a?(T::Types::Simple)}
@@ -171,12 +172,14 @@ module T::Private::Methods::CallValidation
     has_simple_procedure_types = all_args_are_simple && method_sig.return_type.is_a?(T::Private::Types::Void)
 
     T::Configuration.without_ruby_warnings do
-      if has_fixed_arity && has_simple_method_types && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
-        create_validator_method_fast(mod, original_method, method_sig)
-      elsif has_fixed_arity && has_simple_procedure_types && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
-        create_validator_procedure_fast(mod, original_method, method_sig)
-      else
-        create_validator_slow(mod, original_method, method_sig)
+      T::Private::DeclState.current.without_on_method_added do
+        if has_fixed_arity && has_simple_method_types && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
+          create_validator_method_fast(mod, original_method, method_sig)
+        elsif has_fixed_arity && has_simple_procedure_types && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
+          create_validator_procedure_fast(mod, original_method, method_sig)
+        else
+          create_validator_slow(mod, original_method, method_sig)
+        end
       end
     end
     mod.send(original_visibility, method_sig.method_name)
@@ -1161,7 +1164,7 @@ module T::Private::Methods::CallValidation
       "Caller: #{caller_loc.path}:#{caller_loc.lineno}\n" \
       "Definition: #{definition_file}:#{definition_line}"
 
-    T::Private::ErrorHandler.handle_call_validation_error(
+    T::Configuration.call_validation_error_handler(
       method_sig,
       message: error_message,
       pretty_message: pretty_message,

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

@@ -145,13 +145,17 @@ 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
     end
 
+    def final
+      check_live!
+      raise BuilderError.new("The syntax for declaring a method final is `sig(:final) {...}`, not `sig {final. ...}`")
+    end
+
     def override(allow_incompatible: false)
       check_live!
 
@@ -159,11 +163,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
@@ -173,36 +178,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`.
     #
@@ -233,6 +221,10 @@ module T::Private::Methods
     def finalize!
       check_live!
 
+      if decl.returns.equal?(ARG_NOT_PROVIDED)
+        raise BuilderError.new("You must provide a return type; use the `.returns` or `.void` builder methods.")
+      end
+
       if decl.bind.equal?(ARG_NOT_PROVIDED)
         decl.bind = nil
       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]
 
-  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]
+  OVERRIDE_MODES = [self.override, self.overridable_override]
+  NON_OVERRIDE_MODES = MODES - OVERRIDE_MODES
 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
@@ -59,21 +59,15 @@ module T::Private::Methods::SignatureValidation
     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" \
+        raise "You declared `#{signature.method_name}` as #{pretty_mode(signature)}, but the method it overrides is not declared as `overridable` or `abstract`.\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
     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,16 +83,23 @@ 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

data/lib/types/private/sealed.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Private::Sealed
+  module NoInherit
+    def inherited(other)
+      super
+      this_line = Kernel.caller.find {|line| !line.match(/in `inherited'$/)}
+      T::Private::Sealed.validate_inheritance(this_line, self, 'inherited')
+    end
+  end
+
+  module NoIncludeExtend
+    def included(other)
+      super
+      this_line = Kernel.caller.find {|line| !line.match(/in `included'$/)}
+      T::Private::Sealed.validate_inheritance(this_line, self, 'included')
+    end
+
+    def extended(other)
+      super
+      this_line = Kernel.caller.find {|line| !line.match(/in `extended'$/)}
+      T::Private::Sealed.validate_inheritance(this_line, self, 'extended')
+    end
+  end
+
+  def self.declare(mod, decl_file)
+    if !mod.is_a?(Module)
+      raise "#{mod} is not a class or module and cannot be declared `sealed!`"
+    end
+    if sealed_module?(mod)
+      raise "#{mod} was already declared `sealed!` and cannot be re-declared `sealed!`"
+    end
+    if T::Private::Final.final_module?(mod)
+      raise "#{mod} was already declared `final!` and cannot be declared `sealed!`"
+    end
+    mod.extend(mod.is_a?(Class) ? NoInherit : NoIncludeExtend)
+    if !decl_file
+      raise "Couldn't determine declaration file for sealed class."
+    end
+    mod.instance_variable_set(:@sorbet_sealed_module_decl_file, decl_file)
+  end
+
+  def self.sealed_module?(mod)
+    mod.instance_variable_defined?(:@sorbet_sealed_module_decl_file)
+  end
+
+  def self.validate_inheritance(this_line, parent, verb)
+    this_file = this_line&.split(':').first
+    decl_file = parent.instance_variable_get(:@sorbet_sealed_module_decl_file)
+
+    if !this_file || !decl_file
+      raise "Couldn't determine enough file information for checking sealed modules"
+    end
+
+    if !this_file.start_with?(decl_file)
+      raise "#{parent} was declared sealed and can only be #{verb} in #{decl_file}, not #{this_file}"
+    end
+  end
+end

data/lib/types/props/decorator.rb

@@ -486,11 +486,7 @@ class T::Props::Decorator
   sig {params(name: Symbol, rules: Rules).void}
   private def define_getter_and_setter(name, rules)
     T::Configuration.without_ruby_warnings do
-      if rules[:immutable]
-        @class.send(:define_method, "#{name}=") do |_x|
-          raise T::Props::ImmutableProp.new("#{self.class}##{name} cannot be modified after creation.")
-        end
-      else
+      if !rules[:immutable]
         @class.send(:define_method, "#{name}=") do |x|
           self.class.decorator.prop_set(self, name, x, rules)
         end

data/lib/types/types/base.rb

@@ -4,6 +4,7 @@
 module T::Types
   class Base
     def self.method_added(method_name)
+      super(method_name)
       # What is now `subtype_of_single?` used to be named `subtype_of?`. Make sure people don't
       # override the wrong thing.
       #

data/lib/types/types/opus_enum.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Validates that an object is equal to another Opus::Enum singleton value.
+  class OpusEnum < Base
+    attr_reader :val
+
+    def initialize(val)
+      @val = val
+    end
+
+    # @override Base
+    def name
+      @val.inspect
+    end
+
+    # @override Base
+    def valid?(obj)
+      @val == obj
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      case other
+      when OpusEnum
+        @val == other.val
+      else
+        false
+      end
+    end
+  end
+end

data/lib/types/types/typed_array.rb

@@ -8,6 +8,10 @@ module T::Types
       "T::Array[#{@type.name}]"
     end
 
+    def underlying_class
+      Array
+    end
+
     # @override Base
     def valid?(obj)
       obj.is_a?(Array) && super
@@ -16,5 +20,15 @@ module T::Types
     def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
       Array.new(*T.unsafe(args))
     end
+
+    class Untyped < TypedArray
+      def initialize
+        super(T.untyped)
+      end
+
+      def valid?(obj)
+        obj.is_a?(Array)
+      end
+    end
   end
 end

data/lib/types/types/typed_enumerable.rb

@@ -12,6 +12,10 @@ module T::Types
       @type = T::Utils.coerce(type)
     end
 
+    def underlying_class
+      Enumerable
+    end
+
     # @override Base
     def name
       "T::Enumerable[#{@type.name}]"
@@ -68,7 +72,8 @@ module T::Types
 
     # @override Base
     private def subtype_of_single?(other)
-      if self.class <= other.class
+      if other.class <= TypedEnumerable &&
+         underlying_class <= other.underlying_class
         # Enumerables are covariant because they are read only
         #
         # Properly speaking, many Enumerable subtypes (e.g. Set)
@@ -137,5 +142,15 @@ module T::Types
         self.class.new(type_from_instances(obj))
       end
     end
+
+    class Untyped < TypedEnumerable
+      def initialize
+        super(T.untyped)
+      end
+
+      def valid?(obj)
+        obj.is_a?(Enumerable)
+      end
+    end
   end
 end

data/lib/types/types/typed_enumerator.rb

@@ -5,6 +5,10 @@ module T::Types
   class TypedEnumerator < TypedEnumerable
     attr_reader :type
 
+    def underlying_class
+      Enumerator
+    end
+
     # @override Base
     def name
       "T::Enumerator[#{@type.name}]"
@@ -18,5 +22,15 @@ module T::Types
     def new(*args, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
       T.unsafe(Enumerator).new(*args, &blk)
     end
+
+    class Untyped < TypedEnumerator
+      def initialize
+        super(T.untyped)
+      end
+
+      def valid?(obj)
+        obj.is_a?(Enumerator)
+      end
+    end
   end
 end

data/lib/types/types/typed_hash.rb

@@ -6,6 +6,10 @@ module T::Types
     # Technically we don't need these, but they are a nice api
     attr_reader :keys, :values
 
+    def underlying_class
+      Hash
+    end
+
     def initialize(keys:, values:)
       @keys = T::Utils.coerce(keys)
       @values = T::Utils.coerce(values)
@@ -25,5 +29,15 @@ module T::Types
     def new(*args, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
       Hash.new(*T.unsafe(args), &blk) # rubocop:disable PrisonGuard/RestrictHashDefaults
     end
+
+    class Untyped < TypedHash
+      def initialize
+        super(keys: T.untyped, values: T.untyped)
+      end
+
+      def valid?(obj)
+        obj.is_a?(Hash)
+      end
+    end
   end
 end

data/lib/types/types/typed_range.rb

@@ -5,6 +5,10 @@ module T::Types
   class TypedRange < TypedEnumerable
     attr_reader :type
 
+    def underlying_class
+      Hash
+    end
+
     # @override Base
     def name
       "T::Range[#{@type.name}]"

data/lib/types/types/typed_set.rb

@@ -5,6 +5,10 @@ module T::Types
   class TypedSet < TypedEnumerable
     attr_reader :type
 
+    def underlying_class
+      Hash
+    end
+
     # @override Base
     def name
       "T::Set[#{@type.name}]"
@@ -18,5 +22,15 @@ module T::Types
     def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
       Set.new(*T.unsafe(args))
     end
+
+    class Untyped < TypedSet
+      def initialize
+        super(T.untyped)
+      end
+
+      def valid?(obj)
+        obj.is_a?(Set)
+      end
+    end
   end
 end

data/lib/types/utils.rb

@@ -26,6 +26,8 @@ module T::Utils
       T::Types::FixedHash.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
     elsif val.is_a?(T::Private::Methods::DeclBuilder)
       T::Private::Methods.finalize_proc(val.decl)
+    elsif defined?(::Opus) && defined?(::Opus::Enum) && val.is_a?(::Opus::Enum)
+      T::Types::OpusEnum.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
     else
       raise "Invalid value for type constraint. Must be an #{T::Types::Base}, a " \
             "class/module, or an array. Got a `#{val.class}`."

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.4.4446
+  version: 0.4.4788
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-17 00:00:00.000000000 Z
+date: 2019-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.5
 description: Sorbet's runtime type checking component
 email: 
 executables: []
@@ -75,6 +89,7 @@ files:
 - lib/types/private/class_utils.rb
 - lib/types/private/decl_state.rb
 - lib/types/private/error_handler.rb
+- lib/types/private/final.rb
 - lib/types/private/methods/_methods.rb
 - lib/types/private/methods/call_validation.rb
 - lib/types/private/methods/decl_builder.rb
@@ -83,6 +98,7 @@ files:
 - lib/types/private/methods/signature_validation.rb
 - lib/types/private/mixins/mixins.rb
 - lib/types/private/runtime_levels.rb
+- lib/types/private/sealed.rb
 - lib/types/private/types/not_typed.rb
 - lib/types/private/types/string_holder.rb
 - lib/types/private/types/void.rb
@@ -109,6 +125,7 @@ files:
 - lib/types/types/fixed_hash.rb
 - lib/types/types/intersection.rb
 - lib/types/types/noreturn.rb
+- lib/types/types/opus_enum.rb
 - lib/types/types/proc.rb
 - lib/types/types/self_type.rb
 - lib/types/types/simple.rb
@@ -147,8 +164,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Sorbet runtime