sorbet-runtime 0.5.6539 → 0.5.10400

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3594dc0c726d2a7189c7544226a6ced4240f4a6df2c18bdae635cc30bb223e7b
-  data.tar.gz: dae60008d7f685ecdf231edefdf0b01b595c597c6ae646e7ba7070eada079fa2
+  metadata.gz: 93aad7f9ae5bc82ef7440bd821050e9d83993bc82c933871fea517b5f3bbcff3
+  data.tar.gz: f03d589b929263d8553cc27d73c83c9b131aafa0978cbabcbb2150d67548e164
 SHA512:
-  metadata.gz: 519bf1b1c4f04792d88c817a9bb3a213b01e783a96597e1e328a8a5c9736e78ff7a0a93ef31d56787fd9468d09980e4670edffcd71f59ff299cc7a09a80a714b
-  data.tar.gz: 0150d316fb26d07fd0693d3b948dfaa6fe1979053dc12f9811c5c9c6d29b711affaa3e6be16a34a08fd6abf5a1db816b4872b7b655895353cdf65094f7e0ad5c
+  metadata.gz: 4e8188a05baefa453694665587cc68859151ab9243da61a0a370a5aa767a35f719dda6b7b1e778bc9bd7fb67b53603cb73d0868f0d8a5dbfebe051e0e941a067
+  data.tar.gz: dc0fec301dfd6efec2e2f909eae36df55323881604b7a5635eb301e40748d532fca0000eb5ff213cced1b5318187dfb42940635ded58e9a88d0d7b6bdce92560

data/lib/sorbet-runtime.rb

@@ -12,8 +12,6 @@ module T::Private; end
 module T::Private::Abstract; end
 module T::Private::Types; end
 
-require 'set'
-
 # Each section is a group that I believe need a fixed ordering. There is also
 # an ordering between groups.
 
@@ -47,6 +45,7 @@ require_relative 'types/types/t_enum'
 require_relative 'types/types/type_parameter'
 require_relative 'types/types/typed_array'
 require_relative 'types/types/typed_enumerator'
+require_relative 'types/types/typed_enumerator_lazy'
 require_relative 'types/types/typed_hash'
 require_relative 'types/types/typed_range'
 require_relative 'types/types/typed_set'
@@ -112,3 +111,6 @@ require_relative 'types/struct'
 require_relative 'types/non_forcing_constants'
 
 require_relative 'types/compatibility_patches'
+
+# Sorbet Compiler support module
+require_relative 'types/private/compiler'

data/lib/types/_types.rb

@@ -53,7 +53,8 @@ module T
   end
 
   # Matches any of the listed values
-  def self.enum(values)
+  # @deprecated Use T::Enum instead.
+  def self.deprecated_enum(values)
     T::Types::Enum.new(values)
   end
 
@@ -78,14 +79,13 @@ module T
     T::Types::ClassOf.new(klass)
   end
 
-
   ## END OF THE METHODS TO PASS TO `sig`.
 
-
   # Constructs a type alias. Used to create a short name for a larger type. In Ruby this returns a
   # wrapper that contains a proc that is evaluated to get the underlying type. This syntax however
-  # is needed for support by the static checker. Example usage:
+  # is needed for support by the static checker.
   #
+  # @example
   #  NilableString = T.type_alias {T.nilable(String)}
   #
   #  sig {params(arg: NilableString, default: String).returns(String)}
@@ -108,8 +108,9 @@ module T
   # References a type parameter which was previously defined with
   # `type_parameters`.
   #
-  # This is used for generic methods. Example usage:
+  # This is used for generic methods.
   #
+  # @example
   #  sig
   #  .type_parameters(:U)
   #  .params(
@@ -187,7 +188,7 @@ module T
   # cycle. However, we also don't actually need to do so; An untyped
   # identity method works just as well here.
   #
-  # sig {params(value: T.untyped).returns(T.untyped)}
+  # `sig {params(value: T.untyped).returns(T.untyped)}`
   def self.unsafe(value)
     value
   end
@@ -208,7 +209,7 @@ module T
   # Intended to be used to promise sorbet that a given nilable value happens
   # to contain a non-nil value at this point.
   #
-  # sig {params(arg: T.nilable(A)).returns(A)}
+  # `sig {params(arg: T.nilable(A)).returns(A)}`
   def self.must(arg)
     return arg if arg
     return arg if arg == false
@@ -216,7 +217,7 @@ module T
     begin
       raise TypeError.new("Passed `nil` into T.must")
     rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
-      T::Configuration.inline_type_error_handler(e)
+      T::Configuration.inline_type_error_handler(e, {kind: 'T.must', value: arg, type: nil})
     end
   end
 
@@ -241,7 +242,7 @@ module T
     begin
       raise TypeError.new(msg)
     rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
-      T::Configuration.inline_type_error_handler(e)
+      T::Configuration.inline_type_error_handler(e, {kind: 'T.absurd', value: value, type: nil})
     end
   end
 
@@ -285,6 +286,16 @@ module T
         T::Types::TypedEnumerator.new(type)
       end
     end
+
+    module Lazy
+      def self.[](type)
+        if type.is_a?(T::Types::Untyped)
+          T::Types::TypedEnumeratorLazy::Untyped.new
+        else
+          T::Types::TypedEnumeratorLazy.new(type)
+        end
+      end
+    end
   end
 
   module Range

data/lib/types/configuration.rb

@@ -80,6 +80,7 @@ module T::Configuration
     T::Props::Private::DeserializerGenerator.respond_to?(:generate2)
   end
 
+  @use_vm_prop_serde = false
   # Whether to use VM-defined prop serialization/deserialization routines.
   #
   # The default is to use runtime codegen inside sorbet-runtime itself.
@@ -112,11 +113,12 @@ module T::Configuration
   # statically, so that methods don't have to guard themselves from being
   # called incorrectly by untyped code.
   #
-  # @param [:never, :tests, :always] default_checked_level
+  # @param [:never, :compiled, :tests, :always] default_checked_level
   def self.default_checked_level=(default_checked_level)
     T::Private::RuntimeLevels.default_checked_level = default_checked_level
   end
 
+  @inline_type_error_handler = nil
   # Set a handler to handle `TypeError`s raised by any in-line type assertions,
   # including `T.must`, `T.let`, `T.cast`, and `T.assert_type!`.
   #
@@ -130,10 +132,15 @@ module T::Configuration
   #
   # Parameters passed to value.call:
   #
-  # @param [TypeError] error TypeError that was raised
+  #  @param [TypeError] error TypeError that was raised
+  #  @param [Hash] opts A hash containing contextual information on the error:
+  #  @option opts [String] :kind One of:
+  #    ['T.cast', 'T.let', 'T.bind', 'T.assert_type!', 'T.must', 'T.absurd']
+  #  @option opts [Object, nil] :type Expected param/return value type
+  #  @option opts [Object] :value Actual param/return value
   #
   # @example
-  #   T::Configuration.inline_type_error_handler = lambda do |error|
+  #   T::Configuration.inline_type_error_handler = lambda do |error, opts|
   #     puts error.message
   #   end
   def self.inline_type_error_handler=(value)
@@ -141,19 +148,25 @@ module T::Configuration
     @inline_type_error_handler = value
   end
 
-  private_class_method def self.inline_type_error_handler_default(error)
+  private_class_method def self.inline_type_error_handler_default(error, opts)
     raise error
   end
 
-  def self.inline_type_error_handler(error)
+  def self.inline_type_error_handler(error, opts={})
     if @inline_type_error_handler
-      @inline_type_error_handler.call(error)
+      # Backwards compatibility before `inline_type_error_handler` took a second arg
+      if @inline_type_error_handler.arity == 1
+        @inline_type_error_handler.call(error)
+      else
+        @inline_type_error_handler.call(error, opts)
+      end
     else
-      inline_type_error_handler_default(error)
+      inline_type_error_handler_default(error, opts)
     end
     nil
   end
 
+  @sig_builder_error_handler = nil
   # Set a handler to handle errors that occur when the builder methods in the
   # body of a sig are executed. The sig builder methods are inside a proc so
   # that they can be lazily evaluated the first time the method being sig'd is
@@ -169,8 +182,8 @@ module T::Configuration
   #
   # Parameters passed to value.call:
   #
-  # @param [StandardError] error The error that was raised
-  # @param [Thread::Backtrace::Location] location Location of the error
+  #  @param [StandardError] error The error that was raised
+  #  @param [Thread::Backtrace::Location] location Location of the error
   #
   # @example
   #   T::Configuration.sig_builder_error_handler = lambda do |error, location|
@@ -194,6 +207,7 @@ module T::Configuration
     nil
   end
 
+  @sig_validation_error_handler = nil
   # Set a handler to handle sig validation errors.
   #
   # Sig validation errors include things like abstract checks, override checks,
@@ -211,16 +225,16 @@ module T::Configuration
   #
   # Parameters passed to value.call:
   #
-  # @param [StandardError] error The error that was raised
-  # @param [Hash] opts A hash containing contextual information on the error:
-  # @option opts [Method, UnboundMethod] :method Method on which the signature build failed
-  # @option opts [T::Private::Methods::Declaration] :declaration Method
-  #   signature declaration struct
-  # @option opts [T::Private::Methods::Signature, nil] :signature Signature
-  #   that failed (nil if sig build failed before Signature initialization)
-  # @option opts [T::Private::Methods::Signature, nil] :super_signature Super
-  #   method's signature (nil if method is not an override or super method
-  #   does not have a method signature)
+  #  @param [StandardError] error The error that was raised
+  #  @param [Hash] opts A hash containing contextual information on the error:
+  #  @option opts [Method, UnboundMethod] :method Method on which the signature build failed
+  #  @option opts [T::Private::Methods::Declaration] :declaration Method
+  #    signature declaration struct
+  #  @option opts [T::Private::Methods::Signature, nil] :signature Signature
+  #    that failed (nil if sig build failed before Signature initialization)
+  #  @option opts [T::Private::Methods::Signature, nil] :super_signature Super
+  #    method's signature (nil if method is not an override or super method
+  #    does not have a method signature)
   #
   # @example
   #   T::Configuration.sig_validation_error_handler = lambda do |error, opts|
@@ -244,6 +258,7 @@ module T::Configuration
     nil
   end
 
+  @call_validation_error_handler = nil
   # Set a handler for type errors that result from calling a method.
   #
   # By default, errors from calling a method cause an exception to be raised.
@@ -256,17 +271,17 @@ module T::Configuration
   #
   # Parameters passed to value.call:
   #
-  # @param [T::Private::Methods::Signature] signature Signature that failed
-  # @param [Hash] opts A hash containing contextual information on the error:
-  # @option opts [String] :message Error message
-  # @option opts [String] :kind One of:
-  #   ['Parameter', 'Block parameter', 'Return value']
-  # @option opts [Symbol] :name Param or block param name (nil for return
-  #   value)
-  # @option opts [Object] :type Expected param/return value type
-  # @option opts [Object] :value Actual param/return value
-  # @option opts [Thread::Backtrace::Location] :location Location of the
-  #   caller
+  #  @param [T::Private::Methods::Signature] signature Signature that failed
+  #  @param [Hash] opts A hash containing contextual information on the error:
+  #  @option opts [String] :message Error message
+  #  @option opts [String] :kind One of:
+  #    ['Parameter', 'Block parameter', 'Return value']
+  #  @option opts [Symbol] :name Param or block param name (nil for return
+  #    value)
+  #  @option opts [Object] :type Expected param/return value type
+  #  @option opts [Object] :value Actual param/return value
+  #  @option opts [Thread::Backtrace::Location] :location Location of the
+  #    caller
   #
   # @example
   #   T::Configuration.call_validation_error_handler = lambda do |signature, opts|
@@ -290,6 +305,7 @@ module T::Configuration
     nil
   end
 
+  @log_info_handler = nil
   # Set a handler for logging
   #
   # @param [Lambda, Proc, Object, nil] value Proc that handles the error
@@ -297,8 +313,8 @@ module T::Configuration
   #
   # Parameters passed to value.call:
   #
-  # @param [String] str Message to be logged
-  # @param [Hash] extra A hash containing additional parameters to be passed along to the logger.
+  #  @param [String] str Message to be logged
+  #  @param [Hash] extra A hash containing additional parameters to be passed along to the logger.
   #
   # @example
   #   T::Configuration.log_info_handler = lambda do |str, extra|
@@ -321,6 +337,7 @@ module T::Configuration
     end
   end
 
+  @soft_assert_handler = nil
   # Set a handler for soft assertions
   #
   # These generally shouldn't stop execution of the program, but rather inform
@@ -331,8 +348,8 @@ module T::Configuration
   #
   # Parameters passed to value.call:
   #
-  # @param [String] str Assertion message
-  # @param [Hash] extra A hash containing additional parameters to be passed along to the handler.
+  #  @param [String] str Assertion message
+  #  @param [Hash] extra A hash containing additional parameters to be passed along to the handler.
   #
   # @example
   #   T::Configuration.soft_assert_handler = lambda do |str, extra|
@@ -355,6 +372,7 @@ module T::Configuration
     end
   end
 
+  @hard_assert_handler = nil
   # Set a handler for hard assertions
   #
   # These generally should stop execution of the program, and optionally inform
@@ -365,8 +383,8 @@ module T::Configuration
   #
   # Parameters passed to value.call:
   #
-  # @param [String] str Assertion message
-  # @param [Hash] extra A hash containing additional parameters to be passed along to the handler.
+  #  @param [String] str Assertion message
+  #  @param [Hash] extra A hash containing additional parameters to be passed along to the handler.
   #
   # @example
   #   T::Configuration.hard_assert_handler = lambda do |str, extra|
@@ -389,10 +407,11 @@ module T::Configuration
     end
   end
 
+  @scalar_types = nil
   # Set a list of class strings that are to be considered scalar.
   #   (pass nil to reset to default behavior)
   #
-  # @param [String] value Class name.
+  # @param [String] values Class name.
   #
   # @example
   #   T::Configuration.scalar_types = ["NilClass", "TrueClass", "FalseClass", ...]
@@ -405,21 +424,21 @@ module T::Configuration
         raise ArgumentError.new("Provided values must all be class name strings.")
       end
 
-      @scalar_types = Set.new(values).freeze
+      @scalar_types = values.each_with_object({}) {|x, acc| acc[x] = true}.freeze
     end
   end
 
-  @default_scalar_types = Set.new(%w[
-    NilClass
-    TrueClass
-    FalseClass
-    Integer
-    Float
-    String
-    Symbol
-    Time
-    T::Enum
-  ]).freeze
+  @default_scalar_types = {
+    "NilClass" => true,
+    "TrueClass" => true,
+    "FalseClass" => true,
+    "Integer" => true,
+    "Float" => true,
+    "String" => true,
+    "Symbol" => true,
+    "Time" => true,
+    "T::Enum" => true,
+  }.freeze
 
   def self.scalar_types
     @scalar_types || @default_scalar_types
@@ -429,10 +448,10 @@ module T::Configuration
   MODULE_NAME = Module.instance_method(:name)
   private_constant :MODULE_NAME
 
-  if T::Configuration::AT_LEAST_RUBY_2_7
-    @default_module_name_mangler = ->(type) {MODULE_NAME.bind_call(type)}
+  @default_module_name_mangler = if T::Configuration::AT_LEAST_RUBY_2_7
+    ->(type) {MODULE_NAME.bind_call(type)}
   else
-    @default_module_name_mangler = ->(type) {MODULE_NAME.bind(type).call}
+    ->(type) {MODULE_NAME.bind(type).call}
   end
 
   @module_name_mangler = nil
@@ -445,16 +464,17 @@ module T::Configuration
   #   to names in generated code. Used by the runtime implementation
   #   associated with `--stripe-packages` mode.
   #
-  # @param [Lambda, Proc, nil] value Proc that converts a type (Class/Module)
+  # @param [Lambda, Proc, nil] handler Proc that converts a type (Class/Module)
   #   to a String (pass nil to reset to default behavior)
   def self.module_name_mangler=(handler)
     @module_name_mangler = handler
   end
 
+  @sensitivity_and_pii_handler = nil
   # Set to a PII handler function. This will be called with the `sensitivity:`
   # annotations on things that use `T::Props` and can modify them ahead-of-time.
   #
-  # @param [Lambda, Proc, nil] value Proc that takes a hash mapping symbols to the
+  # @param [Lambda, Proc, nil] handler Proc that takes a hash mapping symbols to the
   # prop values. Pass nil to avoid changing `sensitivity:` annotations.
   def self.normalize_sensitivity_and_pii_handler=(handler)
     @sensitivity_and_pii_handler = handler
@@ -470,7 +490,7 @@ module T::Configuration
   # `nil` and will raise an exception when the redacted version of a prop is
   # accessed.
   #
-  # @param [Lambda, Proc, nil] value Proc that converts a value into its
+  # @param [Lambda, Proc, nil] handler Proc that converts a value into its
   # redacted version according to the spec passed as the second argument.
   def self.redaction_handler=(handler)
     @redaction_handler = handler
@@ -480,10 +500,11 @@ module T::Configuration
     @redaction_handler
   end
 
+  @class_owner_finder = nil
   # Set to a function which can get the 'owner' of a class. This is
   # used in reporting deserialization errors
   #
-  # @param [Lambda, Proc, nil] value Proc that takes a class and
+  # @param [Lambda, Proc, nil] handler Proc that takes a class and
   # produces its owner, or `nil` if it does not have one.
   def self.class_owner_finder=(handler)
     @class_owner_finder = handler
@@ -513,6 +534,7 @@ module T::Configuration
     end
   end
 
+  @legacy_t_enum_migration_mode = false
   def self.enable_legacy_t_enum_migration_mode
     @legacy_t_enum_migration_mode = true
   end
@@ -523,6 +545,17 @@ module T::Configuration
     @legacy_t_enum_migration_mode || false
   end
 
+  @prop_freeze_handler = ->(instance, prop_name) {}
+
+  def self.prop_freeze_handler=(handler)
+    @prop_freeze_handler = handler
+  end
+
+  def self.prop_freeze_handler
+    @prop_freeze_handler
+  end
+
+  @sealed_violation_whitelist = nil
   # @param [Array] sealed_violation_whitelist An array of Regexp to validate
   #   whether inheriting /including a sealed module outside the defining module
   #   should be allowed. Useful to whitelist benign violations, like shim files

data/lib/types/enum.rb

@@ -47,7 +47,7 @@ class T::Enum
   SerializedVal = T.type_alias {T.untyped}
   private_constant :SerializedVal
 
-  ## Enum class methods ##
+  ### Enum class methods ###
   sig {returns(T::Array[T.attached_class])}
   def self.values
     if @values.nil?
@@ -134,9 +134,7 @@ class T::Enum
     self.from_serialized(mongo_value)
   end
 
-
-  ## Enum instance methods ##
-
+  ### Enum instance methods ###
 
   sig {returns(T.self_type)}
   def dup
@@ -160,6 +158,13 @@ class T::Enum
     serialize.to_json(*args)
   end
 
+  sig {params(args: T.untyped).returns(T.untyped)}
+  def as_json(*args)
+    serialized_val = serialize
+    return serialized_val unless serialized_val.respond_to?(:as_json)
+    serialized_val.as_json(*args)
+  end
+
   sig {returns(String)}
   def to_s
     inspect
@@ -180,7 +185,6 @@ class T::Enum
     end
   end
 
-
   # NB: Do not call this method. This exists to allow for a safe migration path in places where enum
   # values are compared directly against string values.
   #
@@ -246,9 +250,7 @@ class T::Enum
     )
   end
 
-
-  ## Private implementation ##
-
+  ### Private implementation ###
 
   sig {params(serialized_val: SerializedVal).void}
   def initialize(serialized_val=nil)
@@ -286,19 +288,23 @@ class T::Enum
     # Historical note: We convert to lowercase names because the majority of existing calls to
     # `make_accessible` were arrays of lowercase strings. Doing this conversion allowed for the
     # least amount of repetition in migrated declarations.
-    const_name.to_s.downcase.freeze
+    -const_name.to_s.downcase.freeze
   end
 
   sig {returns(T::Boolean)}
   def self.started_initializing?
-    @started_initializing = T.let(@started_initializing, T.nilable(T::Boolean))
-    @started_initializing ||= false
+    unless defined?(@started_initializing)
+      @started_initializing = T.let(false, T.nilable(T::Boolean))
+    end
+    T.must(@started_initializing)
   end
 
   sig {returns(T::Boolean)}
   def self.fully_initialized?
-    @fully_initialized = T.let(@fully_initialized, T.nilable(T::Boolean))
-    @fully_initialized ||= false
+    unless defined?(@fully_initialized)
+      @fully_initialized = T.let(false, T.nilable(T::Boolean))
+    end
+    T.must(@fully_initialized)
   end
 
   # Maintains the order in which values are defined
@@ -313,8 +319,8 @@ class T::Enum
   sig {params(blk: T.proc.void).void}
   def self.enums(&blk)
     raise "enums cannot be defined for T::Enum" if self == T::Enum
-    raise "Enum #{self} was already initialized" if @fully_initialized
-    raise "Enum #{self} is still initializing" if @started_initializing
+    raise "Enum #{self} was already initialized" if fully_initialized?
+    raise "Enum #{self} is still initializing" if started_initializing?
 
     @started_initializing = true
 
@@ -366,6 +372,6 @@ class T::Enum
 
   sig {params(args: String).returns(T.attached_class)}
   def self._load(args)
-    deserialize(Marshal.load(args))
+    deserialize(Marshal.load(args)) # rubocop:disable Security/MarshalLoad
   end
 end

data/lib/types/generic.rb

@@ -12,11 +12,11 @@ module T::Generic
     self
   end
 
-  def type_member(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
+  def type_member(variance=:invariant, &blk)
     T::Types::TypeMember.new(variance)
   end
 
-  def type_template(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
+  def type_template(variance=:invariant, &blk)
     T::Types::TypeTemplate.new(variance)
   end
 end

data/lib/types/helpers.rb

@@ -2,13 +2,22 @@
 # typed: true
 
 # Use as a mixin with extend (`extend T::Helpers`).
-# Docs at https://confluence.corp.stripe.com/display/PRODINFRA/Ruby+Types
+# Docs at https://sorbet.org/docs/
 module T::Helpers
+  extend T::Sig
+
   Private = T::Private
 
   ### Class/Module Helpers ###
 
   def abstract!
+    if defined?(super)
+      # This is to play nicely with Rails' AbstractController::Base,
+      # which also defines an `abstract!` method.
+      # https://api.rubyonrails.org/classes/AbstractController/Base.html#method-c-abstract-21
+      super
+    end
+
     Private::Abstract::Declare.declare_abstract(self, type: :abstract)
   end
 
@@ -44,7 +53,7 @@ module T::Helpers
   #   module MyHelper
   #     extend T::Helpers
   #
-  #     requires_ancestor Kernel
+  #     requires_ancestor { Kernel }
   #   end
   #
   #   class MyClass < BasicObject # error: `MyClass` must include `Kernel` (required by `MyHelper`)
@@ -52,5 +61,5 @@ module T::Helpers
   #   end
   #
   # TODO: implement the checks in sorbet-runtime.
-  def requires_ancestor(mod, *mods); end
+  def requires_ancestor(&block); end
 end

data/lib/types/interface_wrapper.rb

@@ -43,17 +43,17 @@ class T::InterfaceWrapper
   def initialize(target_obj, interface_mod)
     if target_obj.is_a?(T::InterfaceWrapper)
       # wrapped_dynamic_cast should guarantee this never happens.
-      raise "Unexpected: wrapping a wrapper. Please report to #dev-productivity."
+      raise "Unexpected: wrapping a wrapper. Please report this bug at https://github.com/sorbet/sorbet/issues"
     end
 
     if !target_obj.is_a?(interface_mod)
       # wrapped_dynamic_cast should guarantee this never happens.
-      raise "Unexpected: `is_a?` failed. Please report to #dev-productivity."
+      raise "Unexpected: `is_a?` failed. Please report this bug at https://github.com/sorbet/sorbet/issues"
     end
 
     if target_obj.class == interface_mod
       # wrapped_dynamic_cast should guarantee this never happens.
-      raise "Unexpected: exact class match. Please report to #dev-productivity."
+      raise "Unexpected: exact class match. Please report this bug at https://github.com/sorbet/sorbet/issues"
     end
 
     @target_obj = target_obj
@@ -71,6 +71,10 @@ class T::InterfaceWrapper
         target_obj.send(method_name, *args, &blk)
       end
 
+      if singleton_class.respond_to?(:ruby2_keywords, true)
+        singleton_class.send(:ruby2_keywords, method_name)
+      end
+
       if target_obj.singleton_class.public_method_defined?(method_name)
         # no-op, it's already public
       elsif target_obj.singleton_class.protected_method_defined?(method_name)
@@ -78,7 +82,7 @@ class T::InterfaceWrapper
       elsif target_obj.singleton_class.private_method_defined?(method_name)
         singleton_class.send(:private, method_name)
       else
-        raise "This should never happen. Report to #dev-productivity"
+        raise "This should never happen. Report this bug at https://github.com/sorbet/sorbet/issues"
       end
     end
   end

data/lib/types/non_forcing_constants.rb

@@ -2,11 +2,6 @@
 # typed: strict
 
 module T::NonForcingConstants
-  T::Sig::WithoutRuntime.sig {returns(T::Boolean)}
-  private_class_method def self.stripe_packages_enabled?
-    const_defined?('StripePackages') && const_get('StripePackages').enabled?
-  end
-
   # NOTE: This method is documented on the RBI in Sorbet's payload, so that it
   # shows up in the hover/completion documentation via LSP.
   T::Sig::WithoutRuntime.sig {params(val: BasicObject, klass: String, package: T.nilable(String)).returns(T::Boolean)}
@@ -16,10 +11,11 @@ module T::NonForcingConstants
       raise ArgumentError.new("The string given to `#{method_name}` must not be empty")
     end
 
-    # TODO(gdritter): this might not be want we want in a multipackage
-    # world; revisit this implementation we move on from the monopackage
-    if stripe_packages_enabled?
-      klass = "PkgRegistry::#{package}::#{klass}"
+    # We don't treat packages differently at runtime, but the static
+    # type-checker still needs to have the package and constant
+    # separated out. This just re-assembles the string as needed
+    if !package.nil?
+      klass = "::#{package}::#{klass}"
     end
 
     current_klass = T.let(nil, T.nilable(Module))