sorbet-runtime 0.4.4442 → 0.4.4443

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 640c933effd2dc03efc78babf1ae00ddec93c6cf
-  data.tar.gz: c336afa4260d72745c65e65793f9d00938ebbaf8
+  metadata.gz: f71f4ecf6f6c24f0dd4ba065d1f911e5ca4f3477
+  data.tar.gz: 2992a0f425abcba10f414389cfb23469af9eca1d
 SHA512:
-  metadata.gz: 38cf3b500f073f98d5148e36294f83b33be9fa32d8876f2c277344493df76867f4a387bc424643cb562d9b22af791f6b4dcea0f94158f04330f93fbaac2f3107
-  data.tar.gz: e73a0f9f99a5e17c2e1a6ff598c2b4bbae31155f219c195c4dc8a76795b1c19612b1c3d348ab1b916bab24f73b25b4ab0ecc7075e3bff4c18adf46cc0bb57c10
+  metadata.gz: 4bcdd49035d1e279c21225ad88becc369ad63a5ce046e05587ecba1b6c0f8c4424e28eb2060726248168d6a0c6daee042dd84388e9321682f72e7a003d83f41a
+  data.tar.gz: f5c7844214396806c60bcbee562e72c87b5cb73a352b5593e8758d7b8b8c4fcfb91787475518bab58b28e03ef5b4c19a393c408ffcbb693e730237ea7384900e

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`.
   #

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/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,60 @@ 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)
 
+    _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
@@ -161,15 +219,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 +359,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
@@ -330,8 +421,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

@@ -163,6 +163,7 @@ 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)}

data/lib/types/sig.rb

@@ -7,15 +7,15 @@ 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
@@ -23,8 +23,8 @@ module T::Sig
   # 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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.4.4442
+  version: 0.4.4443
 platform: ruby
 authors:
 - Stripe