sorbet-runtime 0.5.8993 → 0.5.9889

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9b153e0e894eb0a81121fd2c9a2f52cccf1654a78b6fc72d75eacc10d6ee288
-  data.tar.gz: c09b72a6a28a96d35e9076b206d9019df999659145842f6c2b5ec7d3481e4850
+  metadata.gz: 9a7a3fab5ea8600237fa39e859be1e28620584bb1b58349d049e0f5e03146dc1
+  data.tar.gz: 4ae6ef0d6b43dc1205d5a54f141c5a4775eaecacae3b37c1d89dbc32a259d702
 SHA512:
-  metadata.gz: 948194b8718dd728ecaa0668421480103ce052587c6ceebee0ec01818ecf529d0a62715f0c66409ff07594c6ad4c8c0f22a05921129c66cb405f2fe143b46705
-  data.tar.gz: a788eea54fe2321d6060a79ef31ab784b21a6a4e9e15b299600abbe9699e4cc8095eaa69bedbfc07fa5f2a3e3ef959e002562db705050f8882878dbb15b6a14e
+  metadata.gz: 72c661853dc7f8b7243d7b37cc5868c1bb962df3b6df38b8c5d1f8345751bdea0bb69bc15f5eb5dbb1dde132da4720afe0ee87cf112dcd2e33cbd6264f704ecb
+  data.tar.gz: 2d9060c44a422f615c44d1cbc61e24f051f7087c3e18552b5fd702f99649c85eb12276cce7186d2ecf5c2b97f269fe0a503edde775ff94d6d6b2cd9dc1bb781c

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
@@ -180,7 +178,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 +243,7 @@ class T::Enum
     )
   end
 
-
-  ## Private implementation ##
-
+  ### Private implementation ###
 
   sig {params(serialized_val: SerializedVal).void}
   def initialize(serialized_val=nil)
@@ -291,14 +286,18 @@ class T::Enum
 
   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 +312,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 +365,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,13 @@ module T::Generic
     self
   end
 
-  def type_member(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
+  # TODO(jez) Remove these keyword arguments once it's a static error
+  def type_member(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject, &blk)
     T::Types::TypeMember.new(variance)
   end
 
-  def type_template(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
+  # TODO(jez) Remove these keyword arguments once it's a static error
+  def type_template(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject, &blk)
     T::Types::TypeTemplate.new(variance)
   end
 end

data/lib/types/helpers.rb

@@ -4,6 +4,8 @@
 # Use as a mixin with extend (`extend T::Helpers`).
 # Docs at https://confluence.corp.stripe.com/display/PRODINFRA/Ruby+Types
 module T::Helpers
+  extend T::Sig
+
   Private = T::Private
 
   ### Class/Module Helpers ###
@@ -44,7 +46,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 +54,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
@@ -78,7 +78,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))

data/lib/types/private/abstract/data.rb

@@ -12,7 +12,7 @@
 # modules that override the `hash` method with something completely broken.
 module T::Private::Abstract::Data
   def self.get(mod, key)
-    mod.instance_variable_get("@opus_abstract__#{key}")
+    mod.instance_variable_get("@opus_abstract__#{key}") if key?(mod, key)
   end
 
   def self.set(mod, key, value)

data/lib/types/private/abstract/declare.rb

@@ -40,6 +40,11 @@ module T::Private::Abstract::Declare
         end
         super(*args, &blk)
       end
+
+      # Ruby doesn not emit "method redefined" warnings for aliased methods
+      # (more robust than undef_method that would create a small window in which the method doesn't exist)
+      mod.send(:alias_method, :initialize, :initialize)
+
       if mod.respond_to?(:ruby2_keywords, true)
         mod.send(:ruby2_keywords, :initialize)
       end

data/lib/types/private/abstract/hooks.rb

@@ -37,7 +37,6 @@ module T::Private::Abstract::Hooks
   private def prepended(other)
     # Prepending abstract methods is weird. You'd only be able to override them via other prepended
     # modules, or in subclasses. Punt until we have a use case.
-    Kernel.raise "Prepending abstract mixins is not currently supported. Please explain your use case " \
-          "to #dev-productivity."
+    Kernel.raise "Prepending abstract mixins is not currently supported."
   end
 end