sorbet-runtime 0.5.5316 → 0.5.5956

data/lib/types/types/simple.rb

@@ -12,7 +12,11 @@ module T::Types
 
     # @override Base
     def name
-      @raw_type.name
+      # Memoize to mitigate pathological performance with anonymous modules (https://bugs.ruby-lang.org/issues/11119)
+      #
+      # `name` isn't normally a hot path for types, but it is used in initializing a T::Types::Union,
+      # and so in `T.nilable`, and so in runtime constructions like `x = T.let(nil, T.nilable(Integer))`.
+      @name ||= @raw_type.name.freeze
     end
 
     # @override Base
@@ -29,5 +33,22 @@ module T::Types
         false
       end
     end
+
+    def to_nilable
+      @nilable ||= T::Types::Union.new([self, T::Utils::Nilable::NIL_TYPE])
+    end
+
+    module Private
+      module Pool
+        def self.type_for_module(mod)
+          cached = mod.instance_variable_get(:@__as_sorbet_simple_type)
+          return cached if cached
+
+          type = Simple.new(mod)
+          mod.instance_variable_set(:@__as_sorbet_simple_type, type) unless mod.frozen?
+          type
+        end
+      end
+    end
   end
 end

data/lib/types/types/t_enum.rb

@@ -12,7 +12,12 @@ module T::Types
 
     # @override Base
     def name
-      @val.inspect
+      # Strips the #<...> off, just leaving the ...
+      # Reasoning: the user will have written something like
+      #   T.any(MyEnum::A, MyEnum::B)
+      # in the type, so we should print what they wrote in errors, not:
+      #   T.any(#<MyEnum::A>, #<MyEnum::B>)
+      @val.inspect[2..-2]
     end
 
     # @override Base

data/lib/types/types/type_parameter.rb

@@ -17,7 +17,7 @@ module T::Types
     end
 
     def name
-      "T.type_parameter(#{@name})"
+      "T.type_parameter(:#{@name})"
     end
   end
 end

data/lib/types/types/typed_array.rb

@@ -13,11 +13,16 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       obj.is_a?(Array) && super
     end
 
-    def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Array)
+    end
+
+    def new(*args)
       Array.new(*T.unsafe(args))
     end
 

data/lib/types/types/typed_enumerable.rb

@@ -23,13 +23,18 @@ module T::Types
 
     # @override Base
     def valid?(obj)
+      obj.is_a?(Enumerable)
+    end
+
+    # @override Base
+    def recursively_valid?(obj)
       return false unless obj.is_a?(Enumerable)
       case obj
       when Array
         begin
           it = 0
           while it < obj.count
-            return false unless @type.valid?(obj[it])
+            return false unless @type.recursively_valid?(obj[it])
             it += 1
           end
           return true
@@ -42,18 +47,22 @@ module T::Types
         value_type = types[1]
         obj.each_pair do |key, val|
           # Some objects (I'm looking at you Rack::Utils::HeaderHash) don't
-          # iterate over a [key, value] array, so we can't juse use the @type.valid?(v)
-          return false if !key_type.valid?(key) || !value_type.valid?(val)
+          # iterate over a [key, value] array, so we can't juse use the @type.recursively_valid?(v)
+          return false if !key_type.recursively_valid?(key) || !value_type.recursively_valid?(val)
         end
         return true
       when Enumerator
         # Enumerators can be unbounded: see `[:foo, :bar].cycle`
         return true
       when Range
-        @type.valid?(obj.first) && @type.valid?(obj.last)
+        # A nil beginning or a nil end does not provide any type information. That is, nil in a range represents
+        # boundlessness, it does not express a type. For example `(nil...nil)` is not a T::Range[NilClass], its a range
+        # of unknown types (T::Range[T.untyped]).
+        # Similarly, `(nil...1)` is not a `T::Range[T.nilable(Integer)]`, it's a boundless range of Integer.
+        (obj.begin.nil? || @type.recursively_valid?(obj.begin)) && (obj.end.nil? || @type.recursively_valid?(obj.end))
       when Set
         obj.each do |item|
-          return false unless @type.valid?(item)
+          return false unless @type.recursively_valid?(item)
         end
 
         return true
@@ -124,7 +133,13 @@ module T::Types
         inferred_val = type_from_instances(obj.values)
         T::Hash[inferred_key, inferred_val]
       when Range
-        T::Range[type_from_instances([obj.first, obj.last])]
+        # We can't get any information from `NilClass` in ranges (since nil is used to represent boundlessness).
+        typeable_objects = [obj.begin, obj.end].compact
+        if typeable_objects.empty?
+          T::Range[T.untyped]
+        else
+          T::Range[type_from_instances(typeable_objects)]
+        end
       when Enumerator
         T::Enumerator[type_from_instances(obj)]
       when Set
@@ -134,7 +149,8 @@ module T::Types
         # enumerating the object is a destructive operation and might hang.
         obj.class
       else
-        self.class.new(type_from_instances(obj))
+        # This is a specialized enumerable type, just return the class.
+        Object.instance_method(:class).bind(obj).call
       end
     end
 

data/lib/types/types/typed_enumerator.rb

@@ -15,11 +15,16 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       obj.is_a?(Enumerator) && super
     end
 
-    def new(*args, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Enumerator)
+    end
+
+    def new(*args, &blk)
       T.unsafe(Enumerator).new(*args, &blk)
     end
 

data/lib/types/types/typed_hash.rb

@@ -22,12 +22,17 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       obj.is_a?(Hash) && super
     end
 
-    def new(*args, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
-      Hash.new(*T.unsafe(args), &blk) # rubocop:disable PrisonGuard/RestrictHashDefaults
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Hash)
+    end
+
+    def new(*args, &blk)
+      Hash.new(*T.unsafe(args), &blk)
     end
 
     class Untyped < TypedHash

data/lib/types/types/typed_range.rb

@@ -15,11 +15,16 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       obj.is_a?(Range) && super
     end
 
-    def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Range)
+    end
+
+    def new(*args)
       T.unsafe(Range).new(*args)
     end
   end

data/lib/types/types/typed_set.rb

@@ -15,11 +15,16 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       obj.is_a?(Set) && super
     end
 
-    def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Set)
+    end
+
+    def new(*args)
       Set.new(*T.unsafe(args))
     end
 

data/lib/types/types/union.rb

@@ -43,12 +43,13 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
-      @types.each do |type|
-        return true if type.valid?(obj)
-      end
+    def recursively_valid?(obj)
+      @types.any? {|type| type.recursively_valid?(obj)}
+    end
 
-      false
+    # @override Base
+    def valid?(obj)
+      @types.any? {|type| type.valid?(obj)}
     end
 
     # @override Base
@@ -56,5 +57,35 @@ module T::Types
       raise "This should never be reached if you're going through `subtype_of?` (and you should be)"
     end
 
+    module Private
+      module Pool
+        EMPTY_ARRAY = [].freeze
+        private_constant :EMPTY_ARRAY
+
+        # @param type_a [T::Types::Base]
+        # @param type_b [T::Types::Base]
+        # @param types [Array] optional array of additional T::Types::Base instances
+        def self.union_of_types(type_a, type_b, types=EMPTY_ARRAY)
+          if types.empty?
+            # We aren't guaranteed to detect a simple `T.nilable(<Module>)` type here
+            # in cases where there are duplicate types, nested unions, etc.
+            #
+            # That's ok, because this is an optimization which isn't necessary for
+            # correctness.
+            if type_b == T::Utils::Nilable::NIL_TYPE && type_a.is_a?(T::Types::Simple)
+              type_a.to_nilable
+            elsif type_a == T::Utils::Nilable::NIL_TYPE && type_b.is_a?(T::Types::Simple)
+              type_b.to_nilable
+            else
+              Union.new([type_a, type_b])
+            end
+          else
+            # This can't be a `T.nilable(<Module>)` case unless there are duplicates,
+            # which is possible but unexpected.
+            Union.new([type_a, type_b] + types)
+          end
+        end
+      end
+    end
   end
 end

data/lib/types/types/untyped.rb

@@ -21,5 +21,9 @@ module T::Types
     private def subtype_of_single?(other)
       true
     end
+
+    module Private
+      INSTANCE = Untyped.new.freeze
+    end
   end
 end

data/lib/types/utils.rb

@@ -21,15 +21,15 @@ module T::Utils
     elsif val == ::Range
       T::Range[T.untyped]
     elsif val.is_a?(Module)
-      T::Types::Simple.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+      T::Types::Simple::Private::Pool.type_for_module(val)
     elsif val.is_a?(::Array)
-      T::Types::FixedArray.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+      T::Types::FixedArray.new(val)
     elsif val.is_a?(::Hash)
-      T::Types::FixedHash.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+      T::Types::FixedHash.new(val)
     elsif val.is_a?(T::Private::Methods::DeclBuilder)
       T::Private::Methods.finalize_proc(val.decl)
     elsif val.is_a?(::T::Enum)
-      T::Types::TEnum.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+      T::Types::TEnum.new(val)
     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}`."
@@ -109,10 +109,10 @@ module T::Utils
 
   # Returns the arity of a method, unwrapping the sig if needed
   def self.arity(method)
-    arity = method.arity # rubocop:disable PrisonGuard/NoArity
+    arity = method.arity
     return arity if arity != -1 || method.is_a?(Proc)
     sig = T::Private::Methods.signature_for_method(method)
-    sig ? sig.method.arity : arity # rubocop:disable PrisonGuard/NoArity
+    sig ? sig.method.arity : arity
   end
 
   # Elide the middle of a string as needed and replace it with an ellipsis.
@@ -151,6 +151,21 @@ module T::Utils
     "#{start_part}#{ellipsis}#{end_part}"
   end
 
+  def self.lift_enum(enum)
+    unless enum.is_a?(T::Types::Enum)
+      raise ArgumentError.new("#{enum.inspect} is not a T.enum")
+    end
+
+    classes = enum.values.map(&:class).uniq
+    if classes.empty?
+      T.untyped
+    elsif classes.length > 1
+      T::Types::Union.new(classes)
+    else
+      T::Types::Simple::Private::Pool.type_for_module(classes.first)
+    end
+  end
+
   module Nilable
     # :is_union_type, T::Boolean: whether the type is an T::Types::Union type
     # :non_nilable_type, Class: if it is an T.nilable type, the corresponding underlying type; otherwise, nil.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.5316
+  version: 0.5.5956
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-31 00:00:00.000000000 Z
+date: 2020-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -52,6 +52,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.90.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.90.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +94,62 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.1.5
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.7.1
+- !ruby/object:Gem::Dependency
+  name: subprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.3
 description: Sorbet's runtime type checking component
 email: 
 executables: []
@@ -82,6 +166,7 @@ files:
 - lib/types/generic.rb
 - lib/types/helpers.rb
 - lib/types/interface_wrapper.rb
+- lib/types/non_forcing_constants.rb
 - lib/types/private/abstract/data.rb
 - lib/types/private/abstract/declare.rb
 - lib/types/private/abstract/hooks.rb
@@ -97,6 +182,7 @@ files:
 - lib/types/private/methods/signature.rb
 - lib/types/private/methods/signature_validation.rb
 - lib/types/private/mixins/mixins.rb
+- lib/types/private/retry.rb
 - lib/types/private/runtime_levels.rb
 - lib/types/private/sealed.rb
 - lib/types/private/types/not_typed.rb
@@ -109,9 +195,16 @@ files:
 - lib/types/props/custom_type.rb
 - lib/types/props/decorator.rb
 - lib/types/props/errors.rb
+- lib/types/props/generated_code_validation.rb
+- lib/types/props/has_lazily_specialized_methods.rb
 - lib/types/props/optional.rb
 - lib/types/props/plugin.rb
 - lib/types/props/pretty_printable.rb
+- lib/types/props/private/apply_default.rb
+- lib/types/props/private/deserializer_generator.rb
+- lib/types/props/private/parser.rb
+- lib/types/props/private/serde_transform.rb
+- lib/types/props/private/serializer_generator.rb
 - lib/types/props/private/setter_factory.rb
 - lib/types/props/serializable.rb
 - lib/types/props/type_validation.rb