sorbet-runtime 0.5.11144 → 0.5.11218

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5b21bcb5dabd49853b11434c9845cf1530e7c5b1fa475b93fda398e5b8121bb
-  data.tar.gz: 34af59fbefda1547828f8aa5fc668cf588754d9b8b1ac1221a804ba2840ad99b
+  metadata.gz: dc3bbd1acf267719f097fe97d978b1896075899607230c1f64d9c9dd3c5b3d33
+  data.tar.gz: fc59cc7e14e1218a2567b20267562e60bf229283ffc3db5c28096bfbf3a7cf64
 SHA512:
-  metadata.gz: a093baa9c20a21486f6af5bd315bae13c37e59e2581dfff5a8dd6f3e95be0a50222a988358fbc2b7e14f2642d6cc14d6b3f33227d7bf73e03ecaebde1b1cb08d
-  data.tar.gz: d814fc35c1b03fdd2d73639515eb52cd438caa7c6719d647917add140bf9a8432757ee037836eab5011b8e8c677378092225d956452e9f6e3ab063609856d805
+  metadata.gz: 1d5549e16e9f5a96f4fbc692b4fac7a498ce74deb4bff02f92a9c43318418d1d4ccefa594d7884cdd7662b5225e5e3abe41136afe4682c98fe30430099aa93c0
+  data.tar.gz: 20d1ef7401dd881324f02c58f2938bef3f3f304d3bf2c3eefc2b68f7e5fce28e69db27c5ed5bd4c1a4ac3bedd302469f1a45314e8e6858cd898943b788814e17

data/lib/sorbet-runtime.rb

@@ -73,7 +73,6 @@ require_relative 'types/private/abstract/validate'
 
 # Catch all. Sort of built by `cd extn; find types -type f | grep -v test | sort`
 require_relative 'types/generic'
-require_relative 'types/interface_wrapper'
 require_relative 'types/private/abstract/declare'
 require_relative 'types/private/abstract/hooks'
 require_relative 'types/private/casts'

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

@@ -18,7 +18,6 @@ module T::Private::Abstract::Declare
     Abstract::Data.set(mod, :abstract_type, type)
 
     mod.extend(Abstract::Hooks)
-    mod.extend(T::InterfaceWrapper::Helpers)
 
     if mod.is_a?(Class)
       if type == :interface
@@ -35,11 +34,11 @@ module T::Private::Abstract::Declare
       # define_method because of the guard above
 
       mod.send(:define_singleton_method, :new) do |*args, &blk|
-        super(*args, &blk).tap do |result|
-          if result.instance_of?(mod)
-            raise "#{mod} is declared as abstract; it cannot be instantiated"
-          end
+        result = super(*args, &blk)
+        if result.instance_of?(mod)
+          raise "#{mod} is declared as abstract; it cannot be instantiated"
         end
+        result
       end
 
       # Ruby doesn not emit "method redefined" warnings for aliased methods

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

@@ -8,7 +8,7 @@ module T::Private::Methods
   @sigs_that_raised = {}
   # stores method names that were declared final without regard for where.
   # enables early rejection of names that we know can't induce final method violations.
-  @was_ever_final_names = {}
+  @was_ever_final_names = {}.compare_by_identity
   # maps from a module's object_id to the set of final methods declared in that module.
   # we also overload entries slightly: if the value is nil, that means that the
   # module has final methods somewhere along its ancestor chain, but does not itself
@@ -20,7 +20,7 @@ module T::Private::Methods
   # twice is permitted).  we could do this with two tables, but it seems slightly
   # cleaner with a single table.
   # Effectively T::Hash[Module, T.nilable(Set))]
-  @modules_with_final = Hash.new {|hash, key| hash[key] = nil}
+  @modules_with_final = Hash.new {|hash, key| hash[key] = nil}.compare_by_identity
   # 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.
@@ -132,7 +132,7 @@ module T::Private::Methods
     source_ancestors = nil
     # use reverse_each to check farther-up ancestors first, for better error messages.
     target_ancestors.reverse_each do |ancestor|
-      final_methods = @modules_with_final.fetch(ancestor.object_id, nil)
+      final_methods = @modules_with_final.fetch(ancestor, nil)
       # In this case, either ancestor didn't have any final methods anywhere in its
       # ancestor chain, or ancestor did have final methods somewhere in its ancestor
       # chain, but no final methods defined in ancestor itself.  Either way, there
@@ -150,13 +150,13 @@ module T::Private::Methods
             # filter out things without actual final methods just to make sure that
             # the below checks (which should be uncommon) go as quickly as possible.
             source_ancestors.select! do |a|
-              @modules_with_final.fetch(a.object_id, nil)
+              @modules_with_final.fetch(a, nil)
             end
           end
           # final-ness means that there should be no more than one index for which
           # the below block returns true.
           defining_ancestor_idx = source_ancestors.index do |a|
-            @modules_with_final.fetch(a.object_id).include?(method_name)
+            @modules_with_final.fetch(a).include?(method_name)
           end
           next if defining_ancestor_idx && source_ancestors[defining_ancestor_idx] == ancestor
         end
@@ -191,13 +191,11 @@ module T::Private::Methods
     end
   end
 
-  def self.add_module_with_final_method(mod, method_name, is_singleton_method)
-    m = is_singleton_method ? mod.singleton_class : mod
-    mid = m.object_id
-    methods = @modules_with_final[mid]
+  def self.add_module_with_final_method(mod, method_name)
+    methods = @modules_with_final[mod]
     if methods.nil?
       methods = {}
-      @modules_with_final[mid] = methods
+      @modules_with_final[mod] = methods
     end
     methods[method_name] = true
     nil
@@ -205,24 +203,23 @@ module T::Private::Methods
 
   def self.note_module_deals_with_final(mod)
     # Side-effectfully initialize the value if it's not already there
-    @modules_with_final[mod.object_id]
-    @modules_with_final[mod.singleton_class.object_id]
+    @modules_with_final[mod]
+    @modules_with_final[mod.singleton_class]
   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)
+  def self._on_method_added(hook_mod, mod, method_name)
     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
 
     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
     # Don't compute mod.ancestors if we don't need to bother checking final-ness.
-    if @was_ever_final_names.include?(method_name) && @modules_with_final.include?(mod.object_id)
+    if @was_ever_final_names.include?(method_name) && @modules_with_final.include?(mod)
       _check_final_ancestors(mod, mod.ancestors, [method_name], nil)
       # We need to fetch the active declaration again, as _check_final_ancestors
       # may have reset it (see the comment in that method for details).
@@ -287,7 +284,7 @@ module T::Private::Methods
       # 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.
       note_module_deals_with_final(hook_mod)
-      add_module_with_final_method(hook_mod, method_name, is_singleton_method)
+      add_module_with_final_method(mod, method_name)
     end
   end
 
@@ -431,7 +428,7 @@ module T::Private::Methods
     run_sig_block_for_key(method_to_key(method))
   end
 
-  private_class_method def self.run_sig_block_for_key(key)
+  private_class_method def self.run_sig_block_for_key(key, force_type_init: false)
     blk = @sig_wrappers[key]
     if !blk
       sig = @signatures_by_method[key]
@@ -454,14 +451,17 @@ module T::Private::Methods
     end
 
     @sig_wrappers.delete(key)
+
+    sig.force_type_init if force_type_init
+
     sig
   end
 
-  def self.run_all_sig_blocks
+  def self.run_all_sig_blocks(force_type_init: true)
     loop do
       break if @sig_wrappers.empty?
       key, = @sig_wrappers.first
-      run_sig_block_for_key(key)
+      run_sig_block_for_key(key, force_type_init: force_type_init)
     end
   end
 
@@ -474,8 +474,8 @@ module T::Private::Methods
   def self._hook_impl(target, singleton_class, source)
     # we do not need to call add_was_ever_final here, because we have already marked
     # any such methods when source was originally defined.
-    if !@modules_with_final.include?(target.object_id)
-      if !@modules_with_final.include?(source.object_id)
+    if !@modules_with_final.include?(target)
+      if !@modules_with_final.include?(source)
         return
       end
       note_module_deals_with_final(target)
@@ -541,14 +541,14 @@ module T::Private::Methods
   module MethodHooks
     def method_added(name)
       super(name)
-      ::T::Private::Methods._on_method_added(self, name, is_singleton_method: false)
+      ::T::Private::Methods._on_method_added(self, self, name)
     end
   end
 
   module SingletonMethodHooks
     def singleton_method_added(name)
       super(name)
-      ::T::Private::Methods._on_method_added(self, name, is_singleton_method: true)
+      ::T::Private::Methods._on_method_added(self, singleton_class, name)
     end
   end
 

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

@@ -15,8 +15,6 @@ module T::Private::Methods::CallValidation
     original_visibility = visibility_method_name(mod, method_sig.method_name)
     if method_sig.mode == T::Private::Methods::Modes.abstract
       T::Private::ClassUtils.replace_method(mod, method_sig.method_name, true) do |*args, &blk|
-        # TODO: write a cop to ensure that abstract methods have an empty body
-        #
         # We allow abstract methods to be implemented by things further down the ancestor chain.
         # So, if a super method exists, call it.
         if defined?(super)
@@ -67,14 +65,30 @@ module T::Private::Methods::CallValidation
     simple_method = all_args_are_simple && method_sig.return_type.is_a?(T::Types::Simple)
     simple_procedure = all_args_are_simple && method_sig.return_type.is_a?(T::Private::Types::Void)
 
+    # All the types for which valid? unconditionally returns `true`
+    return_is_ignorable =
+      (method_sig.return_type.equal?(T::Types::Untyped::Private::INSTANCE) ||
+       method_sig.return_type.equal?(T::Types::Anything::Private::INSTANCE) ||
+       method_sig.return_type.equal?(T::Types::AttachedClassType::Private::INSTANCE) ||
+       method_sig.return_type.equal?(T::Types::SelfType::Private::INSTANCE) ||
+       method_sig.return_type.is_a?(T::Types::TypeParameter) ||
+       method_sig.return_type.is_a?(T::Types::TypeVariable) ||
+       (method_sig.return_type.is_a?(T::Types::Simple) && method_sig.return_type.raw_type.equal?(BasicObject)))
+
+    returns_anything_method = all_args_are_simple && return_is_ignorable
+
     T::Configuration.without_ruby_warnings do
       T::Private::DeclState.current.without_on_method_added do
         if simple_method
           create_validator_method_fast(mod, original_method, method_sig, original_visibility)
+        elsif returns_anything_method
+          create_validator_method_skip_return_fast(mod, original_method, method_sig, original_visibility)
         elsif simple_procedure
           create_validator_procedure_fast(mod, original_method, method_sig, original_visibility)
         elsif ok_for_fast_path && method_sig.return_type.is_a?(T::Private::Types::Void)
           create_validator_procedure_medium(mod, original_method, method_sig, original_visibility)
+        elsif ok_for_fast_path && return_is_ignorable
+          create_validator_method_skip_return_medium(mod, original_method, method_sig, original_visibility)
         elsif ok_for_fast_path
           create_validator_method_medium(mod, original_method, method_sig, original_visibility)
         elsif can_skip_block_type