sorbet-runtime 0.4.4746 → 0.4.4751

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e13d5fc2bb9079d78d348f97e5eac8e45f5b2ecd188bf5c6e6e0d6940f8a122
-  data.tar.gz: ddbd220e571a1a02b846d187812e9f9d16ec8fba0466490920888cdd2d498397
+  metadata.gz: 9fc9a8079b59e3449f32ad7455bdb1fd82f8a63c333eedcfbb680599d6886180
+  data.tar.gz: 2ea971b7de47aabc186e3434d1f1099f30296f300da305edacc16225467c25cc
 SHA512:
-  metadata.gz: 5e303d0e4648af91329be506f7430caaa246a75b34f677d1c1b1dfeea8ce0b8c8cabcd6b0267bd48b012bcd4ffd8b567f243819c88220f256f308d56d8aac864
-  data.tar.gz: c834e47f42f5e69d987f7971f6bd46c76d0e067000ee649ed6f90920251bbc72875f64c68d4d231d22f983846d4a848071db4eb83293ea4450f4fe12158a55e2
+  metadata.gz: 1cdf121434e68095f82d49903881a4a653db48d05a3b214a45ee71128c32a173a6ca96750ea7be5f9b2b788219414d77c71dd16abe02101739e3cf74d7bbbd30
+  data.tar.gz: 85bd0b9ab445f93cb2e8ed650edde297080bf67aabdc5ff3aa86a3b8c0068c11a41a57e4f750f21607acd9262894547b9588eac046dfb6f2cee2296195bcf2f0

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/methods/decl_builder.rb

@@ -145,8 +145,7 @@ 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
@@ -164,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
@@ -178,13 +178,13 @@ 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
 
@@ -194,16 +194,8 @@ module T::Private::Methods
     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
+      # TODO: remove this
+      override
 
       self
     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,13 +83,6 @@ 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"
-    when Modes.standard, *Modes::NON_OVERRIDE_MODES
-      # Peaceful
-      nil
-    when *Modes::IMPLEMENT_MODES
       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
@@ -106,10 +93,13 @@ module T::Private::Methods::SignatureValidation
         # 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 it doesn't match up with a corresponding abstract method.\n" \
+        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
     else
       raise "Unexpected mode: #{signature.mode}. Please report to #dev-productivity."
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.4.4746
+  version: 0.4.4751
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-12 00:00:00.000000000 Z
+date: 2019-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest