sorbet-runtime 0.4.4788 → 0.4.5059

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31271303dfeb98e19ae3042f9c577f080415b592e005a407be7dab657cae0f77
-  data.tar.gz: 10ebdce3b1e460c9a95b6144e0b0662f98eb77574eb586a1d248c38c91e01b73
+  metadata.gz: '08896772fcca300510e9b2e62c6a16bc70ee4f6eb3bb5409d6e0324f7ae98382'
+  data.tar.gz: 98abf40add7ee4518be064fd14b8eded16d8a326910409d9db13ec6a88e23ea1
 SHA512:
-  metadata.gz: '0027993a7fa1be8694fd2eb2b0b3c64978430bb6d44b91a54ebd8922cbab1a9b40b4ecab04f8d3331acfded84873e49926b6930be53acbd565f418c34e817484'
-  data.tar.gz: 89c69d15484d2f69df868ab465dc8085c1123adae026b1678c28b268211c0b2eb80ef991af6b930572a2c0113fc8bc165e3aba1138d7af187c1487aa79aa2632
+  metadata.gz: 55a0df02cbade8623577ce15eb939435b7cb2fca7d2fc043a7fff25dc83d69659eb777021be2efc134c637a625566f84a6523577266f7f0b33bb23c0bcf2cc79
+  data.tar.gz: d0f9ae6831387b11d283e0badc92d5629e39dde5d5f8fa4d786a6f784b3bdc9648992485b0787e298a8c5bd8832642df83dcee17e346c337dd951c8daa80d959

data/lib/sorbet-runtime.rb

@@ -24,7 +24,6 @@ require_relative 'types/_types'
 require_relative 'types/private/decl_state'
 require_relative 'types/runtime_profiled'
 require_relative 'types/private/class_utils'
-require_relative 'types/private/error_handler'
 require_relative 'types/private/runtime_levels'
 require_relative 'types/private/methods/_methods'
 require_relative 'types/sig'
@@ -43,9 +42,10 @@ require_relative 'types/types/fixed_hash'
 require_relative 'types/types/intersection'
 require_relative 'types/types/noreturn'
 require_relative 'types/types/proc'
+require_relative 'types/types/attached_class'
 require_relative 'types/types/self_type'
 require_relative 'types/types/simple'
-require_relative 'types/types/opus_enum'
+require_relative 'types/types/t_enum'
 require_relative 'types/types/type_parameter'
 require_relative 'types/types/typed_array'
 require_relative 'types/types/typed_enumerator'
@@ -57,6 +57,7 @@ require_relative 'types/types/untyped'
 require_relative 'types/private/types/not_typed'
 require_relative 'types/private/types/void'
 require_relative 'types/private/types/string_holder'
+require_relative 'types/private/types/type_alias'
 
 require_relative 'types/types/type_variable'
 require_relative 'types/types/type_member'
@@ -98,6 +99,8 @@ require_relative 'types/props/constructor'
 require_relative 'types/props/pretty_printable'
 require_relative 'types/props/serializable'
 require_relative 'types/props/type_validation'
+
 require_relative 'types/struct'
+require_relative 'types/enum'
 
 require_relative 'types/compatibility_patches'

data/lib/types/_types.rb

@@ -65,6 +65,11 @@ module T
     T::Types::SelfType.new
   end
 
+  # Matches the instance type in a singleton-class context
+  def self.experimental_attached_class
+    T::Types::AttachedClassType.new
+  end
+
   # Matches any class that subclasses or includes the provided class
   # or module
   def self.class_of(klass)
@@ -75,11 +80,11 @@ module T
   ## 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 is just equivalent to assignment, but this is
-  # needed for support by the static checker. Example usage:
+  # 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:
   #
-  #  NilableString = T.type_alias(T.nilable(String))
+  #  NilableString = T.type_alias {T.nilable(String)}
   #
   #  sig {params(arg: NilableString, default: String).returns(String)}
   #  def or_else(arg, default)
@@ -88,8 +93,14 @@ module T
   #
   # The name of the type alias is not preserved; Error messages will
   # be printed with reference to the underlying type.
-  def self.type_alias(type)
-    T::Utils.coerce(type)
+  #
+  # TODO Remove `type` parameter. This was left in to make life easier while migrating.
+  def self.type_alias(type=nil, &blk)
+    if blk
+      T::Private::Types::TypeAlias.new(blk)
+    else
+      T::Utils.coerce(type)
+    end
   end
 
   # References a type paramater which was previously defined with

data/lib/types/boolean.rb

@@ -4,5 +4,5 @@
 module T
   # T::Boolean is a type alias helper for the common `T.any(TrueClass, FalseClass)`.
   # Defined separately from _types.rb because it has a dependency on T::Types::Union.
-  Boolean = T.type_alias(T.any(TrueClass, FalseClass))
+  Boolean = T.type_alias {T.any(TrueClass, FalseClass)}
 end

data/lib/types/configuration.rb

@@ -356,6 +356,7 @@ module T::Configuration
     String
     Symbol
     Time
+    T::Enum
   }).freeze
 
   def self.scalar_types
@@ -382,6 +383,15 @@ module T::Configuration
     end
   end
 
+  def self.enable_legacy_t_enum_migration_mode
+    @legacy_t_enum_migration_mode = true
+  end
+  def self.disable_legacy_t_enum_migration_mode
+    @legacy_t_enum_migration_mode = false
+  end
+  def self.legacy_t_enum_migration_mode?
+    @legacy_t_enum_migration_mode || false
+  end
 
   private_class_method def self.validate_lambda_given!(value)
     if !value.nil? && !value.respond_to?(:call)

data/lib/types/enum.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+# typed: strict
+
+# Enumerations allow for type-safe declarations of a fixed set of values.
+#
+# Every value is a singleton instance of the class (i.e. `Suit::SPADE.is_a?(Suit) == true`).
+#
+# Each value has a corresponding serialized value. By default this is the constant's name converted
+# to lowercase (e.g. `Suit::Club.serialize == 'club'`); however a custom value may be passed to the
+# constructor. Enum will `freeze` the serialized value.
+#
+# @example Declaring an Enum:
+#   class Suit < T::Enum
+#     enums do
+#       CLUB = new
+#       SPADE = new
+#       DIAMOND = new
+#       HEART = new
+#     end
+#   end
+#
+# @example Custom serialization value:
+#   class Status < T::Enum
+#     enums do
+#       READY = new('rdy')
+#       ...
+#     end
+#   end
+#
+# @example Accessing values:
+#   Suit::SPADE
+#
+# @example Converting from serialized value to enum instance:
+#   Suit.deserialize('club') == Suit::CLUB
+#
+# @example Using enums in type signatures:
+#   sig {params(suit: Suit).returns(Boolean)}
+#   def is_red?(suit); ...; end
+#
+# WARNING: Enum instances are singletons that are shared among all their users. Their internals
+# should be kept immutable to avoid unpredictable action at a distance.
+class T::Enum
+  extend T::Sig
+  extend T::Props::CustomType
+
+  # TODO(jez) Might want to restrict this, or make subclasses provide this type
+  SerializedVal = T.type_alias {T.untyped}
+  private_constant :SerializedVal
+
+  ## Enum class methods ##
+  sig {returns(T::Array[T.experimental_attached_class])}
+  def self.values
+    if @values.nil?
+      raise "Attempting to access values of #{self.class} before it has been initialized." \
+        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+    end
+    @values
+  end
+
+  # Convert from serialized value to enum instance
+  #
+  # Note: It would have been nice to make this method final before people started overriding it.
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  sig {params(serialized_val: SerializedVal).returns(T.nilable(T.experimental_attached_class)).checked(:never)}
+  def self.try_deserialize(serialized_val)
+    if @mapping.nil?
+      raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
+        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+    end
+    @mapping[serialized_val]
+  end
+
+  # Convert from serialized value to enum instance.
+  #
+  # Note: It would have been nice to make this method final before people started overriding it.
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  #
+  # @return [self]
+  # @raise [KeyError] if serialized value does not match any instance.
+  sig {overridable.params(serialized_val: SerializedVal).returns(T.experimental_attached_class).checked(:never)}
+  def self.from_serialized(serialized_val)
+    res = try_deserialize(serialized_val)
+    if res.nil?
+      raise KeyError.new("Enum #{self} key not found: #{serialized_val.inspect}")
+    end
+    res
+  end
+
+  # Note: It would have been nice to make this method final before people started overriding it.
+  # @return [Boolean] Does the given serialized value correspond with any of this enum's values.
+  sig {overridable.params(serialized_val: SerializedVal).returns(T::Boolean)}
+  def self.has_serialized?(serialized_val)
+    if @mapping.nil?
+      raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
+        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+    end
+    @mapping.include?(serialized_val)
+  end
+
+
+  ## T::Props::CustomType
+
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  sig {params(value: T.untyped).returns(T::Boolean).checked(:never)}
+  def self.instance?(value)
+    value.is_a?(self)
+  end
+
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  sig {params(instance: T.nilable(T::Enum)).returns(SerializedVal).checked(:never)}
+  def self.serialize(instance)
+    # This is needed otherwise if a Chalk::ODM::Document with a property of the shape
+    # T::Hash[T.nilable(MyEnum), Integer] and a value that looks like {nil => 0} is
+    # serialized, we throw the error on L102.
+    return nil if instance.nil?
+
+    if self == T::Enum
+      raise "Cannot call T::Enum.serialize directly. You must call on a specific child class."
+    end
+    if instance.class != self
+      raise "Cannot call #serialize on a value that is not an instance of #{self}."
+    end
+    instance.serialize
+  end
+
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  sig {params(mongo_value: SerializedVal).returns(T.experimental_attached_class).checked(:never)}
+  def self.deserialize(mongo_value)
+    if self == T::Enum
+      raise "Cannot call T::Enum.deserialize directly. You must call on a specific child class."
+    end
+    self.from_serialized(mongo_value)
+  end
+
+
+  ## Enum instance methods ##
+
+
+  sig {returns(T.self_type)}
+  def dup
+    self
+  end
+
+  sig {returns(T.self_type).checked(:tests)}
+  def clone
+    self
+  end
+
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  sig {returns(SerializedVal).checked(:never)}
+  def serialize
+    assert_bound!
+    @serialized_val
+  end
+
+  sig {params(args: T.untyped).returns(T.untyped)}
+  def to_json(*args)
+    serialize.to_json(*args)
+  end
+
+  sig {returns(String)}
+  def to_s
+    inspect
+  end
+
+  sig {returns(String)}
+  def inspect
+    "#<#{self.class.name}::#{@const_name || '__UNINITIALIZED__'}>"
+  end
+
+  sig {params(other: BasicObject).returns(T.nilable(Integer))}
+  def <=>(other)
+    case other
+    when self.class
+      self.serialize <=> other.serialize
+    else
+      nil
+    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.
+  #
+  # Ruby's string has a weird quirk where `'my_string' == obj` calls obj.==('my_string') if obj
+  # responds to the `to_str` method. It does not actually call `to_str` however.
+  #
+  # See https://ruby-doc.org/core-2.4.0/String.html#method-i-3D-3D
+  sig {returns(String)}
+  def to_str
+    msg = 'Implicit conversion of Enum instances to strings is not allowed. Call #serialize instead.'
+    if T::Configuration.legacy_t_enum_migration_mode?
+      T::Configuration.soft_assert_handler(
+        msg,
+        storytime: {class: self.class.name},
+      )
+      serialize.to_s
+    else
+      raise NoMethodError.new(msg)
+    end
+  end
+
+  sig {params(other: BasicObject).returns(T::Boolean).checked(:never)}
+  def ==(other)
+    case other
+    when String
+      if T::Configuration.legacy_t_enum_migration_mode?
+        comparison_assertion_failed(:==, other)
+        self.serialize == other
+      else
+        false
+      end
+    else
+      super(other)
+    end
+  end
+
+  sig {params(other: BasicObject).returns(T::Boolean).checked(:never)}
+  def ===(other)
+    case other
+    when String
+      if T::Configuration.legacy_t_enum_migration_mode?
+        comparison_assertion_failed(:===, other)
+        self.serialize == other
+      else
+        false
+      end
+    else
+      super(other)
+    end
+  end
+
+  sig {params(method: Symbol, other: T.untyped).void}
+  private def comparison_assertion_failed(method, other)
+    T::Configuration.soft_assert_handler(
+      'Enum to string comparison not allowed. Compare to the Enum instance directly instead. See go/enum-migration',
+      storytime: {
+        class: self.class.name,
+        self: self.inspect,
+        other: other,
+        other_class: other.class.name,
+        method: method,
+      }
+    )
+  end
+
+
+  ## Private implementation ##
+
+
+  sig {params(serialized_val: SerializedVal).void}
+  private def initialize(serialized_val=nil)
+    raise 'T::Enum is abstract' if self.class == T::Enum
+    if !self.class.started_initializing?
+      raise "Must instantiate all enum values of #{self.class} inside 'enums do'."
+    end
+    if self.class.fully_initialized?
+      raise "Cannot instantiate a new enum value of #{self.class} after it has been initialized."
+    end
+
+    serialized_val = serialized_val.frozen? ? serialized_val : serialized_val.dup.freeze
+    @serialized_val = T.let(serialized_val, T.nilable(SerializedVal))
+    @const_name = T.let(nil, T.nilable(Symbol))
+  end
+
+  sig {returns(NilClass).checked(:never)}
+  private def assert_bound!
+    if @const_name.nil?
+      raise "Attempting to access Enum value on #{self.class} before it has been initialized." \
+        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+    end
+  end
+
+  sig {params(const_name: Symbol).void}
+  def _bind_name(const_name)
+    @const_name = const_name
+    @serialized_val = const_to_serialized_val(const_name) if @serialized_val.nil?
+    freeze
+  end
+
+  sig {params(const_name: Symbol).returns(String)}
+  private def const_to_serialized_val(const_name)
+    # 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
+  end
+
+  sig {returns(T::Boolean)}
+  def self.started_initializing?
+    @started_initializing = T.let(@started_initializing, T.nilable(T::Boolean))
+    @started_initializing ||= false
+  end
+
+  sig {returns(T::Boolean)}
+  def self.fully_initialized?
+    @fully_initialized = T.let(@fully_initialized, T.nilable(T::Boolean))
+    @fully_initialized ||= false
+  end
+
+  # Entrypoint for allowing people to register new enum values.
+  # All enum values must be defined within this block.
+  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
+
+    @started_initializing = true
+
+    yield
+
+    @values = T.let(nil, T.nilable(T::Array[T.experimental_attached_class]))
+    @mapping = T.let(nil, T.nilable(T::Hash[SerializedVal, T.experimental_attached_class]))
+
+    # Freeze the Enum class and bind the constant names into each of the instances.
+    @mapping = {}
+    self.constants(false).each do |const_name|
+      instance = self.const_get(const_name, false)
+      if !instance.is_a?(self)
+        raise "Invalid constant #{self}::#{const_name} on enum. " \
+          "All constants defined for an enum must be instances itself (e.g. `Foo = new`)."
+      end
+
+      instance._bind_name(const_name)
+      serialized = instance.serialize
+      if @mapping.include?(serialized)
+        raise "Enum values must have unique serializations. Value '#{serialized}' is repeated on #{self}."
+      end
+      @mapping[serialized] = instance
+    end
+    @values = @mapping.values.sort.freeze
+    @mapping.freeze
+    @fully_initialized = true
+  end
+
+  sig {params(child_class: Module).void}
+  def self.inherited(child_class)
+    super
+
+    raise "Inheriting from children of T::Enum is prohibited" if self != T::Enum
+  end
+end

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

@@ -58,11 +58,7 @@ module T::Private::Methods::SignatureValidation
   def self.validate_override_mode(signature, super_signature)
     case signature.mode
     when *Modes::OVERRIDE_MODES
-      if !Modes::OVERRIDABLE_MODES.include?(super_signature.mode)
-        raise "You declared `#{signature.method_name}` as #{pretty_mode(signature)}, but the method it overrides is not declared as `overridable` or `abstract`.\n" \
-              "  Parent definition: #{method_loc_str(super_signature.method)}\n" \
-              "  Child definition:  #{method_loc_str(signature.method)}\n"
-      end
+      # Peaceful
     when *Modes::NON_OVERRIDE_MODES
       if super_signature.mode == Modes.standard
         # Peaceful

data/lib/types/private/types/type_alias.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Private::Types
+  # Wraps a proc for a type alias to defer its evaluation.
+  class TypeAlias < T::Types::Base
+
+    def initialize(callable)
+      @callable = callable
+    end
+
+    def aliased_type
+      @aliased_type ||= T::Utils.coerce(@callable.call)
+    end
+
+    # @override Base
+    def name
+      aliased_type.name
+    end
+
+    # @override Base
+    def valid?(obj)
+      aliased_type.valid?(obj)
+    end
+  end
+end

data/lib/types/props/decorator.rb

@@ -10,11 +10,11 @@
 class T::Props::Decorator
   extend T::Sig
 
-  Rules = T.type_alias(T::Hash[Symbol, T.untyped])
-  DecoratedClass = T.type_alias(T.untyped) # T.class_of(T::Props), but that produces circular reference errors in some circumstances
-  DecoratedInstance = T.type_alias(T.untyped) # Would be T::Props, but that produces circular reference errors in some circumstances
-  PropType = T.type_alias(T.any(T::Types::Base, T::Props::CustomType))
-  PropTypeOrClass = T.type_alias(T.any(PropType, Module))
+  Rules = T.type_alias {T::Hash[Symbol, T.untyped]}
+  DecoratedClass = T.type_alias {T.untyped} # T.class_of(T::Props), but that produces circular reference errors in some circumstances
+  DecoratedInstance = T.type_alias {T.untyped} # Would be T::Props, but that produces circular reference errors in some circumstances
+  PropType = T.type_alias {T.any(T::Types::Base, T::Props::CustomType)}
+  PropTypeOrClass = T.type_alias {T.any(PropType, Module)}
 
   class NoRulesError < StandardError; end
 
@@ -156,10 +156,27 @@ class T::Props::Decorator
       else
         type_object.valid?(val)
       end
+
     if !valid
       raise T::Props::InvalidValueError.new("Can't set #{@class.name}.#{prop} to #{val.inspect} " \
         "(instance of #{val.class}) - need a #{type_object}")
     end
+  rescue T::Props::InvalidValueError => err
+    caller_loc = T.must(caller_locations(8, 1))[0]
+
+    pretty_message = "Parameter '#{prop}': #{err.message}\n" \
+      "Caller: #{caller_loc.path}:#{caller_loc.lineno}\n"
+
+    T::Configuration.call_validation_error_handler(
+      nil,
+      message: err.message,
+      pretty_message: pretty_message,
+      kind: 'Parameter',
+      name: prop,
+      type: type,
+      value: val,
+      location: caller_loc,
+    )
   end
 
   # For performance, don't use named params here.
@@ -330,6 +347,7 @@ class T::Props::Decorator
     .void
   end
   def prop_defined(name, cls, rules={})
+    cls = T::Utils.resolve_alias(cls)
     if rules[:optional] == true
       T::Configuration.hard_assert_handler(
         'Use of `optional: true` is deprecated, please use `T.nilable(...)` instead.',
@@ -534,7 +552,7 @@ class T::Props::Decorator
     nil
   end
 
-  # returns the type of the hash key, or nil. Any CustomType could be a key, but we only expect Opus::Enum right now.
+  # returns the type of the hash key, or nil. Any CustomType could be a key, but we only expect T::Enum right now.
   sig do
     params(type: PropType)
     .returns(T.nilable(Module))
@@ -553,9 +571,6 @@ class T::Props::Decorator
 
   # From T::Props::Utils.deep_clone_object, plus String
   TYPES_NOT_NEEDING_CLONE = [TrueClass, FalseClass, NilClass, Symbol, String, Numeric]
-  if defined?(Opus) && defined?(Opus::Enum)
-    TYPES_NOT_NEEDING_CLONE << Opus::Enum
-  end
 
   sig {params(type: PropType).returns(T::Boolean)}
   private def shallow_clone_ok(type)

data/lib/types/props/type_validation.rb

@@ -64,6 +64,8 @@ module T::Props::TypeValidation
         type.types.map {|subtype| find_invalid_subtype(subtype)}.compact.first
       when T::Types::Enum, T::Types::ClassOf
         nil
+      when T::Private::Types::TypeAlias
+        find_invalid_subtype(type.aliased_type)
       when T::Types::Simple
         # TODO Could we manage to define a whitelist, consisting of something
         # like primitives, subdocs, DataInterfaces, and collections/enums/unions

data/lib/types/props/utils.rb

@@ -23,14 +23,10 @@ module T::Props::Utils
       h
     when Regexp
       what.dup
+    when T::Enum
+      what
     else
-      # Some unfortunate nastiness to get around Opus::Enum potentially not
-      # being defined.
-      if defined?(Opus) && defined?(Opus::Enum) && what.class == Opus::Enum
-        what
-      else
-        what.clone
-      end
+      what.clone
     end
     freeze ? result.freeze : result
   end

data/lib/types/sig.rb

@@ -7,15 +7,15 @@ module T::Sig
   module WithoutRuntime
     # At runtime, does nothing, but statically it is treated exactly the same
     # as T::Sig#sig. Only use it in cases where you can't use T::Sig#sig.
-    def self.sig(arg=nil, &blk); end # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+    def self.sig(arg0=nil, &blk); end # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
 
     original_verbose = $VERBOSE
     $VERBOSE = false
 
     # At runtime, does nothing, but statically it is treated exactly the same
     # as T::Sig#sig. Only use it in cases where you can't use T::Sig#sig.
-    T::Sig::WithoutRuntime.sig {params(arg: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
-    def self.sig(arg=nil, &blk); end # rubocop:disable PrisonGuard/BanBuiltinMethodOverride, Lint/DuplicateMethods
+    T::Sig::WithoutRuntime.sig {params(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
+    def self.sig(arg0=nil, &blk); end # rubocop:disable PrisonGuard/BanBuiltinMethodOverride, Lint/DuplicateMethods
 
     $VERBOSE = original_verbose
   end
@@ -23,8 +23,8 @@ module T::Sig
   # Declares a method with type signatures and/or
   # abstract/override/... helpers. See the documentation URL on
   # {T::Helpers}
-  T::Sig::WithoutRuntime.sig {params(arg: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
-  def sig(arg=nil, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
-    T::Private::Methods.declare_sig(self, arg, &blk)
+  T::Sig::WithoutRuntime.sig {params(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
+  def sig(arg0=nil, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+    T::Private::Methods.declare_sig(self, arg0, &blk)
   end
 end

data/lib/types/types/attached_class.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Modeling AttachedClass properly at runtime would require additional
+  # tracking, so at runtime we permit all values and rely on the static checker.
+  # As AttachedClass is modeled statically as a type member on every singleton
+  # class, this is consistent with the runtime behavior for all type members.
+  class AttachedClassType < Base
+
+    def initialize(); end
+
+    # @override Base
+    def name
+      "AttachedClass"
+    end
+
+    # @override Base
+    def valid?(obj)
+      true
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      case other
+      when AttachedClassType
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/lib/types/types/base.rb

@@ -41,6 +41,14 @@ module T::Types
     def subtype_of?(t2)
       t1 = self
 
+      if t2.is_a?(T::Private::Types::TypeAlias)
+        t2 = t2.aliased_type
+      end
+
+      if t1.is_a?(T::Private::Types::TypeAlias)
+        return t1.aliased_type.subtype_of?(t2)
+      end
+
       # pairs to cover: 1  (_, _)
       #                 2  (_, And)
       #                 3  (_, Or)
@@ -134,7 +142,8 @@ module T::Types
     end
 
     def ==(other)
-      other.class == self.class && other.name == self.name
+      (T::Utils.resolve_alias(other).class == T::Utils.resolve_alias(self).class) &&
+        other.name == self.name
     end
 
     alias_method :eql?, :==

data/lib/types/types/intersection.rb

@@ -8,6 +8,7 @@ module T::Types
 
     def initialize(types)
       @types = types.flat_map do |type|
+        type = T::Utils.resolve_alias(type)
         if type.is_a?(Intersection)
           # Simplify nested intersections (mostly so `name` returns a nicer value)
           type.types

data/lib/types/types/{opus_enum.rb → t_enum.rb}

@@ -2,8 +2,8 @@
 # typed: true
 
 module T::Types
-  # Validates that an object is equal to another Opus::Enum singleton value.
-  class OpusEnum < Base
+  # Validates that an object is equal to another T::Enum singleton value.
+  class TEnum < Base
     attr_reader :val
 
     def initialize(val)
@@ -23,7 +23,7 @@ module T::Types
     # @override Base
     private def subtype_of_single?(other)
       case other
-      when OpusEnum
+      when TEnum
         @val == other.val
       else
         false

data/lib/types/types/typed_enumerable.rb

@@ -46,13 +46,8 @@ module T::Types
           return false if !key_type.valid?(key) || !value_type.valid?(val)
         end
         return true
-      when Enumerator::Lazy
-        # Users don't want these walked
-        return true
       when Enumerator
-        obj.each do |elem|
-          return false unless @type.valid?(elem)
-        end
+        # Enumerators can be unbounded: see `[:foo, :bar].cycle`
         return true
       when Range
         @type.valid?(obj.first) && @type.valid?(obj.last)

data/lib/types/types/union.rb

@@ -8,6 +8,7 @@ module T::Types
 
     def initialize(types)
       @types = types.flat_map do |type|
+        type = T::Utils.resolve_alias(type)
         if type.is_a?(Union)
           # Simplify nested unions (mostly so `name` returns a nicer value)
           type.types

data/lib/types/utils.rb

@@ -4,7 +4,9 @@
 module T::Utils
   # Used to convert from a type specification to a `T::Types::Base`.
   def self.coerce(val)
-    if val.is_a?(T::Types::Base)
+    if val.is_a?(T::Private::Types::TypeAlias)
+      val.aliased_type
+    elsif val.is_a?(T::Types::Base)
       val
     elsif val == ::Array
       T::Array[T.untyped]
@@ -26,8 +28,11 @@ module T::Utils
       T::Types::FixedHash.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
     elsif val.is_a?(T::Private::Methods::DeclBuilder)
       T::Private::Methods.finalize_proc(val.decl)
-    elsif defined?(::Opus) && defined?(::Opus::Enum) && val.is_a?(::Opus::Enum)
-      T::Types::OpusEnum.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+    elsif val.is_a?(::T::Enum)
+      T::Types::TEnum.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+    elsif val.is_a?(::String)
+      raise "Invalid String literal for type constraint. Must be an #{T::Types::Base}, a " \
+            "class/module, or an array. Got a String with value `#{val}`."
     else
       raise "Invalid value for type constraint. Must be an #{T::Types::Base}, a " \
             "class/module, or an array. Got a `#{val.class}`."
@@ -76,6 +81,16 @@ module T::Utils
     T::Private::Methods.run_all_sig_blocks
   end
 
+  # Return the underlying type for a type alias. Otherwise returns type.
+  def self.resolve_alias(type)
+    case type
+    when T::Private::Types::TypeAlias
+      type.aliased_type
+    else
+      type
+    end
+  end
+
   # Give a type which is a subclass of T::Types::Base, determines if the type is a simple nilable type (union of NilClass and something else).
   # If so, returns the T::Types::Base of the something else. Otherwise, returns nil.
   def self.unwrap_nilable(type)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.4.4788
+  version: 0.4.5059
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-24 00:00:00.000000000 Z
+date: 2019-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -78,6 +78,7 @@ files:
 - lib/types/boolean.rb
 - lib/types/compatibility_patches.rb
 - lib/types/configuration.rb
+- lib/types/enum.rb
 - lib/types/generic.rb
 - lib/types/helpers.rb
 - lib/types/interface_wrapper.rb
@@ -88,7 +89,6 @@ files:
 - lib/types/private/casts.rb
 - lib/types/private/class_utils.rb
 - lib/types/private/decl_state.rb
-- lib/types/private/error_handler.rb
 - lib/types/private/final.rb
 - lib/types/private/methods/_methods.rb
 - lib/types/private/methods/call_validation.rb
@@ -101,6 +101,7 @@ files:
 - lib/types/private/sealed.rb
 - lib/types/private/types/not_typed.rb
 - lib/types/private/types/string_holder.rb
+- lib/types/private/types/type_alias.rb
 - lib/types/private/types/void.rb
 - lib/types/profile.rb
 - lib/types/props/_props.rb
@@ -118,6 +119,7 @@ files:
 - lib/types/runtime_profiled.rb
 - lib/types/sig.rb
 - lib/types/struct.rb
+- lib/types/types/attached_class.rb
 - lib/types/types/base.rb
 - lib/types/types/class_of.rb
 - lib/types/types/enum.rb
@@ -125,10 +127,10 @@ files:
 - lib/types/types/fixed_hash.rb
 - lib/types/types/intersection.rb
 - lib/types/types/noreturn.rb
-- lib/types/types/opus_enum.rb
 - lib/types/types/proc.rb
 - lib/types/types/self_type.rb
 - lib/types/types/simple.rb
+- lib/types/types/t_enum.rb
 - lib/types/types/type_member.rb
 - lib/types/types/type_parameter.rb
 - lib/types/types/type_template.rb
@@ -145,7 +147,8 @@ files:
 homepage: https://sorbet.run
 licenses:
 - Apache-2.0
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/sorbet/sorbet
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -155,9 +158,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version
       version: 2.3.0
-  - - "<"
-    - !ruby/object:Gem::Version
-      version: 2.7.0.preview1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="