sorbet-runtime 0.6.13275 → 0.6.13277

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 717e7a8e84d644a5afb7d14417ccaed42da2a6ef811c9dd3035feeee101c11fd
-  data.tar.gz: 16f5fb77e086aa31acbf1d1b77f968ddd05511fdec586df1d24e26dfc61c1c2c
+  metadata.gz: 2205d03d1b0986fb0660902a75836d623c48307ad1b7c3b32b4a44ad79fe3c8c
+  data.tar.gz: 4a38dae4916789de65364bfe2bcb44f68fc1abf80c410b285013ffa1b540b902
 SHA512:
-  metadata.gz: d16177658b783935acd782292692cc60f574fa472646eb0d88d78d90e4367352a48232969f7ce907d2e5b08fbbbe1077196c36dba6aa46da0854fd914f556fdd
-  data.tar.gz: f3fb7b569a24bc63aaebb77b0ec9c9b920a6b246fd3bdaf8c1b98a24895529e51305cc6a383acce813696d4b0032a0bec9e4e7762af9aa9d91ad755d8d369a42
+  metadata.gz: c9835bded347ddabb8ea4ca593150f6d37aa676c01eff1ccc652fb176c8ca11886f6bbb303f454d40c6b0c366bd375c4d7781e277d654e7c55dc5dd11b034481
+  data.tar.gz: 625b9908b3f1732a2440252835719c8d6dd46160df04fb45622bd720f142274d4c06ffb0ffe5b01ae4fef73ef6baba5677abb91f72242ff8809a7066cd76eafd

data/lib/sorbet-runtime.rb

@@ -25,7 +25,9 @@ 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/def_mods.rb

@@ -0,0 +1,69 @@
+# 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/private/decl_state.rb

@@ -12,9 +12,17 @@ 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, :loc, :blk_or_decl, :final)
+  DeclarationBlock = Struct.new(:mod, :method_name, :loc, :blk_or_decl, :final, :abstract, :override, :overridable)
 
   def self.declare_sig(mod, loc, arg, &blk)
     if T::Private::DeclState.current.active_declaration
@@ -60,13 +60,122 @@ module T::Private::Methods
       raise "Invalid argument to `sig`: #{arg}"
     end
 
-    T::Private::DeclState.current.active_declaration = DeclarationBlock.new(mod, loc, blk, arg == :final)
+    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
 
     nil
   end
 
   def self.start_proc
-    DeclBuilder.new(PROC_TYPE)
+    # abstract/override/overridable don't make sense on procs
+    abstract = false
+    override = nil
+    overridable = false
+    DeclBuilder.new(PROC_TYPE, abstract, override, overridable)
   end
 
   def self.finalize_proc(decl)
@@ -192,7 +301,7 @@ module T::Private::Methods
       return
     end
 
-    current_declaration = T::Private::DeclState.current.active_declaration
+    current_declaration = T::Private::DeclState.current.consume!
 
     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"
@@ -208,7 +317,8 @@ module T::Private::Methods
     if current_declaration.nil?
       return
     end
-    T::Private::DeclState.current.reset!
+
+    current_declaration.method_name = method_name
 
     if method_name == :method_added || method_name == :singleton_method_added
       raise(
@@ -217,9 +327,23 @@ 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(hook_mod, method_name, original_method, current_declaration)
+      T::Private::Methods.run_sig(method_name, original_method, current_declaration)
     end
 
     # Always replace the original method with this wrapper,
@@ -298,7 +422,7 @@ module T::Private::Methods
 
   # Executes the `sig` block, and converts the resulting Declaration
   # to a Signature.
-  def self.run_sig(hook_mod, method_name, original_method, declaration_block)
+  def self.run_sig(method_name, original_method, declaration_block)
     current_declaration =
       begin
         run_builder(declaration_block)
@@ -312,7 +436,7 @@ module T::Private::Methods
 
     signature =
       if current_declaration
-        build_sig(hook_mod, method_name, original_method, current_declaration)
+        build_sig(method_name, original_method, current_declaration)
       else
         Signature.new_untyped(method: original_method)
       end
@@ -335,27 +459,20 @@ 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)
+    builder = DeclBuilder.new(
+      declaration_block.mod,
+      declaration_block.abstract,
+      declaration_block.override,
+      declaration_block.overridable
+    )
     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(hook_mod, method_name, original_method, current_declaration)
+  def self.build_sig(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,
@@ -475,6 +592,10 @@ 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)
+    def initialize(mod, abstract, override, overridable)
       @decl = Declaration.new(
         mod,
         ARG_NOT_PROVIDED, # params
@@ -28,6 +28,21 @@ 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)

data/lib/types/syntax.rb

@@ -0,0 +1,42 @@
+# 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.6.13275
+  version: 0.6.13277
 platform: ruby
 authors:
 - Stripe
@@ -162,6 +162,7 @@ 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
@@ -212,6 +213,7 @@ 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