sorbet-runtime 0.5.9327 → 0.5.9338

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4086aef427b0d9ba64f92c95e703f259b44d1f0dd7c2cf3187d8873fdcd67db4
-  data.tar.gz: 53e2599d56f09537dba517649a3b7672a0ce38eea85d10a2d1169d270e6472d1
+  metadata.gz: dd07f89d57f3da4bd05dc16bfe0163a67f417549c6e65771415df742fb02882f
+  data.tar.gz: 4e7650cda8f79b6a7bd0afc041ffbf9f2c07e596fb52fc38f8526f4b1cf723da
 SHA512:
-  metadata.gz: 53955733aed646cd83ef989d79ec7d879f39afaa5cde54849972da5634c47d482441cf298509aa1f9d710d2873a37a16b65b051753d6ebc5b7aad686ea43cbbd
-  data.tar.gz: 803cdd8a2273deda3ce67736224fceda59a6483a08cbe52cd7f55d85f2324c86e29748576e4e7dfe11ae6b39d70e99b024ec9285da443fd6e5c5d8d5fdb160d6
+  metadata.gz: 3dfb99200d94190aad5bd3ec27179b43a552c543c03c5be771de8b5985d1571c6e60e9ccc9ecf9b42a0bb1fe09f25ddca10e51a0e70b35cfca5a3fae27e19414
+  data.tar.gz: 31299aee649d7479933ea1b5eb3c1ae514279b02479e6d17f280753a964a5a0a6dd4da9feaeca83201e95cf7e807b302df7b4c31c5fa7f9460610e8a634b5f7c

data/lib/sorbet-runtime.rb

@@ -22,6 +22,8 @@ require_relative 'types/private/decl_state'
 require_relative 'types/private/class_utils'
 require_relative 'types/private/runtime_levels'
 require_relative 'types/private/methods/_methods'
+require_relative 'types/private/methods/modes'
+require_relative 'types/private/methods/decl_builder'
 require_relative 'types/sig'
 require_relative 'types/helpers'
 require_relative 'types/private/final'
@@ -60,7 +62,6 @@ require_relative 'types/types/type_member'
 require_relative 'types/types/type_template'
 
 # Call validation
-require_relative 'types/private/methods/modes'
 require_relative 'types/private/methods/call_validation'
 
 # Signature validation
@@ -74,7 +75,6 @@ require_relative 'types/interface_wrapper'
 require_relative 'types/private/abstract/declare'
 require_relative 'types/private/abstract/hooks'
 require_relative 'types/private/casts'
-require_relative 'types/private/methods/decl_builder'
 require_relative 'types/private/methods/signature'
 require_relative 'types/private/retry'
 require_relative 'types/utils'

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

@@ -29,12 +29,13 @@ module T::Private::Methods
   ARG_NOT_PROVIDED = Object.new
   PROC_TYPE = Object.new
 
-  DeclarationBlock = Struct.new(:mod, :loc, :blk, :final, :raw)
+  DeclarationBlock = Struct.new(:mod, :loc, :blk, :raw, :decl_builder)
 
   def self.declare_sig(mod, loc, arg, &blk)
-    T::Private::DeclState.current.active_declaration = _declare_sig_internal(mod, loc, arg, &blk)
+    declaration = _declare_sig_internal(mod, loc, arg, &blk)
+    T::Private::DeclState.current.active_declaration = declaration
 
-    nil
+    declaration.decl_builder
   end
 
   # See tests for how to use this.  But you shouldn't be using this.
@@ -54,7 +55,10 @@ module T::Private::Methods
       raise "Invalid argument to `sig`: #{arg}"
     end
 
-    DeclarationBlock.new(mod, loc, blk, arg == :final, raw)
+    decl_builder = DeclBuilder.new(mod, raw)
+    decl_builder.final if arg == :final # needed for backwards compatibility with sig(:final) {...}
+
+    DeclarationBlock.new(mod, loc, blk, raw, decl_builder)
   end
 
   def self._with_declared_signature(mod, declblock, &blk)
@@ -213,7 +217,7 @@ module T::Private::Methods
     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)
+    if T::Private::Final.final_module?(mod) && (current_declaration.nil? || !current_declaration.decl_builder.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.
@@ -277,7 +281,7 @@ module T::Private::Methods
     end
 
     @sig_wrappers[key] = sig_block
-    if current_declaration.final
+    if current_declaration.decl_builder.final?
       @was_ever_final_names[method_name] = true
       # 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.
@@ -346,10 +350,9 @@ module T::Private::Methods
   end
 
   def self.run_builder(declaration_block)
-    builder = DeclBuilder.new(declaration_block.mod, declaration_block.raw)
-    builder
-      .instance_exec(&declaration_block.blk)
-      .finalize!
+    declaration_block
+      .decl_builder
+      .run!(&declaration_block.blk)
       .decl
   end
 

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

@@ -2,9 +2,23 @@
 # typed: true
 
 module T::Private::Methods
-  Declaration = Struct.new(:mod, :params, :returns, :bind, :mode, :checked, :finalized, :on_failure, :override_allow_incompatible, :type_parameters, :raw)
+  Declaration = Struct.new(
+    :mod,
+    :params,
+    :returns,
+    :bind,
+    :mode,
+    :checked,
+    :finalized,
+    :on_failure,
+    :override_allow_incompatible,
+    :type_parameters,
+    :raw,
+    :final
+  )
 
   class DeclBuilder
+    # The signature declaration the builder is composing (class `Declaration`)
     attr_reader :decl
 
     class BuilderError < StandardError; end
@@ -15,6 +29,24 @@ module T::Private::Methods
       end
     end
 
+    private def check_sig_block_is_unset!
+      if T::Private::DeclState.current.active_declaration&.blk
+        raise BuilderError.new(
+          "Cannot add more signature statements after the declaration block."
+        )
+      end
+    end
+
+    # Verify if we're trying to invoke the method outside of a signature block. Notice that we need to check if it's a
+    # proc, because this is valid and would lead to a false positive: `T.type_alias { T.proc.params(a: Integer).void }`
+    private def check_running_inside_block!(method_name)
+      unless @inside_sig_block || decl.mod == T::Private::Methods::PROC_TYPE
+        raise BuilderError.new(
+          "Can't invoke #{method_name} outside of a signature declaration block"
+        )
+      end
+    end
+
     def initialize(mod, raw)
       # TODO RUBYPLAT-1278 - with ruby 2.5, use kwargs here
       @decl = Declaration.new(
@@ -28,12 +60,23 @@ module T::Private::Methods
         ARG_NOT_PROVIDED, # on_failure
         nil, # override_allow_incompatible
         ARG_NOT_PROVIDED, # type_parameters
-        raw
+        raw,
+        ARG_NOT_PROVIDED, # final
       )
+      @inside_sig_block = false
+    end
+
+    def run!(&block)
+      @inside_sig_block = true
+      instance_exec(&block)
+      finalize!
+      self
     end
 
     def params(**params)
       check_live!
+      check_running_inside_block!(__method__)
+
       if !decl.params.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .params twice")
       end
@@ -48,6 +91,8 @@ module T::Private::Methods
 
     def returns(type)
       check_live!
+      check_running_inside_block!(__method__)
+
       if decl.returns.is_a?(T::Private::Types::Void)
         raise BuilderError.new("You can't call .returns after calling .void.")
       end
@@ -62,6 +107,8 @@ module T::Private::Methods
 
     def void
       check_live!
+      check_running_inside_block!(__method__)
+
       if !decl.returns.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .void after calling .returns.")
       end
@@ -73,6 +120,8 @@ module T::Private::Methods
 
     def bind(type)
       check_live!
+      check_running_inside_block!(__method__)
+
       if !decl.bind.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .bind multiple times in a signature.")
       end
@@ -84,6 +133,7 @@ module T::Private::Methods
 
     def checked(level)
       check_live!
+      check_running_inside_block!(__method__)
 
       if !decl.checked.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .checked multiple times in a signature.")
@@ -102,6 +152,7 @@ module T::Private::Methods
 
     def on_failure(*args)
       check_live!
+      check_running_inside_block!(__method__)
 
       if !decl.on_failure.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .on_failure multiple times in a signature.")
@@ -115,7 +166,7 @@ module T::Private::Methods
       self
     end
 
-    def abstract
+    def abstract(&blk)
       check_live!
 
       case decl.mode
@@ -127,15 +178,47 @@ module T::Private::Methods
         raise BuilderError.new("`.abstract` cannot be combined with `.override` or `.overridable`.")
       end
 
+      check_sig_block_is_unset!
+
+      if blk
+        T::Private::DeclState.current.active_declaration.blk = blk
+      end
+
       self
     end
 
-    def final
+    def final(&blk)
       check_live!
-      raise BuilderError.new("The syntax for declaring a method final is `sig(:final) {...}`, not `sig {final. ...}`")
+
+      if !decl.final.equal?(ARG_NOT_PROVIDED)
+        raise BuilderError.new("You can't call .final multiple times in a signature.")
+      end
+
+      if @inside_sig_block
+        raise BuilderError.new(
+          "Unlike other sig annotations, the `final` annotation must remain outside the sig block, " \
+          "using either `sig(:final) {...}` or `sig.final {...}`, not `sig {final. ...}"
+        )
+      end
+
+      raise BuilderError.new(".final cannot be repeated in a single signature") if final?
+
+      decl.final = true
+
+      check_sig_block_is_unset!
+
+      if blk
+        T::Private::DeclState.current.active_declaration.blk = blk
+      end
+
+      self
     end
 
-    def override(allow_incompatible: false)
+    def final?
+      !decl.final.equal?(ARG_NOT_PROVIDED) && decl.final
+    end
+
+    def override(allow_incompatible: false, &blk)
       check_live!
 
       case decl.mode
@@ -150,10 +233,16 @@ module T::Private::Methods
         raise BuilderError.new("`.override` cannot be combined with `.abstract`.")
       end
 
+      check_sig_block_is_unset!
+
+      if blk
+        T::Private::DeclState.current.active_declaration.blk = blk
+      end
+
       self
     end
 
-    def overridable
+    def overridable(&blk)
       check_live!
 
       case decl.mode
@@ -167,6 +256,12 @@ module T::Private::Methods
         raise BuilderError.new(".overridable cannot be repeated in a single signature")
       end
 
+      check_sig_block_is_unset!
+
+      if blk
+        T::Private::DeclState.current.active_declaration.blk = blk
+      end
+
       self
     end
 
@@ -183,6 +278,7 @@ module T::Private::Methods
     #  def map(&blk); end
     def type_parameters(*names)
       check_live!
+      check_running_inside_block!(__method__)
 
       names.each do |name|
         raise BuilderError.new("not a symbol: #{name}") unless name.is_a?(Symbol)

data/lib/types/sig.rb

@@ -12,10 +12,53 @@ module T::Sig
     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.
+    # At runtime, only returns a fake declaration builder to allow chaining methods, 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(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
-    def self.sig(arg0=nil, &blk); end # rubocop:disable Lint/DuplicateMethods
+    def self.sig(arg0=nil, &blk) # rubocop:disable Lint/DuplicateMethods
+      DeclBuilder.new
+    end
+
+    # This fake version of DeclBuilder exists so that signatures without runtime don't have to pay the cost associated
+    # with using the actual DeclBuilder
+    class DeclBuilder
+      T::Sig::WithoutRuntime.sig do
+        params(
+          _blk: T.nilable(T.proc.bind(T::Private::Methods::DeclBuilder).void)
+        ).returns(DeclBuilder)
+      end
+      def abstract(&_blk)
+        self
+      end
+
+      T::Sig::WithoutRuntime.sig do
+        params(
+          _blk: T.nilable(T.proc.bind(T::Private::Methods::DeclBuilder).void)
+        ).returns(DeclBuilder)
+      end
+      def final(&_blk)
+        self
+      end
+
+      T::Sig::WithoutRuntime.sig do
+        params(
+          _allow_incompatible: T::Boolean,
+          _blk: T.nilable(T.proc.bind(T::Private::Methods::DeclBuilder).void)
+        ).returns(DeclBuilder)
+      end
+      def override(_allow_incompatible: false, &_blk)
+        self
+      end
+
+      T::Sig::WithoutRuntime.sig do
+        params(
+          _blk: T.nilable(T.proc.bind(T::Private::Methods::DeclBuilder).void)
+        ).returns(DeclBuilder)
+      end
+      def overridable(&_blk)
+        self
+      end
+    end
 
     $VERBOSE = original_verbose
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.9327
+  version: 0.5.9338
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-16 00:00:00.000000000 Z
+date: 2021-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest