sorbet-runtime 0.4.4398 → 0.4.4451

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af4d1867e5caafedef289561e2ad9413bffa3fad
-  data.tar.gz: 5652f7e1c9d2d54b253fcc6d2e5e5330c9c34691
+  metadata.gz: dce4a30b82fe35c4a1e14c4b9e4215daed0a9d87
+  data.tar.gz: 45ffa6a922ea6cf8779952b1157026a8a27d0d4e
 SHA512:
-  metadata.gz: 430f858624d11168a7a5a7109115fc02d26bb919e4d14aa1bb94018abf88276d143a7550e23f320ce135be24d283dc70198d250a568339da9cb2a02ad94dfbbb
-  data.tar.gz: 1f1e4cdaba1209536d9cc5da0ef766f841c80a50963146f11dcda2374beaa62835dd79ce5d8c2d6093f354d176bbac42f34d03067b9adf23d391f50e553e329e
+  metadata.gz: f1d21c72d44210d9c3885a6ff6cbd2ad9d43e5822e5690e61deacf8e68833df6b10a3678ca52581ff5d3fac2f9500f7cc683e750c0ea3caa382a0709093d17e3
+  data.tar.gz: 8a4c58f165eaf65718e5b4adf08c92576503dcd641409ebae59af0e918bc764964210294d329b26f6e37a8f5466e05f2b2a1dc251a43fe743af4790246759e7c

data/lib/sorbet-runtime.rb

@@ -29,6 +29,7 @@ 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'
 
 # The types themselves. First base classes
 require_relative 'types/types/base'

data/lib/types/configuration.rb

@@ -17,6 +17,31 @@ module T::Configuration
     T::Private::RuntimeLevels.enable_checking_in_tests
   end
 
+  # Announce to Sorbet that we would like the final checks to be enabled when
+  # including and extending modules. Iff this is not called, then the following
+  # example will not raise an error.
+  #
+  # ```ruby
+  # module M
+  #   extend T::Sig
+  #   sig(:final) {void}
+  #   def foo; end
+  # end
+  # class C
+  #   include M
+  #   def foo; end
+  # end
+  # ```
+  def self.enable_final_checks_for_include_extend
+    T::Private::Methods.set_final_checks_for_include_extend(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)
+  end
+
   # Configure the default checked level for a sig with no explicit `.checked`
   # builder. When unset, the default checked level is `:always`.
   #
@@ -333,6 +358,26 @@ module T::Configuration
     @scalar_types || @default_scalar_types
   end
 
+  # Temporarily disable ruby warnings while executing the given block. This is
+  # useful when doing something that would normally cause a warning to be
+  # emitted in Ruby verbose mode ($VERBOSE = true).
+  #
+  # @yield
+  #
+  def self.without_ruby_warnings
+    if $VERBOSE
+      begin
+        original_verbose = $VERBOSE
+        $VERBOSE = false
+        yield
+      ensure
+        $VERBOSE = original_verbose
+      end
+    else
+      yield
+    end
+  end
+
 
   private_class_method def self.validate_lambda_given!(value)
     if !value.nil? && !value.respond_to?(:call)

data/lib/types/generic.rb

@@ -13,11 +13,11 @@ module T::Generic
     self
   end
 
-  def type_member(variance=:invariant, fixed: nil)
+  def type_member(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
     T::Types::TypeMember.new(variance) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
   end
 
-  def type_template(variance=:invariant, fixed: nil)
+  def type_template(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
     T::Types::TypeTemplate.new(variance) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
   end
 end

data/lib/types/helpers.rb

@@ -16,6 +16,10 @@ module T::Helpers
     Private::Abstract::Declare.declare_abstract(self, type: :interface)
   end
 
+  def final!
+    Private::Final.declare(self)
+  end
+
   # Causes a mixin to also mix in class methods from the named module.
   #
   # Nearly equivalent to

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

@@ -9,6 +9,9 @@ module T::Private::Abstract::Declare
     if AbstractUtils.abstract_module?(mod)
       raise "#{mod.name} is already declared as abstract"
     end
+    if T::Private::Final.final_module?(mod)
+      raise "#{mod.name} was already declared as final and cannot be declared as abstract"
+    end
 
     Abstract::Data.set(mod, :can_have_abstract_methods, true)
     Abstract::Data.set(mod.singleton_class, :can_have_abstract_methods, true)
@@ -28,6 +31,9 @@ module T::Private::Abstract::Declare
         raise "You must call `abstract!` *before* defining an initialize method"
       end
 
+      # Don't need to silence warnings via without_ruby_warnings when calling
+      # define_method because of the guard above
+
       mod.send(:define_method, :initialize) do |*args, &blk|
         if self.class == mod
           raise "#{mod} is declared as abstract; it cannot be instantiated"

data/lib/types/private/class_utils.rb

@@ -32,7 +32,9 @@ module T::Private::ClassUtils
 
       if @overwritten
         # The original method was overwritten. Overwrite again to restore it.
-        @mod.send(:define_method, @old_method.name, @old_method) # rubocop:disable PrisonGuard/UsePublicSend
+        T::Configuration.without_ruby_warnings do
+          @mod.send(:define_method, @old_method.name, @old_method) # rubocop:disable PrisonGuard/UsePublicSend
+        end
       else
         # The original method was in an ancestor. Restore it by removing the overriding method.
         @mod.send(:remove_method, @old_method.name) # rubocop:disable PrisonGuard/UsePublicSend
@@ -93,8 +95,10 @@ module T::Private::ClassUtils
     end
 
     overwritten = original_owner == mod
-    mod.send(:define_method, name, &blk) # rubocop:disable PrisonGuard/UsePublicSend
-    mod.send(original_visibility, name) # rubocop:disable PrisonGuard/UsePublicSend
+    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
+    end
     new_method = mod.instance_method(name)
 
     ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)

data/lib/types/private/decl_state.rb

@@ -11,6 +11,7 @@ class T::Private::DeclState
   end
 
   attr_accessor :active_declaration
+  attr_accessor :skip_next_on_method_added
 
   def reset!
     self.active_declaration = nil

data/lib/types/private/final.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Private::Final
+  module NoInherit
+    def inherited(arg)
+      super(arg)
+      raise "#{self.name} was declared as final and cannot be inherited"
+    end
+  end
+
+  module NoIncludeExtend
+    def included(arg)
+      super(arg)
+      raise "#{self.name} was declared as final and cannot be included"
+    end
+
+    def extended(arg)
+      super(arg)
+      raise "#{self.name} was declared as final and cannot be extended"
+    end
+  end
+
+  def self.declare(mod)
+    if !mod.is_a?(Module)
+      raise "#{mod.name} is not a class or module and cannot be declared as final with `final!`"
+    end
+    if final_module?(mod)
+      raise "#{mod.name} was already declared as final and cannot be re-declared as final"
+    end
+    if T::AbstractUtils.abstract_module?(mod)
+      raise "#{mod.name} was already declared as abstract 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.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)
+    T::Private::Methods.add_module_with_final(mod)
+  end
+end

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

@@ -6,23 +6,36 @@ module T::Private::Methods
   @signatures_by_method = {}
   @sig_wrappers = {}
   @sigs_that_raised = {}
+  # the info about whether a method is final is not stored in a DeclBuilder nor a Signature, but instead right here.
+  # this is because final checks are special:
+  # - 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.
+  @modules_with_final = Set.new
+  @old_included_extended = nil
 
   ARG_NOT_PROVIDED = Object.new
   PROC_TYPE = Object.new
 
-  DeclarationBlock = Struct.new(:mod, :loc, :blk)
+  DeclarationBlock = Struct.new(:mod, :loc, :blk, :final)
 
-  def self.declare_sig(mod, &blk)
+  def self.declare_sig(mod, arg, &blk)
     install_hooks(mod)
 
     if T::Private::DeclState.current.active_declaration
-      T::Private::DeclState.current.active_declaration = nil
+      T::Private::DeclState.current.reset!
       raise "You called sig twice without declaring a method inbetween"
     end
 
+    if !arg.nil? && arg != :final
+      raise "Invalid argument to `sig`: #{arg}"
+    end
+
     loc = caller_locations(2, 1).first
 
-    T::Private::DeclState.current.active_declaration = DeclarationBlock.new(mod, loc, blk)
+    T::Private::DeclState.current.active_declaration = DeclarationBlock.new(mod, loc, blk, arg == :final)
 
     nil
   end
@@ -106,15 +119,63 @@ module T::Private::Methods
     @signatures_by_method[key]
   end
 
+  # when target includes a module with instance methods source_method_names, ensure there is zero intersection between
+  # 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)
+    # 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|
+      source_method_names.each do |method_name|
+        # the usage of method_owner_and_name_to_key(ancestor, method_name) instead of
+        # method_to_key(ancestor.instance_method(method_name)) is not (just) an optimization, but also required for
+        # correctness, since ancestor.method_defined?(method_name) may return true even if method_name is not defined
+        # 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}`")
+          )
+        end
+      end
+    end
+  end
+
+  private_class_method def self.add_final_method(method_key)
+    @final_methods.add(method_key)
+  end
+
+  private_class_method def self.final_method?(method_key)
+    @final_methods.include?(method_key)
+  end
+
+  def self.add_module_with_final(mod)
+    @modules_with_final.add(mod)
+  end
+
+  private_class_method def self.module_with_final?(mod)
+    @modules_with_final.include?(mod)
+  end
+
   # 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)
-    current_declaration = T::Private::DeclState.current.active_declaration
-    return if !current_declaration
-    T::Private::DeclState.current.reset!
+    if T::Private::DeclState.current.skip_next_on_method_added
+      T::Private::DeclState.current.skip_next_on_method_added = false
+      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.name}` 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?
+    T::Private::DeclState.current.reset!
+
     sig_block = lambda do
       T::Private::Methods.run_sig(hook_mod, method_name, original_method, current_declaration)
     end
@@ -124,6 +185,8 @@ module T::Private::Methods
     # This wrapper is very slow, so it will subsequently re-wrap with a much faster wrapper
     # (or unwrap back to the original method).
     new_method = nil
+    # this prevents us from running the final checks twice for every method def.
+    T::Private::DeclState.current.skip_next_on_method_added = true
     T::Private::ClassUtils.replace_method(mod, method_name) do |*args, &blk|
       if !T::Private::Methods.has_sig_block_for_method(new_method)
         # This should only happen if the user used alias_method to grab a handle
@@ -161,15 +224,16 @@ module T::Private::Methods
     end
 
     new_method = mod.instance_method(method_name)
-    @sig_wrappers[method_to_key(new_method)] = sig_block
+    key = method_to_key(new_method)
+    @sig_wrappers[key] = sig_block
+    if current_declaration.final
+      add_final_method(key)
+      add_module_with_final(mod)
+    end
   end
 
   def self.sig_error(loc, message)
-    raise(
-      ArgumentError.new(
-        "#{loc.path}:#{loc.lineno}: Error interpreting `sig`:\n  #{message}\n\n"
-      )
-    )
+    raise(ArgumentError.new("#{loc.path}:#{loc.lineno}: Error interpreting `sig`:\n  #{message}\n\n"))
   end
 
   # Executes the `sig` block, and converts the resulting Declaration
@@ -300,6 +364,38 @@ module T::Private::Methods
     end
   end
 
+  # 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)
+    if !module_with_final?(target) && !module_with_final?(source)
+      return
+    end
+    add_module_with_final(target)
+    install_hooks(target)
+    _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
+    if enable == is_enabled
+      return
+    end
+    if is_enabled
+      @old_included_extended.each(&:restore)
+      @old_included_extended = 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)
+      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)
+      end
+      @old_included_extended = [old_included, old_extended]
+    end
+  end
+
   def self.install_hooks(mod)
     return if @installed_hooks.include?(mod)
     @installed_hooks << mod
@@ -317,6 +413,9 @@ module T::Private::Methods
 
   private_class_method def self.install_singleton_method_added_hook(singleton_klass)
     attached = nil
+    # this prevents the final checks from triggering about singleton_method_added not being a final method even if the
+    # module is final.
+    T::Private::DeclState.current.skip_next_on_method_added = true
     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)
@@ -330,8 +429,13 @@ module T::Private::Methods
     original_singleton_method.bind(attached).call(:singleton_method_added)
   end
 
+  # use this directly if you don't want/need to box up the method into an object to pass to method_to_key.
+  private_class_method def self.method_owner_and_name_to_key(owner, name)
+    "#{owner.object_id}##{name}"
+  end
+
   private_class_method def self.method_to_key(method)
-    "#{method.owner.object_id}##{method.name}"
+    method_owner_and_name_to_key(method.owner, method.name)
   end
 
   private_class_method def self.key_to_method(key)

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

@@ -35,9 +35,11 @@ module T::Private::Methods::CallValidation
     elsif method_sig.check_level == :always || (method_sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
       create_validator_method(mod, original_method, method_sig, original_visibility)
     else
-      # get all the shims out of the way and put back the original method
-      mod.send(:define_method, method_sig.method_name, original_method)
-      mod.send(original_visibility, method_sig.method_name)
+      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)
+        mod.send(original_visibility, method_sig.method_name)
+      end
     end
     # Return the newly created method (or the original one if we didn't replace it)
     mod.instance_method(method_sig.method_name)
@@ -161,18 +163,21 @@ 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)}
     has_simple_method_types =  all_args_are_simple && method_sig.return_type.is_a?(T::Types::Simple)
     has_simple_procedure_types = all_args_are_simple && method_sig.return_type.is_a?(T::Private::Types::Void)
 
-    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::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)
+      end
     end
     mod.send(original_visibility, method_sig.method_name)
   end

data/lib/types/props/decorator.rb

@@ -485,18 +485,20 @@ class T::Props::Decorator
 
   sig {params(name: Symbol, rules: Rules).void}
   private def define_getter_and_setter(name, rules)
-    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
-      @class.send(:define_method, "#{name}=") do |x|
-        self.class.decorator.prop_set(self, name, x, 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
+        @class.send(:define_method, "#{name}=") do |x|
+          self.class.decorator.prop_set(self, name, x, rules)
+        end
       end
-    end
 
-    @class.send(:define_method, name) do
-      self.class.decorator.prop_get(self, name, rules)
+      @class.send(:define_method, name) do
+        self.class.decorator.prop_get(self, name, rules)
+      end
     end
   end
 

data/lib/types/sig.rb

@@ -7,19 +7,24 @@ module T::Sig
   module WithoutRuntime
     # At runtime, does nothing, but statically it is treated exactly the same
     # as T::Sig#sig. Only use it in cases where you can't use T::Sig#sig.
-    def self.sig(&blk); end # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+    def self.sig(arg=nil, &blk); end # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+
+    original_verbose = $VERBOSE
+    $VERBOSE = false
 
     # At runtime, does nothing, but statically it is treated exactly the same
     # as T::Sig#sig. Only use it in cases where you can't use T::Sig#sig.
-    T::Sig::WithoutRuntime.sig {params(blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
-    def self.sig(&blk); end # rubocop:disable PrisonGuard/BanBuiltinMethodOverride, Lint/DuplicateMethods
+    T::Sig::WithoutRuntime.sig {params(arg: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
+    def self.sig(arg=nil, &blk); end # rubocop:disable PrisonGuard/BanBuiltinMethodOverride, Lint/DuplicateMethods
+
+    $VERBOSE = original_verbose
   end
 
   # Declares a method with type signatures and/or
   # abstract/override/... helpers. See the documentation URL on
   # {T::Helpers}
-  T::Sig::WithoutRuntime.sig {params(blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
-  def sig(&blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
-    T::Private::Methods.declare_sig(self, &blk)
+  T::Sig::WithoutRuntime.sig {params(arg: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
+  def sig(arg=nil, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+    T::Private::Methods.declare_sig(self, arg, &blk)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.4.4398
+  version: 0.4.4451
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-08 00:00:00.000000000 Z
+date: 2019-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -75,6 +75,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