sorbet-runtime 0.6.13279 → 0.6.13281

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94f9430afda35cc983dbaf2b2ece5ce0f8528c3e3928497a9a659f5f177f7a69
-  data.tar.gz: a7b483b8aacb2b23c95a152af38b37cd6c99fba0803bd950a56edfed6bd57922
+  metadata.gz: aaa4eaf7440ab0887a2d95dec4d0be0d149410e22cae9f348b5a8270bb19796a
+  data.tar.gz: 8258b1befb96c28b5df177d984b51a75bbc97f005acf81f86b79add2938ad273
 SHA512:
-  metadata.gz: a0c5963cf3184b283798aaaf31cec437eb366f435f9daeb29a8840f949b7062f2cd460cd80cfb075082f126d9e49850dbd2f6f3741ce3ef3b0a8d733be8f7c8d
-  data.tar.gz: 663c026581f6a6a4bb5d2be94177b0cf839e31bd4a05f7cc9e9f24ada3f5ee7e844c2ead306ac91bfc2e73acb27cfac7925008509b1122fe3f37acb7793369a1
+  metadata.gz: 5bfa0d8826de0338cc2bffc9b11f813fabbb90bde6d1da666b8b870b58ddbc113e3c6ff8e0086ea2f0f91fbacbf2f739edadd0ad1e36bc01418d5161403f68be
+  data.tar.gz: 06cf53f3de854380be2cd661cc9503e73365918f959af3d85827443d5d7594981a27c65acbea58ee518f59f480aa60e9e2acd8dda8ee53e5e327e594b3425a84

data/lib/sorbet-runtime.rb

@@ -25,9 +25,7 @@ require_relative 'types/private/class_utils'
 require_relative 'types/private/runtime_levels'
 require_relative 'types/private/methods/_methods'
 require_relative 'types/sig'
-require_relative 'types/def_mods'
 require_relative 'types/helpers'
-require_relative 'types/syntax'
 require_relative 'types/private/final'
 require_relative 'types/private/sealed'
 

data/lib/types/private/decl_state.rb

@@ -12,17 +12,9 @@ class T::Private::DeclState
 
   attr_accessor :active_declaration
   attr_accessor :skip_on_method_added
-  attr_accessor :previous_declaration
 
   def reset!
     self.active_declaration = nil
-    @previous_declaration = nil
-  end
-
-  def consume!
-    @previous_declaration = self.active_declaration
-    self.active_declaration = nil
-    @previous_declaration
   end
 
   def without_on_method_added

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

@@ -48,7 +48,7 @@ module T::Private::Methods
   #   (This can matter for circular load-time behavior, where a method is
   #   called while its Signature is being built)
   # - It's `nil` if we've finished building the sig
-  DeclarationBlock = Struct.new(:mod, :method_name, :loc, :blk_or_decl, :final, :abstract, :override, :overridable)
+  DeclarationBlock = Struct.new(:mod, :loc, :blk_or_decl, :final)
 
   def self.declare_sig(mod, loc, arg, &blk)
     if T::Private::DeclState.current.active_declaration
@@ -60,122 +60,13 @@ module T::Private::Methods
       raise "Invalid argument to `sig`: #{arg}"
     end
 
-    method_name = nil # will be filled in once the next method is defined
-    abstract = nil
-    override = nil
-    overridable = nil
-    T::Private::DeclState.current.active_declaration = DeclarationBlock.new(mod, method_name, loc, blk, arg == :final, abstract, override, overridable)
-
-    nil
-  end
-
-  private_class_method def self.ensure_valid_declare_dsl!(mod, method_name, dsl_name)
-    previous_declaration = T::Private::DeclState.current.previous_declaration
-    if previous_declaration.nil?
-      # TODO(jez) Eventually, relax this and allow these DSLs without a preceding `sig`
-      raise DeclBuilder::BuilderError.new("You must declare a `sig` before using `#{dsl_name}` on the method `#{method_name}`")
-    end
-
-    if !previous_declaration.blk_or_decl.is_a?(Proc)
-      raise DeclBuilder::BuilderError.new("Cannot call `#{dsl_name} #{method_name.inspect}`, because the sig block has already run")
-    end
-
-    # previous_declaration.mod is the method owner (which for `def self.foo`
-    # is the singleton class). The DSL caller's `self` is the class itself,
-    # so we also accept mod.singleton_class == previous_declaration.mod.
-    mod_matches = previous_declaration.mod == mod || previous_declaration.mod == mod.singleton_class
-    if !mod_matches || previous_declaration.method_name != method_name
-      raise DeclBuilder::BuilderError.new(
-        "Can only call `#{dsl_name} #{method_name.inspect}` for the previously sig'd method. " \
-        "Expected: #{previous_declaration.mod}##{previous_declaration.method_name}"
-      )
-    end
-
-    previous_declaration
-  end
-
-  def self.declare_abstract(mod, method_name)
-    previous_declaration = ensure_valid_declare_dsl!(mod, method_name, :abstract)
-    return unless previous_declaration
-
-    if previous_declaration.abstract
-      raise DeclBuilder::BuilderError.new("Cannot call `abstract` twice for the method `#{method_name}`")
-    end
-
-    previous_declaration.abstract = true
-
-    # # TODO(jez) In the future, we will want some logic like this, but ONLY if
-    # # the method did not have a sig. The first-call sig wrapper is normally in
-    # # charge of running the sig block (even for abstract methods) If we know
-    # # for sure that we're not going to have a sig, but we want the runtime
-    # # `super` logic (possibly because there is an RBS method annotation), we
-    # # are safe to eagerly call `create_abstract_wrapper` to overwrite the
-    # # user's method.
-    # #
-    # # (Omitting this until we support DSL methods without runtime `sig`'s)
-    # original_visibility = T::Private::ClassUtils.visibility_method_name(mod, method_name)
-    # T::Private::Methods::CallValidation.create_abstract_wrapper(mod, method_name, original_visibility)
-
-    nil
-  end
-
-  def self.declare_override(mod, method_name, allow_incompatible:)
-    previous_declaration = ensure_valid_declare_dsl!(mod, method_name, :override)
-    return unless previous_declaration
-
-    if previous_declaration.override
-      raise DeclBuilder::BuilderError.new("Cannot call `override` twice for the method `#{method_name}`")
-    end
-
-    method = mod.instance_method(method_name)
-    super_method = method.super_method
-    if super_method.nil?
-      source_loc = Kernel.caller_locations(2, 1)&.map { |loc| [loc.path || "<unknown>", loc.lineno] }&.first
-      T::Private::Methods::SignatureValidation.validate_non_override_mode(Modes.override, method_name, method, source_loc)
-    end
-
-    previous_declaration.override = {allow_incompatible: allow_incompatible}
-
-    nil
-  end
-
-  def self.declare_final(mod, method_name)
-    previous_declaration = ensure_valid_declare_dsl!(mod, method_name, :final)
-    return unless previous_declaration
-
-    if previous_declaration.final
-      raise DeclBuilder::BuilderError.new("Cannot declare `#{method_name}` final twice (from `sig(:final)` nor `final def`)")
-    end
-
-    previous_declaration.final = true
-
-    # Register final bookkeeping that _on_method_added would have done if it
-    # had seen final=true at that time. Use previous_declaration.mod (the actual
-    # method owner, which is the singleton_class for `def self.foo`).
-    add_module_with_final_method(previous_declaration.mod, method_name)
-
-    nil
-  end
-
-  def self.declare_overridable(mod, method_name)
-    previous_declaration = ensure_valid_declare_dsl!(mod, method_name, :overridable)
-    return unless previous_declaration
-
-    if previous_declaration.overridable
-      raise DeclBuilder::BuilderError.new("Cannot call `overridable` twice for the method `#{method_name}`")
-    end
-
-    previous_declaration.overridable = true
+    T::Private::DeclState.current.active_declaration = DeclarationBlock.new(mod, loc, blk, arg == :final)
 
     nil
   end
 
   def self.start_proc
-    # abstract/override/overridable don't make sense on procs
-    abstract = false
-    override = nil
-    overridable = false
-    DeclBuilder.new(PROC_TYPE, abstract, override, overridable)
+    DeclBuilder.new(PROC_TYPE)
   end
 
   def self.finalize_proc(decl)
@@ -301,7 +192,7 @@ module T::Private::Methods
       return
     end
 
-    current_declaration = T::Private::DeclState.current.consume!
+    current_declaration = T::Private::DeclState.current.active_declaration
 
     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"
@@ -317,8 +208,7 @@ module T::Private::Methods
     if current_declaration.nil?
       return
     end
-
-    current_declaration.method_name = method_name
+    T::Private::DeclState.current.reset!
 
     if method_name == :method_added || method_name == :singleton_method_added
       raise(
@@ -327,23 +217,9 @@ module T::Private::Methods
       )
     end
 
-    # We allow `sig` in the current module's context (normal case) and
-    if hook_mod != current_declaration.mod &&
-       # inside `class << self`, and
-       hook_mod.singleton_class != current_declaration.mod &&
-       # on `self` at the top level of a file
-       current_declaration.mod != TOP_SELF
-      raise "A method (#{method_name}) is being added on a different class/module (#{hook_mod}) than the " \
-            "last call to `sig` (#{current_declaration.mod}). Make sure each call " \
-            "to `sig` is immediately followed by a method definition on the same " \
-            "class/module."
-    end
-    # Overwrite the DeclarationBlock mod with `mod`, which is the Module that owns the method.
-    current_declaration.mod = mod
-
     original_method = mod.instance_method(method_name)
     sig_block = lambda do
-      T::Private::Methods.run_sig(method_name, original_method, current_declaration)
+      T::Private::Methods.run_sig(hook_mod, method_name, original_method, current_declaration)
     end
 
     # Always replace the original method with this wrapper,
@@ -422,7 +298,7 @@ module T::Private::Methods
 
   # Executes the `sig` block, and converts the resulting Declaration
   # to a Signature.
-  def self.run_sig(method_name, original_method, declaration_block)
+  def self.run_sig(hook_mod, method_name, original_method, declaration_block)
     current_declaration =
       begin
         run_builder(declaration_block)
@@ -436,7 +312,7 @@ module T::Private::Methods
 
     signature =
       if current_declaration
-        build_sig(method_name, original_method, current_declaration)
+        build_sig(hook_mod, method_name, original_method, current_declaration)
       else
         Signature.new_untyped(method: original_method)
       end
@@ -459,20 +335,27 @@ module T::Private::Methods
       raise "DeclarationBlock for #{declaration_block.mod} at #{declaration_block.loc} should have already been unwrapped"
     end
 
-    builder = DeclBuilder.new(
-      declaration_block.mod,
-      declaration_block.abstract,
-      declaration_block.override,
-      declaration_block.overridable
-    )
+    builder = DeclBuilder.new(declaration_block.mod)
     decl = builder.instance_exec(&blk_or_decl).finalize!.decl
     # Record that we've already run `blk` once and constructed a `Declaration`
     declaration_block.blk_or_decl = decl
     decl
   end
 
-  def self.build_sig(method_name, original_method, current_declaration)
+  def self.build_sig(hook_mod, method_name, original_method, current_declaration)
     begin
+      # We allow `sig` in the current module's context (normal case) and
+      if hook_mod != current_declaration.mod &&
+         # inside `class << self`, and
+         hook_mod.singleton_class != current_declaration.mod &&
+         # on `self` at the top level of a file
+         current_declaration.mod != TOP_SELF
+        raise "A method (#{method_name}) is being added on a different class/module (#{hook_mod}) than the " \
+              "last call to `sig` (#{current_declaration.mod}). Make sure each call " \
+              "to `sig` is immediately followed by a method definition on the same " \
+              "class/module."
+      end
+
       signature = Signature.new(
         method: original_method,
         method_name: method_name,
@@ -592,10 +475,6 @@ module T::Private::Methods
       key, = first_wrapper
       run_sig_block_for_key(key, force_type_init: force_type_init)
     end
-
-    # Make sure that there are no lingering declaration blocks being kept alive
-    # (so we're not retaining any extra references for a possible GC)
-    T::Private::DeclState.current.reset!
   end
 
   def self.all_checked_tests_sigs

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

@@ -15,7 +15,7 @@ module T::Private::Methods
       end
     end
 
-    def initialize(mod, abstract, override, overridable)
+    def initialize(mod)
       @decl = Declaration.new(
         mod,
         ARG_NOT_PROVIDED, # params
@@ -28,21 +28,6 @@ module T::Private::Methods
         false, # override_allow_incompatible
         ARG_NOT_PROVIDED, # type_parameters
       )
-
-      # Call the methods after the fact (instead of setting them in the constructor)
-      # so we get the BuilderError's, if applicable
-
-      if abstract
-        self.abstract
-      end
-
-      if override
-        self.override(**override)
-      end
-
-      if overridable
-        self.overridable
-      end
     end
 
     def params(*unused_positional_params, **params)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.6.13279
+  version: 0.6.13281
 platform: ruby
 authors:
 - Stripe
@@ -162,7 +162,6 @@ files:
 - lib/types/boolean.rb
 - lib/types/compatibility_patches.rb
 - lib/types/configuration.rb
-- lib/types/def_mods.rb
 - lib/types/enum.rb
 - lib/types/generic.rb
 - lib/types/helpers.rb
@@ -213,7 +212,6 @@ files:
 - lib/types/props/weak_constructor.rb
 - lib/types/sig.rb
 - lib/types/struct.rb
-- lib/types/syntax.rb
 - lib/types/types/anything.rb
 - lib/types/types/attached_class.rb
 - lib/types/types/base.rb

data/lib/types/def_mods.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-# Optional mixin providing `abstract`, `override`, `overridable`, and `final`
-# as method-level DSL keywords. Use with `extend T::DefMods`.
-#
-# These are alternatives to writing modifiers inside a `sig { ... }` block:
-#
-#   sig { void }
-#   abstract def foo; end
-#
-# is equivalent to:
-#
-#   sig { abstract.void }
-#   def foo; end
-#
-# They all return the method name, so that they can be chained with methods
-# like `private`. However, unlike those methods, these methods use the `sig`
-# declaration to discover the most-recently-defined method, instead of needing
-# `*_class_method` variants, like `private_class_method`.
-module T::DefMods
-  def abstract(method_name)
-    Kernel.raise TypeError.new("abstract accepts a Symbol, got #{method_name.class}") unless method_name.is_a?(Symbol)
-
-    begin
-      T::Private::Methods.declare_abstract(T.unsafe(self), method_name)
-    rescue T::Private::Methods::DeclBuilder::BuilderError => e
-      T::Configuration.sig_builder_error_handler(e, Kernel.caller_locations(1, 1)&.first)
-    end
-
-    method_name
-  end
-
-  def override(method_name, allow_incompatible: false)
-    Kernel.raise TypeError.new("override accepts a Symbol, got #{method_name.class}") unless method_name.is_a?(Symbol)
-
-    begin
-      T::Private::Methods.declare_override(T.unsafe(self), method_name, allow_incompatible: allow_incompatible)
-    rescue T::Private::Methods::DeclBuilder::BuilderError => e
-      T::Configuration.sig_builder_error_handler(e, Kernel.caller_locations(1, 1)&.first)
-    end
-
-    method_name
-  end
-
-  def final(method_name)
-    Kernel.raise TypeError.new("final accepts a Symbol, got #{method_name.class}") unless method_name.is_a?(Symbol)
-
-    begin
-      T::Private::Methods.declare_final(T.unsafe(self), method_name)
-    rescue T::Private::Methods::DeclBuilder::BuilderError => e
-      T::Configuration.sig_builder_error_handler(e, Kernel.caller_locations(1, 1)&.first)
-    end
-
-    method_name
-  end
-
-  def overridable(method_name)
-    Kernel.raise TypeError.new("overridable accepts a Symbol, got #{method_name.class}") unless method_name.is_a?(Symbol)
-
-    begin
-      T::Private::Methods.declare_overridable(T.unsafe(self), method_name)
-    rescue T::Private::Methods::DeclBuilder::BuilderError => e
-      T::Configuration.sig_builder_error_handler(e, Kernel.caller_locations(1, 1)&.first)
-    end
-
-    method_name
-  end
-end

data/lib/types/syntax.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-# typed: strict
-
-# Used as a shortcut for mixing in the three most common "syntax" extensions
-# that Sorbet provides: `sig`, the various sig DSL methods like `abstract` and
-# `override`, and the `final!`/`interface!` etc. syntax for class-level
-# annotations
-module T::Syntax
-  include T::Sig
-  include T::DefMods
-  include T::Helpers
-
-  # ===== NOTE: Must keep in sync with `T::Sig`! ==============================
-  #
-  # However, there are some slight differences:
-  #
-  # - We don't need the extra `include ... MethodHooks` lines, because those
-  #   come from the `include T::Sig` (c.f. `T::DefMods` though, where those
-  #   extra `include` *are* required because there is otherwise no inheritance
-  #   relationship between `T::Sig` and `T::DefMods`)
-  #
-  # - We don't do the TOP_SELF things, because it's not clear that you ever
-  #   really want this for TOP_SELF. e.g. what would it mean to write
-  #   `interface!` there?
-  #
-  #   Rather than encourage people to write `extend T::Syntax` in their script
-  #   top-levels, let's encourage people to just write `extend T::Sig` to keep
-  #   things simpler.
-  #
-  #   (We could revisit this in the future if people do really want this.)
-
-  private_class_method def self.included(other)
-    return unless Module == other
-    other.prepend(T::Private::Methods::MethodHooks)
-  end
-
-  private_class_method def self.extended(other)
-    return unless Module.===(other) && other.singleton_class?
-    other.include(T::Private::Methods::SingletonMethodHooks)
-  end
-  # ===========================================================================
-end