sorbet-runtime 0.0.1.pre.prealpha → 0.4.4253

data/lib/types/types/fixed_array.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+# https://jira.corp.stripe.com/browse/RUBYPLAT-1107
+# typed: false
+
+module T::Types
+  # Takes a list of types. Validates each item in an array using the type in the same position
+  # in the list.
+  class FixedArray < Base
+    attr_reader :types
+
+    def initialize(types)
+      @types = types.map {|type| T::Utils.coerce(type)}
+    end
+
+    # @override Base
+    def name
+      "[#{@types.join(', ')}]"
+    end
+
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Array) && obj.length == @types.length &&
+        obj.zip(@types).all? {|item, type| type.valid?(item)}
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      case other
+      when FixedArray
+        # Properly speaking, covariance here is unsound since arrays
+        # can be mutated, but sorbet implements covariant tuples for
+        # ease of adoption.
+        @types.size == other.types.size && @types.zip(other.types).all? do |t1, t2|
+          t1.subtype_of?(t2)
+        end
+      else
+        false
+      end
+    end
+
+    # This gives us better errors, e.g.:
+    # "Expected [String, Symbol], got [String, String]"
+    # instead of
+    # "Expected [String, Symbol], got Array".
+    #
+    # @override Base
+    def describe_obj(obj)
+      if obj.is_a?(Array)
+        if obj.length == @types.length
+          item_classes = obj.map(&:class).join(', ')
+          "type [#{item_classes}]"
+        else
+          "array of size #{obj.length}"
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/lib/types/types/fixed_hash.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Takes a hash of types. Validates each item in an hash using the type in the same position
+  # in the list.
+  class FixedHash < Base
+    attr_reader :types
+
+    def initialize(types)
+      @types = types.each_with_object({}) {|(k, v), h| h[k] = T::Utils.coerce(v)}
+    end
+
+    # @override Base
+    def name
+      "{#{@types.map {|(k, v)| "#{k}: #{v}"}.join(', ')}}"
+    end
+
+    # @override Base
+    def valid?(obj)
+      return false unless obj.is_a?(Hash)
+
+      @types.each do |key, type|
+        return false unless type.valid?(obj[key])
+      end
+
+      obj.each_key do |key|
+        return false unless @types[key]
+      end
+
+      true
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      case other
+      when FixedHash
+        # Using `subtype_of?` here instead of == would be unsound
+        @types == other.types
+      else
+        false
+      end
+    end
+
+    # This gives us better errors, e.g.:
+    # "Expected {a: String}, got {a: TrueClass}"
+    # instead of
+    # "Expected {a: String}, got Hash".
+    #
+    # @override Base
+    def describe_obj(obj)
+      if obj.is_a?(Hash)
+        "type {#{obj.map {|(k, v)| "#{k}: #{v.class}"}.join(', ')}}"
+      else
+        super
+      end
+    end
+  end
+end

data/lib/types/types/intersection.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Takes a list of types. Validates that an object matches all of the types.
+  class Intersection < Base
+    attr_reader :types
+
+    def initialize(types)
+      @types = types.flat_map do |type|
+        if type.is_a?(Intersection)
+          # Simplify nested intersections (mostly so `name` returns a nicer value)
+          type.types
+        else
+          T::Utils.coerce(type)
+        end
+      end.uniq
+    end
+
+    # @override Base
+    def name
+      "T.all(#{@types.map(&:name).sort.join(', ')})"
+    end
+
+    # @override Base
+    def valid?(obj)
+      @types.all? {|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/noreturn.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # The bottom type
+  class NoReturn < Base
+
+    def initialize; end
+
+    # @override Base
+    def name
+      "T.noreturn"
+    end
+
+    # @override Base
+    def valid?(obj)
+      false
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      true
+    end
+  end
+end

data/lib/types/types/proc.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Defines the type of a proc (a ruby callable). At runtime, only
+  # validates that the value is a `::Proc`.
+  #
+  # At present, we only support fixed-arity procs with no optional or
+  # keyword arguments.
+  class Proc < Base
+    attr_reader :arg_types
+    attr_reader :returns
+
+    def initialize(arg_types, returns)
+      @arg_types = {}
+      arg_types.each do |key, raw_type|
+        @arg_types[key] = T::Utils.coerce(raw_type)
+      end
+      @returns = T::Utils.coerce(returns)
+    end
+
+    # @override Base
+    def name
+      args = []
+      @arg_types.each do |k, v|
+        args << "#{k}: #{v.name}"
+      end
+      "T.proc.params(#{args.join(', ')}).returns(#{returns})"
+    end
+
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(::Proc)
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      case other
+      when self.class
+        if arg_types.size != other.arg_types.size
+          return false
+        end
+        arg_types.values.zip(other.arg_types.values).all? do |a, b|
+          b.subtype_of?(a)
+        end && returns.subtype_of?(other.returns)
+      else
+        false
+      end
+    end
+  end
+end

data/lib/types/types/self_type.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Modeling self-types properly at runtime would require additional tracking,
+  # so at runtime we permit all values and rely on the static checker.
+  class SelfType < Base
+
+    def initialize(); end
+
+    # @override Base
+    def name
+      "T.self_type"
+    end
+
+    # @override Base
+    def valid?(obj)
+      true
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      case other
+      when SelfType
+          true
+        else
+          false
+      end
+    end
+  end
+end

data/lib/types/types/simple.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Validates that an object belongs to the specified class.
+  class Simple < Base
+    attr_reader :raw_type
+
+    def initialize(raw_type)
+      @raw_type = raw_type
+    end
+
+    # @override Base
+    def name
+      @raw_type.name
+    end
+
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(@raw_type)
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      case other
+      when Simple
+        @raw_type <= other.raw_type
+      else
+        false
+      end
+    end
+  end
+end

data/lib/types/types/type_member.rb

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

data/lib/types/types/type_parameter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypeParameter < Base
+    def initialize(name)
+      raise ArgumentError.new("not a symbol: #{name}") unless name.is_a?(Symbol)
+      @name = name
+    end
+
+    def valid?(obj)
+      true
+    end
+
+    def subtype_of_single?(type)
+      true
+    end
+
+    def name
+      "T.type_parameter(#{@name})"
+    end
+  end
+end

data/lib/types/types/type_template.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# typed: true
+
+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,20 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedArray < TypedEnumerable
+    # @override Base
+    def name
+      "T::Array[#{@type.name}]"
+    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
+  end
+end

data/lib/types/types/typed_enumerable.rb

@@ -0,0 +1,141 @@
+# 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
+
+    # @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::Lazy
+        # Users don't want these walked
+        return true
+      when Enumerator
+        obj.each do |elem|
+          return false unless @type.valid?(elem)
+        end
+        return true
+      when Range
+        @type.valid?(obj.first) && @type.valid?(obj.last)
+      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 self.class <= other.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
+        T::Range[type_from_instances([obj.first, obj.last])]
+      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
+  end
+end