sorbet-runtime 0.5.5841

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 02df0e4234d0887f7584ed03f2efd4ceabe7cd2aad902a198617207b02d92a6a
+  data.tar.gz: 3cef81d70c297f03d9b6307c32c7c6b079e120ac5a92681ff371bb3d010205b8
+SHA512:
+  metadata.gz: 6e0cb83492e866202da027d8f8a5800a52fb7f0e3e4353952ec0250b28122704ad1bc5317ebd30b388df247d0a353afa239393aeafe3421d100d81a5f5456c81
+  data.tar.gz: 6a8b52a3830af73aec07c37bd6afba1081fbd47fbe0d37601803a1ccd73fa1edd08d9fbb233bb9c0556d81baff8571f791e723e7c84f117622c5fcf42ec91e40

data/lib/sorbet-runtime.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+# typed: true
+
+# This file is hand-crafted to encode the dependencies. They load the whole type
+# system since there is such a high chance of it being used, using an autoloader
+# wouldn't buy us any startup time saving.
+
+# Namespaces without any implementation
+module T; end
+module T::Helpers; end
+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.
+
+# These are pre-reqs for almost everything in here.
+require_relative 'types/configuration'
+require_relative 'types/profile'
+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/runtime_levels'
+require_relative 'types/private/methods/_methods'
+require_relative 'types/sig'
+require_relative 'types/helpers'
+require_relative 'types/private/final'
+require_relative 'types/private/sealed'
+
+# The types themselves. First base classes
+require_relative 'types/types/base'
+require_relative 'types/types/typed_enumerable'
+# Everything else
+require_relative 'types/types/class_of'
+require_relative 'types/types/enum'
+require_relative 'types/types/fixed_array'
+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/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_hash'
+require_relative 'types/types/typed_range'
+require_relative 'types/types/typed_set'
+require_relative 'types/types/union'
+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'
+require_relative 'types/types/type_template'
+
+# Call validation
+require_relative 'types/private/methods/modes'
+require_relative 'types/private/methods/call_validation'
+
+# Signature validation
+require_relative 'types/private/methods/signature_validation'
+require_relative 'types/abstract_utils'
+require_relative 'types/private/abstract/validate'
+
+# Catch all. Sort of built by `cd extn; find types -type f | grep -v test | sort`
+require_relative 'types/generic'
+require_relative 'types/interface_wrapper'
+require_relative 'types/private/abstract/declare'
+require_relative 'types/private/abstract/hooks'
+require_relative 'types/private/casts'
+require_relative 'types/private/methods/decl_builder'
+require_relative 'types/private/methods/signature'
+require_relative 'types/private/retry'
+require_relative 'types/utils'
+require_relative 'types/boolean'
+
+# Props dependencies
+require_relative 'types/private/abstract/data'
+require_relative 'types/private/mixins/mixins'
+require_relative 'types/props/_props'
+require_relative 'types/props/custom_type'
+require_relative 'types/props/decorator'
+require_relative 'types/props/errors'
+require_relative 'types/props/plugin'
+require_relative 'types/props/utils'
+require_relative 'types/enum'
+# Props that run sigs statically so have to be after all the others :(
+require_relative 'types/props/private/setter_factory'
+require_relative 'types/props/private/apply_default'
+require_relative 'types/props/has_lazily_specialized_methods'
+require_relative 'types/props/optional'
+require_relative 'types/props/weak_constructor'
+require_relative 'types/props/constructor'
+require_relative 'types/props/pretty_printable'
+require_relative 'types/props/private/serde_transform'
+require_relative 'types/props/private/deserializer_generator'
+require_relative 'types/props/private/serializer_generator'
+require_relative 'types/props/serializable'
+require_relative 'types/props/type_validation'
+require_relative 'types/props/private/parser'
+require_relative 'types/props/generated_code_validation'
+
+require_relative 'types/struct'
+require_relative 'types/non_forcing_constants'
+
+require_relative 'types/compatibility_patches'

data/lib/types/_types.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+# typed: true
+# This is where we define the shortcuts, so we can't use them here
+# rubocop:disable PrisonGuard/UseOpusTypesShortcut
+
+#  _____
+# |_   _|   _ _ __   ___  ___
+#   | || | | | '_ \ / _ \/ __|
+#   | || |_| | |_) |  __/\__ \
+#   |_| \__, | .__/ \___||___/
+#       |___/|_|
+#
+# Docs at https://sorbet.org/docs/sigs
+#
+# Types that you can pass to `sig`:
+#
+#  - a Ruby class
+#
+#  - [<Type>, <Type>, ...] -- to specify a "tuple"; a fixed-size array with known types for each member
+#
+#  - {key: <Type>, key2: <Type>, ...} -- to speicfy a "shape"; a fixed-size hash
+#  with known keys and type values
+#
+#  - Any of the `T.foo` methods below
+
+module T
+  # T.any(<Type>, <Type>, ...) -- matches any of the types listed
+  def self.any(type_a, type_b, *types)
+    T::Types::Union.new([type_a, type_b] + types)
+  end
+
+  # Shorthand for T.any(type, NilClass)
+  def self.nilable(type)
+    T::Types::Union.new([type, NilClass])
+  end
+
+  # Matches any object. In the static checker, T.untyped allows any
+  # method calls or operations.
+  def self.untyped
+    T::Types::Untyped::Private::INSTANCE
+  end
+
+  # Indicates a function never returns (e.g. "Kernel#raise")
+  def self.noreturn
+    T::Types::NoReturn::Private::INSTANCE
+  end
+
+  # T.all(<Type>, <Type>, ...) -- matches an object that has all of the types listed
+  def self.all(type_a, type_b, *types)
+    T::Types::Intersection.new([type_a, type_b] + types)
+  end
+
+  # Matches any of the listed values
+  def self.enum(values)
+    T::Types::Enum.new(values)
+  end
+
+  # Creates a proc type
+  def self.proc
+    T::Private::Methods.start_proc
+  end
+
+  # Matches `self`:
+  def self.self_type
+    T::Types::SelfType::Private::INSTANCE
+  end
+
+  # Matches the instance type in a singleton-class context
+  def self.attached_class
+    T::Types::AttachedClassType::Private::INSTANCE
+  end
+
+  # Matches any class that subclasses or includes the provided class
+  # or module
+  def self.class_of(klass)
+    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:
+  #
+  #  NilableString = T.type_alias {T.nilable(String)}
+  #
+  #  sig {params(arg: NilableString, default: String).returns(String)}
+  #  def or_else(arg, default)
+  #    arg || default
+  #  end
+  #
+  # The name of the type alias is not preserved; Error messages will
+  # be printed with reference to the underlying 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 parameter which was previously defined with
+  # `type_parameters`.
+  #
+  # This is used for generic methods. Example usage:
+  #
+  #  sig
+  #  .type_parameters(:U)
+  #  .params(
+  #    blk: T.proc.params(arg0: Elem).returns(T.type_parameter(:U)),
+  #  )
+  #  .returns(T::Array[T.type_parameter(:U)])
+  #  def map(&blk); end
+  def self.type_parameter(name)
+    T::Types::TypeParameter.new(name)
+  end
+
+  # Tells the typechecker that `value` is of type `type`. Use this to get additional checking after
+  # an expression that the typechecker is unable to analyze. If `checked` is true, raises an
+  # exception at runtime if the value doesn't match the type.
+  #
+  # Compared to `T.let`, `T.cast` is _trusted_ by static system.
+  def self.cast(value, type, checked: true)
+    return value unless checked
+
+    Private::Casts.cast(value, type, cast_method: "T.cast")
+  end
+
+  # Tells the typechecker to declare a variable of type `type`. Use
+  # like:
+  #
+  #  seconds = T.let(0.0, Float)
+  #
+  # Compared to `T.cast`, `T.let` is _checked_ by static system.
+  #
+  # If `checked` is true, raises an exception at runtime if the value
+  # doesn't match the type.
+  def self.let(value, type, checked: true)
+    return value unless checked
+
+    Private::Casts.cast(value, type, cast_method: "T.let")
+  end
+
+  # Tells the typechecker to ensure that `value` is of type `type` (if not, the typechecker will
+  # fail). Use this for debugging typechecking errors, or to ensure that type information is
+  # statically known and being checked appropriately. If `checked` is true, raises an exception at
+  # runtime if the value doesn't match the type.
+  def self.assert_type!(value, type, checked: true)
+    return value unless checked
+
+    Private::Casts.cast(value, type, cast_method: "T.assert_type!")
+  end
+
+  # For the static type checker, strips all type information from a value
+  # and returns the same value, but statically-typed as `T.untyped`.
+  # Can be used to tell the static checker to "trust you" by discarding type information
+  # you know to be incorrect. Use with care!
+  # (This has no effect at runtime.)
+  #
+  # We can't actually write this sig because we ourselves are inside
+  # the `T::` module and doing this would create a bootstrapping
+  # 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)}
+  def self.unsafe(value)
+    value
+  end
+
+  # A convenience method to `raise` when the argument is `nil` and return it
+  # otherwise.
+  #
+  # Intended to be used as:
+  #
+  #   needs_foo(T.must(maybe_gives_foo))
+  #
+  # Equivalent to:
+  #
+  #   foo = maybe_gives_foo
+  #   raise "nil" if foo.nil?
+  #   needs_foo(foo)
+  #
+  # 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)}
+  def self.must(arg)
+    return arg if arg
+    return arg if arg == false
+
+    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)
+    end
+  end
+
+  # A way to ask Sorbet to show what type it thinks an expression has.
+  # This can be useful for debugging and checking assumptions.
+  # In the runtime, merely returns the value passed in.
+  def self.reveal_type(value)
+    value
+  end
+
+  # A way to ask Sorbet to prove that a certain branch of control flow never
+  # happens. Commonly used to assert that a case or if statement exhausts all
+  # possible cases.
+  def self.absurd(value)
+    msg = "Control flow reached T.absurd."
+
+    case value
+    when Kernel
+      msg += " Got value: #{value}"
+    end
+
+    begin
+      raise TypeError.new(msg)
+    rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
+      T::Configuration.inline_type_error_handler(e)
+    end
+  end
+
+  ### Generic classes ###
+
+  module Array
+    def self.[](type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedArray::Untyped.new
+      else
+        T::Types::TypedArray.new(type)
+      end
+    end
+  end
+
+  module Hash
+    def self.[](keys, values)
+      if keys.is_a?(T::Types::Untyped) && values.is_a?(T::Types::Untyped)
+        T::Types::TypedHash::Untyped.new
+      else
+        T::Types::TypedHash.new(keys: keys, values: values)
+      end
+    end
+  end
+
+  module Enumerable
+    def self.[](type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedEnumerable::Untyped.new
+      else
+        T::Types::TypedEnumerable.new(type)
+      end
+    end
+  end
+
+  module Enumerator
+    def self.[](type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedEnumerator::Untyped.new
+      else
+        T::Types::TypedEnumerator.new(type)
+      end
+    end
+  end
+
+  module Range
+    def self.[](type)
+      T::Types::TypedRange.new(type)
+    end
+  end
+
+  module Set
+    def self.[](type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedSet::Untyped.new
+      else
+        T::Types::TypedSet.new(type)
+      end
+    end
+  end
+end
+# rubocop:enable PrisonGuard/UseOpusTypesShortcut

data/lib/types/abstract_utils.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::AbstractUtils
+  Methods = T::Private::Methods
+
+  # Returns whether a module is declared as abstract. After the module is finished being declared,
+  # this is equivalent to whether it has any abstract methods that haven't been implemented
+  # (because we validate that and raise an error otherwise).
+  #
+  # Note that checking `mod.is_a?(Abstract::Hooks)` is not a safe substitute for this method; when
+  # a class extends `Abstract::Hooks`, all of its subclasses, including the eventual concrete
+  # ones, will still have `Abstract::Hooks` as an ancestor.
+  def self.abstract_module?(mod)
+    !T::Private::Abstract::Data.get(mod, :abstract_type).nil?
+  end
+
+  def self.abstract_method?(method)
+    signature = Methods.signature_for_method(method)
+    signature&.mode == Methods::Modes.abstract
+  end
+
+  # Given a module, returns the set of methods declared as abstract (in itself or ancestors)
+  # that have not been implemented.
+  def self.abstract_methods_for(mod)
+    declared_methods = declared_abstract_methods_for(mod)
+    declared_methods.select do |declared_method|
+      actual_method = mod.instance_method(declared_method.name)
+      # Note that in the case where an abstract method is overridden by another abstract method,
+      # this method will return them both. This is intentional to ensure we validate the final
+      # implementation against all declarations of an abstract method (they might not all have the
+      # same signature).
+      abstract_method?(actual_method)
+    end
+  end
+
+  # Given a module, returns the set of methods declared as abstract (in itself or ancestors)
+  # regardless of whether they have been implemented.
+  def self.declared_abstract_methods_for(mod)
+    methods = []
+    mod.ancestors.each do |ancestor|
+      ancestor_methods = ancestor.private_instance_methods(false) + ancestor.instance_methods(false)
+      ancestor_methods.each do |method_name|
+        method = ancestor.instance_method(method_name)
+        methods << method if abstract_method?(method)
+      end
+    end
+    methods
+  end
+end