sorbet-runtime 0.6.13294 → 0.6.13295

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68497e0df01e0e6fc5bc0484584697a261360be3be24d179d25de375d23814c0
-  data.tar.gz: 2560a9fecde787001fce90f7c9d80cf05dd2fa742443c5f63be7c86779979b15
+  metadata.gz: 1ba71f6fa762bdc985e7d0571384bdb516de33f4c9be69115cf1139975638da8
+  data.tar.gz: 557f176df1c801a3a1da3a9b7c28e112eada5cab30e23762b6d67ca1d1be6a8a
 SHA512:
-  metadata.gz: 9d9becdde0a5c869407f6fc487385a8a217a5c5054994d4ea516c0b6f96ac5df553ae4dafa03ad741617e7860a2a70d22e6c25978ae1c0127ea44e45cc29f961
-  data.tar.gz: 3632721eecefe01e67e32d39ece6653317360ef10ba6108bac84e64de733efa6205f5e974a8bcd742dc2c261108945f383cceb799414b7eeba483c46bf1dd834
+  metadata.gz: e7f17791a3f3e4c7dba12f932ae31f7c7e0a3379399d64037d89c78da0604472a64e55b3c6bad8d350304696f2ac8bc974e9ed1dd32e17542226d04b3e60734f
+  data.tar.gz: 82600633223a670039f18fa7cc0b857bb45a57210a8919a07e523181efdb66d416bf76f53f2c99b1473c5655d8fdfad964e364334f10c0471ad0aab132e99417

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/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)
@@ -211,6 +320,8 @@ module T::Private::Methods
       return
     end
 
+    current_declaration.method_name = method_name
+
     if method_name == :method_added || method_name == :singleton_method_added
       raise(
         "Putting a `sig` on `#{method_name}` is not supported" \
@@ -350,7 +461,12 @@ 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

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.13294
+  version: 0.6.13295
 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