sorbet-runtime 0.5.5841

data/lib/types/types/type_template.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# typed: strict
+
+module T::Types
+  class TypeTemplate < TypeVariable
+  end
+end

data/lib/types/types/type_variable.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Since we do type erasure at runtime, this just validates the variance and
+  # provides some syntax for the static type checker
+  class TypeVariable < Base
+    attr_reader :variance
+
+    VALID_VARIANCES = [:in, :out, :invariant]
+
+    def initialize(variance)
+      if !VALID_VARIANCES.include?(variance)
+        raise TypeError.new("invalid variance #{variance}")
+      end
+      @variance = variance
+    end
+
+    def valid?(obj)
+      true
+    end
+
+    def subtype_of_single?(type)
+      true
+    end
+
+    def name
+      Untyped.new.name
+    end
+  end
+end

data/lib/types/types/typed_array.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedArray < TypedEnumerable
+    # @override Base
+    def name
+      "T::Array[#{@type.name}]"
+    end
+
+    def underlying_class
+      Array
+    end
+
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Array) && super
+    end
+
+    def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+      Array.new(*T.unsafe(args))
+    end
+
+    class Untyped < TypedArray
+      def initialize
+        super(T.untyped)
+      end
+
+      def valid?(obj)
+        obj.is_a?(Array)
+      end
+    end
+  end
+end

data/lib/types/types/typed_enumerable.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Note: All subclasses of Enumerable should add themselves to the
+  # `case` statement below in `describe_obj` in order to get better
+  # error messages.
+  class TypedEnumerable < Base
+    attr_reader :type
+
+    def initialize(type)
+      @type = T::Utils.coerce(type)
+    end
+
+    def underlying_class
+      Enumerable
+    end
+
+    # @override Base
+    def name
+      "T::Enumerable[#{@type.name}]"
+    end
+
+    # @override Base
+    def 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])
+            it += 1
+          end
+          return true
+        end
+      when Hash
+        return false unless @type.is_a?(FixedArray)
+        types = @type.types
+        return false if types.count != 2
+        key_type = types[0]
+        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)
+        end
+        return true
+      when Enumerator
+        # Enumerators can be unbounded: see `[:foo, :bar].cycle`
+        return true
+      when Range
+        # 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.valid?(obj.begin)) && (obj.end.nil? || @type.valid?(obj.end))
+      when Set
+        obj.each do |item|
+          return false unless @type.valid?(item)
+        end
+
+        return true
+      else
+        # We don't check the enumerable since it isn't guaranteed to be
+        # rewindable (e.g. STDIN) and it may be expensive to enumerate
+        # (e.g. an enumerator that makes an HTTP request)"
+        true
+      end
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      if other.class <= TypedEnumerable &&
+         underlying_class <= other.underlying_class
+        # Enumerables are covariant because they are read only
+        #
+        # Properly speaking, many Enumerable subtypes (e.g. Set)
+        # should be invariant because they are mutable and support
+        # both reading and writing. However, Sorbet treats *all*
+        # Enumerable subclasses as covariant for ease of adoption.
+        @type.subtype_of?(other.type)
+      else
+        false
+      end
+    end
+
+    # @override Base
+    def describe_obj(obj)
+      return super unless obj.is_a?(Enumerable)
+      type_from_instance(obj).name
+    end
+
+    private def type_from_instances(objs)
+      return objs.class unless objs.is_a?(Enumerable)
+      obtained_types = []
+      begin
+        objs.each do |x|
+          obtained_types << type_from_instance(x)
+        end
+      rescue
+        return T.untyped # all we can do is go with the types we have so far
+      end
+      if obtained_types.count > 1
+        # Multiple kinds of bad types showed up, we'll suggest a union
+        # type you might want.
+        Union.new(obtained_types)
+      elsif obtained_types.empty?
+        T.noreturn
+      else
+        # Everything was the same bad type, lets just show that
+        obtained_types.first
+      end
+    end
+
+    private def type_from_instance(obj)
+      if [true, false].include?(obj)
+        return T::Boolean
+      elsif !obj.is_a?(Enumerable)
+        return obj.class
+      end
+
+      case obj
+      when Array
+        T::Array[type_from_instances(obj)]
+      when Hash
+        inferred_key = type_from_instances(obj.keys)
+        inferred_val = type_from_instances(obj.values)
+        T::Hash[inferred_key, inferred_val]
+      when Range
+        # 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
+        T::Set[type_from_instances(obj)]
+      when IO
+        # Short circuit for anything IO-like (File, etc.). In these cases,
+        # enumerating the object is a destructive operation and might hang.
+        obj.class
+      else
+        self.class.new(type_from_instances(obj))
+      end
+    end
+
+    class Untyped < TypedEnumerable
+      def initialize
+        super(T.untyped)
+      end
+
+      def valid?(obj)
+        obj.is_a?(Enumerable)
+      end
+    end
+  end
+end

data/lib/types/types/typed_enumerator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedEnumerator < TypedEnumerable
+    attr_reader :type
+
+    def underlying_class
+      Enumerator
+    end
+
+    # @override Base
+    def name
+      "T::Enumerator[#{@type.name}]"
+    end
+
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Enumerator) && super
+    end
+
+    def new(*args, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+      T.unsafe(Enumerator).new(*args, &blk)
+    end
+
+    class Untyped < TypedEnumerator
+      def initialize
+        super(T.untyped)
+      end
+
+      def valid?(obj)
+        obj.is_a?(Enumerator)
+      end
+    end
+  end
+end

data/lib/types/types/typed_hash.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedHash < TypedEnumerable
+    # Technically we don't need these, but they are a nice api
+    attr_reader :keys, :values
+
+    def underlying_class
+      Hash
+    end
+
+    def initialize(keys:, values:)
+      @keys = T::Utils.coerce(keys)
+      @values = T::Utils.coerce(values)
+      @type = T::Utils.coerce([keys, values])
+    end
+
+    # @override Base
+    def name
+      "T::Hash[#{@keys.name}, #{@values.name}]"
+    end
+
+    # @override Base
+    def 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
+    end
+
+    class Untyped < TypedHash
+      def initialize
+        super(keys: T.untyped, values: T.untyped)
+      end
+
+      def valid?(obj)
+        obj.is_a?(Hash)
+      end
+    end
+  end
+end

data/lib/types/types/typed_range.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedRange < TypedEnumerable
+    attr_reader :type
+
+    def underlying_class
+      Hash
+    end
+
+    # @override Base
+    def name
+      "T::Range[#{@type.name}]"
+    end
+
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Range) && super
+    end
+
+    def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+      T.unsafe(Range).new(*args)
+    end
+  end
+end

data/lib/types/types/typed_set.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedSet < TypedEnumerable
+    attr_reader :type
+
+    def underlying_class
+      Hash
+    end
+
+    # @override Base
+    def name
+      "T::Set[#{@type.name}]"
+    end
+
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Set) && super
+    end
+
+    def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+      Set.new(*T.unsafe(args))
+    end
+
+    class Untyped < TypedSet
+      def initialize
+        super(T.untyped)
+      end
+
+      def valid?(obj)
+        obj.is_a?(Set)
+      end
+    end
+  end
+end

data/lib/types/types/union.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Takes a list of types. Validates that an object matches at least one of the types.
+  class Union < Base
+    attr_reader :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
+        else
+          T::Utils.coerce(type)
+        end
+      end.uniq
+    end
+
+    # @override Base
+    def name
+      type_shortcuts(@types)
+    end
+
+    private def type_shortcuts(types)
+      if types.size == 1
+        return types[0].name
+      end
+      nilable = T::Utils.coerce(NilClass)
+      trueclass = T::Utils.coerce(TrueClass)
+      falseclass = T::Utils.coerce(FalseClass)
+      if types.any? {|t| t == nilable}
+        remaining_types = types.reject {|t| t == nilable}
+        "T.nilable(#{type_shortcuts(remaining_types)})"
+      elsif types.any? {|t| t == trueclass} && types.any? {|t| t == falseclass}
+        remaining_types = types.reject {|t| t == trueclass || t == falseclass}
+        type_shortcuts([T::Private::Types::StringHolder.new("T::Boolean")] + remaining_types)
+      else
+        names = types.map(&:name).compact.sort
+        "T.any(#{names.join(', ')})"
+      end
+    end
+
+    # @override Base
+    def valid?(obj)
+      @types.any? {|type| type.valid?(obj)}
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      raise "This should never be reached if you're going through `subtype_of?` (and you should be)"
+    end
+
+  end
+end

data/lib/types/types/untyped.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # A dynamic type, which permits whatever
+  class Untyped < Base
+
+    def initialize; end
+
+    # @override Base
+    def name
+      "T.untyped"
+    end
+
+    # @override Base
+    def valid?(obj)
+      true
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      true
+    end
+
+    module Private
+      INSTANCE = Untyped.new.freeze
+    end
+  end
+end