sorbet-runtime 0.5.10805 → 0.5.10810

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8aaf11e42b38458ad4f9df3fcccea9d2e9c3abcb16cfc6b68e63464537ecf9eb
-  data.tar.gz: c5736c17b5d9152b421062d3fd5db31b7ce6d64a512e23ed11d417cb46fb3c04
+  metadata.gz: 9ce397971b7d821fb18a9d6e46c976b36f6aff58d41ce9c450b55b556a847038
+  data.tar.gz: 27e289b6c887fd4e55b3a4614cd8fd24e4eaf0a5597074f638bdc15832294feb
 SHA512:
-  metadata.gz: 7184b5d378814c673d1f65ca83c0c4c206892775fbbe543bcefbd0aa873df3abd0564a27a6cb32410b1e5a13c77de82d4729eecb82132cf5f0404905272cebb9
-  data.tar.gz: e3caf0d197620e66f66b1ae81d381755aa9a06055829e6a8c7ad46bf4e0a3b4a289ebb8ed477237cffd5eaa7ffd29699e6c544f0f524ff92de37a3501315576a
+  metadata.gz: 761d5c3f85446fb6c2f743868ecdf74f625b3d2c31d2e3045ca91ee626093f09f85f6fdcfdba1d1413896f5e451df450659bb619637fd66fa8d1ed95735d8223
+  data.tar.gz: e6e883faf46cfec00205731384229290d7ef8bbaa1044694d87d2e236d8f37172acf7a477e5a11e2077c6b47f53376ab6f5b7495b14eecd651a23635a7112e50

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

@@ -27,15 +27,15 @@ module T::Private::Abstract::Declare
         raise "Classes can't be interfaces. Use `abstract!` instead of `interface!`."
       end
 
-      if mod.instance_method(:initialize).owner == mod
-        raise "You must call `abstract!` *before* defining an initialize method"
+      if mod.method(:new).owner == mod
+        raise "You must call `abstract!` *before* defining a `new` 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
+      mod.send(:define_singleton_method, :new) do |*args, &blk|
+        if T.unsafe(self) == mod
           raise "#{mod} is declared as abstract; it cannot be instantiated"
         end
         super(*args, &blk)
@@ -43,10 +43,10 @@ module T::Private::Abstract::Declare
 
       # Ruby doesn not emit "method redefined" warnings for aliased methods
       # (more robust than undef_method that would create a small window in which the method doesn't exist)
-      mod.send(:alias_method, :initialize, :initialize)
+      mod.singleton_class.send(:alias_method, :new, :new)
 
-      if mod.respond_to?(:ruby2_keywords, true)
-        mod.send(:ruby2_keywords, :initialize)
+      if mod.singleton_class.respond_to?(:ruby2_keywords, true)
+        mod.singleton_class.send(:ruby2_keywords, :new)
       end
     end
   end

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

@@ -6,14 +6,63 @@ module T::Private::Methods::SignatureValidation
   Modes = Methods::Modes
 
   def self.validate(signature)
+    # Constructors in any language are always a bit weird: they're called in a
+    # static context, but their bodies are implemented by instance methods. So
+    # a mix of the rules that apply to instance methods and class methods
+    # apply.
+    #
+    # In languages like Java and Scala, static methods/companion object methods
+    # are never inherited. (In Java it almost looks like you can inherit them,
+    # because `Child.static_parent_method` works, but this method is simply
+    # resolved statically to `Parent.static_parent_method`). Even though most
+    # instance methods overrides have variance checking done, constructors are
+    # not treated like this, because static methods are never
+    # inherited/overridden, and the constructor can only ever be called
+    # indirectly by way of the static method. (Note: this is only a mental
+    # model--there's not actually a static method for the constructor in Java,
+    # there's an `invokespecial` JVM instruction that handles this).
+    #
+    # But Ruby is not like Java: singleton class methods in Ruby *are*
+    # inherited, unlike static methods in Java. In fact, this is similar to how
+    # JavaScript works. TypeScript simply then sidesteps the issue with
+    # structural typing: `typeof Parent` is not compatible with `typeof Child`
+    # if their constructors are different. (In a nominal type system, simply
+    # having Child descend from Parent should be the only factor in determining
+    # whether those types are compatible).
+    #
+    # Flow has nominal subtyping for classes. When overriding (static and
+    # instance) methods in a child class, the overrides must satisfy variance
+    # constraints. But it still carves out an exception for constructors,
+    # because then literally every class would have to have the same
+    # constructor. This is simply unsound. Hack does a similar thing--static
+    # method overrides are checked, but not constructors. Though what Hack
+    # *does* have is a way to opt into override checking for constructors with
+    # a special annotation.
+    #
+    # It turns out, Sorbet already has this special annotation: either
+    # `abstract` or `overridable`. At time of writing, *no* static override
+    # checking happens unless marked with these keywords (though at runtime, it
+    # always happens). Getting the static system to parity with the runtime by
+    # always checking overrides would be a great place to get to one day, but
+    # for now we can take advantage of it by only doing override checks for
+    # constructors if they've opted in.
+    #
+    # (When we get around to more widely checking overrides statically, we will
+    # need to build a matching special case for constructors statically.)
+    #
+    # Note that this breaks with tradition: normally, constructors are not
+    # allowed to be abstract. But that's kind of a side-effect of everything
+    # above: in Java/Scala, singleton class methods are never abstract because
+    # they're not inherited, and this extends to constructors. TypeScript
+    # simply rejects `new klass()` entirely if `klass` is
+    # `typeof AbstractClass`, requiring instead that you write
+    # `{ new(): AbstractClass }`. We may want to consider building some
+    # analogue to `T.class_of` in the future that works like this `{new():
+    # ...}` type.
     if signature.method_name == :initialize && signature.method.owner.is_a?(Class)
-      # Constructors are special. They look like overrides in terms of a super_method existing,
-      # but in practice, you never call them polymorphically. Conceptually, they're standard
-      # methods (this is consistent with how they're treated in other languages, e.g. Java)
-      if signature.mode != Modes.standard
-        raise "`initialize` should not use `.abstract` or `.implementation` or any other inheritance modifiers."
+      if signature.mode == Modes.standard
+        return
       end
-      return
     end
 
     super_method = signature.method.super_method

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.10805
+  version: 0.5.10810
 platform: ruby
 authors:
 - Stripe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-08 00:00:00.000000000 Z
+date: 2023-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest